Python reference

Returns a printable representation that escapes non-ASCII characters.

Returns the binary representation of an integer.

Tests whether a value can be called like a function.

Convert between a Unicode code point and a one-character string.

Compiles source into a code object that can be executed later.

Creates a complex number.

Lists the names available on an object, useful for exploration.

Evaluates an expression from a string. Never use it on untrusted input.

Runs statements from a string. Never use it on untrusted input.

Formats a value with a format specification.

Reads an attribute by name, with an optional fallback.

Return the current global and local namespaces as dictionaries.

Tests whether an attribute exists.

Returns the hash of a hashable value.

Formats an integer in hexadecimal or octal.

Returns the identity of an object for its lifetime.

Tests whether a class inherits from another class.

Creates an iterator and reads its next value.

A view over a buffer that avoids copying when slicing binary data.

The base class of every object. Useful as a unique sentinel.

Controls the separator and line ending, which is handy for building output.

The function form of the @property decorator.

Sets an attribute by name.

Creates a slice object that can be reused for indexing.

Returns the __dict__ of an object, or the local namespace.

A mutable sequence of bytes.

An immutable sequence of byte values from 0 to 255.

Decodes bytes into a string.

Builds bytes from a hexadecimal string.

Returns the hexadecimal representation of bytes.

Converts bytes into an integer with a chosen byte order.

Defines equality. Return NotImplemented for unrelated types so Python can try the other side.

The initialiser called after an instance is created. Set attributes here.

The developer representation shown in the REPL and debuggers. It should be unambiguous.

Receives the class instead of the instance. Common for alternative constructors.

Generates __init__, __repr__ and __eq__ from annotated fields. The best default for data holders.

Exposes a method as a read-only attribute, keeping the API clean while adding logic.

A function namespaced in a class that receives neither self nor cls.

Defines a new type. Methods take self as the first parameter.

Special methods hook into Python syntax such as len(), iteration and indexing.

A subclass inherits methods and attributes from its parent.

Calls the parent implementation, usually inside a subclass initialiser.

Builds a dictionary from any iterable of pairs or computation.

Creates a new dictionary with the right side winning on duplicate keys.

Reads a key without raising KeyError. Always pass a default for optional data.

A view of key-value pairs, ideal for iteration.

Views of the keys or values. They reflect later changes to the dictionary.

Removes a key and returns its value. Without a default, a missing key raises KeyError.

Removes and returns the last inserted pair.

Returns the value, inserting the default when the key is missing.

Merges another mapping or key-value pairs into the dictionary.

Iterating yields keys. Iterate items() when you need values too.

A development-time check. Assertions can be stripped with -O, so never use them for validation.

Reads and writes CSV safely, including quoting and newlines.

A named exception lets callers handle your failures precisely.

else runs when no exception occurred; finally always runs for cleanup.

Serialises Python values to JSON and back. Use indent=2 for readable output.

An object-oriented path API that is clearer than string concatenation.

Raises an exception. Re-raise with a bare raise inside an except block to preserve the traceback.

Handles expected failures. Catch the narrowest exception you can act on.

Opens a file and closes it automatically, even when an exception occurs.

Raised when a file or directory does not exist.

Raised when a sequence index is out of range.

Raised when a dictionary key is missing.

Raised when an operation receives an unsupported type.

Raised when a value has the right type but an invalid value.

Raised when dividing by zero.

Release the file handle, or push buffered data to disk. Prefer with blocks.

Reads the whole file, or at most size characters.

Read one line, or every remaining line as a list.

Move the read cursor and report its current position.

Write a string, or an iterable of strings, to a file.

Read the final component, extension-less name, suffix and parent directory.

True when the path exists.

Finds paths matching a pattern.

Tests whether the path is a regular file or a directory.

Iterates the entries in a directory.

Creates a directory, optionally including parents and ignoring an existing one.

Read or write raw bytes.

Read or write a whole text file in one call.

Returns the absolute path with symlinks and .. resolved.

Delete a file or move it to a new path.

Returns a new path with a different extension.

Collects extra positional arguments into a tuple and extra keyword arguments into a dictionary.

Defines a function. The body is indented and return sends a value back.

Supplies a value when the argument is omitted. Never use a mutable default such as [].

The first string in a function, class or module. Tools surface it as documentation.

Functions are first-class objects: pass them, store them and return them.

Arguments after a bare star must be passed by keyword, which keeps call sites readable.

A small anonymous function. Use it for short keys, not for named logic.

Applies or filters lazily. Comprehensions are usually more readable in Python.

Sends a value back to the caller. A function without return returns None.

A Python file imported as a module.

A calendar date without a time.

Parses ISO 8601 dates and times.

Returns a copy with fields replaced, useful for normalising values.

Formats a date or datetime with strftime codes.

Parses a date string with an explicit format.

A time of day without a date.

A duration used for date and time arithmetic.

Converts a local datetime to a Unix timestamp.

A simpler unbounded cache decorator.

Caches a function’s results by arguments. Use it for pure, expensive functions.

Pre-fills arguments to create a specialised function.

Folds an iterable into one value. Prefer sum or a loop when clearer.

Preserves the wrapped function’s name and docstring in a decorator.

Write or read JSON directly from a file object.

Reads an environment variable with an optional default.

Joins path components using the platform separator.

The command-line arguments, with the script name first.

The list of directories Python searches for imports.

Counts values and provides most_common().

A dictionary that creates a default value for missing keys.

A double-ended queue with fast appends and pops on both ends.

Current time, arithmetic and formatting. Store timestamps in UTC and convert for display.

Combine tools instead of indexing manually.

Imports a name directly into the namespace.

A lazy version of a comprehension. It uses constant memory.

Runs code only when the file is executed directly, not when imported.

Loads a module. Import the specific names you need to keep dependencies obvious.

Renames a module or name, which is useful for long module paths.

Iterates several iterables as one without copying.

Groups consecutive items with the same key. Sort by the key first.

Random choices for games and sampling. Use secrets for security-sensitive randomness.

Turns a function into a generator that produces values lazily.

Yields running totals or another running combination.

Every unordered selection of r items.

An infinite counter. Combine it with zip or islice.

Repeats an iterable forever.

Skips values while the predicate holds, then yields the rest.

Takes a slice of an iterator without materialising it.

Every ordered arrangement of r items.

The Cartesian product of the inputs.

Repeats a value a fixed number of times.

Yields values until the predicate first fails.

Splits one iterator into several independent iterators.

Builds a list from a loop in one readable expression.

Returns a new list from a range. Assignment through a slice can replace several items at once.

Adds one value to the end.

Removes every item in place.

Returns a shallow copy. Use copy.deepcopy for nested structures.

Counts occurrences of a value.

Adds every item from another iterable.

Returns the first index of a value, or raises ValueError.

Inserts before an index. Indexes past the end append.

Removes and returns an item. The default is the last one.

Removes the first matching value and raises ValueError when absent.

Reverses in place and returns None.

Sorts in place. sorted() returns a new list instead.

A comprehension inside another builds grids and matrices.

Remove every value, or create an independent shallow copy.

Removes values found in the other set.

Keeps only values also present in the other set.

True when the sets share no values.

True when a contains every value of b.

Removes and returns an arbitrary value.

Keeps values that appear in exactly one set.

Adds every value from another iterable in place.

An immutable set that can be used as a dictionary key.

A tuple whose fields have names. Use dataclasses for methods and defaults.

Values in the first set that are not in the second.

Only the values present in both sets.

Values in exactly one of the sets.

Every value from both sets.

Adds one value. Adding an existing value does nothing.

discard ignores a missing value; remove raises KeyError.

Tests whether every value of a is in b. The <= operator does the same.

Assigns tuple items to names in one step. Use *rest to collect the remainder.

Encodes a string to bytes using a named encoding.

Replaces tab characters with spaces.

Formats using a mapping, which is useful for dictionaries of values.

True when every character is a letter or digit and the string is not empty.

True when every character is in the ASCII range.

True for decimal characters that can form base-10 numbers.

True when the string is a valid Python identifier.

Tests the case of cased characters in the string.

True for numeric characters, including fractions and other scripts.

True when every character can be printed.

True when the string contains only whitespace.

True when each word starts uppercase and the rest is lowercase.

Removes characters from only the left or right side.

Splits around the first separator into before, separator and after.

Removes a prefix only when it is present.

Removes a suffix only when it is present.

Find from the right. rindex raises when the substring is missing.

Splits around the last separator.

Splits from the right, with an optional limit.

Splits on line boundaries and drops the terminators.

Swaps uppercase and lowercase characters.

Maps characters through a translation table.

Returns a developer-facing representation, which is invaluable when debugging strings.

A stronger lower() for case-insensitive comparison across languages.

Pads a string to a width. Useful for simple text tables.

Counts non-overlapping occurrences.

find returns -1 when missing; index raises ValueError.

Older formatting style. New code should prefer f-strings.

Tests whether every character belongs to the category. Empty strings return False.

Joins an iterable of strings. It is the inverse of split.

Replaces every occurrence. Strings are immutable, so it returns a new string.

Splits into a list. With no argument it splits on any whitespace and drops empties.

Tests the beginning or end. Accepts a tuple of options.

Removes whitespace, or the given characters, from both ends.

Title-cases each word or capitalises only the first character.

Changes case. Use casefold() for case-insensitive comparisons.

Repeats a string. Pair it with print for simple separators.

Copies a portion of the string. Negative indexes count from the end.

break exits the loop; continue skips to the next iteration.

Removes a name or an item from a mutable container.

Yields index and value pairs, which removes manual counters.

Formats values into a string. Add :.2f for decimals or :>6 for alignment.

Iterates the values of any iterable. Prefer it over index loops.

Runs the first branch whose condition is true. Conditions are evaluated in order.

Structural pattern matching, available from Python 3.10.

A no-op placeholder that keeps a block syntactically valid.

Produces integers up to but not including stop. It is lazy and does not build a list.

Optional annotations read by tools and editors. They are not enforced at runtime.

A name bound to an object. Python is dynamically typed, but clear names and type hints keep code readable.

Assigns and tests in one expression. Use it to avoid computing a value twice.

Repeats while the condition stays true. Make sure something changes inside.

Pairs values from several iterables and stops at the shortest.

Returns the absolute value.

Tests whether any or all values are truthy. Both short-circuit.

Truth values. Empty containers, 0, None and empty strings are falsy.

A mutable mapping of hashable keys to values. Lookup is fast and insertion order is preserved.

Returns the quotient and remainder together.

Double-precision floating point. Compare money with decimal.Decimal or integer cents.

Arbitrary-precision integers. Division with / always returns a float.

Converts between basic types. Conversion fails with ValueError when the text is invalid.

Tests a value against a type or a tuple of types. Prefers inheritance over exact type.

The number of items in a container, character count in a string.

An ordered, mutable sequence. Use it when order and duplicates matter.

Returns the smallest or largest value. Pass key= for custom ordering.

The absence of a value. Test it with is, not ==.

Raises to a power and can apply a modulus efficiently.

Yields items in reverse order without copying the sequence.

Rounds to the nearest value using banker’s rounding on ties.

An unordered collection of unique hashable values, ideal for membership and de-duplication.

Returns a new sorted list. The original is untouched.

An immutable sequence of Unicode characters.

Adds numbers in an iterable.

Empty containers, zero, None and empty strings are false; most other values are true.

An ordered, immutable sequence. Great for fixed records and dictionary keys.

Returns the type object of a value.