Skip to content

Python Intermediate

About

  • Level: Intermediate
  • Lectures: 40 hours
  • Self-study: 20 hours
  • Exercises: 394
  • Lines of Code to write: 1006
  • Format: e-learning + weekly online teleconference with instructor
  • Language: English or Polish

Description

This intermediate, hands-on Python course covers modern language features and practical libraries required to build robust applications and tools. Following the syllabus, students work with advanced syntax, string encodings and formatting, starred expressions and unpacking, enums and pattern matching, regular expressions, dates and timezone handling, generators and iterators, file and path manipulation with pathlib, and logging and module management. The course emphasizes real-world exercises in text processing, serialization and configuration formats, typing, dataclasses, and debugging workflows so learners can tackle daily coding challenges with confidence.

Advantages

Participants will improve reliability and interoperability of their Python code by mastering encoding, timezone-aware datetime handling, serialization (JSON, CSV, TOML, Pickle), and structured typing with dataclasses. The course reduces bugs caused by text and I/O edge cases, improves maintainability through typing and dataclasses, and speeds up development by teaching idiomatic unpacking, generators, and efficient iteration patterns useful in production systems.

Target Audience

  • Intermediate Python developers who want to deepen language and stdlib knowledge and write more robust, maintainable code.
  • Backend and automation engineers who handle file formats, serialization, and timezone-aware processing in production systems.
  • Data engineers and analysts who need reliable parsing, encoding, and data interchange skills (CSV, JSON, TOML, Pickle).
  • QA engineers and maintainers who write tests that involve I/O, logging, and serialization edge cases.
  • Developers preparing to adopt static typing and dataclasses in larger codebases or to progress to advanced Python topics.

Format

The course is delivered as a blended learning experience, comprising numerous short videos that progressively introduce concepts and techniques through a series of practical examples. The course format combines e-learning modules with weekly online teleconferences with the instructor for Q&A, discussions, and code reviews.

During the self-study phase, students complete practical exercises that apply the learned techniques. Each exercise is designed to have 100% test coverage, allowing students to verify their solutions. Additionally, students will have access to a spreadsheet to track their progress.

Students will also receive downloadable resources, including code samples, exercise templates, and reference materials to support their learning journey. Since 2015, we have refined our materials based on student feedback to ensure clarity, engagement, and practical relevance. All code listings undergo automatic testing (over 28,000 tests) to ensure accuracy and reliability. All materials, code listings, exercises, and assignments are handcrafted by our trainers without the use of AI. All case studies and examples are based on real-world scenarios drawn from our extensive experience in software engineering.

Working language of the course is either English or Polish.

Course Outline

  1. Syntax:

    • Underscore

  2. String:

    • Encoding (ASCII, ASCII-ext, UTF-8, CP1250, ISO-8859-2)
    • Escape sequences
    • String literals
    • pprint
    • Print formatting

  3. Star Expressions:

    • Starred assignment (unpacking)
    • API definition
    • Parameter unpacking (*args, **kwargs)
    • Argument unpacking (*args, **kwargs)

  4. Enum:

    • Introduction
    • StrEnum, IntEnum, Flag
    • auto, check

  5. Pattern Matching:

    • Introduction to syntax
    • Patterns: literal, or, wildcard, capture, constant
    • Patterns: sequence, mapping, class
    • Patterns: guard and subpattern

  6. Regular Expressions:

    • Syntax: literals, classes, anchors, negations, quantifiers, groups, backreferences, flags
    • Greedy and lazy expressions
    • Multiline searching
    • Named, positional, and non-capturing groups
    • Using regular expressions in Python: findall, finditer, search, match, sub, split, compile

  7. Dates and Time Zones:

    • Creating date objects, ISO-8601 standard, parsing and formatting – datetime
    • Time and date offsets – timedelta
    • Working with timestamps – time, datetime
    • Time zone handling – zoneinfo
    • Calendar handling – calendar

  8. Generators:

    • Principles of operation and introspection
    • Generator expressions
    • Keywords: yield and yield from
    • Sending values to generators

  9. Iterators:

    • reversed, range, enumerate, zip
    • product, permutations, count, chain, cycle
    • itertools module

  10. Pathlib:

    • Paths and files
    • Directories: creation, modification, searching, deletion
    • Files: creation, modification, searching, deletion

  11. Logging:

    • Usage and logging levels
    • Warnings and marking as deprecated (deprecation)
    • Basic and file-based configuration
    • Formatters, handlers
    • Log rotation and optimization

  12. Modules:

    • Virtual environments – venv
    • pyproject.toml file
    • Dependency management – pip, requirements.txt

  13. Locale:

    • i18n, l10n
    • locale
    • Formats, decimal separator, thousand separator, currency symbol

  14. Serialization:

    • Serialization algorithms and formats
    • Deserialization algorithms and methods
    • Data normalization and type conversion

  15. Pickle Format:

    • Object serialization and deserialization
    • Writing to a file, reading from a file
    • Protocol versions, compatibility, and security

  16. TOML Format:

    • Format specifics and common issues
    • Reading data
    • Configuration files

  17. CSV Format:

    • Format specifics and common issues
    • Writing and reading flat data
    • Writing and reading relational data

  18. JSON Format:

    • Format specifics and common issues
    • Writing and reading simple data
    • Encoder and decoder for dates and complex objects

  19. Typing:

    • Types: basic, optional, unions, literals, sequences, and mappings
    • Callable: functions, objects, and methods
    • Variance: covariance, contravariance, and invariance
    • Generic types, type aliases
    • Concepts: covariance, invariance, contravariance
    • Static type analysis – mypy

  20. Dataclasses:

    • Definition, syntax, basic types, sequences, mappings
    • Relationships and nested dataclasses
    • Post-init, (im)mutable attributes, field, metadata
    • Parameters, helpers, inheritance, introspection

Our Experience

AATC trainers have been teaching software engineering since 2015. We have already delivered over 11,000 (eleven thousand) hours of software engineering training to more than 32,000 (thirty-two thousand) students worldwide.

Requirements

  • Basic knowledge of Python programming
  • Familiarity with using an IDE (e.g., PyCharm, VSCode)
  • Familiarity with using version control systems (e.g., Git)

Setup

  • Newest version of Python
  • IDE of your choice (e.g., PyCharm, VSCode)
  • Git installed and configured
  • GitHub account
  • Web browser (e.g., Chrome, Firefox, Safari, etc.)

Apply

If you are interested in taking this course, please contact us at info@astronaut.center