Python for Engineering

360 ore de studiu

40 ședințe live

6 luni

Python Language Fundamentals

The Python Ecosystem & Dev Environment

• Interpreted languages paradigm • Python 3 ecosystem & popular frameworks by domain • VS Code & PyCharm setup • Jupyter Notebook & Google Colab • Running your first Python script

Language Syntax - Variables & Basic Types

• Python keywords & reserved words • Code blocks & indentation • Comments & multi-line statements (PEP 8) • Variables & identifiers • Numeric types: int, float, bool • Strings: str basics • The None singleton • Dynamic typing

Operators - Expressions & Basic I/O

• Arithmetic, comparison, logical, assignment operators • Identity operators: is, is not • Operator precedence & order of evaluation • The ternary operator • Reading input from keyboard: input() • Writing to console: print(), f-strings

Control Flow & Program Structure

• if / elif / else • while loops • for loops & range() • break, continue, pass • match / case (structural pattern matching)

Strings & Text Processing

• String indexing & slicing • Common string methods: strip, split, join, replace, find • String formatting: f-strings, format() • Raw strings & escape sequences • Multiline strings • String immutability

Functions — Definition - Parameters & Reuse

• Defining functions: def, return • Positional & keyword arguments • Default parameter values • *args & **kwargs • Variable scope: local vs global • Docstrings

Python code in practice:

• Exercises covering syntax, control flow, strings & functions • Code review & debugging practice • Writing clean, readable Python from day one

Organising Code and Data

Modules, Packages & the Standard Library

• What is a module: import forms • The __name__ == '__main__' pattern • Packages & __init__.py • Useful standard library modules: os, sys, math, random, datetime, pathlib • Third-party packages overview

Managing Python Environments (venv, requirements.txt, pyproject.toml)

• Why isolated environments matter • pyenv — managing Python versions • Creating & activating virtual environments with venv • Installing packages with pip • Freezing dependencies: requirements.txt • Modern project config: pyproject.toml & TOML format • pipx for global tools

Lists, Tuples, Sets & Dictionaries

• Lists: creation, indexing, slicing, mutation • Tuples: immutability & unpacking • Sets: uniqueness, set operations • Dictionaries: keys, values, items, nested dicts • Choosing the right data structure • Common patterns: counting, grouping, deduplication

Comprehensions, Generators & Iterators

• List, dict & set comprehensions • Conditional comprehensions • The iterator protocol: __iter__, __next__ • Generator functions & yield • Generator expressions • Lazy evaluation & memory efficiency

Object-Oriented Programming — Basics

• Classes & objects • __init__ & instance attributes • Instance methods vs class methods vs static methods • Encapsulation & name mangling • __str__ & __repr__ • Dunder methods overview

Data Classes, NamedTuple & Enum

• @dataclass — automatic __init__, __repr__, __eq__ • field() — defaults, factories, metadata • Frozen dataclasses • NamedTuple — lightweight immutable records • Enum & IntEnum — named constants • When to use each

Advanced OOP in practice

• Inheritance & polymorphism • Abstract base classes • Hands-on refactoring exercise

Understanding Pythonic Code

Functions as First-Class Citizens

• Functions as objects: passing & returning functions • Higher-order functions: map(), filter(), sorted() • Lambda expressions: syntax & use cases • functools.partial — pre-filling arguments • Practical patterns with higher-order functions

Decorators

• Closures & free variables • Writing a decorator from scratch • functools.wraps — preserving metadata • Decorators with arguments • Stacking multiple decorators • Real-world examples: timing, logging, access control

Functional Programming in Practice

• functools: reduce, lru_cache, cached_property, singledispatch • itertools: chain, islice, groupby, product, combinations • Generator pipelines • Lazy evaluation patterns • When functional style improves readability

File I/O & Context Managers

• JSON, CSV & pathlib • Context managers: with statement • Parsing & serializing JSON • Files for big data: JSONL, parquet

Exceptions & Debugging

• Exception hierarchy • try / except / else / finally • Raising & re-raising exceptions • Custom exception classes • Writing __enter__ & __exit__ • Debugging in VS Code: breakpoints, watch, call stack • Reading tracebacks

Type Hints & the Typing System

• Why type hints matter • Basic annotations: int, str, float, bool, None • Collections: list[int], dict[str, int], tuple • Optional & Union • Type aliases • Running mypy for static analysis

Advanced Typing

• TypedDict, Intro to Pydantic • Protocol — static duck typing • Runtime type inspection • Parsing & serializing JSON • Why Pydantic over plain dataclasses for APIs
Networking and Communication

HTTP Protocol, requests & Sessions

• HTTP request/response cycle • Methods: GET, POST, PUT, DELETE, PATCH • Status codes & headers • The requests library: get, post, params, json, headers • Sessions & connection reuse • Handling timeouts & errors

FastAPI — App Structure & Defining Endpoints

• FastAPI project structure • Defining routes: @app.get, @app.post • Path & query parameters • Request body with Pydantic • Response models • Auto-generated docs: Swagger UI & Redoc • Running with uvicorn

Pydantic — Validation, API Serialization

• Pydantic v2 changes & performance • Field aliases & field mapping • Custom validators: @field_validator, @model_validator • Serialization: model_dump(), model_dump_json() • Handling optional & default fields • Config & model settings

API Authentication & Secrets Management

• API keys in headers & query params • Bearer tokens & OAuth2 basics • HTTPBearer in FastAPI • Storing secrets safely: .env files • python-dotenv & pydantic-settings • Never committing secrets to git

Web Scraping with BeautifulSoup

• Inspecting HTML with browser dev tools • requests + BeautifulSoup workflow • Navigating the DOM: find, find_all, select (CSS selectors) • Extracting text, attributes & links • Handling pagination • Respecting robots.txt & rate limiting

Async communication with asyncio

• Concurrency vs parallelism vs async • The event loop • async def & await • asyncio.gather & asyncio.create_task • Async context managers & iterators • httpx for async HTTP requests • async endpoints in FastAPI

Intro to Agentic AI

• Tool calling & function calling pattern • Building a simple agent loop with an LLM API • Async in agentic workflows • Practical exercise: a minimal research agent

Data Science and Machine Learning

NumPy — Arrays, Vectorized Operations & Broadcasting

• ndarray: shapes, dtypes, dimensions • Creating arrays: zeros, ones, arange, linspace • Indexing, slicing & boolean masks • Vectorized arithmetic — no loops • Broadcasting rules • Useful functions: sum, mean, std, argmax • NumPy vs plain Python performance

Pandas — DataFrames & Filtering

• Series & DataFrame fundamentals • Reading data: read_csv, read_excel, read_json • Selecting columns & rows: loc, iloc • Filtering with boolean conditions • Adding & transforming columns • Sorting & ranking • Writing output: to_csv, to_excel

Data Cleaning & Exploratory Analysis

• Identifying missing values: isnull(), info(), describe() • Filling & dropping missing data • Removing duplicates • Type casting & formatting • groupby, agg & pivot_table • Merging & joining DataFrames • Basic EDA workflow

Data visualisation with matplotlib

• Anatomy of a matplotlib figure • Line plots, bar charts, histograms, scatter plots • Subplots & layouts • Customizing: titles, labels, legends, colors • Saving figures • Brief intro to seaborn for statistical plots

scikit-learn — Training, Evaluation & Model Persistence

• The scikit-learn API: fit, predict, transform • Train/test split • Linear regression & logistic regression • Decision trees & random forests • Evaluation metrics: accuracy, precision, recall, RMSE • Saving & loading models with joblib

Feature Engineering & Preprocessing Pipelines

• Handling categorical features: encoding strategies • Scaling & normalization • Imputation strategies • sklearn Pipeline & ColumnTransformer • Feature selection basics • Avoiding data leakage

Intro to DS&ML in practice

• MLOps and why it matters • Serving a model as an API (FastAPI + joblib) • Monitoring predictions in production • Hands-on: train → log → serve pipeline

Building Productive Systems in Python

Project Layout and Code Organization, Packaging & Distribution

• Standard Python project structure • src layout vs flat layout • pyproject.toml deep dive: metadata, dependencies, scripts • Building a distributable package • Publishing to PyPI (overview) • Monorepo vs multi-repo considerations

Layered Architecture — Routes, Services & Repositories

• Separation of concerns in web apps • HTTP layer: routers & request handling • Service layer: business logic • Repository layer: data access abstraction • Dependency injection in FastAPI • Practical refactoring exercise

Data persistence, ORM

• Relational database basics: tables, keys, relationships • SQLite for development • SQLAlchemy Core vs ORM • Defining models with DeclarativeBase • CRUD with SQLAlchemy ORM • Alembic for migrations • Connecting ORM to FastAPI repository layer

pytest Fundamentals & Test Discovery

• Why testing matters • pytest installation & test discovery conventions • Writing test functions & assertions • Running & filtering tests • Fixtures: setup & teardown • Parametrize: testing multiple inputs • conftest.py

Structured Logging & Debugging Pipelines

• Python logging module: levels, handlers, formatters • Structured logging with JSON output • Correlation IDs & request tracing • Debugging async code • Logging best practices in production • Integration with log aggregation tools

Production Observability — Metrics, Latency & Error Rates

• The three pillars: logs, metrics, traces • Prometheus metrics with FastAPI • Latency, error rate & throughput • Health check endpoints • Alerting basics • Intro to OpenTelemetry

Intro to DevOps for python stack

• Writing a Dockerfile for FastAPI • Hands-on: deploy a containerized API