PROWIDIT Education Academy

Blog
About us
How it works
FAQ

+994 77 333 38 36 Trial lesson Account

AZ RU EN

← Back to account

Switch coursePython course

AI for developers course104
Algorithms and data structures course129
Django & FastAPI course140
Docker & deployment course103
Full Stack Developer course270
Git & GitHub course103
HTML & CSS course154
JavaScript course169
Laravel course136
Provider Networks: MPLS, BGP and BNG81
Next.js course113
Node.js course123
PHP course144
Python course153
React course122
SQL & databases course122
TypeScript course112
Vue.js course111

Getting Started with Python
What Python Is and Where It Is Used Free
Installing Python and First Terminal Commands
The REPL and Your First Script: Running Python Code
Setting Up VS Code for Python: Extensions, Interpreter, Debugging
print(), Comments and Syntax Basics
Reading Errors: Tracebacks and Common Beginner Mistakes
Virtual Environments with venv and Installing Your First Package
Variables, Numbers and Logic
Variables and Assignment
Dynamic Typing: Objects, Types and References
int and float: Arithmetic and Operator Precedence
Built-in Numeric Functions and the math Module
Decimal and Fraction: Exact Money and Fraction Arithmetic
input() and Type Conversion
The bool Type and Comparison Operators
and, or, not and Truthiness (Truthy/Falsy)
Project: Currency and Unit Converter
Strings
Strings: Creation, Escaping and Basic Operations
String Indexing and Slicing
String Methods: Case, Searching and Checks
String Methods: split, join, strip, replace and Padding
f-strings: Embedding Expressions and Debugging
Formatting Numbers and Text: Format Specifiers
Unicode and Encodings: ord, chr, encode, decode
Project: Store Receipt Generator
Conditions and Loops
The if/else Statement
elif, Nested Conditions and the Conditional Expression
match/case: Matching Literal Values
The while Loop and the := Operator
The for Loop and range()
break, continue and else in Loops
enumerate(), zip() and reversed() in Loops
Nested Loops
Project: Number Guessing Game
Lists and Tuples
Lists: Creation, Indexing and Slicing
List Methods: Adding, Removing, Searching
Sorting: sort() and sorted()
List References and Copying
Nested Lists and Matrices
Tuples and Unpacking
Project: Class Grade Book
Dictionaries, Sets and Comprehensions
Dictionaries: Creation, Access and Modification
Dictionary Methods and Iteration
Nested Structures: Lists of Dicts and Dicts of Lists
match/case: List and Dictionary Patterns
Dictionary Patterns: Counting, Grouping and Dispatch Tables
Sets and Set Operations
List Comprehensions
Dict and Set Comprehensions
Nested Comprehensions
Generator Expressions with any, all and sum
Project: Text Statistics Tool
Functions
Functions: Defining, Calling and return
Parameters: Positional, Keyword, Defaults, / and *
*args, **kwargs and Argument Unpacking
Type Annotations and Docstrings in Functions
Scope: LEGB, global and nonlocal
Recursion
Project: Password Generator and Checker
Functional Techniques, Decorators and Generators
Functions as First-Class Objects
Anonymous lambda Functions
map, filter and functools.reduce
Sorting with key: lambda, itemgetter and Multiple Fields
Closures
Decorators: How They Work
Decorators with Arguments and Stacking Decorators
Iterables and Iterators: iter() and next()
Generator Functions and yield
yield from and Generator Pipelines
Exceptions and Working with Files
Handling Exceptions: try/except
else and finally: The Complete try Statement
Raising Exceptions: raise, raise from and assert
Custom Exception Classes
Reading Files: open(), Modes, Encodings and with
Writing Files: w, a, x Modes and Binary Files
pathlib: Working with Paths
os and shutil: Copying, Moving and Deleting Files
JSON: Saving and Loading Data
CSV: Reading and Writing Tables
Project: Contact Book with JSON Storage
Modules, Packages and Tooling
Importing Modules: import, from, as and sys.path
Your Own Modules and if __name__ == '__main__'
Packages and Project Structure
pip and Dependencies: PyPI, Versions, requirements.txt
uv: A Modern Project and Package Manager
pyproject.toml and Building Your Own Package
The Standard Library
datetime: Dates, Times and Intervals
Date Formatting and Time Zones (zoneinfo)
collections: Counter, defaultdict, namedtuple, deque
itertools: Efficient Iterators
functools: partial, cache, lru_cache and singledispatch
random and secrets: Random Numbers and Secure Tokens
Regular Expressions: re Module Basics
Regular Expressions: Groups, Substitution and Flags
logging: Logging Instead of print
argparse: Command-Line Tools with Arguments
Project: Expense Tracker with CSV Storage
OOP Fundamentals
Classes and Objects: Why OOP
The __init__ Constructor, self and Instance Attributes
Instance Methods
Class Attributes vs Instance Attributes
@classmethod and @staticmethod
Encapsulation and @property
Inheritance and super()
Multiple Inheritance, MRO and Mixins
Advanced OOP
Magic Methods __str__ and __repr__
Comparing and Hashing Objects: __eq__, __lt__, __hash__
Operators and Container Protocols: __add__, __len__, __getitem__, __iter__
dataclasses: Data Classes Without Boilerplate
dataclasses: field, frozen, slots, __post_init__ and match/case
Abstract Base Classes: the abc Module
Composition vs Inheritance
Enumerations: Enum, StrEnum and IntEnum
Custom Context Managers
Project: OOP Bank Account System
Type Hints, Testing and Code Quality
Type Hints in Depth: Literal, TypedDict, Callable, Aliases
Generics and Protocols
mypy: Static Type Checking
PEP 8 and Ruff: Code Style, Linting and Formatting
pytest: Writing Your First Tests
pytest: Fixtures and conftest.py
pytest: Parametrization, Markers and Coverage
Mocking: unittest.mock and monkeypatch
Project: Shopping Cart with TDD
HTTP, APIs and Web Scraping
How HTTP and REST APIs Work
requests: GET Requests and Working with JSON
requests: POST, Headers, Authentication and Sessions
Reliable HTTP Requests: Timeouts, Errors and Retries
httpx: A Modern HTTP Client
Project: Weather Forecast CLI Using an API
Web Scraping: HTML and BeautifulSoup
Scraping in Practice: Pagination, Delays and Ethics
Project: Book Catalog Scraper
Databases and FastAPI
SQLite and the sqlite3 Module: First Queries
sqlite3: Query Parameters, CRUD and Transactions
SQLAlchemy 2.0: Introduction to ORM
FastAPI: Your First REST API
Project: Notes REST API with FastAPI and SQLite
Concurrency, asyncio and Telegram Bots
Concurrency and Parallelism: Threads, Processes, asyncio and the GIL
Threads: threading and ThreadPoolExecutor
Processes: multiprocessing and ProcessPoolExecutor
asyncio: async/await and the Event Loop
asyncio: Tasks, TaskGroup, Timeouts and Cancellation
Async HTTP Requests: httpx.AsyncClient and aiohttp
Telegram Bots with aiogram: Commands and Handlers
Telegram Bots: Keyboards, Callback Buttons and States (FSM)
Project: Course Enrollment Telegram Bot
Automation, Data and the Final Project
Excel from Python: openpyxl
pandas: DataFrames, Loading and Filtering Data
pandas: Grouping, Aggregation and Reports
Automated Email: smtplib and email
Scheduling Tasks and Running Programs: schedule, cron, subprocess
Project: Automatic File Organizer
Final Project: Your Own Application from Idea to Release

Python course · OOP Fundamentals

@classmethod and @staticmethod

🔒 This is the beginning of the lesson. The full lesson is available with a subscription.

Create account Log in

← Previous lesson🔒 Class Attributes vs Instance Attributes Next lesson →🔒 Encapsulation and @property

PROWIDIT Education Academy

Online programming courses in Baku. Live lessons in Azerbaijani and Russian, 80% practice, mentor support and job placement assistance.

Front End

HTML & CSS JavaScript TypeScript React Next.js Vue.js

Back End

SQL (PostgreSQL, MySQL) PHP Laravel Python Algorithms Django & FastAPI Node.js Full Stack

Tools & AI

Git & GitHub Docker & deployment AI for developers

Useful links

Free trial lesson Mentoring & interviews For companies Blog FAQ

Contacts

+994 77 333 38 36 info@prowid.com Video lessons Send a request

© 2021–2026 Prowid — IT Education Academy. All rights reserved. Baku, Azerbaijan