Python

Python is strongly typed, in that every object has a definite type, and dynamically typed, in that nothing is checked before the code runs; the best description of its type system is duck typing, where an object's suitability for a context is decided at run time. It is general-purpose, less suited only to extremely time-sensitive or memory-constrained work. Calling it "interpreted" is a slight misstatement: Python is compiled to bytecode first, but invisibly, so the experience is of running code the moment it is edited. Whitespace delimits blocks, which removes a great deal of punctuation and makes all Python code look alike in important ways.[2]

The reference implementation, CPython, is written in C; Jython targets the Java Virtual Machine, IronPython the .NET platform, and PyPy, written in a restricted Python called RPython, has a just-in-time compiler that makes it much faster for some programs.[2][3] Distributions wrap the interpreter with packages: Anaconda, aimed at data science and installed with its own conda tool, and WinPython, which runs from a USB stick on a locked-down Windows machine. Python also runs on Android and iOS through apps, and on a Raspberry Pi costing as little as ten dollars.[3]

Much of the appeal is the interactive shell, the REPL, where an expression's value is printed without print() and _ holds the last result.[11] IDLE, the editor that ships with Python, is built on the standard library's tkinter; Thonny, PyCharm, Spyder, Jupyter and VSCodium are the usual alternatives.[1] Authors outside the Python world choose it for the same reasons: a discrete mathematics text because the syntax is close to natural language, almost every snippet is under ten lines and the interactive mode invites experiment;[12] a genetic-algorithms book because an entry-level programmer can follow its low-ceremony code, which is why it avoids third-party modules.[13] The language's aesthetic is written down in the Zen of Python, whose "simple is better than complex" one cheat sheet prints at the foot of its first page.[14]

The built-in types are a beginner's first month. Integers are unbounded and floats double precision; // rounds towards the smaller integer; None, zero, empty strings and empty containers are false and everything else true, with not binding tighter than and, and and tighter than or.[15] Strings take single, double or triple quotes, and f-strings embed expressions.[14] Lists are ordered and mutable, indexed from zero with negative indices from the end; tuples are lists that cannot change; dictionaries hold key-value pairs iterated with items(), keys() or values(); sets hold unique elements and test membership in constant time.[14][15] A list's sort is Timsort, and append with pop makes a stack.[15] Slicing, [start:stop:step] on any sequence, has a puzzle book of its own,[16] fifty puzzles of the "what does this print" kind cover the rest of the syntax,[17] and comprehensions, a list or set built from a for clause in one expression, are the idiom beginners are told to reach for.[15]

Control flow is if/elif/else, for over any iterable, and while; input() returns a string, converted with int() or float().[14] A guide for PowerShell users sets each beside its equivalent, print() against Write-Host, input() against Read-Host, to learn the new language through the known one.[18] Functions are defined with def, take arguments with defaults, return a value and carry a docstring.[14] One short book exists only to say why they matter: they chunk code, let a bug be fixed in one place, give a task a name, and are the step out of scripting towards object-oriented programming.[19] Errors are exceptions handled with try, except and else; files open under with, which closes them on the way out.[14]

Everything in Python is an object, and a variable is a name bound to one; names have no type of their own. Namespaces are dictionaries, and a name is looked up locally, then in enclosing functions, then in the module's globals, then the builtins. Assigning to a global inside a function creates a local instead, which is why global exists; nonlocal does the same for an enclosing function's variable and is what makes a closure such as a counter factory work.[20] eval and exec run a string as an expression or a suite of statements with optional dictionaries for globals and locals; replacing the builtins there is how an online interpreter sandboxes user code,[20] and passing user input to eval is unsafe outside a tool run only by its author.[11]

A class statement is executed, not declared: running it creates a class object, and the body's namespace is not a scope the methods can see, so a class attribute is reached through the class name. The class of a class is type, and a class can be rebuilt by running its body with exec into a dictionary and calling type with the name, the bases and that dictionary.[20] In everyday code a class has __init__, methods taking self and subclasses calling super(),[14] an introductory course teaches constructors and reference semantics through a Flight class,[2] and a short in-progress book covers inheritance and method resolution, polymorphism, operator overloading and exceptions for readers who find the object-oriented part hard.[21]

Below that, the simplicity ends. A training company's trilogy maps the depth: an apprentice volume on the core language, collections, exceptions, comprehensions, generators, classes, files and unit testing;[2] a journeyman volume on packages, closures and decorators, properties, iteration protocols, multiple inheritance, the collection protocols, context managers and introspection;[22] and a master volume on __getattribute__, slots, descriptors, instance creation, metaclasses, class decorators and abstract base classes.[23] A single intermediate text covers much the same ground, from the object model through generators, coroutines, decorators, metaclasses and the import system.[20]

What CPython does with a file is a pipeline: source to parse tree, abstract syntax tree and symbol table, then to code objects holding bytecode; a frame object per call; and an evaluation loop in the C file ceval.c that executes opcodes, keeps the block stack for exceptions and implements generators. One book follows a piece of Python down that path and ends by extending the language.[24] The parser and the loop have both been reworked recently, so the CPython version an account describes matters. Two consequences reach every programmer: the global interpreter lock lets one thread run bytecode at a time, so CPU-bound parallelism uses processes, and one introduction treats threads, processes, profiling and debugging together as the intermediate layer;[3] and because the target is a virtual machine, PyPy can keep the language and change the machine.[3]

Command-line tools begin with sys.argv and the -c option that runs a one-line program,[11] and grow into argparse, which replaced optparse: a parser with a description and epilogue, required and optional arguments with defaults and types, short and long names and mutually exclusive groups, producing help text for free.[25] The collections module supplies ChainMap, which layers mappings so that command-line arguments override environment variables which override defaults, with defaultdict, deque, namedtuple and OrderedDict; the same tour covers contextlib, functools, itertools, typing, unittest and the concurrency modules.[25]

Text processing has the string methods and re. Regular expressions are a small language for sanitising, extracting and replacing text, and Python's dialect resembles Perl's with significant differences; re.search returns a match object or None, so it reads naturally in an if, patterns are raw strings, and re.I ignores case. One book works from there through anchors, groups, lookarounds, flags and Unicode to the third-party regex module, every feature from REPL examples the reader retypes;[10] another pairs each feature with a video and a puzzle.[26] subprocess runs shell commands, which is how a terminal agent gets its hands,[27] and datetime is the standard clock, though bindings can disagree with it: QuantLib's Date takes day, month, year.[28]

Packages install with pip, spelled python -m pip install so they land in the interpreter you mean; --user installs for one account and -U upgrades.[7] Isolation is a virtual environment, the virtualenv package for Python 2 and early 3 and the venv module since 3.3, a folder holding a copy of the interpreter and pip that is activated before use.[7] One agent-building book makes "never install into the system Python" a rule, since AI libraries move fast and conflict with system packages.[27] pipenv folds pip and virtualenv into one tool,[9] and conda, with Miniconda as its small installer, manages environments that hold non-Python dependencies, which is why the geospatial and deep-learning books set it up first and then introduce uv as the fast alternative.[29][30] A production-practice guide uses uv for dependencies and for packaging a project for PyPI,[31] and pinning a version, pip install pycaret[full]==3.0.0, is how a book keeps its examples running.[32] Distribution to users is separate: a cross-platform package, a Windows executable and installer, and a Mac application are each a chapter,[3] and GUI books end with PyInstaller.[9]

Testing has two homes. The standard library's unittest closes the apprentice curriculum,[2] and pytest, which runs any function starting with test_ with no boilerplate, is what new code uses: a coding-agent book writes four tests before its main loop and, because model calls are slow, expensive and non-deterministic, adds a FakeBrain test double so the suite never makes one,[27] and a clean-architecture text assumes pytest and mocks as its prerequisite.[33] The notebook is Python's other interface: a Jupyter notebook mixes prose with code cells and their outputs, numbered In [N] and Out [N], in one shared scope, with data frames and plots rendered inline.[28] JupyterLab is the current interface and the classic Notebook its predecessor,[32] covered in a 2018 guide from sharing through Binder and Colab to nbconvert, widgets, debugging and kernels for other languages.[34] Their limits in production motivate a guide that pairs each practice with one tool: Git, uv, pytest, Hydra for configuration, Loguru for logging, Pandera for data validation, DVC for data versioning, GitHub Actions and marimo for reproducible notebooks.[31]

Django, released in 2005, is the full-stack framework: an object-relational mapper, templates, forms, authentication, sessions and an admin site, organised in what its users call Model-View-Template. Two editions of a University of Glasgow textbook teach it by building one application, Rango, a directory of categories and pages, from the terminal, a virtual environment, pip and Git through models, templates, forms, static files, authentication, sessions, Bootstrap, jQuery and AJAX to deployment on PythonAnywhere.[6][35] The method is design first: before any code the reader draws a three-tier architecture, a browser, a Django application and the SQLite database Python ships with, then wireframes, URL mappings for the index, about and category pages, and an entity-relationship diagram whose fields are already Django types. The authors make the one-to-many assumption between categories and pages explicit and tell the reader to write such assumptions down. The book is, in its own words, not designed to be read but typed along with.[6] The Django 2 edition adds class-based views and unit testing,[35] and a Django sheet sits among the beginner cheat sheets.[14]

Flask (2010) is the microframework: routing, requests and templates, everything else the developer's choice. Its brevity shows in the samples. A security book's target is a Flask app whose file route takes a path parameter and opens it, so an encoded ../etc/shadow reads the password file; the same book stages a cross-site scripting attack and its cure, leaving the template engine's autoescaping on and never trusting user input.[36] A machine learning guide serves a Keras model from a Flask POST route and deploys it to App Engine with one command.[37] A clean-architecture text uses Flask as the web layer over a domain model kept free of frameworks, with SQLAlchemy and PostgreSQL or MongoDB behind repositories.[33] FastAPI, built on type hints and async, serves a BERT model in a PyTorch project book,[38] Streamlit turns a model into a web page with no web code,[32] and the ecosystem survey lists Flask, FastAPI, Django, Dash and Pyramid with pros and cons.[4] At the architectural end, a 2026 book presents event sourcing as a pattern language in fifteen chapters of working Python, from domain events and aggregates through event stores and snapshots to process managers, as a companion to the author's eventsourcing library.[39]

Three toolkits cover the desktop. Tkinter is in the standard library, builds IDLE,[1] and suffices for a tic-tac-toe game with a computer opponent.[11] wxPython binds the C++ wxWidgets toolkit, first released in 1998, and draws native widgets on Windows, Mac and Linux; its hello world creates a wx.App, a wx.Frame for the window and a wx.Panel inside it, which is what makes tabbing between widgets work, then enters MainLoop(), and real code puts frame and panel into classes calling super().[9] PyQt5 wraps Qt: widgets and layouts, signals and slots, Qt Designer, database-backed views, plotting with PyQtGraph and matplotlib, threads and packaging.[40] Qt's other binding, PySide, is the interface toolkit of film and games pipelines.[41]

ReportLab has generated PDFs from Python since 2000, and Wikipedia's "Download as PDF" is built on it. Its pdfgen canvas is painted in points, 72 to the inch, from the bottom-left corner, so a US letter page is 612 by 792; a five-line program creates a Canvas and calls drawString, showPage and save. Above it sits PLATYPUS for paragraphs, tables and flowables, and beside it PyPDF2, pdfminer and PyFPDF.[7] An introductory text's tutorials run XML, JSON, CSV, SQLite, Excel and PDF.[3] Other writing systems need other tools: Japanese has no spaces between words, so tokenisation is itself the problem, and one book teaches fugashi, a Cython wrapper for the MeCab analyser with the unidic-lite dictionary, from a one-line install through a project that censors proper nouns and unknown words.[42] The survey's text shelf is spaCy, NLTK, TextBlob, CoreNLP and Gensim.[4]