The Complete Python Reference Guide 2026: Data Types, OOP, Asyncio, Stdlib, and Package Management

Executive Summary

Python in 2026 is the world's most popular programming language, holding the #1 position on TIOBE, GitHub Octoverse, and Stack Overflow surveys for the fourth consecutive year. Its dominance spans data science, machine learning, web development, automation, scripting, and increasingly systems-level work. Python 3.13 introduced an experimental free-threaded mode (PEP 703) that makes the GIL optional, and Python 3.14 brings template strings and deferred annotation evaluation. The packaging ecosystem has been transformed by uv (10-100x faster than pip) and Ruff (linting at Rust speed).

This report covers every major Python feature, from the six core data types through object-oriented programming, decorators, generators, context managers, type hints, and asyncio, to a comprehensive tour of the standard library and modern package management. Every section includes reference tables, practical code patterns, and data on adoption and ecosystem trends. Whether you are learning Python for the first time or are a senior engineer looking up a specific API, this guide is designed to be the single reference you need.

• FastAPI has surpassed Flask in popularity at 52% vs 22%, making it the most popular Python web framework in 2026. Django remains the choice for full-stack applications at 38%.
• Python 3.13 adoption has reached 35% within 18 months of release, making it the fastest adoption of any Python version. Python 3.12 holds 25%, and 3.14 is at 15% early adoption.
• uv has replaced pip for 40%+ of new projects, offering 10-100x faster dependency resolution and installation. The Astral ecosystem (uv + Ruff) is becoming the standard Python toolchain.
• The free-threaded CPython build (no GIL) is available experimentally in 3.13+, enabling true multi-threaded parallelism for the first time in Python's history. Major libraries (NumPy, Pandas) are adding free-threaded support.

Part 1: Python Data Types

Python is dynamically typed: variables do not have types, values do. You do not declare types at assignment (x = 42 creates an int without any type annotation). Python has six core built-in types that form the foundation of all programs: int, float, str, bool, list, dict, tuple, set, and NoneType. Understanding the distinction between mutable and immutable types is fundamental to writing correct Python code.

Numeric Types: int, float, complex

int: Arbitrary-precision integers. Unlike C or Java, Python integers have no maximum value. 2**1000 works perfectly. Integers support standard arithmetic (+, -, *, /), integer division (//), modulo (%), and exponentiation (**). Division always returns a float (10 / 3 = 3.3333); use // for integer division (10 // 3 = 3). Numeric literals support underscore separators for readability: 1_000_000. Base literals: 0b1010 (binary), 0o17 (octal), 0xff (hex).

float: IEEE 754 double-precision (64-bit) floating-point numbers. About 15-17 significant decimal digits. Special values: float('inf'), float('-inf'), float('nan'). For exact decimal arithmetic (financial calculations), use the decimal module. For fractions, use the fractions module. Common pitfall: 0.1 + 0.2 != 0.3 in any IEEE 754 system; use math.isclose() for approximate comparison.

complex: Complex numbers with j suffix: 3+4j. Real and imaginary parts are floats. Access with .real and .imag attributes. The cmath module provides complex-valued math functions. Used in scientific computing, signal processing, and electrical engineering.

Strings (str)

Strings are immutable sequences of Unicode characters. Created with single quotes ('hello'), double quotes ("hello"), or triple quotes ('''multiline'''). Strings are sequences: indexable (s[0]), sliceable (s[1:3]), iterable (for c in s), and have a length (len(s)). Python strings support 40+ built-in methods covering search, transformation, testing, splitting, and formatting. f-strings (Python 3.6+) are the preferred formatting method: f"Name: {name}, Age: {age}".

Collections: list, tuple, dict, set

list: Mutable, ordered sequence. [1, 2, 3]. Supports indexing, slicing, appending, extending, inserting, removing, sorting, and reversing. Lists can contain any mix of types. List comprehensions ([x**2 for x in range(10)]) are the Pythonic way to create lists from transformations. Lists are implemented as dynamic arrays.

tuple: Immutable, ordered sequence. (1, 2, 3). Tuples are hashable (if all elements are hashable), so they can be dict keys and set elements. Use tuples for fixed collections: function returns, database rows, coordinate pairs. Named tuples (collections.namedtuple or typing.NamedTuple) add field names. Single-element tuple requires a trailing comma: (42,).

dict: Mutable, ordered (since Python 3.7) key-value mapping. {"name": "Alice", "age": 30}. Keys must be hashable (strings, numbers, tuples). O(1) average lookup, insertion, and deletion. Dict comprehensions: {k: v for k, v in items}. The | merge operator (3.9+) creates a new merged dict: d1 | d2. Dict views (keys(), values(), items()) are set-like and support set operations.

set: Mutable, unordered collection of unique hashable elements. {1, 2, 3}. O(1) membership testing (x in s). Set operations: union (|), intersection (&), difference (-), symmetric difference (^). frozenset is the immutable version. Sets are essential for deduplication and membership testing. Empty set must be created with set(), not {} (which creates an empty dict).

None and Booleans

None: Python's null value. The sole instance of NoneType. Used for default return values, optional parameters, and sentinel values. Always test with "is None" (identity), not "== None" (equality). None is falsy in boolean contexts. Functions without a return statement return None.

bool: True or False. A subclass of int (True == 1, False == 0). Falsy values: False, 0, 0.0, 0j, "", [], (), {}, set(), None, and objects whose __bool__() returns False. Everything else is truthy. The bool() built-in converts any value to its boolean equivalent.

Part 2: Functions and Scope

Functions are first-class objects in Python: they can be assigned to variables, passed as arguments, returned from other functions, and stored in data structures. Defined with the def keyword: def greet(name: str) -> str: return f"Hello, {name}!". Lambda functions provide anonymous single-expression functions: lambda x: x**2.

Parameters and Arguments

Python supports: positional parameters, keyword parameters, default values, *args (variable positional), **kwargs (variable keyword), positional-only (before /, PEP 570), and keyword-only (after *). The full signature: def f(pos_only, /, normal, *, kw_only, **kwargs). Default values are evaluated once at function definition time, not at each call. This means mutable defaults (def f(items=[])) are shared between calls. Use None sentinel pattern: def f(items=None): items = items or [].

Scope Rules (LEGB)

Python uses the LEGB rule for variable lookup: Local (inside current function), Enclosing (inside enclosing functions, for closures), Global (module-level), Built-in (Python built-in names). The global keyword lets a function modify a module-level variable. The nonlocal keyword (Python 3) lets a nested function modify a variable from its enclosing function scope. Without these keywords, assignment inside a function creates a local variable.

Closures

A closure is created when a nested function references variables from its enclosing scope. The inner function "closes over" those variables, retaining access even after the outer function returns. Closures are the mechanism behind decorators, factory functions, and callback patterns. The nonlocal keyword allows modifying enclosed variables. Example: def counter(): count = 0; def increment(): nonlocal count; count += 1; return count; return increment.

Higher-Order Functions and functools

Higher-order functions take functions as arguments or return functions. Built-in: map(), filter(), sorted() with key=. The functools module provides: @lru_cache/@cache (memoization), @wraps (preserve function metadata in decorators), partial (partial function application), reduce (fold operation), and @singledispatch (single-dispatch generic functions). functools.cached_property is a descriptor that computes a value once and caches it as an instance attribute.

Part 3: Object-Oriented Programming and Classes

Everything in Python is an object: integers, strings, functions, modules, and classes themselves. Python supports classes with single and multiple inheritance, properties, class methods, static methods, abstract base classes, and a rich set of special ("dunder") methods for operator overloading and protocol implementation.

Class Basics

Classes are defined with the class keyword. __init__ is the constructor (initializer). self is the conventional name for the instance reference (mandatory first parameter in instance methods). Instance attributes are created by assigning to self.attribute in __init__. Class attributes are shared across all instances. Python has no access modifiers (public/private/protected); by convention, _name indicates "protected" and __name triggers name mangling (becomes _ClassName__name).

Inheritance and MRO

Python supports single and multiple inheritance. The Method Resolution Order (MRO) uses C3 linearization to determine which method is called. View MRO with ClassName.__mro__ or ClassName.mro(). super() returns a proxy that follows the MRO, enabling cooperative multiple inheritance. The diamond problem is resolved by C3. Best practice: prefer composition over inheritance; use mixins for adding specific capabilities.

Dataclasses (Python 3.7+)

The @dataclass decorator (PEP 557) automatically generates __init__, __repr__, __eq__, and optionally __hash__, __lt__/__gt__/__le__/__ge__, and __post_init__ from annotated class fields. dataclasses reduce boilerplate for data-holding classes. Options: frozen=True (immutable), slots=True (use __slots__ for memory savings, 3.10+), kw_only=True (all fields keyword-only, 3.10+). Field-level options: field(default=..., default_factory=..., repr=False, compare=False).

Special (Dunder) Methods

Python uses double-underscore methods to define how objects interact with operators and built-in functions. Key dunders: __init__ (construction), __str__ (human-readable string), __repr__ (developer string), __len__ (len()), __getitem__/__setitem__ (indexing), __iter__/__next__ (iteration), __eq__/__lt__ etc. (comparison), __add__/__mul__ etc. (arithmetic), __enter__/__exit__ (context manager), __call__ (callable object), __hash__ (hashability), __contains__ (in operator).

Properties and Descriptors

The @property decorator creates managed attributes with getter, setter, and deleter methods that look like simple attribute access. Properties enforce encapsulation while maintaining a clean API. Descriptors are the underlying mechanism: objects with __get__, __set__, and/or __delete__ methods. Descriptors power properties, methods, classmethod, staticmethod, and __slots__. Data descriptors (with __set__) take priority over instance dictionaries.

Part 4: Decorators

A decorator is a function that takes another function (or class) and returns a modified version of it. The @decorator syntax is sugar for function = decorator(function). Decorators enable aspect-oriented programming: adding cross-cutting concerns (logging, timing, caching, access control, validation) without modifying the original function code.

Basic pattern: def my_decorator(func): @functools.wraps(func) def wrapper(*args, **kwargs): # before; result = func(*args, **kwargs); # after; return result; return wrapper. Always use @functools.wraps to preserve the original function's __name__, __doc__, __module__, and __qualname__. Without it, the decorated function loses its identity, breaking help() and debugging.

Decorators with arguments require an extra layer: def repeat(n): def decorator(func): @functools.wraps(func) def wrapper(*args, **kwargs): for _ in range(n): result = func(*args, **kwargs); return result; return wrapper; return decorator. Usage: @repeat(3). This three-level nesting is the standard pattern for parameterized decorators.

Class-based decorators implement __call__: class Timer: def __init__(self, func): self.func = func; def __call__(self, *args, **kwargs): start = time.time(); result = self.func(*args, **kwargs); print(f"Took {time.time()-start}s"); return result. Class decorators on classes themselves can modify class creation: @dataclass, @total_ordering, @register.

Common built-in and stdlib decorators: @property (managed attributes), @staticmethod (no self/cls), @classmethod (cls as first arg), @functools.lru_cache (memoization with maxsize), @functools.cache (unlimited memoization, 3.9+), @functools.wraps (preserve metadata), @functools.singledispatch (single-dispatch generic functions), @functools.cached_property (one-time computation), @abc.abstractmethod (enforce interface), @contextlib.contextmanager (generator-based context managers).

Part 5: Generators and Iterators

The iterator protocol is fundamental to Python. Any object that implements __iter__ (returns self) and __next__ (returns next value or raises StopIteration) is an iterator. All for loops, comprehensions, unpacking operations, and many built-in functions work through the iterator protocol. Iterables (lists, strings, dicts, files) produce iterators via their __iter__ method.

Generators are the easiest way to create iterators. A generator function uses yield to produce values one at a time, suspending state between calls. When next() is called, execution resumes from where it left off. This lazy evaluation means generators use constant memory regardless of how many values they produce. A generator for range(1_000_000_000) uses almost no memory, while a list would use 8+ GB.

Generator expressions provide a concise syntax: (x**2 for x in range(10)). They are like list comprehensions but produce values lazily. Use generator expressions when you only need to iterate once and do not need random access. They are commonly used with functions that consume iterables: sum(x**2 for x in range(10)), ",".join(str(x) for x in items).

yield from (PEP 380, Python 3.3) delegates to a sub-iterator: yield from iterable replaces for item in iterable: yield item but also handles send(), throw(), and close() correctly. This is essential for composing generator pipelines and implementing recursive generators (e.g., tree traversal).

The itertools module provides fast, memory-efficient building blocks for iterator-based programming: chain (concatenate), islice (slice iterators), product (Cartesian product), permutations, combinations, groupby, cycle, repeat, accumulate, zip_longest, starmap, tee, and more. Mastering itertools is key to writing efficient, Pythonic data processing code.

Part 6: Context Managers

Context managers guarantee cleanup code runs even if exceptions occur. The with statement calls __enter__ on entry and __exit__ on exit (whether by normal completion, exception, or return). The most common use is file handling: with open("file.txt") as f: data = f.read(). The file is automatically closed when the with block exits, even if an exception occurs during reading.

Creating context managers with classes: implement __enter__ (returns the resource) and __exit__ (handles cleanup, receives exception info). The __exit__ method receives (exc_type, exc_val, exc_tb) and can suppress exceptions by returning True. Common uses: database connections, locks, temporary directories, timing blocks, and transaction management.

The @contextlib.contextmanager decorator creates context managers from generators. The generator yields once: code before yield runs on __enter__, code after yield runs on __exit__. This is often simpler than the class-based approach. contextlib also provides: suppress() (ignore specific exceptions), redirect_stdout/stderr(), ExitStack (manage multiple context managers dynamically), nullcontext() (no-op context manager), and closing() (call .close() on exit).

Python 3.10 added parenthesized multi-line context managers: with (open("a") as a, open("b") as b). Python 3.13 supports "using" declarations for async resource management in the style of explicit resource management (PEP 707). async with statements handle asynchronous context managers (__aenter__/__aexit__) for async database connections, HTTP sessions, and similar resources.

Part 7: Type Hints

Type hints (PEP 484, Python 3.5+) annotate function parameters and return values with expected types. They are not enforced at runtime but are checked by static type checkers (mypy, pyright, pytype) and used by IDEs for autocomplete and error detection. Type hints serve as executable documentation and catch bugs before runtime. Python 3.9+ allows generic types in standard collections (list[int] instead of typing.List[int]). Python 3.10+ supports the | union syntax (int | str instead of Union[int, str]).

Core type annotations: str, int, float, bool, None, list[str], dict[str, int], tuple[int, str], set[float], Optional[str] (equivalent to str | None), Any (any type), Union[int, str] (or int | str in 3.10+). For function signatures: def greet(name: str, age: int = 0) -> str. For variables: x: int = 42. Collections with generic types: def process(items: list[dict[str, Any]]) -> list[str].

Advanced typing features: TypeVar (generic type variables), Generic (generic classes), Protocol (structural subtyping / duck typing in the type system, PEP 544), TypedDict (typed dictionaries), Literal (restrict to specific values), Final (cannot be reassigned), Annotated (attach metadata to types), ParamSpec (generic callable signatures), TypeVarTuple (variadic generics). Python 3.12 introduced the simpler type parameter syntax: def first[T](items: list[T]) -> T (PEP 695).

Practical type checking workflow: (1) Annotate function signatures first (parameters and return types). (2) Run mypy or pyright in CI/CD. (3) Gradually add annotations to existing code (gradual typing). (4) Use strict mode for new projects. (5) Use reveal_type() for debugging inferred types. (6) Configure with pyproject.toml: [tool.mypy] strict = true. Type checking catches real bugs: wrong argument types, missing return statements, None-safety violations, and incorrect container element types.

Part 8: Asyncio and Concurrency

asyncio is Python's built-in framework for writing concurrent code using async/await syntax. It is designed for I/O-bound operations: HTTP requests, database queries, file I/O, and network communication. asyncio uses a single-threaded event loop that manages coroutines cooperatively: when one coroutine awaits an I/O operation, the event loop runs another coroutine instead of blocking.

Coroutines are defined with async def and suspended with await. asyncio.run(main()) is the standard entry point that creates and runs the event loop. asyncio.gather(*coros) runs multiple coroutines concurrently and collects results. asyncio.create_task(coro) schedules a coroutine without waiting for it. TaskGroup (Python 3.11+, PEP 654) provides structured concurrency: async with asyncio.TaskGroup() as tg: tg.create_task(coro1()); tg.create_task(coro2()). All tasks are automatically awaited and exceptions propagated.

Key asyncio APIs: asyncio.sleep(seconds) (non-blocking delay), asyncio.Queue (producer-consumer pattern), asyncio.Lock/Event/Semaphore (synchronization), asyncio.wait_for(coro, timeout) (timeout wrapper), asyncio.shield(coro) (protect from cancellation), asyncio.to_thread(fn, *args) (run blocking code in a thread). For HTTP: use httpx or aiohttp. For databases: use asyncpg, aiomysql, or async SQLAlchemy.

Python concurrency options beyond asyncio: threading (concurrent I/O, limited by GIL for CPU), multiprocessing (parallel CPU work, separate processes), concurrent.futures (high-level ThreadPoolExecutor and ProcessPoolExecutor), and the new free-threaded CPython (3.13+, no GIL, true multi-threaded parallelism). Choose asyncio for many concurrent I/O operations (thousands of connections), threading for moderate concurrency with blocking libraries, and multiprocessing for CPU-intensive parallelism.

Part 9: Standard Library Tour

Python's "batteries included" philosophy means the standard library provides modules for nearly every common task. This section covers the most important modules that every Python developer should know.

os and sys

os: Operating system interface. os.path (path manipulation, largely replaced by pathlib), os.environ (environment variables), os.getcwd(), os.listdir(), os.makedirs(), os.remove(), os.rename(), os.walk() (directory tree traversal), os.getenv(). sys: System-specific parameters. sys.argv (command-line arguments), sys.path (module search path), sys.stdin/stdout/stderr, sys.exit(), sys.version, sys.platform, sys.getsizeof() (object memory size).

json

The json module serializes Python objects to JSON and deserializes JSON to Python. json.dumps(obj) produces a JSON string. json.loads(s) parses a JSON string. json.dump(obj, file) writes to a file. json.load(file) reads from a file. Options: indent (pretty-print), default (custom serializer for non-standard types), sort_keys, ensure_ascii. For custom objects, provide a default function or create a JSONEncoder subclass.

re (Regular Expressions)

The re module provides Perl-style regular expressions. Key functions: re.search(pattern, string) (first match), re.match(pattern, string) (match at start), re.findall(pattern, string) (all matches), re.sub(pattern, repl, string) (replace), re.split(pattern, string) (split). Compile patterns for reuse: pattern = re.compile(r"\d+"). Use raw strings (r"...") to avoid backslash escaping issues. Named groups: (?P<name>pattern).

datetime and zoneinfo

The datetime module provides date and time types. datetime.datetime.now() (current local time), datetime.datetime.utcnow() (UTC, prefer datetime.now(timezone.utc)), datetime.date.today(), timedelta for arithmetic. The zoneinfo module (Python 3.9+) provides IANA timezone support: from zoneinfo import ZoneInfo; dt = datetime.now(ZoneInfo("America/New_York")). Always store datetimes in UTC and convert to local time for display.

collections

Specialized container types: defaultdict (factory for missing keys), Counter (count occurrences), OrderedDict (ordered dict, mostly unnecessary since 3.7), deque (double-ended queue, O(1) append/pop on both ends), namedtuple (tuple with named fields), ChainMap (combine multiple dicts). collections.abc provides abstract base classes for containers: Iterable, Iterator, Sequence, Mapping, MutableMapping, Callable.

itertools

Iterator building blocks for efficient looping. Infinite iterators: count(), cycle(), repeat(). Terminating iterators: chain(), compress(), dropwhile(), takewhile(), groupby(), islice(), starmap(), accumulate(), zip_longest(). Combinatoric iterators: product() (Cartesian product), permutations(), combinations(), combinations_with_replacement(). All functions return lazy iterators, not lists.

pathlib

Object-oriented filesystem paths (Python 3.4+). Path objects use the / operator for joining: Path("src") / "main.py". Key methods: .read_text(), .write_text(), .read_bytes(), .exists(), .is_file(), .is_dir(), .mkdir(parents=True), .glob("*.py"), .rglob("**/*.py") (recursive), .stat(), .name, .stem, .suffix, .parent, .resolve() (absolute path). Python 3.12 added Path.walk() as a replacement for os.walk(). Preferred over os.path for all new code.

Part 10: Package Management

Python packaging has evolved dramatically. The 2026 landscape offers three main approaches: pip (traditional, universal), Poetry (modern, batteries-included), and uv (blazing fast, Rust-powered). All three use PyPI (Python Package Index) as the package source. pyproject.toml (PEP 518/621) is the standard project configuration file, replacing the legacy setup.py.

pip

The standard package installer, bundled with Python. Commands: pip install package, pip install -r requirements.txt, pip install -e . (editable install), pip freeze > requirements.txt, pip uninstall package, pip list, pip show package. Supports version specifiers: package==1.2.3 (exact), package>=1.2 (minimum), package~=1.2 (compatible release). Virtual environments: python -m venv .venv.

Poetry

A modern dependency management and packaging tool. Uses pyproject.toml for project metadata and poetry.lock for reproducible installs. Commands: poetry init, poetry add package, poetry install, poetry update, poetry build, poetry publish. Features: automatic virtual environment management, dependency groups (dev, test, docs), version constraints with sensible defaults, and script definitions. Ideal for application projects that need reproducible builds.

uv

An extremely fast Python package installer and resolver written in Rust by Astral (creators of Ruff). Drop-in replacement for pip and pip-tools. 10-100x faster than pip for resolution and installation. Commands: uv pip install package, uv pip compile requirements.in, uv pip sync requirements.txt, uv venv (create virtual environment), uvx (run tools without installing). uv also manages Python versions: uv python install 3.13. Rapidly becoming the default tool for Python dependency management.

Part 11: Built-in Functions Reference (68+)

Python provides 68+ built-in functions available without any import. This searchable, sortable reference table covers every built-in function with signature, description, example, and category.

String Methods (40+)

List Methods

Dict Methods

Part 12: Python 3.x Changelog

A comprehensive timeline of every Python 3.x release, from the breaking changes of 3.0 through the free-threaded GIL-optional builds of 3.13 to the template strings of 3.14.

Glossary (60+ Terms)

A comprehensive glossary of Python terminology covering implementations, syntax, OOP, concurrency, iterators, typing, standard library, packaging, frameworks, and tooling.

FAQ (20 Questions)

Try It Yourself

Use these embedded tools to practice with data formats and patterns discussed in this guide.

Raw Data Downloads

All datasets from this report are available for download in CSV format under a Creative Commons Attribution 4.0 license.

Citations and Sources

Related Articles and Tools

Related Research Reports