The default Python prompt of the interactive shell. Often\nseen for code examples which can be executed interactively in the\ninterpreter.
\nThe default Python prompt of the interactive shell. Often\nseen for code examples which can be executed interactively in the\ninterpreter.
\nCan refer to:
\nThe default Python prompt of the interactive shell when entering the\ncode for an indented code block, when within a pair of matching left and\nright delimiters (parentheses, square brackets, curly braces or triple\nquotes), or after specifying a decorator.
The Ellipsis built-in constant.
Abstract base classes complement duck-typing by\nproviding a way to define interfaces when other techniques like\nhasattr() would be clumsy or subtly wrong (for example with\nmagic methods). ABCs introduce virtual\nsubclasses, which are classes that don\u2019t inherit from a class but are\nstill recognized by isinstance() and issubclass(); see the\nabc module documentation. Python comes with many built-in ABCs for\ndata structures (in the collections.abc module), numbers (in the\nnumbers module), streams (in the io module), import finders\nand loaders (in the importlib.abc module). You can create your own\nABCs with the abc module.
A label associated with a variable, a class\nattribute or a function parameter or return value,\nused by convention as a type hint.
\nAnnotations of local variables cannot be accessed at runtime, but\nannotations of global variables, class attributes, and functions\nare stored in the __annotations__\nspecial attribute of modules, classes, and functions,\nrespectively.
See variable annotation, function annotation, PEP 484\nand PEP 526, which describe this functionality.\nAlso see Annotations Best Practices\nfor best practices on working with annotations.
\nA value passed to a function (or method) when calling the\nfunction. There are two kinds of argument:
\nkeyword argument: an argument preceded by an identifier (e.g.\nname=) in a function call or passed as a value in a dictionary\npreceded by **. For example, 3 and 5 are both keyword\narguments in the following calls to complex():
complex(real=3, imag=5)\ncomplex(**{'real': 3, 'imag': 5})\npositional argument: an argument that is not a keyword argument.\nPositional arguments can appear at the beginning of an argument list\nand/or be passed as elements of an iterable preceded by *.\nFor example, 3 and 5 are both positional arguments in the\nfollowing calls:
complex(3, 5)\ncomplex(*(3, 5))\nArguments are assigned to the named local variables in a function body.\nSee the Calls section for the rules governing this assignment.\nSyntactically, any expression can be used to represent an argument; the\nevaluated value is assigned to the local variable.
\nSee also the parameter glossary entry, the FAQ question on\nthe difference between arguments and parameters, and PEP 362.
\nAn object which controls the environment seen in an\nasync with statement by defining __aenter__() and\n__aexit__() methods. Introduced by PEP 492.
A function which returns an asynchronous generator iterator. It\nlooks like a coroutine function defined with async def except\nthat it contains yield expressions for producing a series of\nvalues usable in an async for loop.
Usually refers to an asynchronous generator function, but may refer to an\nasynchronous generator iterator in some contexts. In cases where the\nintended meaning isn\u2019t clear, using the full terms avoids ambiguity.
\nAn asynchronous generator function may contain await\nexpressions as well as async for, and async with\nstatements.
An object created by a asynchronous generator function.
\nThis is an asynchronous iterator which when called using the\n__anext__() method returns an awaitable object which will execute\nthe body of the asynchronous generator function until the next\nyield expression.
Each yield temporarily suspends processing, remembering the\nexecution state (including local variables and pending\ntry-statements). When the asynchronous generator iterator effectively\nresumes with another awaitable returned by __anext__(), it\npicks up where it left off. See PEP 492 and PEP 525.
An object, that can be used in an async for statement.\nMust return an asynchronous iterator from its\n__aiter__() method. Introduced by PEP 492.
An object that implements the __aiter__() and __anext__()\nmethods. __anext__() must return an awaitable object.\nasync for resolves the awaitables returned by an asynchronous\niterator\u2019s __anext__() method until it raises a\nStopAsyncIteration exception. Introduced by PEP 492.
A value associated with an object which is usually referenced by name\nusing dotted expressions.\nFor example, if an object o has an attribute\na it would be referenced as o.a.
\nIt is possible to give an object an attribute whose name is not an\nidentifier as defined by Identifiers and keywords, for example using\nsetattr(), if the object allows it.\nSuch an attribute will not be accessible using a dotted expression,\nand would instead need to be retrieved with getattr().
An object that can be used in an await expression. Can be\na coroutine or an object with an __await__() method.\nSee also PEP 492.
Benevolent Dictator For Life, a.k.a. Guido van Rossum, Python\u2019s creator.
\nA file object able to read and write\nbytes-like objects.\nExamples of binary files are files opened in binary mode ('rb',\n'wb' or 'rb+'), sys.stdin.buffer,\nsys.stdout.buffer, and instances of\nio.BytesIO and gzip.GzipFile.
See also text file for a file object able to read and write\nstr objects.
In Python\u2019s C API, a borrowed reference is a reference to an object,\nwhere the code using the object does not own the reference.\nIt becomes a dangling\npointer if the object is destroyed. For example, a garbage collection can\nremove the last strong reference to the object and so destroy it.
\nCalling Py_INCREF() on the borrowed reference is\nrecommended to convert it to a strong reference in-place, except\nwhen the object cannot be destroyed before the last usage of the borrowed\nreference. The Py_NewRef() function can be used to create a new\nstrong reference.
An object that supports the Buffer Protocol and can\nexport a C-contiguous buffer. This includes all bytes,\nbytearray, and array.array objects, as well as many\ncommon memoryview objects. Bytes-like objects can\nbe used for various operations that work with binary data; these include\ncompression, saving to a binary file, and sending over a socket.
Some operations need the binary data to be mutable. The documentation\noften refers to these as \u201cread-write bytes-like objects\u201d. Example\nmutable buffer objects include bytearray and a\nmemoryview of a bytearray.\nOther operations require the binary data to be stored in\nimmutable objects (\u201cread-only bytes-like objects\u201d); examples\nof these include bytes and a memoryview\nof a bytes object.
Python source code is compiled into bytecode, the internal representation\nof a Python program in the CPython interpreter. The bytecode is also\ncached in .pyc files so that executing the same file is\nfaster the second time (recompilation from source to bytecode can be\navoided). This \u201cintermediate language\u201d is said to run on a\nvirtual machine that executes the machine code corresponding to\neach bytecode. Do note that bytecodes are not expected to work between\ndifferent Python virtual machines, nor to be stable between Python\nreleases.
A list of bytecode instructions can be found in the documentation for\nthe dis module.
\nA callable is an object that can be called, possibly with a set\nof arguments (see argument), with the following syntax:
\ncallable(argument1, argument2, argumentN)\nA function, and by extension a method, is a callable.\nAn instance of a class that implements the __call__()\nmethod is also a callable.
A subroutine function which is passed as an argument to be executed at\nsome point in the future.
\nA template for creating user-defined objects. Class definitions\nnormally contain method definitions which operate on instances of the\nclass.
\nA variable defined in a class and intended to be modified only at\nclass level (i.e., not in an instance of the class).
\nA free variable referenced from a nested scope that is defined in an outer\nscope rather than being resolved at runtime from the globals or builtin namespaces.\nMay be explicitly defined with the nonlocal keyword to allow write access,\nor implicitly defined if the variable is only being read.
For example, in the inner function in the following code, both x and print are\nfree variables, but only x is a closure variable:
def outer():\n x = 0\n def inner():\n nonlocal x\n x += 1\n print(x)\n return inner\nDue to the codeobject.co_freevars attribute (which, despite its name, only\nincludes the names of closure variables rather than listing all referenced free\nvariables), the more general free variable term is sometimes used even\nwhen the intended meaning is to refer specifically to closure variables.
An extension of the familiar real number system in which all numbers are\nexpressed as a sum of a real part and an imaginary part. Imaginary\nnumbers are real multiples of the imaginary unit (the square root of\n-1), often written i in mathematics or j in\nengineering. Python has built-in support for complex numbers, which are\nwritten with this latter notation; the imaginary part is written with a\nj suffix, e.g., 3+1j. To get access to complex equivalents of the\nmath module, use cmath. Use of complex numbers is a fairly\nadvanced mathematical feature. If you\u2019re not aware of a need for them,\nit\u2019s almost certain you can safely ignore them.
This term has different meanings depending on where and how it is used.\nSome common meanings:
\nThe temporary state or environment established by a context\nmanager via a with statement.
The collection of key\u00advalue bindings associated with a particular\ncontextvars.Context object and accessed via\nContextVar objects. Also see context\nvariable.
A contextvars.Context object. Also see current\ncontext.
The __enter__() and __exit__() methods called\nby the with statement. See PEP 343.
An object which implements the context management protocol and\ncontrols the environment seen in a with statement. See\nPEP 343.
A variable whose value depends on which context is the current\ncontext. Values are accessed via contextvars.ContextVar\nobjects. Context variables are primarily used to isolate state between\nconcurrent asynchronous tasks.
A buffer is considered contiguous exactly if it is either\nC-contiguous or Fortran contiguous. Zero-dimensional buffers are\nC and Fortran contiguous. In one-dimensional arrays, the items\nmust be laid out in memory next to each other, in order of\nincreasing indexes starting from zero. In multidimensional\nC-contiguous arrays, the last index varies the fastest when\nvisiting items in order of memory address. However, in\nFortran contiguous arrays, the first index varies the fastest.
\nCoroutines are a more generalized form of subroutines. Subroutines are\nentered at one point and exited at another point. Coroutines can be\nentered, exited, and resumed at many different points. They can be\nimplemented with the async def statement. See also\nPEP 492.
A function which returns a coroutine object. A coroutine\nfunction may be defined with the async def statement,\nand may contain await, async for, and\nasync with keywords. These were introduced\nby PEP 492.
The canonical implementation of the Python programming language, as\ndistributed on python.org. The term \u201cCPython\u201d\nis used when necessary to distinguish this implementation from others\nsuch as Jython or IronPython.
\nThe context (contextvars.Context object) that is\ncurrently used by ContextVar objects to access (get\nor set) the values of context variables. Each\nthread has its own current context. Frameworks for executing asynchronous\ntasks (see asyncio) associate each task with a context which\nbecomes the current context whenever the task starts or resumes execution.
A function returning another function, usually applied as a function\ntransformation using the @wrapper syntax. Common examples for\ndecorators are classmethod() and staticmethod().
The decorator syntax is merely syntactic sugar, the following two\nfunction definitions are semantically equivalent:
\ndef f(arg):\n ...\nf = staticmethod(f)\n\n@staticmethod\ndef f(arg):\n ...\nThe same concept exists for classes, but is less commonly used there. See\nthe documentation for function definitions and\nclass definitions for more about decorators.
\nAny object which defines the methods __get__(),\n__set__(), or __delete__().\nWhen a class attribute is a descriptor, its special\nbinding behavior is triggered upon attribute lookup. Normally, using\na.b to get, set or delete an attribute looks up the object named b in\nthe class dictionary for a, but if b is a descriptor, the respective\ndescriptor method gets called. Understanding descriptors is a key to a\ndeep understanding of Python because they are the basis for many features\nincluding functions, methods, properties, class methods, static methods,\nand reference to super classes.
For more information about descriptors\u2019 methods, see Implementing Descriptors\nor the Descriptor How To Guide.
\nAn associative array, where arbitrary keys are mapped to values. The\nkeys can be any object with __hash__() and\n__eq__() methods.\nCalled a hash in Perl.
A compact way to process all or part of the elements in an iterable and\nreturn a dictionary with the results. results = {n: n ** 2 for n in\nrange(10)} generates a dictionary containing key n mapped to\nvalue n ** 2. See Displays for lists, sets and dictionaries.
The objects returned from dict.keys(), dict.values(), and\ndict.items() are called dictionary views. They provide a dynamic\nview on the dictionary\u2019s entries, which means that when the dictionary\nchanges, the view reflects these changes. To force the\ndictionary view to become a full list use list(dictview). See\nDictionary view objects.
A string literal which appears as the first expression in a class,\nfunction or module. While ignored when the suite is executed, it is\nrecognized by the compiler and put into the __doc__ attribute\nof the enclosing class, function or module. Since it is available via\nintrospection, it is the canonical place for documentation of the\nobject.
A programming style which does not look at an object\u2019s type to determine\nif it has the right interface; instead, the method or attribute is simply\ncalled or used (\u201cIf it looks like a duck and quacks like a duck, it\nmust be a duck.\u201d) By emphasizing interfaces rather than specific types,\nwell-designed code improves its flexibility by allowing polymorphic\nsubstitution. Duck-typing avoids tests using type() or\nisinstance(). (Note, however, that duck-typing can be complemented\nwith abstract base classes.) Instead, it\ntypically employs hasattr() tests or EAFP programming.
Easier to ask for forgiveness than permission. This common Python coding\nstyle assumes the existence of valid keys or attributes and catches\nexceptions if the assumption proves false. This clean and fast style is\ncharacterized by the presence of many try and except\nstatements. The technique contrasts with the LBYL style\ncommon to many other languages such as C.
A piece of syntax which can be evaluated to some value. In other words,\nan expression is an accumulation of expression elements like literals,\nnames, attribute access, operators or function calls which all return a\nvalue. In contrast to many other languages, not all language constructs\nare expressions. There are also statements which cannot be used\nas expressions, such as while. Assignments are also statements,\nnot expressions.
A module written in C or C++, using Python\u2019s C API to interact with the\ncore and with user code.
\nString literals prefixed with 'f' or 'F' are commonly called\n\u201cf-strings\u201d which is short for\nformatted string literals. See also PEP 498.
An object exposing a file-oriented API (with methods such as\nread() or write()) to an underlying resource. Depending\non the way it was created, a file object can mediate access to a real\non-disk file or to another type of storage or communication device\n(for example standard input/output, in-memory buffers, sockets, pipes,\netc.). File objects are also called file-like objects or\nstreams.
There are actually three categories of file objects: raw\nbinary files, buffered\nbinary files and text files.\nTheir interfaces are defined in the io module. The canonical\nway to create a file object is by using the open() function.
A synonym for file object.
\nEncoding and error handler used by Python to decode bytes from the\noperating system and encode Unicode to the operating system.
\nThe filesystem encoding must guarantee to successfully decode all bytes\nbelow 128. If the file system encoding fails to provide this guarantee,\nAPI functions can raise UnicodeError.
The sys.getfilesystemencoding() and\nsys.getfilesystemencodeerrors() functions can be used to get the\nfilesystem encoding and error handler.
The filesystem encoding and error handler are configured at\nPython startup by the PyConfig_Read() function: see\nfilesystem_encoding and\nfilesystem_errors members of PyConfig.
See also the locale encoding.
\nAn object that tries to find the loader for a module that is\nbeing imported.
\nThere are two types of finder: meta path finders for use with sys.meta_path, and path\nentry finders for use with sys.path_hooks.
See Finders and loaders and importlib for much more detail.
Mathematical division that rounds down to nearest integer. The floor\ndivision operator is //. For example, the expression 11 // 4\nevaluates to 2 in contrast to the 2.75 returned by float true\ndivision. Note that (-11) // 4 is -3 because that is -2.75\nrounded downward. See PEP 238.
A threading model where multiple threads can run Python bytecode\nsimultaneously within the same interpreter. This is in contrast to\nthe global interpreter lock which allows only one thread to\nexecute Python bytecode at a time. See PEP 703.
\nFormally, as defined in the language execution model, a free\nvariable is any variable used in a namespace which is not a local variable in that\nnamespace. See closure variable for an example.\nPragmatically, due to the name of the codeobject.co_freevars attribute,\nthe term is also sometimes used as a synonym for closure variable.
A series of statements which returns some value to a caller. It can also\nbe passed zero or more arguments which may be used in\nthe execution of the body. See also parameter, method,\nand the Function definitions section.
\nAn annotation of a function parameter or return value.
\nFunction annotations are usually used for\ntype hints: for example, this function is expected to take two\nint arguments and is also expected to have an int\nreturn value:
def sum_two_numbers(a: int, b: int) -> int:\n return a + b\nFunction annotation syntax is explained in section Function definitions.
\nSee variable annotation and PEP 484,\nwhich describe this functionality.\nAlso see Annotations Best Practices\nfor best practices on working with annotations.
\nA future statement, from __future__ import <feature>,\ndirects the compiler to compile the current module using syntax or\nsemantics that will become standard in a future release of Python.\nThe __future__ module documents the possible values of\nfeature. By importing this module and evaluating its variables,\nyou can see when a new feature was first added to the language and\nwhen it will (or did) become the default:
>>> import __future__\n>>> __future__.division\n_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)\nThe process of freeing memory when it is not used anymore. Python\nperforms garbage collection via reference counting and a cyclic garbage\ncollector that is able to detect and break reference cycles. The\ngarbage collector can be controlled using the gc module.
A function which returns a generator iterator. It looks like a\nnormal function except that it contains yield expressions\nfor producing a series of values usable in a for-loop or that can be\nretrieved one at a time with the next() function.
Usually refers to a generator function, but may refer to a\ngenerator iterator in some contexts. In cases where the intended\nmeaning isn\u2019t clear, using the full terms avoids ambiguity.
\nAn object created by a generator function.
\nEach yield temporarily suspends processing, remembering the\nexecution state (including local variables and pending\ntry-statements). When the generator iterator resumes, it picks up where\nit left off (in contrast to functions which start fresh on every\ninvocation).
An expression that returns an iterator. It looks like a normal expression\nfollowed by a for clause defining a loop variable, range,\nand an optional if clause. The combined expression\ngenerates values for an enclosing function:
>>> sum(i*i for i in range(10)) # sum of squares 0, 1, 4, ... 81\n285\nA function composed of multiple functions implementing the same operation\nfor different types. Which implementation should be used during a call is\ndetermined by the dispatch algorithm.
\nSee also the single dispatch glossary entry, the\nfunctools.singledispatch() decorator, and PEP 443.
A type that can be parameterized; typically a\ncontainer class such as list or\ndict. Used for type hints and\nannotations.
For more details, see generic alias types,\nPEP 483, PEP 484, PEP 585, and the typing module.
The mechanism used by the CPython interpreter to assure that\nonly one thread executes Python bytecode at a time.\nThis simplifies the CPython implementation by making the object model\n(including critical built-in types such as dict) implicitly\nsafe against concurrent access. Locking the entire interpreter\nmakes it easier for the interpreter to be multi-threaded, at the\nexpense of much of the parallelism afforded by multi-processor\nmachines.
However, some extension modules, either standard or third-party,\nare designed so as to release the GIL when doing computationally intensive\ntasks such as compression or hashing. Also, the GIL is always released\nwhen doing I/O.
\nAs of Python 3.13, the GIL can be disabled using the --disable-gil\nbuild configuration. After building Python with this option, code must be\nrun with -X gil=0 or after setting the PYTHON_GIL=0\nenvironment variable. This feature enables improved performance for\nmulti-threaded applications and makes it easier to use multi-core CPUs\nefficiently. For more details, see PEP 703.
A bytecode cache file that uses the hash rather than the last-modified\ntime of the corresponding source file to determine its validity. See\nCached bytecode invalidation.
\nAn object is hashable if it has a hash value which never changes during\nits lifetime (it needs a __hash__() method), and can be\ncompared to other objects (it needs an __eq__() method).\nHashable objects which\ncompare equal must have the same hash value.
Hashability makes an object usable as a dictionary key and a set member,\nbecause these data structures use the hash value internally.
\nMost of Python\u2019s immutable built-in objects are hashable; mutable\ncontainers (such as lists or dictionaries) are not; immutable\ncontainers (such as tuples and frozensets) are only hashable if\ntheir elements are hashable. Objects which are\ninstances of user-defined classes are hashable by default. They all\ncompare unequal (except with themselves), and their hash value is derived\nfrom their id().
An Integrated Development and Learning Environment for Python.\nIDLE \u2014 Python editor and shell is a basic editor and interpreter environment\nwhich ships with the standard distribution of Python.
\nImmortal objects are a CPython implementation detail introduced\nin PEP 683.
\nIf an object is immortal, its reference count is never modified,\nand therefore it is never deallocated while the interpreter is running.\nFor example, True and None are immortal in CPython.
An object with a fixed value. Immutable objects include numbers, strings and\ntuples. Such an object cannot be altered. A new object has to\nbe created if a different value has to be stored. They play an important\nrole in places where a constant hash value is needed, for example as a key\nin a dictionary.
\nA list of locations (or path entries) that are\nsearched by the path based finder for modules to import. During\nimport, this list of locations usually comes from sys.path, but\nfor subpackages it may also come from the parent package\u2019s __path__\nattribute.
The process by which Python code in one module is made available to\nPython code in another module.
\nAn object that both finds and loads a module; both a\nfinder and loader object.
\nPython has an interactive interpreter which means you can enter\nstatements and expressions at the interpreter prompt, immediately\nexecute them and see their results. Just launch python with no\narguments (possibly by selecting it from your computer\u2019s main\nmenu). It is a very powerful way to test out new ideas or inspect\nmodules and packages (remember help(x)). For more on interactive\nmode, see Interactive Mode.
Python is an interpreted language, as opposed to a compiled one,\nthough the distinction can be blurry because of the presence of the\nbytecode compiler. This means that source files can be run directly\nwithout explicitly creating an executable which is then run.\nInterpreted languages typically have a shorter development/debug cycle\nthan compiled ones, though their programs generally also run more\nslowly. See also interactive.
\nWhen asked to shut down, the Python interpreter enters a special phase\nwhere it gradually releases all allocated resources, such as modules\nand various critical internal structures. It also makes several calls\nto the garbage collector. This can trigger\nthe execution of code in user-defined destructors or weakref callbacks.\nCode executed during the shutdown phase can encounter various\nexceptions as the resources it relies on may not function anymore\n(common examples are library modules or the warnings machinery).
\nThe main reason for interpreter shutdown is that the __main__ module\nor the script being run has finished executing.
An object capable of returning its members one at a time. Examples of\niterables include all sequence types (such as list, str,\nand tuple) and some non-sequence types like dict,\nfile objects, and objects of any classes you define\nwith an __iter__() method or with a\n__getitem__() method\nthat implements sequence semantics.
Iterables can be\nused in a for loop and in many other places where a sequence is\nneeded (zip(), map(), \u2026). When an iterable object is passed\nas an argument to the built-in function iter(), it returns an\niterator for the object. This iterator is good for one pass over the set\nof values. When using iterables, it is usually not necessary to call\niter() or deal with iterator objects yourself. The for\nstatement does that automatically for you, creating a temporary unnamed\nvariable to hold the iterator for the duration of the loop. See also\niterator, sequence, and generator.
An object representing a stream of data. Repeated calls to the iterator\u2019s\n__next__() method (or passing it to the built-in function\nnext()) return successive items in the stream. When no more data\nare available a StopIteration exception is raised instead. At this\npoint, the iterator object is exhausted and any further calls to its\n__next__() method just raise StopIteration again. Iterators\nare required to have an __iter__() method that returns the iterator\nobject itself so every iterator is also iterable and may be used in most\nplaces where other iterables are accepted. One notable exception is code\nwhich attempts multiple iteration passes. A container object (such as a\nlist) produces a fresh new iterator each time you pass it to the\niter() function or use it in a for loop. Attempting this\nwith an iterator will just return the same exhausted iterator object used\nin the previous iteration pass, making it appear like an empty container.
More information can be found in Iterator Types.
\nCPython implementation detail: CPython does not consistently apply the requirement that an iterator\ndefine __iter__().\nAnd also please note that the free-threading CPython does not guarantee\nthe thread-safety of iterator operations.
A key function or collation function is a callable that returns a value\nused for sorting or ordering. For example, locale.strxfrm() is\nused to produce a sort key that is aware of locale specific sort\nconventions.
A number of tools in Python accept key functions to control how elements\nare ordered or grouped. They include min(), max(),\nsorted(), list.sort(), heapq.merge(),\nheapq.nsmallest(), heapq.nlargest(), and\nitertools.groupby().
There are several ways to create a key function. For example. the\nstr.lower() method can serve as a key function for case insensitive\nsorts. Alternatively, a key function can be built from a\nlambda expression such as lambda r: (r[0], r[2]). Also,\noperator.attrgetter(), operator.itemgetter(), and\noperator.methodcaller() are three key function constructors. See the Sorting HOW TO for examples of how to create and use key functions.
See argument.
\nAn anonymous inline function consisting of a single expression\nwhich is evaluated when the function is called. The syntax to create\na lambda function is lambda [parameters]: expression
Look before you leap. This coding style explicitly tests for\npre-conditions before making calls or lookups. This style contrasts with\nthe EAFP approach and is characterized by the presence of many\nif statements.
In a multi-threaded environment, the LBYL approach can risk introducing a\nrace condition between \u201cthe looking\u201d and \u201cthe leaping\u201d. For example, the\ncode, if key in mapping: return mapping[key] can fail if another\nthread removes key from mapping after the test, but before the lookup.\nThis issue can be solved with locks or by using the EAFP approach.
Formal name for the tokenizer; see token.
\nA built-in Python sequence. Despite its name it is more akin\nto an array in other languages than to a linked list since access to\nelements is O(1).
\nA compact way to process all or part of the elements in a sequence and\nreturn a list with the results. result = ['{:#04x}'.format(x) for x in\nrange(256) if x % 2 == 0] generates a list of strings containing\neven hex numbers (0x..) in the range from 0 to 255. The if\nclause is optional. If omitted, all elements in range(256) are\nprocessed.
An object that loads a module.\nIt must define the exec_module() and create_module() methods\nto implement the Loader interface.\nA loader is typically returned by a finder.\nSee also:
On Unix, it is the encoding of the LC_CTYPE locale. It can be set with\nlocale.setlocale(locale.LC_CTYPE, new_locale).
On Windows, it is the ANSI code page (ex: "cp1252").
On Android and VxWorks, Python uses "utf-8" as the locale encoding.
locale.getencoding() can be used to get the locale encoding.
See also the filesystem encoding and error handler.
\nAn informal synonym for special method.
\nA container object that supports arbitrary key lookups and implements the\nmethods specified in the collections.abc.Mapping or\ncollections.abc.MutableMapping\nabstract base classes. Examples\ninclude dict, collections.defaultdict,\ncollections.OrderedDict and collections.Counter.
A finder returned by a search of sys.meta_path. Meta path\nfinders are related to, but different from path entry finders.
See importlib.abc.MetaPathFinder for the methods that meta path\nfinders implement.
The class of a class. Class definitions create a class name, a class\ndictionary, and a list of base classes. The metaclass is responsible for\ntaking those three arguments and creating the class. Most object oriented\nprogramming languages provide a default implementation. What makes Python\nspecial is that it is possible to create custom metaclasses. Most users\nnever need this tool, but when the need arises, metaclasses can provide\npowerful, elegant solutions. They have been used for logging attribute\naccess, adding thread-safety, tracking object creation, implementing\nsingletons, and many other tasks.
\nMore information can be found in Metaclasses.
\nA function which is defined inside a class body. If called as an attribute\nof an instance of that class, the method will get the instance object as\nits first argument (which is usually called self).\nSee function and nested scope.
Method Resolution Order is the order in which base classes are searched\nfor a member during lookup. See The Python 2.3 Method Resolution Order for details of the\nalgorithm used by the Python interpreter since the 2.3 release.
\nAn object that serves as an organizational unit of Python code. Modules\nhave a namespace containing arbitrary Python objects. Modules are loaded\ninto Python by the process of importing.
\nSee also package.
\nA namespace containing the import-related information used to load a\nmodule. An instance of importlib.machinery.ModuleSpec.
See also Module specs.
\nMutable objects can change their value but keep their id(). See\nalso immutable.
The term \u201cnamed tuple\u201d applies to any type or class that inherits from\ntuple and whose indexable elements are also accessible using named\nattributes. The type or class may have other features as well.
\nSeveral built-in types are named tuples, including the values returned\nby time.localtime() and os.stat(). Another example is\nsys.float_info:
>>> sys.float_info[1] # indexed access\n1024\n>>> sys.float_info.max_exp # named field access\n1024\n>>> isinstance(sys.float_info, tuple) # kind of tuple\nTrue\nSome named tuples are built-in types (such as the above examples).\nAlternatively, a named tuple can be created from a regular class\ndefinition that inherits from tuple and that defines named\nfields. Such a class can be written by hand, or it can be created by\ninheriting typing.NamedTuple, or with the factory function\ncollections.namedtuple(). The latter techniques also add some\nextra methods that may not be found in hand-written or built-in named\ntuples.
The place where a variable is stored. Namespaces are implemented as\ndictionaries. There are the local, global and built-in namespaces as well\nas nested namespaces in objects (in methods). Namespaces support\nmodularity by preventing naming conflicts. For instance, the functions\nbuiltins.open and os.open() are distinguished by\ntheir namespaces. Namespaces also aid readability and maintainability by\nmaking it clear which module implements a function. For instance, writing\nrandom.seed() or itertools.islice() makes it clear that those\nfunctions are implemented by the random and itertools\nmodules, respectively.
A package which serves only as a container for subpackages.\nNamespace packages may have no physical representation,\nand specifically are not like a regular package because they\nhave no __init__.py file.
Namespace packages allow several individually installable packages to have a common parent package.\nOtherwise, it is recommended to use a regular package.
\nFor more information, see PEP 420 and Namespace packages.
\nSee also module.
\nThe ability to refer to a variable in an enclosing definition. For\ninstance, a function defined inside another function can refer to\nvariables in the outer function. Note that nested scopes by default work\nonly for reference and not for assignment. Local variables both read and\nwrite in the innermost scope. Likewise, global variables read and write\nto the global namespace. The nonlocal allows writing to outer\nscopes.
Old name for the flavor of classes now used for all class objects. In\nearlier Python versions, only new-style classes could use Python\u2019s newer,\nversatile features like __slots__, descriptors,\nproperties, __getattribute__(), class methods, and static\nmethods.
Any data with state (attributes or value) and defined behavior\n(methods). Also the ultimate base class of any new-style\nclass.
\nA scope where target local variable names are reliably known to the\ncompiler when the code is compiled, allowing optimization of read and\nwrite access to these names. The local namespaces for functions,\ngenerators, coroutines, comprehensions, and generator expressions are\noptimized in this fashion. Note: most interpreter optimizations are\napplied to all scopes, only those relying on a known set of local\nand nonlocal variable names are restricted to optimized scopes.
\nA Python module which can contain submodules or recursively,\nsubpackages. Technically, a package is a Python module with a\n__path__ attribute.
See also regular package and namespace package.
\nA named entity in a function (or method) definition that\nspecifies an argument (or in some cases, arguments) that the\nfunction can accept. There are five kinds of parameter:
\npositional-or-keyword: specifies an argument that can be passed\neither positionally or as a keyword argument. This is the default kind of parameter, for example foo\nand bar in the following:
\ndef func(foo, bar=None): ...\npositional-only: specifies an argument that can be supplied only\nby position. Positional-only parameters can be defined by including a\n/ character in the parameter list of the function definition after\nthem, for example posonly1 and posonly2 in the following:
def func(posonly1, posonly2, /, positional_or_keyword): ...\nkeyword-only: specifies an argument that can be supplied only\nby keyword. Keyword-only parameters can be defined by including a\nsingle var-positional parameter or bare * in the parameter list\nof the function definition before them, for example kw_only1 and\nkw_only2 in the following:
def func(arg, *, kw_only1, kw_only2): ...\nvar-positional: specifies that an arbitrary sequence of\npositional arguments can be provided (in addition to any positional\narguments already accepted by other parameters). Such a parameter can\nbe defined by prepending the parameter name with *, for example\nargs in the following:
def func(*args, **kwargs): ...\nvar-keyword: specifies that arbitrarily many keyword arguments\ncan be provided (in addition to any keyword arguments already accepted\nby other parameters). Such a parameter can be defined by prepending\nthe parameter name with **, for example kwargs in the example\nabove.
Parameters can specify both optional and required arguments, as well as\ndefault values for some optional arguments.
\nSee also the argument glossary entry, the FAQ question on\nthe difference between arguments and parameters, the inspect.Parameter class, the\nFunction definitions section, and PEP 362.
A single location on the import path which the path\nbased finder consults to find modules for importing.
\nA finder returned by a callable on sys.path_hooks\n(i.e. a path entry hook) which knows how to locate modules given\na path entry.
See importlib.abc.PathEntryFinder for the methods that path entry\nfinders implement.
A callable on the sys.path_hooks list which returns a path\nentry finder if it knows how to find modules on a specific path\nentry.
One of the default meta path finders which\nsearches an import path for modules.
\nAn object representing a file system path. A path-like object is either\na str or bytes object representing a path, or an object\nimplementing the os.PathLike protocol. An object that supports\nthe os.PathLike protocol can be converted to a str or\nbytes file system path by calling the os.fspath() function;\nos.fsdecode() and os.fsencode() can be used to guarantee a\nstr or bytes result instead, respectively. Introduced\nby PEP 519.
Python Enhancement Proposal. A PEP is a design document\nproviding information to the Python community, or describing a new\nfeature for Python or its processes or environment. PEPs should\nprovide a concise technical specification and a rationale for proposed\nfeatures.
\nPEPs are intended to be the primary mechanisms for proposing major new\nfeatures, for collecting community input on an issue, and for documenting\nthe design decisions that have gone into Python. The PEP author is\nresponsible for building consensus within the community and documenting\ndissenting opinions.
\nSee PEP 1.
\nA set of files in a single directory (possibly stored in a zip file)\nthat contribute to a namespace package, as defined in PEP 420.
\nSee argument.
\nA provisional API is one which has been deliberately excluded from\nthe standard library\u2019s backwards compatibility guarantees. While major\nchanges to such interfaces are not expected, as long as they are marked\nprovisional, backwards incompatible changes (up to and including removal\nof the interface) may occur if deemed necessary by core developers. Such\nchanges will not be made gratuitously \u2013 they will occur only if serious\nfundamental flaws are uncovered that were missed prior to the inclusion\nof the API.
\nEven for provisional APIs, backwards incompatible changes are seen as\na \u201csolution of last resort\u201d - every attempt will still be made to find\na backwards compatible resolution to any identified problems.
\nThis process allows the standard library to continue to evolve over\ntime, without locking in problematic design errors for extended periods\nof time. See PEP 411 for more details.
\nSee provisional API.
\nNickname for the Python 3.x release line (coined long ago when the\nrelease of version 3 was something in the distant future.) This is also\nabbreviated \u201cPy3k\u201d.
\nAn idea or piece of code which closely follows the most common idioms\nof the Python language, rather than implementing code using concepts\ncommon to other languages. For example, a common idiom in Python is\nto loop over all elements of an iterable using a for\nstatement. Many other languages don\u2019t have this type of construct, so\npeople unfamiliar with Python sometimes use a numerical counter instead:
for i in range(len(food)):\n print(food[i])\nAs opposed to the cleaner, Pythonic method:
\nfor piece in food:\n print(piece)\nA dotted name showing the \u201cpath\u201d from a module\u2019s global scope to a\nclass, function or method defined in that module, as defined in\nPEP 3155. For top-level functions and classes, the qualified name\nis the same as the object\u2019s name:
\n>>> class C:\n... class D:\n... def meth(self):\n... pass\n...\n>>> C.__qualname__\n'C'\n>>> C.D.__qualname__\n'C.D'\n>>> C.D.meth.__qualname__\n'C.D.meth'\nWhen used to refer to modules, the fully qualified name means the\nentire dotted path to the module, including any parent packages,\ne.g. email.mime.text:
>>> import email.mime.text\n>>> email.mime.text.__name__\n'email.mime.text'\nThe number of references to an object. When the reference count of an\nobject drops to zero, it is deallocated. Some objects are\nimmortal and have reference counts that are never modified, and\ntherefore the objects are never deallocated. Reference counting is\ngenerally not visible to Python code, but it is a key element of the\nCPython implementation. Programmers can call the\nsys.getrefcount() function to return the\nreference count for a particular object.
A traditional package, such as a directory containing an\n__init__.py file.
See also namespace package.
\nAn acronym for the \u201cread\u2013eval\u2013print loop\u201d, another name for the\ninteractive interpreter shell.
\nA declaration inside a class that saves memory by pre-declaring space for\ninstance attributes and eliminating instance dictionaries. Though\npopular, the technique is somewhat tricky to get right and is best\nreserved for rare cases where there are large numbers of instances in a\nmemory-critical application.
\nAn iterable which supports efficient element access using integer\nindices via the __getitem__() special method and defines a\n__len__() method that returns the length of the sequence.\nSome built-in sequence types are list, str,\ntuple, and bytes. Note that dict also\nsupports __getitem__() and __len__(), but is considered a\nmapping rather than a sequence because the lookups use arbitrary\nhashable keys rather than integers.
The collections.abc.Sequence abstract base class\ndefines a much richer interface that goes beyond just\n__getitem__() and __len__(), adding\ncount(), index(), __contains__(), and\n__reversed__(). Types that implement this expanded\ninterface can be registered explicitly using\nregister(). For more documentation on sequence\nmethods generally, see\nCommon Sequence Operations.
A compact way to process all or part of the elements in an iterable and\nreturn a set with the results. results = {c for c in 'abracadabra' if\nc not in 'abc'} generates the set of strings {'r', 'd'}. See\nDisplays for lists, sets and dictionaries.
A form of generic function dispatch where the implementation is\nchosen based on the type of a single argument.
\nAn object usually containing a portion of a sequence. A slice is\ncreated using the subscript notation, [] with colons between numbers\nwhen several are given, such as in variable_name[1:3:5]. The bracket\n(subscript) notation uses slice objects internally.
A soft deprecated API should not be used in new code,\nbut it is safe for already existing code to use it.\nThe API remains documented and tested, but will not be enhanced further.
\nSoft deprecation, unlike normal deprecation, does not plan on removing the API\nand will not emit warnings.
\n\nA method that is called implicitly by Python to execute a certain\noperation on a type, such as addition. Such methods have names starting\nand ending with double underscores. Special methods are documented in\nSpecial method names.
\nA statement is part of a suite (a \u201cblock\u201d of code). A statement is either\nan expression or one of several constructs with a keyword, such\nas if, while or for.
An external tool that reads Python code and analyzes it, looking for\nissues such as incorrect types. See also type hints\nand the typing module.
In Python\u2019s C API, a strong reference is a reference to an object\nwhich is owned by the code holding the reference. The strong\nreference is taken by calling Py_INCREF() when the\nreference is created and released with Py_DECREF()\nwhen the reference is deleted.
The Py_NewRef() function can be used to create a strong reference\nto an object. Usually, the Py_DECREF() function must be called on\nthe strong reference before exiting the scope of the strong reference, to\navoid leaking one reference.
See also borrowed reference.
\nA string in Python is a sequence of Unicode code points (in range\nU+0000\u2013U+10FFFF). To store or transfer a string, it needs to be\nserialized as a sequence of bytes.
Serializing a string into a sequence of bytes is known as \u201cencoding\u201d, and\nrecreating the string from the sequence of bytes is known as \u201cdecoding\u201d.
\nThere are a variety of different text serialization\ncodecs, which are collectively referred to as\n\u201ctext encodings\u201d.
\nA file object able to read and write str objects.\nOften, a text file actually accesses a byte-oriented datastream\nand handles the text encoding automatically.\nExamples of text files are files opened in text mode ('r' or 'w'),\nsys.stdin, sys.stdout, and instances of\nio.StringIO.
See also binary file for a file object able to read and write\nbytes-like objects.
\nA small unit of source code, generated by the\nlexical analyzer (also called the tokenizer).\nNames, numbers, strings, operators,\nnewlines and similar are represented by tokens.
\nThe tokenize module exposes Python\u2019s lexical analyzer.\nThe token module contains information on the various types\nof tokens.
A string which is bound by three instances of either a quotation mark\n(\u201d) or an apostrophe (\u2018). While they don\u2019t provide any functionality\nnot available with single-quoted strings, they are useful for a number\nof reasons. They allow you to include unescaped single and double\nquotes within a string and they can span multiple lines without the\nuse of the continuation character, making them especially useful when\nwriting docstrings.
\nThe type of a Python object determines what kind of object it is; every\nobject has a type. An object\u2019s type is accessible as its\n__class__ attribute or can be retrieved with\ntype(obj).
A synonym for a type, created by assigning the type to an identifier.
\nType aliases are useful for simplifying type hints.\nFor example:
\ndef remove_gray_shades(\n colors: list[tuple[int, int, int]]) -> list[tuple[int, int, int]]:\n pass\ncould be made more readable like this:
\nColor = tuple[int, int, int]\n\ndef remove_gray_shades(colors: list[Color]) -> list[Color]:\n pass\nAn annotation that specifies the expected type for a variable, a class\nattribute, or a function parameter or return value.
\nType hints are optional and are not enforced by Python but\nthey are useful to static type checkers.\nThey can also aid IDEs with code completion and refactoring.
\nType hints of global variables, class attributes, and functions,\nbut not local variables, can be accessed using\ntyping.get_type_hints().
A manner of interpreting text streams in which all of the following are\nrecognized as ending a line: the Unix end-of-line convention '\\n',\nthe Windows convention '\\r\\n', and the old Macintosh convention\n'\\r'. See PEP 278 and PEP 3116, as well as\nbytes.splitlines() for an additional use.
An annotation of a variable or a class attribute.
\nWhen annotating a variable or a class attribute, assignment is optional:
\nclass C:\n field: 'annotation'\nVariable annotations are usually used for\ntype hints: for example this variable is expected to take\nint values:
count: int = 0\nVariable annotation syntax is explained in section Annotated assignment statements.
\nSee function annotation, PEP 484\nand PEP 526, which describe this functionality.\nAlso see Annotations Best Practices\nfor best practices on working with annotations.
\nA cooperatively isolated runtime environment that allows Python users\nand applications to install and upgrade Python distribution packages\nwithout interfering with the behaviour of other Python applications\nrunning on the same system.
\nSee also venv.
A computer defined entirely in software. Python\u2019s virtual machine\nexecutes the bytecode emitted by the bytecode compiler.
\nListing of Python design principles and philosophies that are helpful in\nunderstanding and using the language. The listing can be found by typing\n\u201cimport this\u201d at the interactive prompt.