Python Index

Browse all 1,283 Python keywords, built-in functions, standard library modules, and popular packages.

1,283

Items

83

Categories

11,547

Total Pages

Keyword

35

Boolean literal representing false/0

Represents the absence of a value; Python's null equivalent

Boolean literal representing true/1

Logical AND operator; returns True if both operands are true

Creates an alias (used with import, with, except)

Debugging aid that tests a condition and raises AssertionError if false

Declares an asynchronous coroutine function or context manager

Pauses execution of an async coroutine until a result is available

Exits the nearest enclosing for or while loop immediately

Defines a new class (blueprint for creating objects)

Skips the rest of the current loop iteration and moves to the next

Defines a new function or method

Deletes a variable, list item, dictionary entry, or object attribute

Short for 'else if'; adds another condition to an if chain

Catch-all branch when preceding if/elif conditions are all false

Catches and handles exceptions raised in a try block

Block that always executes after try/except, used for cleanup

Starts a loop that iterates over a sequence or iterable

Used with import to bring in specific names from a module

Declares a variable inside a function as belonging to the global scope

Starts a conditional statement; executes block only if condition is true

Loads a module or package into the current namespace

Membership test operator; also used in for loops to iterate over items

Identity operator; tests whether two variables reference the same object

Creates a small anonymous (unnamed) function in a single expression

Declares a variable inside a nested function as belonging to the enclosing scope

Logical NOT operator; inverts a boolean value

Logical OR operator; returns True if at least one operand is true

A no-op placeholder; does nothing, used where syntax requires a statement

Throws an exception manually

Exits a function and optionally sends a value back to the caller

Starts a block of code that will be monitored for exceptions

Starts a loop that repeats as long as its condition is true

Wraps a block with a context manager for automatic setup/teardown

Pauses a generator function and produces a value to the caller

Soft Keyword

4

Begins a structural pattern matching block (3.10+)

Defines a pattern branch inside a match statement (3.10+)

Declares a type alias (3.12+)

Wildcard pattern in match/case; catches anything

Built-in Function

71

Returns the absolute value of a number

Returns an asynchronous iterator from an async iterable

Returns True if every element in an iterable is truthy

Retrieves the next item from an async iterator

Returns True if at least one element in an iterable is truthy

Returns a string with non-ASCII characters escaped

Converts an integer to a binary string prefixed with '0b'

Converts a value to a Boolean (True or False)

Drops into the debugger at the point of the call

Creates a mutable sequence of bytes

Creates an immutable sequence of bytes

Returns True if the object appears callable (has __call__)

Returns the character for a given Unicode code point

Transforms a method so it receives the class as its first argument

Compiles source code into a code object for exec() or eval()

Creates a complex number (e.g. 3+4j)

Deletes a named attribute from an object

Creates a new dictionary

Lists the names (attributes and methods) of an object or current scope

Returns both the quotient and remainder of integer division

Adds a counter to an iterable, yielding (index, value) pairs

Evaluates a string as a Python expression and returns the result

Executes a string or code object as Python statements

Returns elements from an iterable for which a function returns True

Converts a value to a floating-point number

Formats a value according to a format specification string

Creates an immutable set

Returns the value of a named attribute of an object

Returns a dictionary of the current global symbol table

Returns True if an object has the given named attribute

Returns the hash value of an object (used in dicts and sets)

Invokes the built-in help system for an object or topic

Converts an integer to a hexadecimal string prefixed with '0x'

Returns the unique identity (memory address) of an object

Reads a line of text from the user via the console

Converts a value to an integer

Returns True if an object is an instance of a given class or tuple of classes

Returns True if a class is a subclass of another class

Returns an iterator object from an iterable

Returns the number of items in a container

Creates a new list or converts an iterable into a list

Returns a dictionary of the current local symbol table

Applies a function to every item in an iterable and returns an iterator

Returns the largest item in an iterable or among arguments

Creates a memory view object for binary data without copying

Returns the smallest item in an iterable or among arguments

Retrieves the next item from an iterator

Base class for all Python classes; returns a featureless object

Converts an integer to an octal string prefixed with '0o'

Opens a file and returns a file object for reading or writing

Returns the Unicode code point for a single character

Returns base raised to a power, optionally with modulus

Outputs text or values to the console

Creates a managed attribute with getter, setter, and deleter

Generates an immutable sequence of integers

Returns a developer-friendly string representation of an object

Returns a reverse iterator over a sequence

Rounds a number to a given number of decimal places

Creates a new mutable set of unique elements

Sets the value of a named attribute on an object

Creates a slice object for use in extended indexing

Returns a new sorted list from any iterable

Transforms a method so it doesn't receive the instance or class

Converts a value to a string

Returns the total of all items in an iterable

Returns a proxy object that delegates calls to a parent class

Creates a new immutable tuple

Returns the type of an object, or creates a new type dynamically

Returns the __dict__ attribute of an object

Combines multiple iterables element-wise into tuples

Low-level function invoked by the import statement

Built-in Constant

3

A special constant used as a placeholder (e.g. in type hints and slicing)

Returned by special methods to indicate an operation is not supported

True under normal execution; False when run with -O flag

Built-in Exception

56

Root base class for all exceptions including KeyboardInterrupt and SystemExit

Base class for all non-exit exceptions; used to define custom exceptions

ArithmeticError

Base class for arithmetic errors (ZeroDivisionError, OverflowError, etc.)

Base class for lookup errors (KeyError, IndexError)

Raised when a function receives an argument of the right type but wrong value

Raised when an operation is applied to an object of inappropriate type

Raised when a dictionary key is not found

Raised when a sequence index is out of range

Raised when an attribute reference or assignment fails

Raised when a variable name is not found in scope

FileNotFoundError

Raised when trying to open a file that doesn't exist

Raised when an import statement fails to find a module

ModuleNotFoundError

Subclass of ImportError; raised when a module cannot be located

Raised when an error doesn't fit any other category

Raised by next() to signal that an iterator is exhausted

StopAsyncIteration

Raised by __anext__() to signal an async iterator is exhausted

Raised when a generator's close() method is called

ZeroDivisionError

Raised when dividing or modding by zero

Raised when an arithmetic result is too large to represent

Raised when the maximum recursion depth is exceeded

PermissionError

Raised when an operation lacks sufficient access rights

Raised when a system function times out

NotImplementedError

Raised to indicate an abstract method must be overridden

KeyboardInterrupt

Raised when the user presses Ctrl+C

Raised by sys.exit(); used to exit the interpreter

Base class for OS-related errors

Alias for OSError; raised on I/O failures

Raised when the parser encounters invalid Python syntax

IndentationError

Raised when indentation is incorrect

Raised when tabs and spaces are mixed inconsistently

Base class for Unicode encoding/decoding errors

UnicodeDecodeError

Raised when decoding bytes to a string fails

UnicodeEncodeError

Raised when encoding a string to bytes fails

Raised when a buffer-related operation fails

Raised when input() hits end-of-file without reading data

Raised when an operation runs out of memory

ConnectionError

Base class for connection-related errors

BrokenPipeError

Raised when writing to a pipe whose other end has closed

ConnectionResetError

Raised when a connection is reset by the remote host

ConnectionRefusedError

Raised when a connection attempt is refused

ConnectionAbortedError

Raised when a connection attempt is aborted

FileExistsError

Raised when trying to create a file that already exists

IsADirectoryError

Raised when a file operation is attempted on a directory

NotADirectoryError

Raised when a directory operation is attempted on a non-directory

InterruptedError

Raised when a system call is interrupted by a signal

ProcessLookupError

Raised when a process specified by PID doesn't exist

ChildProcessError

Raised when an operation on a child process fails

BlockingIOError

Raised when a non-blocking I/O operation would block

Groups multiple exceptions together (3.11+); used with except*

Base class for warning categories

DeprecationWarning

Warning about features to be removed in future versions

Warning about behavior changes in future versions

Default category for warnings issued by the user

Warning about suspicious syntax

Warning about suspicious runtime behavior

ResourceWarning

Warning about resource management issues

Dunder Method

61

Constructor; called when a new instance is created to initialize its attributes

Creates and returns a new instance before __init__ is called

Destructor; called when the object is about to be garbage collected

Returns a human-readable string representation (used by print and str())

Returns an unambiguous developer-facing string representation

Called by len(); returns the number of items in the object

Enables indexing with square brackets (obj[key])

Enables item assignment with square brackets (obj[key] = value)

Enables item deletion with del obj[key]

Returns an iterator; makes the object usable in for loops

Returns the next value from an iterator; raises StopIteration when done

Called by the 'in' operator to test membership

Makes an instance callable like a function (obj())

Called at the start of a with block; returns the context resource

Called at the end of a with block; handles cleanup and exceptions

Defines behavior for the == equality operator

Defines behavior for the != inequality operator

Defines behavior for the < less-than operator

Defines behavior for the > greater-than operator

Defines behavior for the <= operator

Defines behavior for the >= operator

Defines behavior for the + addition operator

Defines behavior for the - subtraction operator

Defines behavior for the * multiplication operator

Defines behavior for the / true division operator

Defines behavior for the // floor division operator

Defines behavior for the % modulo operator

Defines behavior for the ** power operator

Defines behavior for the & bitwise AND operator

Defines behavior for the | bitwise OR operator

Defines behavior for the ^ bitwise XOR operator

Defines behavior for the ~ bitwise NOT operator

Defines behavior for the unary - negation operator

Defines behavior for the unary + positive operator

Called by abs(); returns the absolute value

Called by bool(); defines truthiness of the object

Returns the hash value; required for dict key or set member

Called when the default attribute access fails

Called on every attribute assignment

Called when deleting an attribute with del

Called by format() and f-strings for custom formatting

Called by bytes(); returns a bytes representation

Called by int(); returns an integer representation

Called by float(); returns a float representation

Called by complex(); returns a complex number representation

Returns an integer for use in slicing and bin()/hex()/oct()

Called by dict subclasses when a key is not found

Descriptor protocol: called to get an attribute of the owner class

Descriptor protocol: called to set an attribute on the owner class

Descriptor protocol: called to delete an attribute on the owner class

__init_subclass__

Called when a class is subclassed; hook for parent class customization

__class_getitem__

Called for subscripting a class (e.g. list[int]); used in generics

Returns an async iterator from an async iterable

Returns the next value from an async iterator

Async version of __enter__ for async with blocks

Async version of __exit__ for async with blocks

Returns an iterator for use with the await expression

Returns the memory size of the object in bytes

Helper for pickling; returns reconstruction info

Called by copy.copy() for shallow copying

Called by copy.deepcopy() for deep copying

Dunder Attribute

17

Reference to the class that an instance belongs to

Dictionary holding an object's writable attributes

The docstring of a module, class, method, or function

The name of a module; equals '__main__' when run as a script

Restricts instance attributes to a fixed set for memory savings

List of public names exported by a module with 'from module import *'

The file path from which a module was loaded

Tuple of base classes of a class

Method Resolution Order; the order in which base classes are searched

__annotations__

Dictionary of type annotations for a function or class

Convention for storing a package or module's version string

The name of the package a module belongs to

The loader object that loaded the module

The module spec used to import the module

List of paths where a package's submodules can be found

Path to the compiled bytecode (.pyc) file of the module

Qualified name of a class or function (includes enclosing scope)

Stdlib — Data

12

Specialized containers: deque, Counter, defaultdict, OrderedDict, ChainMap, namedtuple

Efficient arrays of numeric values; more compact than lists

Heap queue algorithm (priority queue) on plain lists

Binary search and sorted-list insertion functions

Thread-safe FIFO, LIFO, and priority queues

Names for built-in types and dynamic type creation utilities

Shallow and deep copy operations for objects

Pretty-printer for data structures

Support for enumerations — named symbolic constants

Decorator for auto-generating class boilerplate (__init__, __repr__, etc.)

Topological sorting of directed acyclic graphs

Pack and unpack binary data (C-style structs) to/from bytes

Stdlib — Text

8

Common string constants (ascii_letters, digits) and Template class

Regular expression matching, searching, and substitution

Text wrapping and filling to a given line width

Helpers for computing deltas and comparing sequences

Access to the Unicode Character Database

Codec registry for encoding/decoding text and binary data

Interface to GNU readline for line-editing in the terminal

Tab-completion for the interactive interpreter

Stdlib — Math

7

Mathematical functions: sqrt, sin, cos, log, factorial, pi, e, inf, nan

Mathematical functions for complex numbers

Arbitrary-precision decimal floating-point arithmetic

Rational number arithmetic (exact fractions like 1/3)

Basic statistical functions: mean, median, mode, stdev, variance

Pseudo-random number generation, shuffling, and sampling

Cryptographically strong random numbers for tokens and passwords

Stdlib — OS/File

16

Interface to the OS: env vars, process management, file operations

Pathname manipulations: join, split, exists, isfile, isdir, abspath

Object-oriented filesystem paths (modern replacement for os.path)

High-level file operations: copy, move, remove trees, archives

Unix-style pathname pattern expansion (wildcards like *.txt)

Filename matching with shell-style wildcards

Create temporary files and directories that auto-clean up

Iterate over lines from multiple input streams or files

Compare files and directories for equality

Interpret results of os.stat() (permissions, size, timestamps)

Core I/O tools: StringIO, BytesIO, and file I/O class hierarchy

Interpreter variables: argv, path, stdin, stdout, exit

Retrieve platform info (OS name, version, architecture)

Memory-mapped file support for efficient large file access

File control and I/O control on Unix file descriptors

POSIX terminal I/O control

Stdlib — Date/Time

4

Classes for dates and times: date, time, datetime, timedelta

Time access: sleep, monotonic, perf_counter, strftime

Calendar functions: month/year calendars, weekday, leap years

Concrete IANA time zone support (3.9+)

Stdlib — Serialization

12

Encode and decode JSON data

Read and write CSV files

Serialize/deserialize Python objects to binary format

Persistent dictionary backed by pickle and dbm

Internal object serialization (used for .pyc files)

Read and write INI-style configuration files

Parse TOML configuration files (read-only, 3.11+)

xml.etree.ElementTree

Lightweight XML parsing and creation

xml.dom.minidom

Minimal DOM implementation for XML

Event-driven SAX XML parsing for large documents

Encode/decode binary data as base64/base32/base16 text

Convert between binary and ASCII-encoded representations

Stdlib — Networking

21

Low-level TCP/UDP socket interface

TLS/SSL wrapper for sockets; enables HTTPS

Low-level HTTP protocol client

Basic HTTP server for development and testing

HTTP cookie handling: parsing and generating headers

Open URLs: HTTP GET/POST, auth, proxies, redirects

Parse and construct URLs: urlparse, urlencode, quote

Exception classes for urllib.request errors

urllib.robotparser

Parse robots.txt files for crawling permissions

FTP protocol client for file transfers

SMTP protocol client for sending email

IMAP4 protocol client for reading email

POP3 protocol client for retrieving email

Construct, parse, and manipulate email messages

HTML entity escaping and unescaping

Simple HTML and XHTML parser

XML-RPC client for remote procedure calls

XML-RPC server framework

Framework for building network servers

Create and validate IPv4 and IPv6 addresses and networks

Open URLs in the user's default web browser

Stdlib — Concurrency

8

Thread-based parallelism: Thread, Lock, RLock, Semaphore, Event, Condition

multiprocessing

Process-based parallelism: Process, Pool, Queue, shared memory

concurrent.futures

High-level async execution: ThreadPoolExecutor, ProcessPoolExecutor

Async I/O: event loop, coroutines, tasks, streams, queues

Spawn and manage child processes: run(), Popen, pipes

Set handlers for OS signals (SIGINT, SIGTERM, etc.)

General-purpose event scheduler for timed callbacks

High-level I/O multiplexing (select/poll/epoll/kqueue)

Stdlib — Security

3

Secure hashing: SHA-256, SHA-512, MD5, BLAKE2

Keyed-hash message authentication codes

Prompt for password without echoing to terminal

Stdlib — Testing

7

Built-in unit testing framework (TestCase, assertions, runners)

Mock objects for tests (Mock, MagicMock, patch)

Test code examples embedded in docstrings

Interactive Python debugger: breakpoints, stepping, inspection

Print and format stack traces for exceptions

Dump tracebacks on crash (segfault, timeout, signal)

Issue and control warning messages

Stdlib — Profiling

4

Measure execution time of small code snippets

Deterministic profiler for function call frequency and duration

Pure-Python profiler (slower but extensible)

Trace memory allocations to find leaks

Stdlib — Functional

3

Higher-order functions: lru_cache, partial, reduce, wraps, singledispatch

Iterator building blocks: chain, cycle, product, permutations, groupby

Standard operators as functions: itemgetter, attrgetter, add, mul

Stdlib — Compression

6

Read and write ZIP archives

Read and write tar archives (.tar.gz, .tar.bz2)

Read and write gzip-compressed files

Read and write bzip2-compressed files

Read and write LZMA/XZ-compressed files

Low-level compression using the zlib/deflate algorithm

Stdlib — i18n

2

Locale-aware formatting for numbers, currency, and dates

Internationalization via message catalogs

Stdlib — Typing

3

Type hint support: List, Dict, Optional, Union, Any, Callable, Generic, Protocol

typing_extensions

Backports of new typing features for older Python versions

Abstract Base Classes: define interfaces subclasses must implement

Stdlib — Introspection

12

Inspect live objects: source code, signatures, class hierarchies

Disassemble Python bytecode to human-readable instructions

Parse Python source into an Abstract Syntax Tree

Garbage collector interface: enable/disable, find reference cycles

Weak references that don't prevent garbage collection

Programmatic import system: dynamic imports, reload, hooks

Utilities for finding and iterating over packages

Site-specific configuration: user site-packages, .pth files

Constants for Python parse tree token types

Tokenize Python source code into individual tokens

Access the compiler's symbol table for analysis

Byte-compile all .py files in a directory tree

Stdlib — CLI

4

Parse command-line arguments with type checking and help messages

C-style command-line option parsing

Split and quote strings using shell-like syntax rules

Framework for building line-oriented command interpreters

Stdlib — Misc

15

Flexible logging: loggers, handlers, formatters, levels

Context manager utilities: @contextmanager, suppress, ExitStack

Generate universally unique identifiers (UUID1, UUID4, UUID5)

Register cleanup functions for interpreter shutdown

Call functions in C shared libraries directly from Python

multiprocessing.shared_memory

Shared memory for direct access between processes (3.8+)

Access Python configuration info: paths, compile flags, platform

Create lightweight virtual environments

Bootstrap pip into a Python installation

Create executable Python zip archives (.pyz files)

Compile Python source files to bytecode

Read and write Apple plist (property list) files

Read IFF chunked data (audio formats like WAV, AIFF)

Convert between color systems: RGB, HSV, HLS, YIQ

Turtle graphics for learning and simple drawing

Stdlib — Database

2

Built-in SQLite database interface; no server needed

Simple dictionary-like interface to DBM-style databases

Stdlib — GUI

4

Standard Python GUI toolkit (Tcl/Tk bindings)

Themed widgets for tkinter with native OS look and feel

tkinter.messagebox

Pop-up message box dialogs in tkinter

tkinter.filedialog

File open/save dialog windows in tkinter

Package — Web Framework

18

Lightweight micro-framework for web apps and APIs with Jinja2 templates

Full-stack web framework with ORM, admin panel, auth, templates, migrations

Modern async API framework with automatic OpenAPI docs and Pydantic validation

Lightweight ASGI framework; the foundation under FastAPI

Async web framework with built-in event loop

Single-file micro-framework for small web applications

Flexible framework suited to both small apps and large projects

Async web framework designed for fast HTTP responses

Async HTTP client/server framework on asyncio

High-performance ASGI framework with dependency injection and OpenAPI

Minimalist, high-performance REST API framework

Mature object-oriented web framework with built-in HTTP server

API framework that auto-generates documentation from type annotations

ASGI web framework combining best ideas from Flask and Falcon

Async reimplementation of Flask using ASGI instead of WSGI

Build APIs from OpenAPI/Swagger specs with automatic validation

Fast async ASGI web framework inspired by ASP.NET Core

Async Python web framework with a Rust runtime for speed

Package — HTTP

13

Simple HTTP library for GET, POST, PUT, DELETE requests

Modern HTTP client with async support, HTTP/2, requests-like API

Low-level HTTP client with connection pooling, retries, thread safety

WebSocket servers and clients with asyncio

Python bindings for gRPC high-performance RPC framework

Python interface to libcurl for advanced HTTP operations

Event-driven networking engine: protocols, transports, deferreds

Python bindings for ZeroMQ distributed messaging

Python client for NATS messaging system

RabbitMQ client library implementing AMQP 0-9-1

Messaging library for Python; abstraction over AMQP, Redis, SQS

Coroutine-based networking library using greenlets

Concurrent networking library using green threads

Package — Scraping

12

HTML/XML parser for extracting data from web pages

Full-featured web crawling and scraping framework

Browser automation for testing and scraping dynamic JS pages

Modern browser automation by Microsoft; Chromium, Firefox, WebKit

Fast XML and HTML parsing with XPath and XSLT support

Programmatic web browsing: navigate, fill forms, handle cookies

Fast HTTP parsing toolkit (used by uvicorn)

Scrapy's selector library standalone; CSS and XPath selectors on HTML/XML

HTML parsing integrated into requests; JavaScript rendering support

Article extraction and text scraping from news websites

Parse RSS and Atom feeds from blogs and news sites

Extract main text content from web pages; robust article extraction

Package — Data Science

21

N-dimensional arrays, vectorized math, linear algebra, FFT

Data manipulation with DataFrame and Series structures

Lightning-fast DataFrame library written in Rust

Scientific computing: optimization, integration, signal processing, statistics

Symbolic mathematics: algebra, calculus, equation solving

Statistical modeling: regression, time series, hypothesis tests, ANOVA

Parallel computing scaling pandas, NumPy, scikit-learn to clusters

Out-of-core DataFrames for lazy computation on billion-row datasets

Labeled multi-dimensional arrays for scientific data

Apache Arrow bindings: columnar data, Parquet I/O, zero-copy

Drop-in pandas replacement that parallelizes operations across cores

GPU-accelerated DataFrame library by NVIDIA (RAPIDS)

Fast data manipulation for large datasets (inspired by R data.table)

Python API for Apache Spark distributed data processing

Pandas-like API on Apache Spark (now merged into PySpark)

Read and write HDF5 binary data files for large datasets

PyTables: manage HDF5 datasets with advanced querying

Fast, lightweight columnar data format for DataFrames

Graph and network analysis: algorithms, generation, visualization

High-performance graph library for large-scale network analysis

Efficient graph analysis with C++ backend and Python interface

Package — Visualization

23

Comprehensive 2D/3D plotting; foundation of Python data viz

Statistical visualization on matplotlib with attractive defaults

Interactive browser-based charts and dashboards

Interactive visualization for modern web browsers with streaming

Declarative statistical visualization based on Vega-Lite

Build analytical web dashboards with Plotly

Build data apps with minimal code; auto-reactive UI

Interactive dashboards from notebooks or scripts (HoloViz)

SVG chart library for clean, scalable vector graphics

Declarative data visualization that works with Bokeh and Matplotlib

Render huge datasets into meaningful images (millions/billions of points)

Interactive Leaflet.js maps in Python (choropleth, markers, heatmaps)

Large-scale 3D geospatial visualization powered by deck.gl

Geospatial data in pandas: GeoDataFrame, spatial operations, plotting

Grammar of graphics for Python (ggplot2 port)

Generate word clouds from text data

Visualize missing data patterns in datasets

Python interface to Graphviz for graph/digraph rendering (DOT language)

3D animations and visualizations in the browser for physics/education

3D scientific data visualization using VTK

High-performance interactive 2D/3D visualization using OpenGL

Fast real-time plotting and scientific graphics with Qt

Programmatically generate SVG images and animations

Package — ML

33

Classification, regression, clustering, preprocessing, pipelines, model selection

Gradient boosting framework optimized for speed and performance

Fast gradient boosting by Microsoft for large datasets

Gradient boosting by Yandex; handles categorical features natively

Hyperparameter optimization with pruning and visualization

Distributed hyperparameter optimization using Bayesian methods

ML experiment tracking, model registry, and deployment platform

Weights & Biases: experiment tracking and collaboration for ML

Lightweight pipelining: memory caching and parallel execution

Imbalanced-learn: SMOTE and other tools for imbalanced datasets

Online/streaming machine learning for real-time data

Low-code ML library: automates comparison, tuning, and deployment

Automated machine learning using scikit-learn pipelines

Automated ML that optimizes pipelines using genetic programming

Feature engineering and selection for scikit-learn pipelines

category-encoders

Categorical variable encoding (target, ordinal, binary, hashing, etc.)

SHAP values for interpreting ML model predictions

Local Interpretable Model-agnostic Explanations for ML models

Debug and explain ML classifiers and regressors

Visual analysis and diagnostic tools for scikit-learn models

Decision tree visualization and interpretation

Time series machine learning: classification, regression, forecasting

Time series machine learning: DTW, clustering, classification

Hidden Markov Models for sequence modeling

Probabilistic models: Bayesian networks, HMMs, GMMs, Markov chains

Fast online learning for large-scale problems

Recommendation systems: collaborative filtering algorithms

Fast collaborative filtering for implicit feedback datasets

Approximate Nearest Neighbors for fast similarity search

Facebook AI Similarity Search: billion-scale vector similarity

Uniform Manifold Approximation: dimensionality reduction and visualization

Hierarchical density-based clustering (better than DBSCAN)

Extensions for scikit-learn: plotting, feature selection, stacking

Package — Deep Learning

25

PyTorch: dynamic neural networks with GPU acceleration by Meta

End-to-end ML platform by Google: neural networks, TPU support

High-level neural network API; multi-backend (TF, PyTorch, JAX)

High-performance numerical computing with auto-differentiation by Google

Neural network library built on JAX

Hugging Face: state-of-the-art NLP/vision/audio models (BERT, GPT, etc.)

Open Neural Network Exchange: interoperable model format

High-performance inference engine for ONNX models

PyTorch datasets, model architectures, and transforms for vision

PyTorch audio processing: datasets, transforms, models

PyTorch text processing: datasets, tokenization, vocabularies

PyTorch Lightning: structured deep learning training framework

Hugging Face library for multi-GPU, TPU, and mixed-precision training

Microsoft deep learning optimization: ZeRO, model parallelism

PyTorch extensions for high-performance large-scale training

PyTorch Image Models: 700+ pretrained vision model architectures

Meta AI platform for object detection and segmentation

OpenMMLab detection toolbox: 200+ models for object detection

segmentation-models-pytorch

Neural network architectures for image segmentation

Flexible tensor operations with readable Einstein notation

Safe, fast tensor serialization format (replacing pickle for models)

8-bit optimizers and quantization for large model training

Parameter-Efficient Fine-Tuning (LoRA, prefix tuning, adapters)

Transformer Reinforcement Learning: RLHF and PPO for LLMs

OpenAI Triton: write custom GPU kernels in Python

Package — NLP

18

Industrial NLP: tokenization, NER, POS tagging, dependency parsing

Natural Language Toolkit: text processing, corpora, classification

Topic modeling: Word2Vec, Doc2Vec, LDA, TF-IDF

Simple NLP: sentiment analysis, translation, noun phrases

sentence-transformers

Dense embeddings for sentences using transformer models

Fast BPE tokenizer used by OpenAI models

Hugging Face fast tokenizer library (Rust backend)

State-of-the-art NLP: NER, POS, classification with contextual embeddings

Stanford NLP library: 70+ language support, NER, parsing, sentiment

Multilingual NLP: language detection, NER, sentiment, transliteration

Detect the language of a text string (port of Google's library)

Facebook library for text classification and word embeddings

Web mining, NLP, machine learning, network analysis, and visualization

Automatic text summarization: LSA, LexRank, TextRank, etc.

ROUGE metrics for evaluating text summarization quality

BLEU score computation for machine translation evaluation

Convert text to phoneme sequences for speech processing

Hyphenation library based on OpenOffice dictionaries

Package — LLM/AI

26

Framework for LLM applications: chains, agents, retrieval

Data framework for connecting LLMs to external data (RAG)

Official Python client for OpenAI API (GPT, DALL-E, Whisper)

Official Python client for Anthropic's Claude API

Open-source vector database for embedding storage and retrieval

Managed vector database for semantic search

Constrained generation and templating for language models

Multi-agent conversation framework for AI workflows

Framework for orchestrating autonomous AI agent teams

semantic-kernel

Microsoft SDK for integrating LLMs into applications

Unified API to call 100+ LLM providers (OpenAI, Anthropic, etc.)

High-throughput LLM serving engine with PagedAttention

llama-cpp-python

Python bindings for llama.cpp: run LLMs locally on CPU/GPU

Python bindings for GGML transformer models

Structured generation: constrain LLM output to JSON, regex, grammars

Structured outputs from LLMs using Pydantic models

Add validation and structure to LLM outputs

All-in-one embeddings database for semantic search, LLM pipelines

NLP framework for building search, QA, and RAG pipelines

weaviate-client

Python client for Weaviate vector search engine

Python client for Qdrant vector similarity search engine

Python SDK for Milvus open-source vector database

LangChain's platform for tracing, testing, and monitoring LLM apps

Microsoft toolkit for building and evaluating LLM workflows

Framework for programming (not prompting) language models

AI engineering toolkit: AI functions, classifiers, extractors

Package — Vision

19

OpenCV: real-time computer vision, image processing, video analysis

Python Imaging Library: open, manipulate, save images (JPEG, PNG)

Image processing: filters, morphology, segmentation, features

Read and write images and video in many formats

PyTorch datasets, architectures, transforms for computer vision

Fast image augmentation for training deep learning models

YOLOv8+: real-time object detection and segmentation

Differentiable computer vision library for PyTorch

Image augmentation for ML: geometric, color, blur, noise transforms

Reusable vision tools: annotation, detection zones, tracking

Google's cross-platform ML solutions for face, hands, pose detection

Python wrapper for Tesseract OCR engine

Ready-to-use OCR with 80+ language support

Baidu's OCR toolkit: text detection, recognition, layout analysis

Face recognition and facial attribute analysis framework

face-recognition

Simple face recognition library built on dlib

Open-source 2D/3D face analysis toolkit

3D data processing: point clouds, meshes, RGBD images, visualization

Load and process 3D triangular meshes

Package — Bayesian

17

Bayesian modeling with MCMC/NUTS sampling for posterior inference

Visualization and diagnostics for Bayesian models: trace plots, WAIC, LOO

Bayesian Model Building Interface; R-style formulas on top of PyMC

Python interface to Stan probabilistic programming language

Lightweight interface to CmdStan for Bayesian inference

Bayesian modeling on JAX for GPU-accelerated MCMC sampling

Affine-invariant MCMC ensemble sampler for Bayesian analysis

Deep probabilistic programming on PyTorch (by Uber AI)

tensorflow-probability

Probabilistic reasoning and statistical analysis on TensorFlow

Probabilistic programming language built on TensorFlow

Probabilistic graphical models: Bayesian networks, Markov models

Bayesian network modeling, inference, and learning

Gaussian process framework for regression and optimization

Gaussian processes on TensorFlow for scalable GP models

Gaussian processes on PyTorch with GPU acceleration

Bayesian optimization on PyTorch using GPyTorch

Visualize multidimensional posterior distributions with corner plots

Package — Time Series

13

Facebook's time series forecasting with seasonality and holidays

Fast statistical forecasting: ARIMA, ETS, Theta, CrostonSBA

Neural network-based time series forecasting (Prophet + PyTorch)

Time series library: forecasting, anomaly detection, many models

Automatic time series feature extraction and selection

Auto-ARIMA for Python: automatic seasonal ARIMA model selection

ARCH, GARCH models for financial volatility modeling

Bayesian time series forecasting by Uber

LinkedIn's forecasting library with interpretable models

Meta's toolkit for time series analysis: detection, forecasting, feature extraction

State-of-the-art deep learning for time series (built on fastai)

Amazon's toolkit for probabilistic time series modeling

Scikit-learn compatible time series forecasting with lag features

Package — RL

9

OpenAI Gym successor: standard API for RL environments

stable-baselines3

Reliable RL algorithm implementations: PPO, A2C, SAC, DQN, TD3

Scalable RL library with distributed training on Ray

Modular RL platform built on PyTorch

Single-file RL implementations for education and research

Multi-agent RL environments API

Minimalistic gridworld environments for RL research

Physics simulator for robotics and RL (DeepMind)

Physics simulation for robotics, games, and machine learning

Package — Database

29

SQL toolkit and ORM: engine, session, declarative models, query builder

PostgreSQL adapter: most popular Python driver for PostgreSQL

Next-gen PostgreSQL adapter (psycopg 3) with async support

Pure-Python MySQL client library

Official MongoDB driver for Python

Python client for Redis in-memory data store

Async MongoDB driver for asyncio/Tornado

High-performance async PostgreSQL driver

Small, expressive ORM for SQLite, MySQL, PostgreSQL

Async ORM inspired by Django for asyncio frameworks

SQL databases with Pydantic and SQLAlchemy (by FastAPI creator)

Database migration tool for SQLAlchemy

Async database support for SQLAlchemy Core queries

Official Python client for Elasticsearch

cassandra-driver

DataStax driver for Apache Cassandra

Official Python driver for Neo4j graph database

Community Neo4j driver with OGM and Cypher toolkit

Async Redis client for asyncio applications

Persistent dict backed by SQLite; simple key-value store

Lightweight document-oriented database stored in JSON files

Python bindings for Lightning Memory-Mapped Database

clickhouse-driver

Python driver for ClickHouse columnar analytics database

In-process analytical SQL database (like SQLite for analytics)

Pandas-like API that compiles to SQL for multiple backends

Simple database toolkit: SQLite/PostgreSQL/MySQL with a dict-like API

Document-Object Mapper for MongoDB (Django-style)

Async ODM for MongoDB using Pydantic models

Python client for EdgeDB next-generation graph-relational database

Type-safe database client auto-generated from your schema

Package — Validation

12

Data validation using Python type annotations; settings management

Object serialization/deserialization and validation

Lightweight, extensible data validation

Classes without boilerplate: attributes with validation

Data validation for dictionaries and data structures

Validate JSON data against JSON Schema specifications

Simple data validation library using Python literals

Statistical data validation for pandas DataFrames

great-expectations

Data quality testing and documentation framework

ORM-like models for validating and transforming unstructured data

Runtime type checking for Python functions and arguments

Ultra-fast runtime type checking via decorators

Package — Testing

28

Feature-rich testing: fixtures, parametrize, plugins, auto-discovery

Property-based testing: auto-generates edge-case test inputs

Test across multiple Python versions and environments

Flexible test automation configured with Python

Measure code coverage; shows untested lines/branches

Generate fake data (names, addresses, emails) for testing

Test fixtures: create complex object hierarchies

Mock the requests library for unit testing HTTP

Mock httpx requests in tests

Pytest plugin for testing asyncio coroutines

Load testing: simulate users and measure performance

Pytest plugin for coverage.py integration

Run pytest tests in parallel across multiple CPUs

Thin wrapper around unittest.mock for pytest

pytest-benchmark

Benchmark functions inside pytest with statistics

Pytest plugin for Django projects

Pytest plugin for Flask application testing

Record and replay HTTP interactions for deterministic tests

Mock datetime for testing time-dependent code

Fast datetime mocking (C extension, faster than freezegun)

Mock AWS services for unit testing boto3 code

Spin up Docker containers (databases, brokers) for integration tests

Behavior-driven development (BDD) framework using Gherkin syntax

Robot Framework: keyword-driven test automation for acceptance testing

Property-based testing for APIs using OpenAPI/Swagger specs

Generate mock data from Pydantic models and dataclasses

High-performance fake data generator for 30+ locales

Mutation testing: verify test suite quality by injecting bugs

Package — Cloud/DevOps

26

AWS SDK: S3, EC2, Lambda, DynamoDB, and every AWS service

google-cloud-storage

Google Cloud Storage client library

azure-storage-blob

Azure Blob Storage client library

Docker Engine API SDK: containers, images, volumes, networks

Remote command execution and deployment over SSH

SSH2 protocol library for remote connections and file transfers

IT automation: config management, provisioning, deployment

Distributed task queue for async job processing

Modern workflow orchestration for data pipelines

Apache Airflow: author, schedule, monitor data pipelines

Define cloud infrastructure using Python with Terraform CDK

Infrastructure as code using Python (AWS, Azure, GCP, K8s)

Official Kubernetes client library for Python

Distributed computing framework: scale Python across clusters

Data orchestrator for ML, analytics, and ETL pipelines

Spotify's pipeline framework for batch data processing

Modern data pipeline tool: extract, transform, load with UI

great-expectations

Data quality testing and documentation for pipelines

Pythonic task execution library (modern replacement for Fabric 1.x tasks)

Shell scripting in Python: local/remote commands, CLI building

Process control system: manage long-running processes on Unix

Cross-platform process and system monitoring (CPU, RAM, disk, network)

Error tracking and performance monitoring for production apps

prometheus-client

Instrument Python apps with Prometheus metrics

opentelemetry-api

OpenTelemetry observability: traces, metrics, logs

Datadog API client for monitoring and analytics

Package — CLI

15

Composable CLI toolkit with decorators for options and arguments

Build CLI apps with type hints; built on Click

Auto-generate CLIs from any Python object

Rich text, tables, progress bars, syntax highlighting in terminal

TUI framework: terminal apps with widgets

Build interactive command-line applications and REPLs

Fast, extensible progress bars for loops and iterables

Cross-platform colored terminal text output

Interactive CLI prompts (select, confirm, checkbox, text)

Animated, informative progress bars for the terminal

Pretty-print tabular data as ASCII, HTML, or Markdown tables

Terminal formatting: colors, positioning, keyboard input

Detect the current shell (bash, zsh, fish, etc.)

Tab-completion for argparse-based CLI tools

Auto-generate CLI from function signatures (minimal boilerplate)

Package — GUI

13

Python bindings for Qt GUI framework; desktop application development

Official Qt for Python bindings (LGPL licensed)

Python wrapper for wxWidgets; native cross-platform GUIs

Cross-platform GUI for multi-touch apps (desktop, mobile)

Fast GPU-accelerated GUI for tools and visualizations

Modern extension of tkinter with customizable widgets

Cross-platform apps (web, desktop, mobile) using Flutter widgets

Build web-based GUIs with Python; auto-updates via WebSocket

Build ML demo UIs in minutes: inputs, outputs, sharing

BeeWare's native UI toolkit for Python (cross-platform)

Lightweight cross-platform wrapper for web views (HTML/JS in a window)

Simple Electron-like library for making HTML/JS GUI apps

System tray icon management for desktop applications

Package — Game Dev

10

2D game development: sprites, sounds, input handling, rendering

Windowing and multimedia for games and visualization

Modern 2D game framework with a Pythonic API

3D game engine by Disney/CMU

Easy-to-use 3D game engine built on Panda3D

Visual novel engine for interactive storytelling

Python scripting plugin for the Godot game engine

Retro game engine for making 8-bit style games

2D game framework: scenes, sprites, actions, particle effects

Python bindings for raylib: simple 2D/3D game programming

Package — Media

12

Audio manipulation: cut, concatenate, export, effects

Video editing: cut, concatenate, effects, titles, audio

Python bindings for FFmpeg transcoding and processing

Music and audio analysis: spectrograms, tempo, beat tracking

Play and record audio using PortAudio

ImageMagick bindings for advanced image manipulation

PortAudio bindings for real-time audio I/O

Read and write audio files (WAV, FLAC, OGG, etc.)

Spotify's audio effects library: reverb, compression, EQ, etc.

Audio analysis: pitch detection, onset detection, tempo tracking

Create mathematical animations (3Blue1Brown-style videos)

High-performance video processing with multi-threaded pipelines

Package — Documents

20

Read, merge, split, extract text from PDFs

Create PDF documents: text, tables, charts, images

Extract text, tables, metadata from PDFs

Extract tables from PDFs into pandas DataFrames

Create and modify Word .docx files

Read and write Excel .xlsx files with formulas and formatting

Create and modify PowerPoint .pptx presentations

Extract tables from PDFs using Tabula Java

Write Excel .xlsx files with charts, formatting, and images

Read data from legacy .xls Excel files

Read and write OpenDocument Format files (ODS, ODT, ODP)

Extract text from Word .docx files (simple extraction)

Extract text from any document format (PDF, DOCX, PPTX, etc.)

Convert HTML/CSS to PDF documents

HTML to PDF conversion using wkhtmltopdf

Simple PDF generation library (no dependencies)

Read, write, and manipulate PDF documents in pure Python

File type identification using libmagic (MIME types)

Universal character encoding detector

charset-normalizer

Fast, accurate character encoding detection

Package — Config

16

Parse and emit YAML files

Read and write TOML configuration files

MessagePack: fast compact binary serialization

Google Protocol Buffers: efficient binary serialization

Fast JSON library written in Rust (3-10x faster)

Ultra-fast JSON encoding/decoding in C

Memory-efficient serialization without parsing/unpacking

Apache Avro data serialization with schema evolution

CBOR (Concise Binary Object Representation) encoding/decoding

Structured/unstructured conversion for attrs and dataclasses

YAML 1.2 parser/emitter preserving comments and formatting

Settings management: env vars, TOML, YAML, INI, Redis, Vault

Facebook's configuration framework for complex applications

Hierarchical configuration with merge, interpolation, and validation

python-decouple

Separate settings from code; reads .env and .ini files

Configuration library for reading YAML config with validation

Package — Security

18

Encryption, hashing, key derivation, X.509 certificates

Password hashing using the bcrypt algorithm

Encode, decode, verify JSON Web Tokens

Comprehensive password hashing (30+ schemes)

Generic OAuth 1/2 implementation

JOSE: JWS, JWE, JWK, JWT implementation

OAuth, OpenID Connect, JOSE for clients and servers

Cryptographically sign data for untrusted channels

Mozilla's CA certificate bundle for TLS/SSL verification

Argon2 password hashing (winner of Password Hashing Competition)

Python bindings for libsodium: modern crypto primitives

SSH2 protocol: secure remote connections and SFTP

Poor man's VPN: transparent proxy over SSH

Access the system keyring for secure credential storage

GnuPG interface for encryption, decryption, signing

Security linter: find vulnerabilities in Python code

Check installed packages for known security vulnerabilities

Audit Python environments for packages with known vulnerabilities

Package — Scheduling

7

Advanced scheduler: cron, interval, and date-based jobs

Human-friendly scheduling: schedule.every(10).minutes.do(job)

Redis Queue: simple job queue backed by Redis

Lightweight task queue (Redis, SQLite, in-memory)

Fast, reliable distributed task processing

Async task queue built on Redis and asyncio

Async distributed task framework with multiple brokers

Package — Packaging

20

Build system and distribution tools (setup.py, setup.cfg)

Built-package format for faster installs

Dependency management with lockfile and virtual env

Modern package manager with PEP 582 and lockfiles

Project manager: build, publish, envs, scripts

Simple PyPI publishing with minimal config

Upload packages to PyPI securely

PEP 517 frontend: build sdists and wheels

Ultra-fast Python package installer in Rust

Install CLI tools in isolated environments

Build and publish Rust-based Python packages

Seamless C++/Python interoperability for extension modules

C extensions for Python: compile Python to C for speed

Python compiler: compile to standalone executables

Bundle Python apps into standalone executables

Freeze Python scripts into executables

BeeWare: package Python apps for Windows, macOS, Linux, iOS, Android

Cross-platform package and environment manager (Anaconda)

Display dependency tree of installed packages

Pin and compile requirements with hash checking

Package — Code Quality

21

Extremely fast linter and formatter in Rust; replaces flake8, isort

Opinionated formatter: one canonical Python style

Linting: PyFlakes + pycodestyle + McCabe complexity

Comprehensive static analysis: errors, style, refactoring

Static type checker for Python type annotations

Fast type checker by Microsoft (VS Code Pylance)

Auto-sort and organize import statements

Auto-format to PEP 8 style

Security linter for common vulnerabilities

Git pre-commit hook framework

Find unused code (dead code detection)

Code metrics: cyclomatic complexity, maintainability index

Multi-tool Python code analysis (pylint, pyflakes, mccabe, etc.)

Check Python code against PEP 8 style conventions

Check docstring conventions against PEP 257

Fast, lightweight linting for logical errors (no style)

AI-powered refactoring suggestions for cleaner Python code

Meta's auto-fix linting framework with CST-based rules

Opinionated wrapper combining black, isort, pyupgrade, autoflake

Auto-upgrade Python syntax to newer versions

Remove unused imports and variables automatically

Package — Templates

5

Powerful template engine used by Flask, Ansible, etc.

Fast template library with embedded Python

Fast HTML/XML template engine using TAL

django-templates

Django's built-in template engine with tags and filters

XML/HTML template toolkit with stream processing

Package — Server

8

Lightning-fast ASGI server on uvloop and httptools

Production WSGI server for Flask and Django

ASGI server: HTTP/1, HTTP/2, HTTP/3 (QUIC)

Django Channels ASGI server for WebSocket and HTTP/2

Production pure-Python WSGI server (Windows + Unix)

Ultra-fast asyncio event loop replacement (libuv-based)

Rust-based ASGI/WSGI server for high performance

High-performance WSGI-compliant web server

Package — GraphQL

5

Code-first GraphQL with type hints and dataclasses

Schema-first GraphQL: bind resolvers to SDL schemas

GraphQL framework with Django/Flask integration

Simple GraphQL Client: auto-generate Python classes from schemas

GraphQL client library with sync/async support

Package — Geospatial

15

Geospatial DataFrames: spatial operations, GeoJSON, Shapefile I/O

Geometric objects and operations (points, lines, polygons)

Read and write geospatial vector data (Shapefile, GeoJSON, GPKG)

Cartographic projections and coordinate transformations

Read and write geospatial raster data (GeoTIFF, satellite imagery)

Interactive Leaflet.js maps in Python

Geocoding: convert addresses to lat/lon and vice versa

Download and analyze street networks from OpenStreetMap

Uber's hexagonal hierarchical spatial index

Large-scale geospatial visualization in Jupyter notebooks

Tile map provider database for web maps

Add basemaps to matplotlib/geopandas plots

Movement trajectory analysis on top of geopandas

SpatioTemporal Asset Catalog (STAC) client for satellite data

Tools for working with spatial data in earth science

Package — Finance

20

Download market data from Yahoo Finance (stocks, ETFs, crypto)

Technical analysis indicators for pandas DataFrames

Technical analysis library: 80+ indicators (RSI, MACD, Bollinger)

Python wrapper for TA-Lib: 200+ technical analysis functions

Quantitative finance: derivatives pricing, risk management

Algorithmic trading backtesting framework

Trading strategy backtesting with live trading support

High-performance backtesting and analysis with vectorized operations

alpaca-trade-api

Alpaca API client for commission-free stock/crypto trading

Unified cryptocurrency exchange API (100+ exchanges)

Python client for Federal Reserve Economic Data (FRED)

Binance cryptocurrency exchange API client

Interactive Brokers API for trading and market data

Flexible backtesting framework for quantitative strategies

Portfolio and risk analytics: Sharpe, drawdown, factor exposure

Financial risk metrics: alpha, beta, Sharpe, Sortino, max drawdown

Financial Functions for Python: performance analysis and evaluation

Portfolio analytics and reporting: tearsheets, benchmarks

exchange-calendars

Trading calendars for global financial exchanges

Matplotlib-based financial charting (candlestick, OHLC, volume)

Package — Blockchain

6

Web3.py: interact with Ethereum blockchain (contracts, transactions)

Smart contract development and testing framework for Ethereum

Pythonic smart contract language for the EVM

Solidity compiler wrapper for Python

Ethereum account management: signing, key generation

Ethereum ABI encoding and decoding

Package — Robotics/IoT

11

Python client for ROS (Robot Operating System)

Python client for ROS 2

Python for microcontrollers (ESP32, RP2040, STM32)

Adafruit's Python for microcontroller boards

Simple GPIO interface for Raspberry Pi

Low-level GPIO control for Raspberry Pi

Serial port communication (RS-232, USB serial)

MQTT protocol client for IoT messaging

Bluetooth Low Energy (BLE) client for asyncio

adafruit-circuitpython

Adafruit hardware driver libraries for sensors and displays

Drone programming API for MAVLink-based autopilots

Package — Scientific

20

Astronomy: coordinate transforms, FITS files, cosmology, units

Bioinformatics: sequences, BLAST, PDB, phylogenetics

Cheminformatics: molecule manipulation, fingerprints, descriptors

Molecular dynamics trajectory analysis

Chemical toolbox: format conversion, search, fingerprints

Materials science: crystal structures, phase diagrams, analysis

Atomic Simulation Environment: build, run, analyze atomic simulations

Physical quantities with unit conversion and dimensional analysis

Transparent error propagation for calculations with uncertainties

Finite element computing for PDEs and scientific modeling

Distributed Evolutionary Algorithms in Python

Geophysical simulations and inversions

Seismology framework: waveform analysis, station metadata

Solar physics: solar data analysis, maps, timeseries

RF/microwave engineering: network analysis, calibration

Control systems library: transfer functions, state space, frequency response

Multibody dynamics simulation with SymPy

Chemical kinetics, thermodynamics, and transport processes

Thermophysical properties of fluids (refrigerants, gases, etc.)

Multidisciplinary design analysis and optimization framework

Package — Bioinformatics

10

Single-cell RNA-seq analysis: preprocessing, clustering, visualization

Annotated data matrices for single-cell genomics

Read and manipulate SAM/BAM/CRAM alignment files

Parse and manipulate VCF (Variant Call Format) files

High-throughput sequencing data analysis

Workflow management for reproducible bioinformatics pipelines

Data-driven computational pipeline framework

Bioinformatics algorithms: alignment, diversity, phylogeny

Phylogenetic tree analysis and visualization

Phylogenetic computing: tree manipulation, simulation, analysis

Package — Notebook

12

Interactive computing: notebooks, kernels, widgets

Next-gen Jupyter interface with extensions and file browser

Classic Jupyter Notebook web interface

Enhanced interactive Python shell: magic commands, history, completion

Read, write, and manipulate Jupyter notebook files (.ipynb)

Convert notebooks to HTML, PDF, slides, scripts, etc.

Parameterize and execute Jupyter notebooks programmatically

Turn Jupyter notebooks into standalone web applications

Interactive HTML widgets for Jupyter notebooks

Reactive Python notebook: cells auto-update when dependencies change

Strip output from notebooks for clean version control

Edit Jupyter notebooks as plain Python or Markdown files

Package — Web Auth

18

User session management for Flask applications

flask-jwt-extended

JWT authentication for Flask APIs

Django authentication: social accounts, email verification

django-rest-framework

Powerful toolkit for building REST APIs in Django

Fast Django REST framework with type hints (FastAPI-inspired)

django-cors-headers

Handle CORS headers in Django applications

CORS handling for Flask applications

flask-sqlalchemy

SQLAlchemy integration for Flask

Alembic database migrations for Flask-SQLAlchemy

Build REST APIs quickly with Flask

WebSocket support for Flask via Socket.IO

django-channels

WebSocket and async protocol support for Django

django-celery-beat

Database-backed periodic task scheduler for Celery + Django

Dynamic queryset filtering for Django REST Framework

django-extensions

Custom management commands and utilities for Django

django-debug-toolbar

Debugging panel for Django: SQL queries, templates, signals

Serve static files efficiently in Django/WSGI apps

starlette-admin

Admin interface for Starlette/FastAPI applications

Package — Email

12

SendGrid API client for transactional and marketing email

python-mailchimp

Mailchimp API client for email campaigns

Send email via Amazon SES using boto3

Simple Gmail/SMTP sending with attachments

Modern email sending library with HTML templates

Pythonic IMAP client for reading email

Email address and MIME parsing library by Mailgun

Twilio API: SMS, voice calls, video, WhatsApp messaging

Official Slack API client: messages, events, modals, shortcuts

Discord bot framework: commands, events, voice, interactions

python-telegram-bot

Telegram Bot API wrapper for building Telegram bots

Twitter/X API client: tweets, streams, user management

Package — Reporting

7

HTML/CSS to PDF conversion engine

Convert HTML/CSS to PDF (formerly pisa)

Lightweight PDF generation (no dependencies)

jinja2 + weasyprint

Template HTML reports then render to PDF

Create beautiful publication-quality tables

Interactive DataTables in Jupyter notebooks

dataframe-image

Export pandas DataFrames as images (PNG, PDF)

Package — Caching

7

Extensible memoizing collections: TTL, LRU, LFU cache

Disk-based cache using SQLite; survives restarts

Caching API with pluggable backends (Memcached, Redis, file)

Async caching library: Redis, Memcached, in-memory

Async cache framework with decorators and backends

django-cacheops

Automatic query caching for Django ORM using Redis

Caching extension for Flask applications

Package — Logging

10

Simplified logging with structured output and sane defaults

Structured logging: key-value log events for parsing

python-json-logger

JSON formatter for Python's logging module

Error tracking and performance monitoring

prometheus-client

Prometheus metrics instrumentation

opentelemetry-api

Distributed tracing, metrics, and logs

Elastic APM agent for performance monitoring

New Relic APM agent for Python application monitoring

StatsD client for sending metrics (counters, gauges, timers)

AWS CloudWatch Logs handler for Python logging

Package — API

15

pydantic-settings

Application settings management with Pydantic

Fast HTTP parsing toolkit (powers uvicorn)

python-multipart

Multipart form data parsing for ASGI frameworks

Data signing for secure cookies and tokens

JOSE: JWS, JWE, JWK, JWT for API authentication

Pluggable API specification generator (OpenAPI/Swagger)

Swagger UI integration for Flask APIs

API validation and documentation for Flask/Starlette/Falcon

Ready-to-use user management for FastAPI

fastapi-pagination

Pagination support for FastAPI endpoints

Rate limiting for Starlette and FastAPI

Rate limiting library with multiple storage backends

Function decorator for retries with exponential backoff

Retry library: backoff, wait strategies, stop conditions

Production-grade retry library with sensible defaults

Package — Data Engineering

14

Unified batch and streaming data processing

Apache Kafka client for producing and consuming messages

confluent-kafka

High-performance Kafka client by Confluent

Stream processing library inspired by Kafka Streams

Python stream processing engine built on Rust

ETL: extract, transform, load tabular data

Lightweight ETL framework with a graph-based API

Open-source standard for data integration (taps and targets)

DataOps platform for ELT pipelines using Singer

Data load tool: Python-first ELT library for data pipelines

SQL linter and auto-formatter for data teams

Data build tool: transform data in your warehouse with SQL

Delta Lake: ACID transactions on data lakes

Native Delta Lake reader/writer for Python (no Spark needed)

Package — Search

6

Pure-Python full-text search engine library

elasticsearch-dsl

High-level Elasticsearch query DSL for Python

Python client for Apache Solr search platform

Python client for Typesense typo-tolerant search engine

Python SDK for MeiliSearch instant search engine

Python bindings for Tantivy full-text search engine (Rust)

Package — Generative AI

10

Hugging Face: Stable Diffusion, DALL-E, image generation pipelines

Textual prompt weighting and blending for diffusion models

Auxiliary models for ControlNet (edge detection, pose, depth)

invisible-watermark

Add invisible watermarks to AI-generated images

Coqui TTS: deep learning text-to-speech synthesis

Suno's text-to-audio model: speech, music, sound effects

Meta's audio generation: MusicGen, AudioGen, EnCodec

OpenAI Whisper: speech-to-text transcription and translation

CTranslate2-accelerated Whisper inference (4x faster)

stable-diffusion-webui

AUTOMATIC1111: web UI for Stable Diffusion image generation

Package — Speech

6

speechrecognition

Speech recognition: Google, Sphinx, Whisper, Azure backends

PortAudio bindings for real-time audio capture and playback

Offline speech recognition toolkit (20+ languages)

Speaker embedding and voice cloning analysis

NVIDIA NeMo: ASR, NLP, TTS models and training

End-to-end speech processing toolkit (ASR, TTS, translation)

Package — Utility

37

Drop-in datetime replacement with better timezone and parsing

Human-friendly dates and times

python-dateutil

Datetime extensions: relative deltas, parsing, recurrence

Additional iterator building blocks beyond itertools

230+ pure-Python utilities filling stdlib gaps

Retry library with backoff, wait strategies, stop conditions

Extensible memoizing collections and decorators

Load environment variables from .env files

Simplified logging with structured output

Structured logging for easy parsing and analysis

Subprocess replacement: call shell commands as functions

Monitor filesystem events in real time

Monitor and control keyboard and mouse

Cross-platform clipboard copy and paste

Sanitize and validate filenames and paths

Progress bars for loops and iterables

Human-readable numbers, dates, file sizes, time deltas

Pluralize words, number-to-words, a/an articles

Generate URL-friendly slugs from strings (Unicode support)

Parse, format, validate phone numbers (Google libphonenumber)

ISO databases for countries, languages, currencies, subdivisions

Internationalization: locale data, number/date formatting, translations

Fix broken Unicode text (mojibake, encoding issues)

Drop-in replacement for re with additional features and Unicode support

Reverse of format(): extract data from formatted strings

Functional utilities: curry, pipe, merge, groupby for iterables and dicts

Cython-accelerated version of toolz for performance

Robust decorator and wrapper utilities for Python

Decorator to mark functions and classes as deprecated

Get the currently executing AST node (used by rich tracebacks)

Read, rewrite, and write Python ASTs as source code

Extended pickling: serialize functions, lambdas, closures, classes

Extended pickling for distributed computing (lambdas, closures)

System monitoring: CPU, RAM, disk, network, processes

Get detailed CPU information

Get GPU status: usage, memory, temperature (NVIDIA)

Interactive NVIDIA GPU process viewer and monitor

IDE / Editor

32

JetBrains IDE for Python: smart code completion, debugging, refactoring, testing, VCS integration

PyCharm Community

Free, open-source edition of PyCharm with core Python development features

PyCharm Professional

Paid edition with web frameworks, database tools, scientific tools, remote interpreters

Microsoft's free, extensible code editor; Python support via the Python extension and Pylance

Microsoft's full IDE with Python workload support for debugging, profiling, and mixed-language projects

Scientific Python IDE bundled with Anaconda; variable explorer, inline plots, IPython console

Beginner-friendly Python IDE with step-through debugger, simple UI, and built-in pip manager

Python's built-in IDE: lightweight editor and interactive shell included with every Python install

Jupyter Notebook

Web-based interactive computing: mix code, output, markdown, and visualizations in cells

Next-gen Jupyter interface: tabbed editing, terminal, file browser, extensions

Free cloud-based Jupyter environment by Google with GPU/TPU access

Kaggle Notebooks

Cloud notebooks on Kaggle with free GPU, preinstalled data science packages, and datasets

Amazon SageMaker Studio

AWS cloud IDE for ML: notebooks, experiment tracking, model deployment

Terminal-based editor; Python support via plugins (jedi-vim, coc-pyright, nvim-lspconfig)

Extensible editor; Python support via elpy, lsp-mode, or python-mode packages

Fast, lightweight editor; Python support via LSP, Anaconda plugin, or SublimeLinter

Hackable open-source editor; Pulsar is the community fork after GitHub archived Atom

Python-specific IDE: powerful debugger, code intelligence, remote development

Multi-language IDE by ActiveState with Python debugging, profiling, and regex toolkit

Full-featured Python/Ruby IDE built with PyQt; integrated debugger and profiler

Simple editor for Python beginners, MicroPython, and CircuitPython

Lightweight GTK editor/IDE with Python syntax highlighting and basic code completion

Kate / KDevelop

KDE editors with Python support via LSP; Kate is lightweight, KDevelop is a full IDE

High-performance editor written in Rust with Python LSP support and AI code assistance

AI-first code editor (VS Code fork) with built-in AI pair programming for Python

Cloud IDE and hosting platform: write, run, and deploy Python in the browser

Cloud development environment: automated, prebuilt dev setups in VS Code or JetBrains

GitHub Codespaces

Cloud-hosted VS Code environments launched directly from GitHub repositories

JetBrains IDE designed for data science: notebooks, SQL, scientific Python tools

VS Code-based IDE by Posit (RStudio) for Python and R data science workflows

Reactive Python notebook: cells auto-re-execute when dependencies change

Cloud-based reactive notebooks for data visualization and exploration

IDE Extension

15

Python Extension (VS Code)

Microsoft's official VS Code extension: IntelliSense, linting, debugging, Jupyter, testing

Pylance (VS Code)

Fast type checking, auto-imports, and IntelliSense for VS Code (powered by Pyright)

Python Debugger (VS Code)

Debug Python scripts, tests, and remote processes in VS Code

Jupyter Extension (VS Code)

Run Jupyter notebooks directly inside VS Code with interactive cell output

autoDocstring (VS Code)

Auto-generate Python docstrings in Google, NumPy, or Sphinx format

Python Test Explorer (VS Code)

Discover, run, and debug pytest/unittest tests in the VS Code sidebar

Ruff Extension (VS Code)

Ruff linting and formatting integration for VS Code

Black Formatter (VS Code)

Black code formatting integrated into VS Code's format-on-save

AI pair programmer: code suggestions, completions, chat, and generation in most editors

AI code completion supporting Python in VS Code, PyCharm, and other editors

Free AI code completion and chat for Python in multiple editors

AI-powered Python completions (discontinued but historically significant)

Python autocompletion and static analysis plugin for Vim

coc-pyright (Neovim)

Pyright integration for Neovim via coc.nvim

Emacs Python Development Environment: completion, navigation, refactoring, testing

Dev Tool — VCS

11

Distributed version control system; the standard for all Python projects

Cloud hosting for Git repos: pull requests, Actions CI/CD, issues, Copilot

Self-hosted or cloud Git platform: CI/CD pipelines, container registry, DevSecOps

Atlassian Git hosting: integrates with Jira, Bamboo, and Trello

Python library to interact with Git repositories programmatically

Python bindings for libgit2: low-level Git operations

Framework for managing Git pre-commit hooks (linting, formatting, etc.)

Conventional commits tool: standardize commit messages and auto-generate changelogs

Auto-generate changelogs from Git commit history

Automate version bumping in files and Git tags

semantic-release

Automated versioning and changelog generation based on commit messages

Dev Tool — Docs

16

Python documentation generator: reStructuredText, autodoc, themes, PDF/HTML output

Project documentation with Markdown; simple config, fast builds

MkDocs Material

Popular MkDocs theme with search, dark mode, tabs, and rich formatting

Free documentation hosting: auto-builds from GitHub/GitLab on every push

Auto-generate API docs from Python docstrings (simple alternative to Sphinx)

Built-in documentation generator; run 'pydoc module_name' from the terminal

reStructuredText processing framework (powers Sphinx)

napoleon (Sphinx)

Sphinx extension for Google and NumPy style docstrings

sphinx-autodoc-typehints

Sphinx extension to include type hints in auto-generated docs

sphinx-rtd-theme

Read the Docs theme for Sphinx documentation

Write Sphinx docs in Markdown instead of reStructuredText

Check Python code for missing docstrings and report coverage

API documentation generator used by Twisted and other projects

Auto-generate Markdown API docs from Python source code

Python API documentation loader and parser (powers mkdocstrings)

Auto-generate MkDocs pages from Python docstrings

Dev Tool — CI/CD

12

CI/CD workflows triggered by GitHub events: test, build, deploy Python projects

Built-in CI/CD pipelines in GitLab with YAML configuration

Open-source automation server: build, test, deploy Python projects

Cloud CI/CD platform with Python orbs and Docker support

Hosted CI service; historically popular for open-source Python testing

Hybrid CI/CD: cloud dashboard with self-hosted agents

Test Python packages across multiple environments and versions

Flexible test automation configured with Python (tox alternative)

Classic build automation; commonly used for Python project task runners

Task runner for Python projects defined in pyproject.toml

Command runner (like Make) with simpler syntax; popular in Python/Rust projects

Programmable CI/CD engine: write pipelines in Python that run anywhere

Dev Tool — Deploy

15

Containerize Python apps for consistent deployment across environments

Define multi-container apps (Python app + database + Redis) in YAML

Container orchestration for deploying and scaling Python services

PaaS for deploying Python web apps with git push (Procfile + requirements.txt)

Deploy Python apps globally with Dockerfile or buildpacks

Cloud platform for deploying Python apps with automatic builds

Cloud hosting for Python web apps, APIs, and background workers

Serverless deployment for Python API endpoints and web frameworks

Serverless compute: run Python functions in response to events

Google Cloud Run

Serverless containers: deploy Dockerized Python apps on GCP

Azure Functions

Microsoft's serverless compute for Python event-driven functions

Cloud platform specifically designed for hosting Python web apps

Reverse proxy and load balancer commonly placed in front of Python WSGI/ASGI servers

Process control system for managing Python daemons on Unix

Linux init system: create service files to run Python apps as background services

Python Runtime

15

The reference Python implementation written in C; what you get from python.org

Fast Python implementation with a JIT compiler; 4-10x faster for many workloads

Compile Python to C for performance; write C extensions with Python-like syntax

Lean Python 3 implementation for microcontrollers and embedded systems

Adafruit's MicroPython fork optimized for education and hardware boards

Python running on the JVM; interoperate with Java libraries

Python running on .NET/CLR; interoperate with C# and .NET libraries

Python on GraalVM: high-performance polyglot runtime by Oracle

Stackless Python

CPython fork with microthreads (tasklets) for massive concurrency

CPython compiled to WebAssembly; run Python in the browser

Python interpreter written in Rust; embeddable in Rust applications

High-performance Python compiler using LLVM; near-C speed for numeric code

Compile type-annotated Python to C extensions using mypy's type info

JIT compiler for NumPy code: decorate functions to compile to machine code

High-performance parallel computing: compile Python to GPU/CPU kernels

Ecosystem

19

Python Package Index: the official repository of 500,000+ third-party packages

The default package installer for Python; downloads from PyPI

Cross-platform package and environment manager by Anaconda

Built-in module for creating lightweight virtual environments

Third-party virtual environment creator (more features than venv)

Manage multiple Python versions on a single machine

Multi-language version manager that supports Python via plugin

Python Enhancement Proposals: the design documents that shape Python's evolution

Style guide for Python code: naming, indentation, line length, imports

The Zen of Python: guiding principles (import this)

Type hints specification: introduced function annotations for static typing

Build system standards: pyproject.toml and build backends

Making the GIL optional (free-threaded Python, experimental in 3.13+)

Python Software Foundation: non-profit organization that stewards the Python language

Annual Python conference held worldwide (US, EU, APAC, and regional editions)

Popular tutorial and learning resource site for Python developers

Official Python documentation at docs.python.org

Q&A platform; Python is consistently the most-asked-about language

Curated GitHub list of Python frameworks, libraries, and resources