(A) Structural pattern matching against values and data shapes (B) Type checking using built-in assert statements (C) Recursive function binding for functional programming (D) Compile-time constant evaluation
For instance, some code examples use the terms "spam" and "eggs" (in reference to a Monty Python sketch), rather than the typical terms "foo" and "bar". [94][95] A common neologism in the Python community is pythonic, which has a wide range of meanings related to program style. Pythonic code may use Python idioms well; be natural or show fluency in the language; or conform with Python's minimalist philosophy and emphasis on readability. [96]  Syntax and semantics  Python is meant to be an easily readable language. Its formatting is  visually  uncluttered  and  often  uses  English  keywords  where other  languages  use  punctuation. Unlike  many  other  languages, it does not use curly brackets to delimit blocks, and semicolons after  statements  are  allowed  but  rarely  used. It  has  fewer syntactic exceptions and special cases than C or Pascal. [97]  Indentation  Python uses whitespace indentation, rather than curly brackets or keywords,  to  delimit  blocks. An  increase  in  indentation  comes after  certain  statements;  a  decrease  in  indentation  signifies  the  end  of  the  current  block. [98]  Thus,  the program's  visual  structure  accurately  represents  its  semantic  structure. [99]  This  feature  is  sometimes termed the off-side rule. Some other languages use indentation this way; but in most, indentation has no semantic meaning. The recommended indent size is four spaces. [100]  An example of Python code and indentation  Statements and control flow  Python's statements include the following:  The assignment statement, using a single equals sign =  The if statement, which conditionally executes a block of code, along with else and elif (a contraction of else if)  The for statement, which iterates over an iterable object, capturing each element to a local variable for use by the attached block  Example of C# code with curly braces and semicolons  The while statement, which executes a block of code as long as its condition is true  The try statement, which allows exceptions raised in its attached code block to be caught and handled by except clauses (or new syntax except* in Python 3. 11 for exception groups[101]); the try statement also ensures that clean-up code in a finally block is always run regardless of how the block exits  The raise statement, used to raise a specified exception or re-raise a caught exception  The class statement, which executes a block of code and attaches its local namespace to a class, for use in object-oriented programming  The def statement, which defines a function or method  The with statement, which encloses a code block within a context manager, allowing resource-acquisition-is-initialization (RAII)-like behavior and replacing a common try/finally idiom[102] Examples of a context include acquiring a lock before some code is run, and then releasing the lock; or opening and then closing a file  The break statement, which exits a loop  The continue statement, which skips the rest of the current iteration and continues with the next  The del statement, which removes a variable—deleting the reference from the name to the value, and producing an error if the variable is referred to before it is redefined [a] The pass statement, serving as a NOP (i. e. , no operation), which is syntactically needed to create an empty code block  The assert statement, used in debugging to check for conditions that should apply  The yield statement, which returns a value from a generator function (and also an operator); used to implement coroutines  The return statement, used to return a value from a function  The import and from statements, used to import modules whose functions or variables can be used in the current program  The match and case statements, analogous to a switch statement construct, which compares an expression against one or more cases as a control-flow measure  The  assignment  statement  (=)  binds  a  name  as  a  reference  to  a  separate,  dynamically  allocated  object.
Python (programming language)

Python  is  a  high-level,  general-purpose  programming
language.  Its  design  philosophy  emphasizes  code
readability with the use of significant indentation.[33]

Python

It

including

Python  is  dynamically  type-checked  and  garbage-
programming
supports  multiple
collected.
(particularly
structured
paradigms,
procedural),
functional
programming.  It  is  often  described  as  a  "batteries
included"  language  due  to  its  comprehensive  standard
library.[34][35]

object-oriented

and

Guido  van  Rossum  began  working  on  Python  in  the
late  1980s  as  a  successor  to  the  ABC  programming
language,  and  he  first  released
in  1991  as
Python  0.9.0.[36]  Python  2.0  was  released  in  2000.
Python 3.0, released in 2008, was a major revision not
completely backward-compatible with earlier versions.
Python 2.7.18, released in 2020, was the last release of
Python 2.[37]

it

Python  consistently  ranks  as  one  of  the  most  popular
programming languages, and it has gained widespread
use in the machine learning community.[38][39][40][41]

History

OS

Python  was  conceived  in  the  late  1980s[42]  by  Guido
van  Rossum  at  Centrum  Wiskunde  &  Informatica
(CWI)  in  the  Netherlands;  it  was  conceived  as  a
successor  to  the  ABC  programming  language,  which
was  inspired  by  SETL,[43]  capable  of  exception
handling  and  interfacing  with  the  Amoeba  operating
system.[12]
in
December  1989.[44]  Van  Rossum  assumed  sole
responsibility  for  the  project,  as  the  lead  developer,
until 12 July 2018, when he announced his "permanent
vacation" from responsibilities as Python's "benevolent
dictator  for  life"  (BDFL);  this  title  was  bestowed  on
him by the Python community to reflect his long-term

implementation

Python

began

Paradigm

Multi-paradigm: object-
oriented,[1] procedural
(imperative), functional,
structured, reflective

Designed by

Guido van Rossum

Developer
First appeared 20 February 1991[2]

Python Software Foundation

Stable release 3.13.2 / 4 February 2025

Typing
discipline

duck, dynamic, strong;[3]
optional type annotations

(since 3.5, but those hints are
ignored, except with unofficial
tools)[4]

Tier 1: 64-bit Linux, macOS;
64- and 32-bit Windows
10+[5]

Tier 2: E.g. 32-bit
WebAssembly (WASI)
Tier 3: 64-bit Android,[6] iOS,
FreeBSD, and (32-bit)
Raspberry Pi OS
Unofficial (or has been known
to work): Other Unix-like/BSD
variants) and a few other
platforms[7][8][9]

License

Python Software Foundation

License

commitment  as  the  project's  chief  decision-maker.[45]
(He has since come out of retirement and is self-titled
"BDFL-emeritus".)  In  January  2019,  active  Python
core  developers  elected  a  five-member  Steering
Council to lead the project.[46][47]

The  name  Python  is  said  to  derive  from  the  British
comedy series Monty Python's Flying Circus.[48]

Python  2.0  was  released  on  16  October  2000,  with
many major new features such as list comprehensions,
cycle-detecting garbage collection, reference counting,
and  Unicode  support.[49]  Python  2.7's  end-of-life  was
initially  set  for  2015,  and  then  postponed  to  2020  out
of concern that a large body of existing code could not
easily  be  forward-ported  to  Python  3.[50][51]  It  no
longer  receives  security  patches  or  updates.[52][53]
While  Python  2.7  and  older  versions  are  officially
Python
different
unsupported,
implementation,  PyPy,  continues  to  support  Python  2,
i.e., "2.7.18+" (plus 3.10), with the plus signifying (at
least some) "backported security updates".[54]

unofficial

a

Filename
extensions

Website

.py, .pyw, .pyz,[10]
.pyi, .pyc, .pyd

python.org (https://www.pytho
n.org/)

Major implementations

CPython, PyPy, Stackless Python,
MicroPython, CircuitPython, IronPython,
Jython

Dialects
Cython, RPython, Starlark[11]

Influenced by

ABC,[12] Ada,[13] ALGOL 68,[14]
APL,[15] C,[16] C++,[17] CLU,[18] Dylan,[19]
Haskell,[20][15] Icon,[21] Lisp,[22]
Modula-3,[14][17] Perl,[23] Standard ML[15]

Influenced
Apache Groovy, Boo, Cobra, CoffeeScript,[24]
D, F#, GDScript, Go, JavaScript,[25][26]
Julia,[27] Mojo,[28] Nim, Ring,[29] Ruby,[30]
Swift,[31] V[32]

Python  3.0  was  released  on  3  December  2008,  with
some  new  semantics  and  changed  syntax.  At  least
every  Python  release  since  (the  now  unsupported)  3.5  has  added
some  syntax  to  the  language;  a  few  later  releases  have  removed
outdated  modules  and  have  changed  semantics,  at  least  in  a  minor
way.

 Python Programming at Wikibooks

As  of  8  April  2025,  Python  3.13.3  is  the  latest  stable  release  (it's
highly recommended to upgrade to it, or upgrade any other older 3.x
release).  This  version  currently  receives  full  bug-fix  and  security
updates, while Python 3.12—released in October 2023—had active
bug-fix  support  only  until April  2025,  and  since  then  only  security
fixes. Python 3.9[55] is the oldest supported version of Python (albeit
in  the  'security  support'  phase),  because  Python  3.8  has  become  an
end-of-life  product.[56][57]  Starting  with  Python  3.13,  it  and  later
versions receive two years of full support (which has increased from
one  and  a  half  years),  followed  by  three  years  of  security  support;
this is the same total duration of support as previously.

The designer of Python, Guido
van Rossum, at PyCon US 2024

Security  updates  were  expedited  in  2021  and  again  twice  in  2022.
More issues were fixed in 2023 and in September 2024 (for Python
versions  3.8.20  through  3.12.6)—all  versions  (including  2.7)[58]  had  been  insecure  because  of  issues
leading to possible remote code execution[59] and web-cache poisoning.[60]

Python  3.10  added  the  |  union  type  operator[61]  and  the  match  and  case  keywords  (for  structural
pattern matching statements). Python 3.11 expanded exception handling functionality. Python 3.12 added
the new keyword type. Notable changes from version 3.10 to 3.11 include increased program execution
speed and improved error reporting.[62] Python 3.11 is claimed to be 10–60% faster than Python 3.10, and
Python  3.12  increases  by  an  additional  5%.  Python  3.12  also  includes  improved  error  messages  (again
improved in 3.14) and many other changes.

Python  3.13  introduces  more  syntax  for  types;  a  new  and  improved  interactive  interpreter  (REPL),
featuring multi-line editing and color support; an incremental garbage collector, which results in shorter
pauses  for  collection  in  programs  that  have  many  objects,  as  well  as  increasing  the  improved  speed  in
3.11  and  3.12);  an  experimental  just-in-time  (JIT)  compiler  (such  features,  can/needs  to  be  enabled
specifically for the increase in speed);[63] and an experimental free-threaded build mode, which disables
to  run  more  concurrently,  as  enabled
the  global
inpython3.13t or python3.13t.exe.

lock  (GIL),  allowing

interpreter

threads

Python  3.13  introduces  some  changes  in  behavior,  i.e.,  new  "well-defined  semantics",  fixing  bugs,  and
removing  many  deprecated  classes,  functions  and  methods  (as  well  as  some  of  the  Python/C API  and
outdated  modules).  "The  old  implementation  of  locals()  and  frame.f_locals  was  slow,
inconsistent  and  buggy,  and  it  had  many  corner  cases  and  oddities.  Code  that  works  around  those  may
need  revising;  code  that  uses  locals()  for  simple  templating  or  print  debugging  should  continue  to
work correctly."[64]

Python 3.13 introduces the experimental free-threaded build mode, which disables the Global Interpreter
Lock (GIL); the GIL is a feature of CPython that previously prevented multiple threads from executing
Python  bytecode  simultaneously.  This  optional  build,  introduced  through  PEP  703,  enables  better
exploitation of multi-core CPUs. By allowing multiple threads to run Python code in parallel, the free-
threaded  mode  addresses  long-standing  performance  bottlenecks  associated  with  the  GIL.  This  change
offers a new path for parallelism in Python, without resorting to multiprocessing or external concurrency
frameworks.[65]

Some  additional  standard-library  modules  will  be  removed  in  Python  3.15  or  3.16,  as  will  be  many
deprecated classes, functions and methods.[66][67]

Python 3.11 adds Sigstore digital verification signatures for all CPython artifacts (in addition to the now
deprecated  PGP  signatures);  the  use  of  PGP  has  been  criticized  by  security  practitioners,  Python  is
transitioning to Sigstore exclusively and plans to drop PGP in version 3.14.[68]

Python  3.12  removed  wstr  meaning  Python  extensions[69]  need  to  be  modified,[70]  and  3.10  added
pattern matching to the language.[71]

Python 3.12 dropped some outdated modules, and more will be dropped in the future, deprecated as of
3.13; already deprecated array 'u' format code will emit DeprecationWarning since 3.13 and will be
removed in Python 3.16. The 'w' format code should be used instead. Part of ctypes is also deprecated and
http.server.CGIHTTPRequestHandler  will  emit  a  DeprecationWarning,  and  will  be  removed
in 3.15. Using that code already has a high potential for both security and functionality bugs. Parts of the
typing module are deprecated, e.g. creating a typing.NamedTuple class using keyword arguments to
denote the fields and such (and more) will be disallowed in Python 3.15.

Python 3.14 is now in the alpha 3 phase. With regard to possible change to annotations, "In Python 3.14,
from  __future__  import  annotations  will  continue  to  work  as  it  did  before,  converting
annotations into strings."[72]

Python  Enhancement  Proposal  (PEP)  711  proposes  PyBI—a  standard  format  for  distributing  Python
binaries.[73]

Python 3.15 will "Make UTF-8 mode default";[74] This mode is supported in all current Python versions,
but it currently must be opted into. UTF-8 is already used by default on Windows (and other operating
systems) for most purposes; an exception is opening files. Enabling UTF-8 also makes code fully cross-
platform.

Design philosophy and features

Python  is  a  multi-paradigm  programming  language.  Object-oriented  programming  and  structured
programming are fully supported, and many of their features support functional programming and aspect-
oriented programming (including metaprogramming[75] and metaobjects).[76] Many other paradigms are
supported via extensions, including design by contract[77][78] and logic programming.[79] Python is often
referred  to  as  a  'glue  language'[80]  because  it  can  seamlessly  integrate  components  written  in  other
languages.

Python  uses  dynamic  typing  and  a  combination  of  reference  counting  and  a  cycle-detecting  garbage
collector  for  memory  management.[81]  It  uses  dynamic  name  resolution  (late  binding),  which  binds
method and variable names during program execution.

Python's  design  offers  some  support  for  functional  programming  in  the  Lisp  tradition.  It  has
filter,mapandreduce
sets,  and  generator
expressions.[82] The standard library has two modules (itertools and functools) that implement
functional tools borrowed from Haskell and Standard ML.[83]

list  comprehensions,  dictionaries,

functions;

Python's core philosophy is summarized in the Zen of Python (PEP 20), which includes aphorisms such
as these:[84]

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Readability counts.

However,  Python  features  regularly  violate  these  principles  and  have  received  criticism  for  adding
unnecessary language bloat.[85] Responses to these criticisms note that the Zen of Python is a guideline
rather  than  a  rule.[86]  The  addition  of  some  new  features  had  been  controversial:  Guido  van  Rossum
resigned as Benevolent Dictator for Life after conflict about adding the assignment expression operator in
Python 3.8.[87][88]

Nevertheless,  rather  than  building  all  functionality  into  its  core,  Python  was  designed  to  be  highly
extensible via modules. This compact modularity has made it particularly popular as a means of adding
programmable  interfaces  to  existing  applications. Van  Rossum's  vision  of  a  small  core  language  with  a

large  standard  library  and  easily  extensible  interpreter  stemmed  from  his  frustrations  with ABC,  which
represented the opposite approach.[42]

Python claims to strive for a simpler, less-cluttered syntax and grammar, while giving developers a choice
in  their  coding  methodology.  In  contrast  to  Perl's  motto  "there  is  more  than  one  way  to  do  it",  Python
advocates an approach where "there should be one—and preferably only one—obvious way to do it.".[84]
In practice, however, Python provides many ways to achieve a given goal. There are, for example, at least
three ways to format a string literal, with no certainty as to which one a programmer should use.[89] Alex
Martelli  is  a  Fellow  at  the  Python  Software  Foundation  and  Python  book  author;  he  wrote  that  "To
describe something as 'clever' is not considered a compliment in the Python culture."[90]

Python's developers usually try to avoid premature optimization; they also reject patches to non-critical
parts of the CPython reference implementation that would offer marginal increases in speed at the cost of
clarity.[91]  Execution  speed  can  be  improved  by  moving  speed-critical  functions  to  extension  modules
written in languages such as C, or by using a just-in-time compiler like PyPy. It is also possible to cross-
compile to other languages; but this approach either fails to achieve the expected speed-up, since Python
is  a  very  dynamic  language,  or  only  a  restricted  subset  of  Python  is  compiled  (with  potential  minor
semantic changes).[92]

Python's developers aim for the language to be fun to use. This goal is reflected in the name—a tribute to
the British comedy group Monty Python[93]—and in playful approaches to some tutorials and reference
materials. For instance, some code examples use the terms "spam" and "eggs" (in reference to a Monty
Python sketch), rather than the typical terms "foo" and "bar".[94][95] A common neologism in the Python
community is pythonic, which has a wide range of meanings related to program style. Pythonic code may
use Python idioms well; be natural or show fluency in the language; or conform with Python's minimalist
philosophy and emphasis on readability.[96]

Syntax and semantics

Python is meant to be an easily readable language. Its formatting
is  visually  uncluttered  and  often  uses  English  keywords  where
other  languages  use  punctuation.  Unlike  many  other  languages,
it does not use curly brackets to delimit blocks, and semicolons
after  statements  are  allowed  but  rarely  used.  It  has  fewer
syntactic exceptions and special cases than C or Pascal.[97]

Indentation

Python uses whitespace indentation, rather than curly brackets or
keywords,  to  delimit  blocks. An  increase  in  indentation  comes
after  certain  statements;  a  decrease  in  indentation  signifies  the  end  of  the  current  block.[98]  Thus,  the
program's  visual  structure  accurately  represents  its  semantic  structure.[99]  This  feature  is  sometimes
termed the off-side rule. Some other languages use indentation this way; but in most, indentation has no
semantic meaning. The recommended indent size is four spaces.[100]

An example of Python code and
indentation

Statements and control flow

Python's statements include the following:

The assignment statement, using a single equals sign
=

The if statement, which conditionally executes a
block of code, along with else and elif (a
contraction of else if)

The for statement, which iterates over an iterable
object, capturing each element to a local variable for
use by the attached block

Example of C# code with curly braces
and semicolons

The while statement, which executes a block of code as long as its condition is true

The try statement, which allows exceptions raised in its attached code block to be caught
and handled by except clauses (or new syntax except* in Python 3.11 for exception
groups[101]); the try statement also ensures that clean-up code in a finally block is
always run regardless of how the block exits

The raise statement, used to raise a specified exception or re-raise a caught exception

The class statement, which executes a block of code and attaches its local namespace to
a class, for use in object-oriented programming

The def statement, which defines a function or method

The with statement, which encloses a code block within a context manager, allowing
resource-acquisition-is-initialization (RAII)-like behavior and replacing a common try/finally
idiom[102] Examples of a context include acquiring a lock before some code is run, and then
releasing the lock; or opening and then closing a file

The break statement, which exits a loop

The continue statement, which skips the rest of the current iteration and continues with
the next

The del statement, which removes a variable—deleting the reference from the name to the
value, and producing an error if the variable is referred to before it is redefined [a]
The pass statement, serving as a NOP (i.e., no operation), which is syntactically needed to
create an empty code block

The assert statement, used in debugging to check for conditions that should apply

The yield statement, which returns a value from a generator function (and also an
operator); used to implement coroutines

The return statement, used to return a value from a function

The import and from statements, used to import modules whose functions or variables
can be used in the current program

The match and case statements, analogous to a switch statement construct, which
compares an expression against one or more cases as a control-flow measure

The  assignment  statement  (=)  binds  a  name  as  a  reference  to  a  separate,  dynamically  allocated  object.
Variables may subsequently be rebound at any time to any object. In Python, a variable name is a generic
reference holder without a fixed data type; however, it always refers to some object with a type. This is
called dynamic typing—in contrast to statically-typed languages, where each variable may contain only a
value of a certain type.

Python does not support tail call optimization or first-class continuations; according to Van Rossum, the
language  never  will.[103][104]  However,  better  support  for  coroutine-like  functionality  is  provided  by
extending  Python's  generators.[105]  Before  2.5,  generators  were  lazy  iterators;  data  was  passed
unidirectionally out of the generator. From Python 2.5 on, it is possible to pass data back into a generator
function; and from version 3.3, data can be passed through multiple stack levels.[106]

Expressions

Python's expressions include the following:

The +, -, and * operators for mathematical addition, subtraction, and multiplication are
similar to other languages, but the behavior of division differs. There are two types of
division in Python: floor division (or integer division) //, and floating-point division /.[107]
Python uses the ** operator for exponentiation.

Python uses the + operator for string concatenation. The language uses the * operator for
duplicating a string a specified number of times.

The @ infix operator is intended to be used by libraries such as NumPy for matrix
multiplication.[108][109]
The syntax :=, called the "walrus operator", was introduced in Python 3.8. This operator
assigns values to variables as part of a larger expression.[110]
In Python, == compares two objects by value. Python's is operator may be used to
compare object identities (i.e., comparison by reference), and comparisons may be chained
—for example, a <= b <= c.

Python uses and, or, and not as Boolean operators.
Python has a type of expression called a list comprehension, and a more general
expression called a generator expression.[82]
Anonymous functions are implemented using lambda expressions; however, there may be
only one expression in each body.
Conditional expressions are written as x if c else y.[111] (This is different in operand
order from the c ? x : y operator common to many other languages.)

Python makes a distinction between lists and tuples. Lists are written as [1, 2, 3], are
mutable, and cannot be used as the keys of dictionaries (since dictionary keys must be
immutable in Python). Tuples, written as (1, 2, 3), are immutable and thus can be used
as the keys of dictionaries, provided that all of the tuple's elements are immutable. The +
operator can be used to concatenate two tuples, which does not directly modify their
contents, but produces a new tuple containing the elements of both. For example, given the
variable t initially equal to (1, 2, 3), executing t = t + (4, 5) first evaluates t +
(4, 5), which yields (1, 2, 3, 4, 5); this result is then assigned back to t—thereby
effectively "modifying the contents" of t while conforming to the immutable nature of tuple
objects. Parentheses are optional for tuples in unambiguous contexts.[112]
Python features sequence unpacking where multiple expressions, each evaluating to
something assignable (e.g., a variable or a writable property) are associated just as in
forming tuple literal; as a whole, the results are then put on the left-hand side of the equal
sign in an assignment statement. This statement expects an iterable object on the right-
hand side of the equal sign to produce the same number of values as the writable
expressions on the left-hand side; while iterating, the statement assigns each of the values
produced on the right to the corresponding expression on the left.[113]

Python has a "string format" operator % that functions analogously to printf format strings
in the C language—e.g. "spam=%s eggs=%d" % ("blah", 2) evaluates to
"spam=blah eggs=2". In Python 2.6+ and 3+, this operator was supplemented by the
format() method of the str class, e.g., "spam={0} eggs={1}".format("blah",
2). Python 3.6 added "f-strings": spam = "blah"; eggs = 2; f'spam={spam}
eggs={eggs}'.[114]
Strings in Python can be concatenated by "adding" them (using the same operator as for
adding integers and floats); e.g., "spam" + "eggs" returns "spameggs". If strings
contain numbers, they are concatenated as strings rather than as integers, e.g. "2" + "2"
returns "22".
Python supports string literals in several ways:

Delimited by single or double quotation marks; single and double quotation marks have
equivalent functionality (unlike in Unix shells, Perl, and Perl-influenced languages). Both
marks use the backslash (\) as an escape character. String interpolation became
available in Python 3.6 as "formatted string literals".[114]
Triple-quoted, i.e., starting and ending with three single or double quotation marks; this
may span multiple lines and function like here documents in shells, Perl, and Ruby.

Raw string varieties, denoted by prefixing the string literal with r. Escape sequences are
not interpreted; hence raw strings are useful where literal backslashes are common,
such as in regular expressions and Windows-style paths. (Compare "@-quoting" in C#.)

Python has array index and array slicing expressions in lists, which are written as a[key],
a[start:stop] or a[start:stop:step]. Indexes are zero-based, and negative
indexes are relative to the end. Slices take elements from the start index up to, but not
including, the stop index. The (optional) third slice parameter, called step or stride, allows
elements to be skipped or reversed. Slice indexes may be omitted—for example, a[:]
returns a copy of the entire list. Each element of a slice is a shallow copy.

In Python, a distinction between expressions and statements is rigidly enforced, in contrast to languages
such  as  Common  Lisp,  Scheme,  or  Ruby.  This  distinction  leads  to  duplicating  some  functionality,  for
example:

List comprehensions vs. for-loops

Conditional expressions vs. if blocks

The eval() vs. exec() built-in functions (in Python 2, exec is a statement); the former
function is for expressions, while the latter is for statements

A statement cannot be part of an expression; because of this restriction, expressions such as list and dict
comprehensions (and lambda expressions) cannot contain statements. As a particular case, an assignment
statement such as a = 1 cannot be part of the conditional expression of a conditional statement.

Methods

Methods  of  objects  are  functions  attached  to  the  object's  class;  the  syntax  for  normal  methods  and
functions,  instance.method(argument),  is  syntactic  sugar  for  Class.method(instance,
argument). Python methods have an explicit self parameter to access instance data, in contrast to the
implicit  self  (or  this)  parameter  in  some  object-oriented  programming  languages  (e.g.,  C++,  Java,

Objective-C,  Ruby).[115]  Python  also  provides  methods,  often  called  dunder  methods  (because  their
names begin and end with double underscores); these methods allow user-defined classes to modify how
they are handled by native operations including length, comparison, arithmetic, and type conversion.[116]

Typing

Python uses duck typing, and it has typed objects but untyped
variable names. Type constraints are not checked at definition
time;  rather,  operations  on  an  object  may  fail  at  usage  time,
indicating  that  the  object  is  not  of  an  appropriate  type.
Despite  being  dynamically  typed,  Python  is  strongly  typed,
forbidding  operations  that  are  poorly  defined  (e.g.,  adding  a
number  and  a  string)  rather  than  quietly  attempting  to
interpret them.

Python  allows  programmers  to  define  their  own  types  using
classes,  most  often  for  object-oriented  programming.  New
instances  of  classes  are  constructed  by  calling  the  class,  for
example,  SpamClass()  or  EggsClass());  the  classes
are instances of the metaclass type (which is an instance of
itself), thereby allowing metaprogramming and reflection.

The standard type hierarchy in Python 3

Before  version  3.0,  Python  had  two  kinds  of  classes,  both  using  the  same  syntax:  old-style  and  new-
style.[117] Current Python versions support the semantics of only the new style.

Python supports optional type annotations.[4][118] These annotations are not enforced by the language, but
may  be  used  by  external  tools  such  as  mypy  to  catch  errors.[119][120]  Mypy  also  supports  a  Python
compiler called mypyc, which leverages type annotations for optimization.[121]

Summary of Python 3's built-in types

Type

Mutability

Description

Syntax examples

bool

immutable Boolean value

True
False

bytearray

bytes

mutable

Sequence of
bytes

bytearray(b'Some ASCII')
bytearray(b"Some ASCII")
bytearray([119, 105, 107, 105])

immutable

Sequence of
bytes

b'Some ASCII'
b"Some ASCII"
bytes([119, 105, 107, 105])

complex

immutable

Complex
number with real
and imaginary
parts

3+2.7j
3 + 2.7j

dict

mutable

types.EllipsisType

immutable

float

immutable

frozenset

immutable

Associative
array (or
dictionary) of
key and value
pairs; can
contain mixed
types (keys and
values); keys
must be a
hashable type

An ellipsis
placeholder to
be used as an
index in NumPy
arrays

Double-
precision
floating-point
number. The
precision is
machine-
dependent, but
in practice it is
generally
implemented as
a 64-bit
IEEE 754
number with
53 bits of
precision.[122]

Unordered set,
contains no
duplicates; can
contain mixed
types, if
hashable

Integer of
unlimited
magnitude[123]

{'key1': 1.0, 3: False}
{}

...
Ellipsis

1.33333

frozenset([4.0, 'string', True])

42

int

list

immutable

mutable

List, can contain
mixed types

[4.0, 'string', True]
[]

types.NoneType

immutable

types.NotImplementedType

immutable

range

immutable

set

mutable

str

immutable

An object
representing the
absence of a
value, often
called null in
other languages

A placeholder
that can be
returned from
overloaded
operators to
indicate
unsupported
operand types.

An immutable
sequence of
numbers,
commonly used
for iterating a
specific number
of times in for
loops[124]

Unordered set,
contains no
duplicates; can
contain mixed
types, if
hashable

A character
string: sequence
of Unicode
codepoints

None

NotImplemented

range(−1, 10)
range(10, −5, −2)

{4.0, 'string', True}
set()

'Wikipedia'
"Wikipedia"

"""Spanning
multiple
lines"""

Spanning
multiple
lines

tuple

immutable

Tuple, can
contain mixed
types

(4.0, 'string', True)
('single element',)
()

Arithmetic operations

Python  includes  conventional  symbols  for  arithmetic  operators  (+,  -,  *,  /),  the  floor-division  operator
//, and the modulo operator %. (With the module operator, a remainder can be negative, e.g., 4 % -3
== -2.) Python also offers the ** symbol for exponentiation, e.g. 5**3 == 125 and 9**0.5 ==
3.0;  it  also  offers  the  matrix‑multiplication  operator  @  .[125]  These  operators  work  as  in  traditional
mathematics; with the same precedence rules, the infix operators + and - can also be unary, to represent
positive and negative numbers respectively.

Division  between  integers  produces  floating-point  results.  The  behavior  of  division  has  changed
significantly over time:[126]

The current version of Python (i.e., since 3.0) changed the / operator to always represent
floating-point division, e.g., 5/2 == 2.5.

The floor division // operator was introduced. Thus 7//3 == 2, -7//3 == -3, 7.5//3
== 2.0, and -7.5//3 == -3.0. For outdated Python 2.7 adding the
from __future__ import division statement causes a module in Python 2.7 to use
Python 3.0 rules for division instead (see above).

In  Python  terms,  the  /  operator  represents  true  division  (or  simply  division),  while  the  //  operator
represents floor division. Before version 3.0, the / operator represents classic division.[126]

Rounding towards negative infinity, though a different method than in most languages, adds consistency
to  Python.  For  instance,  this  rounding  implies  that  the  equation  (a  +  b)//b  ==  a//b  +  1  is
always  true. The  rounding  also  implies  that  the  equation  b*(a//b)  +  a%b  ==  a  is  valid  for  both
positive  and  negative  values  of  a. As  expected,  the  result  of  a%b  lies  in  the  half-open  interval  [0,  b),
where  b  is  a  positive  integer;  however,  maintaining  the  validity  of  the  equation  requires  that  the  result
must lie in the interval (b, 0] when b is negative.[127]

Python provides a round function for rounding a float to the nearest integer. For tie-breaking, Python 3
uses the round to even method: round(1.5) and round(2.5) both produce 2.[128] Python versions
before  3  used  the  round-away-from-zero  method:  round(0.5)  is  1.0,  and  round(-0.5)  is
−1.0.[129]

Python allows Boolean expressions that contain multiple equality relations to be consistent with general
usage in mathematics. For example, the expression a < b < c tests whether a is less than b and b is
less than c.[130] C-derived languages interpret this expression differently: in C, the expression would first
evaluate a < b, resulting in 0 or 1, and that result would then be compared with c.[131]

Python  uses  arbitrary-precision  arithmetic  for  all  integer  operations.  The  Decimal  type/class  in  the
decimal  module  provides  decimal  floating-point  numbers  to  a  pre-defined  arbitrary  precision  with
several  rounding  modes.[132]  The  Fraction  class  in  the  fractions  module  provides  arbitrary
precision for rational numbers.[133]

Due  to  Python's  extensive  mathematics  library  and  the  third-party  library  NumPy,  the  language  is
frequently  used
tasks  such  as  numerical  data  processing  and
manipulation.[134][135]

for  scientific  scripting

in

Function syntax

Functions are created in Python by using the def keyword. A function is defined similarly to how it is
called,  by  first  providing  the  function  name  and  then  the  required  parameters.  Here  is  an  example  of  a
function that prints its inputs:

def printer(input1, input2="already there"):
    print(input1)
    print(input2)

printer("hello")

# Example output:
# hello
# already there

To assign a default value to a function parameter in case no actual value is provided at run time, variable-
definition syntax can be used inside the function header.

Code examples

"Hello, World!" program:

print('Hello, world!')

Program to calculate the factorial of a positive integer:

1
2
3
4
5
6
7
8
9
10

n = int(input('Type a number, and its factorial will be printed: '))

if n < 0:
    raise ValueError('You must enter a non-negative integer')

factorial = 1
for i in range(2, n + 1):
    factorial *= i

print(factorial)

Libraries

Python's large standard library[136] is commonly cited as one of its greatest strengths. For Internet-facing
applications, many standard formats and protocols such as MIME and HTTP are supported. The language
includes  modules  for  creating  graphical  user  interfaces,  connecting  to  relational  databases,  generating
pseudorandom  numbers,  arithmetic  with  arbitrary-precision  decimals,[132]  manipulating  regular
expressions, and unit testing.

Some parts of the standard library are covered by specifications—for example, the Web Server Gateway
Interface (WSGI) implementation wsgiref follows PEP 333[137]—but most parts are specified by their
code,  internal  documentation,  and  test  suites.  However,  because  most  of  the  standard  library  is  cross-
platform Python code, only a few modules must be altered or rewritten for variant implementations.

As  of  13  March  2025,  the  Python  Package  Index  (PyPI),  the  official  repository  for  third-party  Python
software,  contains  over  614,339[138]  packages. These  have  a  wide  range  of  functionality,  including  the
following:

Automation
Data analytics
Databases
Documentation
Graphical user interfaces
Image processing
Machine learning
Mobile apps
Multimedia

Computer networking
Scientific computing
System administration
Test frameworks
Text processing
Web frameworks
Web scraping

Development environments

Most Python implementations (including CPython) include a read–eval–print loop (REPL); this permits
the environment to function as a command line interpreter, with which users enter statements sequentially
and receive results immediately.

Python is also bundled with an integrated development environment (IDE) called IDLE, which is oriented
toward beginners.

Other shells, including IDLE and IPython, add additional capabilities such as improved auto-completion,
session-state retention, and syntax highlighting.

Standard desktop IDEs include PyCharm, IntelliJ Idea, Visual Studio Code; there are also web browser-
based IDEs, such as the following environments:

SageMath, for developing science- and math-related programs;
Jupyter Notebooks, an open-source interactive computing platform;
PythonAnywhere, a browser-based IDE and hosting environment; and
Canopy IDE, a commercial IDE that emphasizes scientific computing.[139][140]

Implementations

Reference implementation

CPython is the reference implementation of Python. This implementation is written in C, meeting the C11
standard[141] (since version 3.11, older versions use the C89 standard with several select C99 features),
but third-party extensions are not limited to older C versions—e.g., they can be implemented using C11
or  C++.[142][143]  CPython  compiles  Python  programs  into  an  intermediate  bytecode,[144]  which  is  then
executed  by  a  virtual  machine.[145]  CPython  is  distributed  with  a  large  standard  library  written  in  a
combination of C and native Python.

CPython  is  available  for  many  platforms,  including  Windows  and  most  modern  Unix-like  systems,
including macOS (and Apple M1 Macs, since Python 3.9.1, using an experimental installer). Starting with
Python 3.9, the Python installer intentionally fails to install on Windows 7 and 8;[146][147] Windows XP
was  supported  until  Python  3.5,  with  unofficial  support  for  VMS.[148]  Platform  portability  was  one  of
Python's  earliest  priorities.[149]  During  development  of  Python  1  and  2,  even  OS/2  and  Solaris  were
supported;[150] since that time, support has been dropped for many platforms.

All  current  Python  versions  (since  3.7)  support  only  operating  systems  that  feature  multithreading,  by
now supporting not nearly as many operating systems (dropping many outdated) than in the past.

Other implementations

All alternative implementations have at least slightly different semantic. For example, an alternative may
include  unordered  dictionaries,  in  contrast  to  other  current  Python  versions. As  another  example  in  the
larger  Python  ecosystem,  PyPy  does  not  support  the  full  C  Python  API.  Alternative  implementations
include the following:

PyPy is a fast, compliant interpreter of Python 2.7 and 3.10.[151][152] PyPy's just-in-time
compiler often improves speed significantly relative to CPython, but PyPy does not support
some libraries written in C.[153] PyPy offers support for the RISC-V instruction-set
architecture, for example.
Codon is an implentation with an ahead-of-time (AOT) compiler, which compiles a statically-
typed Python-like language whose "syntax and semantics are nearly identical to Python's,
there are some notable differences"[154] For example, Codon uses 64-bit machine integers
for speed, not arbitrarily as with Python; Codon developers claim that speedups over
CPython are usually on the order of ten to a hundred times. Codon compiles to machine
code (via LLVM) and supports native multithreading.[155] Codon can also compile to Python
extension modules that can be imported and used from Python.
MicroPython and CircuitPython are Python 3 variants that are optimized for microcontrollers,
including the Lego Mindstorms EV3.[156]
Pyston is a variant of the Python runtime that uses just-in-time compilation to speed up
execution of Python programs.[157]
Cinder is a performance-oriented fork of CPython 3.8 that features a number of
optimizations, including bytecode inline caching, eager evaluation of coroutines, a method-
at-a-time JIT, and an experimental bytecode compiler.[158]
The Snek[159][160][161] embedded computing language "is Python-inspired, but it is not
Python. It is possible to write Snek programs that run under a full Python system, but most
Python programs will not run under Snek."[162] Snek is compatible with 8-bit AVR
microcontrollers such as ATmega 328P-based Arduino, as well as larger microcontrollers
that are compatible with MicroPython. Snek is an imperative language that (unlike Python)
omits object-oriented programming. Snek supports only one numeric data type, which
features 32-bit single precision (resembling JavaScript numbers, though smaller).

Unsupported implementations

Stackless  Python  is  a  significant  fork  of  CPython  that  implements  microthreads.  This  implementation
uses the call stack differently, thus allowing massively concurrent programs. PyPy also offers a stackless
version.[163]

Just-in-time Python compilers have been developed, but are now unsupported:

Google began a project named Unladen Swallow in 2009: this project aimed to speed up the
Python interpreter five-fold by using LLVM, and improve multithreading capability for scaling
to thousands of cores,[164] while typical implementations are limited by the global interpreter
lock.
Psyco is a discontinued just-in-time specializing compiler, which integrates with CPython
and transforms bytecode to machine code at runtime. The emitted code is specialized for

certain data types and is faster than standard Python code. Psyco does not support
Python 2.7 or later.
PyS60 was a Python 2 interpreter for Series 60 mobile phones, which was released by
Nokia in 2005. The interpreter implemented many modules from Python's standard library,
as well as additional modules for integration with the Symbian operating system. The Nokia
N900 also supports Python through the GTK widget library, allowing programs to be written
and run on the target device.[165]

Cross-compilers to other languages

There are several compilers/transpilers to high-level object languages; the source language is unrestricted
Python, a subset of Python, or a language similar to Python:

Brython,[166] Transcrypt,[167][168] and Pyjs compile Python to JavaScript. (The latest release
of Pyjs was in 2012.)
Cython compiles a superset of Python to C. The resulting code can be used with Python via
direct C-level API calls into the Python interpreter.
PyJL compiles/transpiles a subset of Python to "human-readable, maintainable, and high-
performance Julia source code".[92] Despite the developers' performance claims, this is not
possible for arbitrary Python code; that is, compiling to a faster language or machine code is
known to be impossible in the general case. The semantics of Python might potentially be
changed, but in many cases speedup is possible with few or no changes in the Python
code. The faster Julia source code can then be used from Python or compiled to machine
code.
Nuitka compiles Python into C.[169] This compiler works with Python 3.4 to 3.12 (and 2.6 and
2.7) for Python's main supported platforms (and Windows 7 or even Windows XP) and for
Android. The compiler developers claim full support for Python 3.10, partial support for
Python 3.11 and 3.12, and experimental support for Python 3.13. Nuitka supports macOS
including Apple Silicon-based versions. The compiler is free of cost, though it has
commercial add-ons (e.g., for hiding source code).
Numba is a JIT compiler that is used from Python; the compiler translates a subset of
Python and NumPy code into fast machine code. This tool is enabled by adding a decorator
to the relevant Python code.
Pythran compiles a subset of Python 3 to C++ (C++11).[170]
RPython can be compiled to C, and it is used to build the PyPy interpreter for Python.
The Python → 11l → C++ transpiler[171] compiles a subset of Python 3 to C++ (C++17).

There are also specialized compilers:

MyHDL is a Python-based hardware description language (HDL) that converts MyHDL code
to Verilog or VHDL code.

Some older projects existed, as well as compilers not designed for use with Python 3.x and related syntax:

Google's Grumpy transpiles Python 2 to Go.[172][173][174] The latest release was in 2017.
IronPython allows running Python 2.7 programs with the .NET Common Language
Runtime.[175] An alpha version (released in 2021), is available for "Python 3.4, although
features and behaviors from later versions may be included."[176]
Jython compiles Python 2.7 to Java bytecode, allowing the use of Java libraries from a
Python program.[177]

Pyrex (last released in 2010) and Shed Skin (last released in 2013) compile to C and C++
respectively.

Performance

A perforance comparison among various Python implementations, using a non-numerical (combinatorial)
workload,  was  presented  at  EuroSciPy  '13.[178]  In  addition,  Python's  performance  relative  to  other
programming languages is benchmarked by The Computer Language Benchmarks Game.[179]

There  are  several  approaches  to  optimizing  Python  performance,  given  the  inherent  slowness  of  an
interpreted language. These approaches include the following strategies or tools:

Just-in-time compilation: Dynamically compiling Python code just before it is executed. This
technique is used in libraries such as Numba and PyPy.
Static compilation: Python code is compiled into machine code sometime before execution.
An example of this approach is Cython, which compiles Python into C.
Concurrency and parallelism: Multiple tasks can be run simultaneously. Python contains
modules such as `multiprocessing` to support this form of parallelism. Moreover, this
approach helps to overcome limitations of the Global Interpreter Lock (GIL) in CPU tasks.
Efficient data structures: Performance can also be improved by using data types such as
Set for membership tests, or deque from collections for queue operations.

Language Development

Python's  development  is  conducted  largely  through  the  Python  Enhancement  Proposal  (PEP)  process;
this process is the primary mechanism for proposing major new features, collecting community input on
issues,  and  documenting  Python  design  decisions.[180]  Python  coding  style  is  covered  in  PEP  8.[181]
Outstanding  PEPs  are  reviewed  and  commented  on  by  the  Python  community  and  the  steering
council.[180]

Enhancement of the language corresponds with development of the CPython reference implementation.
The  mailing  list  python-dev  is  the  primary  forum  for  the  language's  development.  Specific  issues  were
originally  discussed  in  the  Roundup  bug  tracker  hosted  by  the  foundation.[182]  In  2022,  all  issues  and
discussions  were  migrated  to  GitHub.[183]  Development  originally  took  place  on  a  self-hosted  source-
code repository running Mercurial, until Python moved to GitHub in January 2017.[184]

CPython's  public  releases  have  three  types,  distinguished  by  which  part  of  the  version  number  is
incremented:

Backward-incompatible versions, where code is expected to break and must be manually
ported. The first part of the version number is incremented. These releases happen
infrequently—version 3.0 was released 8 years after 2.0. According to Guido van Rossum, a
version 4.0 will probably never exist.[185]
Major or "feature" releases are largely compatible with the previous version but introduce
new features. The second part of the version number is incremented. Starting with
Python 3.9, these releases are expected to occur annually.[186][187] Each major version is
supported by bug fixes for several years after its release.[188]
Bug fix releases,[189] which introduce no new features, occur approximately every three
months; these releases are made when a sufficient number of bugs have been fixed

upstream since the last release. Security vulnerabilities are also patched in these releases.
The third and final part of the version number is incremented.[189]

Many  alpha,  beta,  and  release-candidates  are  also  released  as  previews  and  for  testing  before  final
releases. Although there is a rough schedule for releases, they are often delayed if the code is not ready
yet. Python's development team monitors the state of the code by running a large unit test suite during
development.[190]

The major academic conference on Python is PyCon. There are also special Python mentoring programs,
such as PyLadies.

API documentation generators

Tools  that  can  generate  documentation  for  Python API  include  pydoc  (available  as  part  of  the  standard
library); Sphinx; and Pdoc and its forks, Doxygen and Graphviz.[191]

Naming

Python's name is inspired by the British comedy group Monty Python, whom Python creator Guido van
Rossum  enjoyed  while  developing  the  language.  Monty  Python  references  appear  frequently  in  Python
code and culture;[192] for example, the metasyntactic variables often used in Python literature are spam
and eggs, rather than the traditional foo and bar.[192][193] The official Python documentation also contains
various  references  to  Monty  Python  routines.[194][195]  Python  users  are  sometimes  referred  to  as
"Pythonistas".[196]

The  affix  Py  is  often  used  when  naming  Python  applications  or  libraries.  Some  examples  include  the
following:

Pygame, a binding of Simple DirectMedia Layer to Python (commonly used to create
games);
PyQt and PyGTK, which bind Qt and GTK to Python respectively;
PyPy, a Python implementation originally written in Python;
NumPy, a Python library for numerical processing.

Popularity

Since 2003, Python has consistently ranked in the top ten of the most popular programming languages in
the  TIOBE  Programming  Community  Index;  as  of  December  2022,  Python  was  the  most  popular
language.[40] Python was selected as Programming Language of the Year (for "the highest rise in ratings
in a year") in 2007, 2010, 2018, and 2020—the only language to have done so four times as of 2020[197]).
In the TIOBE Index, monthly rankings are based on the volume of searches for programming languages
on  Google, Amazon,  Wikipedia,  Bing,  and  20  other  platforms. According  to  the  accompanying  graph,
Python  has  shown  a  marked  upward  trend  since  the  early  2000s,  eventually  passing  more  established
languages  such  as  C,  C++,  and  Java.  This  trend  can  be  attributed  to  Python's  readable  syntax,
comprehensive standard library, and application in data science and machine learning fields.[198]

CERN,[201]

Yahoo!,[200]

Large  organizations  that  use  Python  include  Wikipedia,
Google,[199]
NASA,[202]
Facebook,[203]  Amazon,  Instagram,[204]  Spotify,[205]  and
some  smaller  entities  such  as  Industrial  Light  &  Magic[206]
and  ITA.[207]  The  social  news  networking  site  Reddit  was
developed  mostly  in  Python.[208]  Organizations  that  partly
use Python include Discord[209] and Baidu.[210]

TIOBE Index Chart showing Python's
popularity compared to other
programming languages

Types of Use

Python has many uses, including the following:

Scripting for web applications
Scientific computing
Artificial-intelligence and machine-learning projects
Graphical user interfaces and desktop environments
Embedded scripting in software and hardware
products
Operating systems
Information security

Software that is powered by Python

Python can serve as a scripting language for web applications,
e.g.,  via  the  mod_wsgi  module  for  the Apache  web  server.[211]  With  Web  Server  Gateway  Interface,  a
standard  API  has  evolved  to  facilitate  these  applications.  Web  frameworks  such  as  Django,  Pylons,
Pyramid,  TurboGears,  web2py,  Tornado,  Flask,  Bottle,  and  Zope  support  developers  in  the  design  and
maintenance of complex applications. Pyjs and IronPython can be used to develop the client-side of Ajax-
based  applications.  SQLAlchemy  can  be  used  as  a  data  mapper  to  a  relational  database.  Twisted  is  a
framework  to  program  communication  between  computers;  this  framework  is  used  by  Dropbox,  for
example.

Libraries  such  as  NumPy,  SciPy  and  Matplotlib  allow  the  effective  use  of  Python  in  scientific
computing,[212][213] with specialized libraries such as Biopython and Astropy providing domain-specific
functionality. SageMath is a computer algebra system with a notebook interface that is programmable in
Python;  the  SageMath  library  covers  many  aspects  of  mathematics,  including  algebra,  combinatorics,
numerical mathematics, number theory, and calculus.[214] OpenCV has Python bindings with a rich set of
features for computer vision and image processing.[215]

Python  is  commonly  used  in  artificial-intelligence  and  machine-learning  projects,  with  support  from
libraries
logic
language).[216][217][218][219][220] As a scripting language with a modular architecture, simple syntax, and
rich text processing tools, Python is often used for natural language processing.[221]

as  TensorFlow,  Keras,  Pytorch,

and  ProbLog

scikit-learn

such

(a

The  combination  of  Python  and  Prolog  has  proven  useful  for  AI  applications,  with  Prolog  providing
knowledge representation and reasoning capabilities. The Janus system, in particular, exploits similarities
between  these  two  languages,  in  part  because  of  their  dynamic  typing  and  their  simple,  recursive  data
structures.  This  combination  is  typically  applied  natural  language  processing,  visual  query  answering,

geospatial  reasoning,  and  handling  semantic  web  data.[222][223]  The  Natlog  system,  implemented  in
Python, uses Definite Clause Grammars (DCGs) to create prompts for two types of generators: text-to-
text generators such as GPT3, and text-to-image generators such as DALL-E or Stable Diffusion.[224]

Python can be used for graphical user interfaces (GUIs), by using libraries such as Tkinter.[225] Similarly,
for the One Laptop per Child XO computer, most of the Sugar desktop environment is written in Python
(as of 2008).[226]

Python  is  embedded  in  many  software  products  (and  some  hardware  products)  as  a  scripting  language.
These products include the following:

finite element method software such as Abaqus,
3D parametric modelers such as FreeCAD,
3D animation packages such as 3ds Max, Blender, Cinema 4D, Lightwave, Houdini, Maya,
modo, MotionBuilder, Softimage,
the visual effects compositor Nuke,
2D imaging programs such as GIMP,[227] Inkscape, Scribus and Paint Shop Pro,[228] and
musical notation programs such as scorewriter and capella.

Similarly,  GNU  Debugger  uses  Python  as  a  pretty  printer  to  show  complex  structures  such  as  C++
containers.  Esri  promotes  Python  as  the  best  choice  for  writing  scripts  in ArcGIS.[229]  Python  has  also
been  used  in  several  video  games,[230][231]  and  it  has  been  adopted  as  first  of  the  three  programming
languages available in Google App Engine (the other two being Java and Go).[232] LibreOffice includes
Python, and its developers plan to replace Java with Python; LibreOffice's Python Scripting Provider is a
core feature[233] since version 4.0 (from 7 February 2013).

Among  hardware  products,  the  Raspberry  Pi  single-board  computer  project  has  adopted  Python  as  its
main user-programming language.

Many  operating  systems  include  Python  as  a  standard  component.  Python  ships  with  most  Linux
distributions,[234] AmigaOS 4 (using Python 2.7), FreeBSD (as a package), NetBSD, and OpenBSD (as a
package);  it  can  be  used  from  the  command  line  (terminal).  Many  Linux  distributions  use  installers
written  in  Python:  Ubuntu  uses  the  Ubiquity  installer,  while  Red  Hat  Linux  and  Fedora  Linux  use  the
Anaconda installer. Gentoo Linux uses Python in its package management system, Portage.[235]

is  used  extensively

Python
development.[236][237]

in

the

information

security

industry,

including

in  exploit

Languages influenced by Python

Python's design and philosophy have influenced many other programming languages:

Boo uses indentation, a similar syntax, and a similar object model.[238]
Cobra uses indentation and a similar syntax; its Acknowledgements document lists Python
first among influencing languages.[239]
CoffeeScript, a programming language that cross-compiles to JavaScript, has a Python-
inspired syntax.
ECMAScript–JavaScript borrowed iterators and generators from Python.[240]

GDScript, a Python-like scripting language that is built in to the Godot game engine.[241]
Go is designed for "speed of working in a dynamic language like Python"[242]; Go shares
Python's syntax for slicing arrays.
Groovy was motivated by a desire to incorporate the Python design philosophy into
Java.[243]
Julia was designed to be "as usable for general programming as Python".[27]
Mojo is a non-strict[28][244] superset of Python (e.g., omitting classes, and adding struct).[245]
Nim uses indentation and a similar syntax.[246]
Ruby's creator, Yukihiro Matsumoto, said that "I wanted a scripting language that was more
powerful than Perl, and more object-oriented than Python. That's why I decided to design
my own language."[247]
Swift, a programming language developed by Apple, has some Python-inspired syntax.[248]
Kotlin blends Python and Java features, which minimizes boilerplate code and enhances
developer efficiency.[249]

Python's  development  practices  have  also  been  emulated  by  other  languages.  For  example,  Python
requires a document that describes the rationale and context for any language change; this document is
known  as  a  Python  Enhancement  Proposal  or  PEP.  This  practice  is  also  used  by  the  developers  of
Tcl,[250] Erlang,[251] and Swift.[252]

See also

Computer
programming portal
Free and open-
source software
portal

Python syntax and semantics
pip (package manager)
List of programming languages
History of programming languages
Comparison of programming languages

Notes

a. del in Python does not behave the same way delete in languages such as C++ does,

where such a word is used to call the destructor and deallocate heap memory.

References

1. "General Python FAQ – Python 3 documentation" (https://docs.python.org/3/faq/general.htm

l#what-is-python). docs.python.org. Retrieved 7 July 2024.

2. "Python 0.9.1 part 01/21" (https://www.tuhs.org/Usenet/alt.sources/1991-February/001749.h
tml). alt.sources archives. Archived (https://web.archive.org/web/20210811171015/https://w
ww.tuhs.org/Usenet/alt.sources/1991-February/001749.html) from the original on 11 August
2021. Retrieved 11 August 2021.

3. "Why is Python a dynamic language and also a strongly typed language" (https://wiki.pytho

n.org/moin/Why%20is%20Python%20a%20dynamic%20language%20and%20also%20a%2
0strongly%20typed%20language). Python Wiki. Archived (https://web.archive.org/web/2021
0314173706/https://wiki.python.org/moin/Why%20is%20Python%20a%20dynamic%20langu
age%20and%20also%20a%20strongly%20typed%20language) from the original on 14
March 2021. Retrieved 27 January 2021.

4. "PEP 483 – The Theory of Type Hints" (https://www.python.org/dev/peps/pep-0483/).

Python.org. Archived (https://web.archive.org/web/20200614153558/https://www.python.org/
dev/peps/pep-0483/) from the original on 14 June 2020. Retrieved 14 June 2018.

5. "PEP 11 – CPython platform support | peps.python.org" (https://peps.python.org/pep-0011/).

Python Enhancement Proposals (PEPs). Retrieved 22 April 2024.

6. "PEP 738 – Adding Android as a supported platform | peps.python.org" (https://peps.python.

org/pep-0738/). Python Enhancement Proposals (PEPs). Retrieved 19 May 2024.
7. "Download Python for Other Platforms" (https://www.python.org/download/other/).

Python.org. Archived (https://web.archive.org/web/20201127015815/https://www.python.org/
download/other/) from the original on 27 November 2020. Retrieved 18 August 2023.

8. "test – Regression tests package for Python – Python 3.7.13 documentation" (https://docs.p
ython.org/3.7/library/test.html?highlight=android#test.support.is_android). docs.python.org.
Archived (https://web.archive.org/web/20220517151240/https://docs.python.org/3.7/library/t
est.html?highlight=android#test.support.is_android) from the original on 17 May 2022.
Retrieved 17 May 2022.

9. "platform – Access to underlying platform's identifying data – Python 3.10.4 documentation"

(https://docs.python.org/3/library/platform.html?highlight=android). docs.python.org.
Archived (https://web.archive.org/web/20220517150826/https://docs.python.org/3/library/pla
tform.html?highlight=android) from the original on 17 May 2022. Retrieved 17 May 2022.
10. Holth, Moore (30 March 2014). "PEP 0441 – Improving Python ZIP Application Support" (htt
ps://www.python.org/dev/peps/pep-0441/). Archived (https://web.archive.org/web/20181226
141117/https://www.python.org/dev/peps/pep-0441/%20) from the original on 26 December
2018. Retrieved 12 November 2015.

11. "Starlark Language" (https://docs.bazel.build/versions/master/skylark/language.html).

Archived (https://web.archive.org/web/20200615140534/https://docs.bazel.build/versions/m
aster/skylark/language.html) from the original on 15 June 2020. Retrieved 25 May 2019.
12. "Why was Python created in the first place?" (https://docs.python.org/faq/general.html#why-

was-python-created-in-the-first-place). General Python FAQ. Python Software Foundation.
Archived (https://web.archive.org/web/20121024164224/http://docs.python.org/faq/general.h
tml#why-was-python-created-in-the-first-place) from the original on 24 October 2012.
Retrieved 22 March 2007. "I had extensive experience with implementing an interpreted
language in the ABC group at CWI, and from working with this group I had learned a lot
about language design. This is the origin of many Python features, including the use of
indentation for statement grouping and the inclusion of very high-level data types (although
the details are all different in Python)."

13. "Ada 83 Reference Manual (raise statement)" (https://archive.adaic.com/standards/83lrm/ht
ml/lrm-11-03.html#11.3). Archived (https://web.archive.org/web/20191022155758/http://archi
ve.adaic.com/standards/83lrm/html/lrm-11-03.html#11.3) from the original on 22 October
2019. Retrieved 7 January 2020.

14. Kuchling, Andrew M. (22 December 2006). "Interview with Guido van Rossum (July 1998)"

(https://web.archive.org/web/20070501105422/http://www.amk.ca/python/writing/gvr-intervie
w). amk.ca. Archived from the original (http://www.amk.ca/python/writing/gvr-interview) on 1
May 2007. Retrieved 12 March 2012. "I'd spent a summer at DEC's Systems Research
Center, which introduced me to Modula-2+; the Modula-3 final report was being written there
at about the same time. What I learned there later showed up in Python's exception
handling, modules, and the fact that methods explicitly contain 'self' in their parameter list.
String slicing came from Algol-68 and Icon."

15. "itertools – Functions creating iterators for efficient looping – Python 3.7.1 documentation" (h

ttps://docs.python.org/3/library/itertools.html). docs.python.org. Archived (https://web.archiv
e.org/web/20200614153629/https://docs.python.org/3/library/itertools.html) from the original
on 14 June 2020. Retrieved 22 November 2016. "This module implements a number of
iterator building blocks inspired by constructs from APL, Haskell, and SML."

16. van Rossum, Guido (1993). "An Introduction to Python for UNIX/C Programmers".

Proceedings of the NLUUG Najaarsconferentie (Dutch UNIX Users Group).
CiteSeerX 10.1.1.38.2023 (https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.38.20
23). "even though the design of C is far from ideal, its influence on Python is considerable."

17. "Classes" (https://docs.python.org/tutorial/classes.html). The Python Tutorial. Python

Software Foundation. Archived (https://web.archive.org/web/20121023030209/http://docs.py
thon.org/tutorial/classes.html) from the original on 23 October 2012. Retrieved 20 February
2012. "It is a mixture of the class mechanisms found in C++ and Modula-3"

18. Lundh, Fredrik. "Call By Object" (http://effbot.org/zone/call-by-object.htm). effbot.org.

Archived (https://web.archive.org/web/20191123043655/http://effbot.org/zone/call-by-object.
htm) from the original on 23 November 2019. Retrieved 21 November 2017. "replace "CLU"
with "Python", "record" with "instance", and "procedure" with "function or method", and you
get a pretty accurate description of Python's object model."

19. Simionato, Michele. "The Python 2.3 Method Resolution Order" (https://www.python.org/dow
nload/releases/2.3/mro/). Python Software Foundation. Archived (https://web.archive.org/we
b/20200820231854/https://www.python.org/download/releases/2.3/mro/) from the original on
20 August 2020. Retrieved 29 July 2014. "The C3 method itself has nothing to do with
Python, since it was invented by people working on Dylan and it is described in a paper
intended for lispers"

20. Kuchling, A. M. "Functional Programming HOWTO" (https://docs.python.org/howto/functiona
l.html). Python v2.7.2 documentation. Python Software Foundation. Archived (https://web.ar
chive.org/web/20121024163217/http://docs.python.org/howto/functional.html) from the
original on 24 October 2012. Retrieved 9 February 2012. "List comprehensions and
generator expressions [...] are a concise notation for such operations, borrowed from the
functional programming language Haskell."

21. Schemenauer, Neil; Peters, Tim; Hetland, Magnus Lie (18 May 2001). "PEP 255 – Simple

Generators" (https://www.python.org/dev/peps/pep-0255/). Python Enhancement Proposals.
Python Software Foundation. Archived (https://web.archive.org/web/20200605012926/http
s://www.python.org/dev/peps/pep-0255/) from the original on 5 June 2020. Retrieved
9 February 2012.

22. "More Control Flow Tools" (https://docs.python.org/3.2/tutorial/controlflow.html). Python 3

documentation. Python Software Foundation. Archived (https://web.archive.org/web/201606
04080843/https://docs.python.org/3.2/tutorial/controlflow.html) from the original on 4 June
2016. Retrieved 24 July 2015. "By popular demand, a few features commonly found in
functional programming languages like Lisp have been added to Python. With the lambda
keyword, small anonymous functions can be created."

23. "re – Regular expression operations – Python 3.10.6 documentation" (https://docs.python.or
g/3/library/re.html). docs.python.org. Archived (https://web.archive.org/web/2018071813224
1/https://docs.python.org/3/library/re.html) from the original on 18 July 2018. Retrieved
6 September 2022. "This module provides regular expression matching operations similar to
those found in Perl."

24. "CoffeeScript" (https://coffeescript.org/). coffeescript.org. Archived (https://web.archive.org/w
eb/20200612100004/http://coffeescript.org/) from the original on 12 June 2020. Retrieved
3 July 2018.

25. "Perl and Python influences in JavaScript" (https://www.2ality.com/2013/02/javascript-influen
ces.html). www.2ality.com. 24 February 2013. Archived (https://web.archive.org/web/201812
26141121/http://2ality.com/2013/02/javascript-influences.html%0A) from the original on 26
December 2018. Retrieved 15 May 2015.

26. Rauschmayer, Axel. "Chapter 3: The Nature of JavaScript; Influences" (http://speakingjs.co
m/es5/ch03.html). O'Reilly, Speaking JavaScript. Archived (https://web.archive.org/web/201
81226141123/http://speakingjs.com/es5/ch03.html%0A) from the original on 26 December
2018. Retrieved 15 May 2015.

27. "Why We Created Julia" (https://julialang.org/blog/2012/02/why-we-created-julia). Julia

website. February 2012. Archived (https://web.archive.org/web/20200502144010/https://julia
lang.org/blog/2012/02/why-we-created-julia/) from the original on 2 May 2020. Retrieved
5 June 2014. "We want something as usable for general programming as Python [...]"

28. Krill, Paul (4 May 2023). "Mojo language marries Python and MLIR for AI development" (http
s://www.infoworld.com/article/3695588/mojo-language-marries-python-and-mlir-for-ai-develo
pment.html). InfoWorld. Archived (https://web.archive.org/web/20230505064554/https://ww
w.infoworld.com/article/3695588/mojo-language-marries-python-and-mlir-for-ai-developmen
t.html) from the original on 5 May 2023. Retrieved 5 May 2023.

29. Ring Team (4 December 2017). "Ring and other languages" (https://ring-lang.sourceforge.ne
t/doc1.6/introduction.html#ring-and-other-languages). ring-lang.net. ring-lang. Archived (http
s://web.archive.org/web/20181225175312/http://ring-lang.sourceforge.net/doc1.6/introductio
n.html#ring-and-other-languages) from the original on 25 December 2018. Retrieved
4 December 2017.

30. Bini, Ola (2007). Practical JRuby on Rails Web 2.0 Projects: bringing Ruby on Rails to the
Java platform (https://archive.org/details/practicaljrubyon0000bini/page/3). Berkeley:
APress. p. 3 (https://archive.org/details/practicaljrubyon0000bini/page/3). ISBN 978-1-
59059-881-8.

31. Lattner, Chris (3 June 2014). "Chris Lattner's Homepage" (http://nondot.org/sabre/). Chris
Lattner. Archived (https://web.archive.org/web/20181225175312/http://nondot.org/sabre/)
from the original on 25 December 2018. Retrieved 3 June 2014. "The Swift language is the
product of tireless effort from a team of language experts, documentation gurus, compiler
optimization ninjas, and an incredibly important internal dogfooding group who provided
feedback to help refine and battle-test ideas. Of course, it also greatly benefited from the
experiences hard-won by many other languages in the field, drawing ideas from Objective-
C, Rust, Haskell, Ruby, Python, C#, CLU, and far too many others to list."

32. "V documentation (Introduction)" (https://github.com/vlang/v/blob/master/doc/docs.md#intro

duction). GitHub. Retrieved 24 December 2024.

33. Kuhlman, Dave. "A Python Book: Beginning Python, Advanced Python, and Python

Exercises" (https://web.archive.org/web/20120623165941/http://cutter.rexx.com/~dkuhlman/
python_book_01.html). Section 1.1. Archived from the original (https://www.davekuhlman.or
g/python_book_01.pdf) (PDF) on 23 June 2012.

34. "About Python" (https://www.python.org/about). Python Software Foundation. Archived (http
s://web.archive.org/web/20120420010049/http://www.python.org/about/) from the original on
20 April 2012. Retrieved 24 April 2012., second section "Fans of Python use the phrase
"batteries included" to describe the standard library, which covers everything from
asynchronous processing to zip files."

35. "PEP 206 – Python Advanced Library" (https://www.python.org/dev/peps/pep-0206/).

Python.org. Archived (https://web.archive.org/web/20210505003659/https://www.python.org/
dev/peps/pep-0206/) from the original on 5 May 2021. Retrieved 11 October 2021.

36. Rossum, Guido Van (20 January 2009). "The History of Python: A Brief Timeline of Python"

(https://python-history.blogspot.com/2009/01/brief-timeline-of-python.html). The History of
Python. Archived (https://web.archive.org/web/20200605032200/https://python-history.blogs
pot.com/2009/01/brief-timeline-of-python.html) from the original on 5 June 2020. Retrieved
5 March 2021.

37. Peterson, Benjamin (20 April 2020). "Python 2.7.18, the last release of Python 2" (https://pyt

honinsider.blogspot.com/2020/04/python-2718-last-release-of-python-2.html). Python
Insider. Archived (https://web.archive.org/web/20200426204118/https://pythoninsider.blogsp
ot.com/2020/04/python-2718-last-release-of-python-2.html) from the original on 26 April
2020. Retrieved 27 April 2020.

38. "Stack Overflow Developer Survey 2022" (https://survey.stackoverflow.co/2022/). Stack

Overflow. Archived (https://web.archive.org/web/20220627175307/https://survey.stackoverfl
ow.co/2022/) from the original on 27 June 2022. Retrieved 12 August 2022.

39. "The State of Developer Ecosystem in 2020 Infographic" (https://www.jetbrains.com/lp/deve
cosystem-2020/). JetBrains: Developer Tools for Professionals and Teams. Archived (https://
web.archive.org/web/20210301062411/https://www.jetbrains.com/lp/devecosystem-2020/)
from the original on 1 March 2021. Retrieved 5 March 2021.

40. "TIOBE Index" (https://www.tiobe.com/tiobe-index/). TIOBE. Archived (https://web.archive.or

g/web/20180225101948/https://www.tiobe.com/tiobe-index/) from the original on 25
February 2018. Retrieved 3 January 2023. "The TIOBE Programming Community index is
an indicator of the popularity of programming languages" Updated as required.

41. "PYPL PopularitY of Programming Language index" (https://pypl.github.io/PYPL.html).

pypl.github.io. Archived (https://web.archive.org/web/20170314232030/https://pypl.github.io/
PYPL.html) from the original on 14 March 2017. Retrieved 26 March 2021.

42. Venners, Bill (13 January 2003). "The Making of Python" (http://www.artima.com/intv/python
P.html). Artima Developer. Artima. Archived (https://web.archive.org/web/20160901183332/h
ttp://www.artima.com/intv/pythonP.html) from the original on 1 September 2016. Retrieved
22 March 2007.

43. van Rossum, Guido (29 August 2000). "SETL (was: Lukewarm about range literals)" (https://

mail.python.org/pipermail/python-dev/2000-August/008881.html). Python-Dev (Mailing list).
Archived (https://web.archive.org/web/20180714064019/https://mail.python.org/pipermail/pyt
hon-dev/2000-August/008881.html) from the original on 14 July 2018. Retrieved 13 March
2011.

44. van Rossum, Guido (20 January 2009). "A Brief Timeline of Python" (https://python-history.bl

ogspot.com/2009/01/brief-timeline-of-python.html). The History of Python. Archived (https://
web.archive.org/web/20200605032200/https://python-history.blogspot.com/2009/01/brief-tim
eline-of-python.html) from the original on 5 June 2020. Retrieved 20 January 2009.

45. Fairchild, Carlie (12 July 2018). "Guido van Rossum Stepping Down from Role as Python's

Benevolent Dictator For Life" (https://www.linuxjournal.com/content/guido-van-rossum-steppi
ng-down-role-pythons-benevolent-dictator-life). Linux Journal. Archived (https://web.archive.
org/web/20180713192427/https://www.linuxjournal.com/content/guido-van-rossum-stepping-
down-role-pythons-benevolent-dictator-life) from the original on 13 July 2018. Retrieved
13 July 2018.

46. "PEP 8100" (https://www.python.org/dev/peps/pep-8100/). Python Software Foundation.

Archived (https://web.archive.org/web/20200604235027/https://www.python.org/dev/peps/p
ep-8100/) from the original on 4 June 2020. Retrieved 4 May 2019.

47. "PEP 13 – Python Language Governance" (https://www.python.org/dev/peps/pep-0013/).

Python.org. Archived (https://web.archive.org/web/20210527000035/https://www.python.org/
dev/peps/pep-0013/) from the original on 27 May 2021. Retrieved 25 August 2021.

48. Briggs, Jason R.; Lipovača, Miran (2013). Python for kids: a playful introduction to
programming. San Francisco, Calif: No Starch Press. ISBN 978-1-59327-407-8.

49. Kuchling, A. M.; Zadka, Moshe (16 October 2000). "What's New in Python 2.0" (https://docs.
python.org/whatsnew/2.0.html). Python Software Foundation. Archived (https://web.archive.
org/web/20121023112045/http://docs.python.org/whatsnew/2.0.html) from the original on 23
October 2012. Retrieved 11 February 2012.

50. "PEP 373 – Python 2.7 Release Schedule" (https://legacy.python.org/dev/peps/pep-0373/).
python.org. Archived (https://web.archive.org/web/20200519075520/https://legacy.python.or
g/dev/peps/pep-0373/) from the original on 19 May 2020. Retrieved 9 January 2017.

51. "PEP 466 – Network Security Enhancements for Python 2.7.x" (https://www.python.org/dev/
peps/pep-0466/). python.org. Archived (https://web.archive.org/web/20200604232833/http
s://www.python.org/dev/peps/pep-0466/) from the original on 4 June 2020. Retrieved
9 January 2017.

52. "Sunsetting Python 2" (https://www.python.org/doc/sunset-python-2/). Python.org. Archived
(https://web.archive.org/web/20200112080903/https://www.python.org/doc/sunset-python-
2/) from the original on 12 January 2020. Retrieved 22 September 2019.

53. "PEP 373 – Python 2.7 Release Schedule" (https://www.python.org/dev/peps/pep-0373/).

Python.org. Archived (https://web.archive.org/web/20200113033257/https://www.python.org/
dev/peps/pep-0373/) from the original on 13 January 2020. Retrieved 22 September 2019.

54. mattip (25 December 2023). "PyPy v7.3.14 release" (https://www.pypy.org/posts/2023/12/py
py-v7314-release.html). PyPy. Archived (https://web.archive.org/web/20240105132820/http
s://www.pypy.org/posts/2023/12/pypy-v7314-release.html) from the original on 5 January
2024. Retrieved 5 January 2024.

55. Langa, Łukasz (17 May 2022). "Python 3.9.13 is now available" (https://pythoninsider.blogsp
ot.com/2022/05/python-3913-is-now-available.html). Python Insider. Archived (https://web.ar
chive.org/web/20220517173546/https://pythoninsider.blogspot.com/2022/05/python-3913-is-
now-available.html) from the original on 17 May 2022. Retrieved 21 May 2022.

56. "Status of Python versions" (https://devguide.python.org/versions/). Python Developer's

Guide. Retrieved 7 October 2024.

57. "Python" (https://endoflife.date/python). endoflife.date. 8 October 2024. Retrieved

20 November 2024.

58. "CVE-2021-3177" (https://access.redhat.com/security/cve/cve-2021-3177). Red Hat

Customer Portal. Archived (https://web.archive.org/web/20210306183700/https://access.red
hat.com/security/cve/cve-2021-3177) from the original on 6 March 2021. Retrieved
26 February 2021.

59. "CVE-2021-3177" (https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-3177). CVE.
Archived (https://web.archive.org/web/20210227192918/https://cve.mitre.org/cgi-bin/cvenam
e.cgi?name=CVE-2021-3177) from the original on 27 February 2021. Retrieved 26 February
2021.

60. "CVE-2021-23336" (https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-23336).

CVE. Archived (https://web.archive.org/web/20210224160700/https://cve.mitre.org/cgi-bin/c
vename.cgi?name=CVE-2021-23336) from the original on 24 February 2021. Retrieved
26 February 2021.

61. "Built-in Types" (https://docs.python.org/3/library/stdtypes.html#types-union).
62. corbet (24 October 2022). "Python 3.11 released [LWN.net]" (https://lwn.net/Articles/91221

6/). lwn.net. Retrieved 15 November 2022.

63. "What's New In Python 3.13" (https://docs.python.org/3.13/whatsnew/3.13.html#experiment

al-jit-compiler). Python documentation. Retrieved 30 April 2024.

64. "PEP 667 – Consistent views of namespaces | peps.python.org" (https://peps.python.org/pe

p-0667/). Python Enhancement Proposals (PEPs). Retrieved 7 October 2024.

65. "PEP 703 – Making the GIL Optional in CPython" (https://peps.python.org/pep-0703/).

Python Enhancement Proposals (PEPs). Retrieved 30 March 2025.

66. Wouters, Thomas (9 April 2024). "Python Insider: Python 3.12.3 and 3.13.0a6 released" (htt
ps://pythoninsider.blogspot.com/2024/04/python-3123-and-3130a6-released.html). Python
Insider. Retrieved 29 April 2024.

67. "PEP 594 – Removing dead batteries from the standard library" (https://peps.python.org/pep
-0594/). Python Enhancement Proposals. Python Softtware Foundation. 20 May 2019.
68. "PEP 761 – Deprecating PGP signatures for CPython artifacts | peps.python.org" (https://pe
ps.python.org/pep-0761/). Python Enhancement Proposals (PEPs). Retrieved 6 January
2025.

69. "1. Extending Python with C or C++ – Python 3.9.1 documentation" (https://docs.python.org/
3/extending/extending.html). docs.python.org. Archived (https://web.archive.org/web/202006
23232830/https://docs.python.org/3/extending/extending.html) from the original on 23 June
2020. Retrieved 14 February 2021.

70. "PEP 623 – Remove wstr from Unicode" (https://www.python.org/dev/peps/pep-0623/).

Python.org. Archived (https://web.archive.org/web/20210305153214/https://www.python.org/
dev/peps/pep-0623/) from the original on 5 March 2021. Retrieved 14 February 2021.

71. "PEP 634 – Structural Pattern Matching: Specification" (https://www.python.org/dev/peps/pe
p-0634/). Python.org. Archived (https://web.archive.org/web/20210506005315/https://www.p
ython.org/dev/peps/pep-0634/) from the original on 6 May 2021. Retrieved 14 February
2021.

72. "PEP 749 – Implementing PEP 649 | peps.python.org" (https://peps.python.org/pep-0749/).

Python Enhancement Proposals (PEPs). Retrieved 20 November 2024.

73. "PEP 711: PyBI: a standard format for distributing Python Binaries" (https://discuss.python.o
rg/t/pep-711-pybi-a-standard-format-for-distributing-python-binaries/25547). Discussions on
Python.org. 7 April 2023. Retrieved 20 November 2024.

74. "PEP 686 – Make UTF-8 mode default | peps.python.org" (https://peps.python.org/pep-068

6/). Python Enhancement Proposals (PEPs). Retrieved 20 November 2024.

75. The Cain Gang Ltd. "Python Metaclasses: Who? Why? When?" (https://web.archive.org/we
b/20090530030205/http://www.python.org/community/pycon/dc2004/papers/24/metaclasses
-pycon.pdf) (PDF). Archived from the original (https://www.python.org/community/pycon/dc2
004/papers/24/metaclasses-pycon.pdf) (PDF) on 30 May 2009. Retrieved 27 June 2009.
76. "3.3. Special method names" (https://docs.python.org/3.0/reference/datamodel.html#special
-method-names). The Python Language Reference. Python Software Foundation. Archived
(https://web.archive.org/web/20181215123146/https://docs.python.org/3.0/reference/datamo
del.html#special-method-names) from the original on 15 December 2018. Retrieved 27 June
2009.

77. "PyDBC: method preconditions, method postconditions and class invariants for Python" (htt
p://www.nongnu.org/pydbc/). Archived (https://web.archive.org/web/20191123231931/http://
www.nongnu.org/pydbc/) from the original on 23 November 2019. Retrieved 24 September
2011.

78. "Contracts for Python" (http://www.wayforward.net/pycontract/). Archived (https://web.archiv
e.org/web/20200615173404/http://www.wayforward.net/pycontract/) from the original on 15
June 2020. Retrieved 24 September 2011.

79. "PyDatalog" (https://sites.google.com/site/pydatalog/). Archived (https://web.archive.org/we
b/20200613160231/https://sites.google.com/site/pydatalog/) from the original on 13 June
2020. Retrieved 22 July 2012.

80. "Glue It All Together With Python" (https://www.python.org/doc/essays/omg-darpa-mcc-positi

on/). Python.org. Retrieved 30 September 2024.

81. "Extending and Embedding the Python Interpreter: Reference Counts" (https://docs.python.
org/extending/extending.html#reference-counts). Docs.python.org. Archived (https://web.arc
hive.org/web/20121018063230/http://docs.python.org/extending/extending.html#reference-c
ounts) from the original on 18 October 2012. Retrieved 5 June 2020. "Since Python makes
heavy use of malloc() and free(), it needs a strategy to avoid memory leaks as well as
the use of freed memory. The chosen method is called reference counting."

82. Hettinger, Raymond (30 January 2002). "PEP 289 – Generator Expressions" (https://www.py

thon.org/dev/peps/pep-0289/). Python Enhancement Proposals. Python Software
Foundation. Archived (https://web.archive.org/web/20200614153717/https://www.python.or
g/dev/peps/pep-0289/) from the original on 14 June 2020. Retrieved 19 February 2012.
83. "6.5 itertools – Functions creating iterators for efficient looping" (https://docs.python.org/3/lib
rary/itertools.html). Docs.python.org. Archived (https://web.archive.org/web/2020061415362
9/https://docs.python.org/3/library/itertools.html) from the original on 14 June 2020.
Retrieved 22 November 2016.

84. Peters, Tim (19 August 2004). "PEP 20 – The Zen of Python" (https://www.python.org/dev/p
eps/pep-0020/). Python Enhancement Proposals. Python Software Foundation. Archived (ht
tps://web.archive.org/web/20181226141127/https://www.python.org/dev/peps/pep-0020/)
from the original on 26 December 2018. Retrieved 24 November 2008.

85. Lutz, Mark (January 2022). "Python Changes 2014+" (https://learning-python.com/python-ch
anges-2014-plus.html). Learning Python. Archived (https://web.archive.org/web/2024031507
5935/https://learning-python.com/python-changes-2014-plus.html) from the original on 15
March 2024. Retrieved 25 February 2024.

86. "Confusion regarding a rule in The Zen of Python" (https://discuss.python.org/t/confusion-re
garding-a-rule-in-the-zen-of-python/15927). Python Help - Discussions on Python.org. 3
May 2022. Archived (https://web.archive.org/web/20240225221142/https://discuss.python.or
g/t/confusion-regarding-a-rule-in-the-zen-of-python/15927) from the original on 25 February
2024. Retrieved 25 February 2024.

87. Ambi, Chetan (4 July 2021). "The Most Controversial Python Walrus Operator" (https://pytho

nsimplified.com/the-most-controversial-python-walrus-operator/). Python Simplified.
Archived (https://web.archive.org/web/20230827154931/https://pythonsimplified.com/the-mo
st-controversial-python-walrus-operator/) from the original on 27 August 2023. Retrieved
5 February 2024.

88. Grifski, Jeremy (24 May 2020). "The Controversy Behind The Walrus Operator in Python" (h

ttps://therenegadecoder.com/code/the-controversy-behind-the-walrus-operator-in-python/).
The Renegade Coder. Archived (https://web.archive.org/web/20231228135749/https://there
negadecoder.com/code/the-controversy-behind-the-walrus-operator-in-python/) from the
original on 28 December 2023. Retrieved 25 February 2024.

89. Bader, Dan. "Python String Formatting Best Practices" (https://realpython.com/python-string
-formatting/). Real Python. Archived (https://web.archive.org/web/20240218083506/https://re
alpython.com/python-string-formatting/) from the original on 18 February 2024. Retrieved
25 February 2024.

90. Martelli, Alex; Ravenscroft, Anna; Ascher, David (2005). Python Cookbook, 2nd Edition (htt
p://shop.oreilly.com/product/9780596007973.do). O'Reilly Media. p. 230. ISBN 978-0-596-
00797-3. Archived (https://web.archive.org/web/20200223171254/http://shop.oreilly.com/pro
duct/9780596007973.do) from the original on 23 February 2020. Retrieved 14 November
2015.

91. "Python Culture" (https://web.archive.org/web/20140130021902/http://ebeab.com/2014/01/2
1/python-culture/). ebeab. 21 January 2014. Archived from the original (http://ebeab.com/20
14/01/21/python-culture/) on 30 January 2014.

92. "Transpiling Python to Julia using PyJL" (https://web.ist.utl.pt/antonio.menezes.leitao/ADA/d
ocuments/publications_docs/2022_TranspilingPythonToJuliaUsingPyJL.pdf) (PDF). Archived
(https://web.archive.org/web/20231119071525/https://web.ist.utl.pt/antonio.menezes.leitao/
ADA/documents/publications_docs/2022_TranspilingPythonToJuliaUsingPyJL.pdf) (PDF)
from the original on 19 November 2023. Retrieved 20 September 2023. "After manually
modifying one line of code by specifying the necessary type information, we obtained a
speedup of 52.6×, making the translated Julia code 19.5× faster than the original Python
code."

93. "Why is it called Python?" (https://docs.python.org/3/faq/general.html#why-is-it-called-pytho
n). General Python FAQ. Docs.python.org. Archived (https://web.archive.org/web/20121024
164224/http://docs.python.org/faq/general.html#why-is-it-called-python) from the original on
24 October 2012. Retrieved 3 January 2023.

94. "15 Ways Python Is a Powerful Force on the Web" (https://web.archive.org/web/201905110
65650/http://insidetech.monster.com/training/articles/8114-15-ways-python-is-a-powerful-for
ce-on-the-web). Archived from the original (https://insidetech.monster.com/training/articles/8
114-15-ways-python-is-a-powerful-force-on-the-web) on 11 May 2019. Retrieved 3 July
2018.

95. "pprint – Data pretty printer – Python 3.11.0 documentation" (https://docs.python.org/3/librar
y/pprint.html). docs.python.org. Archived (https://web.archive.org/web/20210122224848/http
s://docs.python.org/3/library/pprint.html) from the original on 22 January 2021. Retrieved
5 November 2022. "stuff=['spam', 'eggs', 'lumberjack', 'knights', 'ni']"

96. "Code Style – The Hitchhiker's Guide to Python" (https://docs.python-guide.org/writing/styl

e). docs.python-guide.org. Archived (https://web.archive.org/web/20210127154341/https://d
ocs.python-guide.org/writing/style/) from the original on 27 January 2021. Retrieved
20 January 2021.

97. "Is Python a good language for beginning programmers?" (https://docs.python.org/faq/gener
al.html#is-python-a-good-language-for-beginning-programmers). General Python FAQ.
Python Software Foundation. Archived (https://web.archive.org/web/20121024164224/http://
docs.python.org/faq/general.html#is-python-a-good-language-for-beginning-programmers)
from the original on 24 October 2012. Retrieved 21 March 2007.

98. "Myths about indentation in Python" (https://web.archive.org/web/20180218162410/http://w

ww.secnetix.de/~olli/Python/block_indentation.hawk). Secnetix.de. Archived from the original
(http://www.secnetix.de/~olli/Python/block_indentation.hawk) on 18 February 2018.
Retrieved 19 April 2011.

99. Guttag, John V. (12 August 2016). Introduction to Computation and Programming Using
Python: With Application to Understanding Data. MIT Press. ISBN 978-0-262-52962-4.
100. "PEP 8 – Style Guide for Python Code" (https://www.python.org/dev/peps/pep-0008/).

Python.org. Archived (https://web.archive.org/web/20190417223549/https://www.python.org/
dev/peps/pep-0008/) from the original on 17 April 2019. Retrieved 26 March 2019.

101. "8. Errors and Exceptions – Python 3.12.0a0 documentation" (https://docs.python.org/3.11/t
utorial/errors.html). docs.python.org. Archived (https://web.archive.org/web/2022050914574
5/https://docs.python.org/3.11/tutorial/errors.html) from the original on 9 May 2022.
Retrieved 9 May 2022.

102. "Highlights: Python 2.5" (https://www.python.org/download/releases/2.5/highlights/).

Python.org. Archived (https://web.archive.org/web/20190804120408/https://www.python.org/
download/releases/2.5/highlights/) from the original on 4 August 2019. Retrieved 20 March
2018.

103. van Rossum, Guido (22 April 2009). "Tail Recursion Elimination" (http://neopythonic.blogspo

t.be/2009/04/tail-recursion-elimination.html). Neopythonic.blogspot.be. Archived (https://we
b.archive.org/web/20180519225253/http://neopythonic.blogspot.be/2009/04/tail-recursion-eli
mination.html) from the original on 19 May 2018. Retrieved 3 December 2012.

104. van Rossum, Guido (9 February 2006). "Language Design Is Not Just Solving Puzzles" (htt
p://www.artima.com/weblogs/viewpost.jsp?thread=147358). Artima forums. Artima. Archived
(https://web.archive.org/web/20200117182525/https://www.artima.com/weblogs/viewpost.js
p?thread=147358) from the original on 17 January 2020. Retrieved 21 March 2007.
105. van Rossum, Guido; Eby, Phillip J. (10 May 2005). "PEP 342 – Coroutines via Enhanced

Generators" (https://www.python.org/dev/peps/pep-0342/). Python Enhancement Proposals.
Python Software Foundation. Archived (https://web.archive.org/web/20200529003739/http
s://www.python.org/dev/peps/pep-0342/) from the original on 29 May 2020. Retrieved
19 February 2012.

106. "PEP 380" (https://www.python.org/dev/peps/pep-0380/). Python.org. Archived (https://web.
archive.org/web/20200604233821/https://www.python.org/dev/peps/pep-0380/) from the
original on 4 June 2020. Retrieved 3 December 2012.

107. "division" (https://docs.python.org). python.org. Archived (https://web.archive.org/web/20060
720033244/http://docs.python.org/) from the original on 20 July 2006. Retrieved 30 July
2014.

108. "PEP 0465 – A dedicated infix operator for matrix multiplication" (https://www.python.org/de
v/peps/pep-0465/). python.org. Archived (https://web.archive.org/web/20200604224255/http
s://www.python.org/dev/peps/pep-0465/) from the original on 4 June 2020. Retrieved
1 January 2016.

109. "Python 3.5.1 Release and Changelog" (https://www.python.org/downloads/release/python-
351/). python.org. Archived (https://web.archive.org/web/20200514034938/https://www.pyth
on.org/downloads/release/python-351/) from the original on 14 May 2020. Retrieved
1 January 2016.

110. "What's New in Python 3.8" (https://docs.python.org/3.8/whatsnew/3.8.html). Archived (http

s://web.archive.org/web/20200608124345/https://docs.python.org/3.8/whatsnew/3.8.html)
from the original on 8 June 2020. Retrieved 14 October 2019.

111. van Rossum, Guido; Hettinger, Raymond (7 February 2003). "PEP 308 – Conditional
Expressions" (https://www.python.org/dev/peps/pep-0308/). Python Enhancement
Proposals. Python Software Foundation. Archived (https://web.archive.org/web/2016031311
3147/https://www.python.org/dev/peps/pep-0308/) from the original on 13 March 2016.
Retrieved 13 July 2011.

112. "4. Built-in Types – Python 3.6.3rc1 documentation" (https://docs.python.org/3/library/stdtype
s.html#tuple). python.org. Archived (https://web.archive.org/web/20200614194325/https://do
cs.python.org/3/library/stdtypes.html#tuple) from the original on 14 June 2020. Retrieved
1 October 2017.

113. "5.3. Tuples and Sequences – Python 3.7.1rc2 documentation" (https://docs.python.org/3/tut
orial/datastructures.html#tuples-and-sequences). python.org. Archived (https://web.archive.
org/web/20200610050047/https://docs.python.org/3/tutorial/datastructures.html#tuples-and-
sequences) from the original on 10 June 2020. Retrieved 17 October 2018.

114. "PEP 498 – Literal String Interpolation" (https://www.python.org/dev/peps/pep-0498/).

python.org. Archived (https://web.archive.org/web/20200615184141/https://www.python.org/
dev/peps/pep-0498/) from the original on 15 June 2020. Retrieved 8 March 2017.

115. "Why must 'self' be used explicitly in method definitions and calls?" (https://docs.python.org/f
aq/design.html#why-must-self-be-used-explicitly-in-method-definitions-and-calls). Design
and History FAQ. Python Software Foundation. Archived (https://web.archive.org/web/20121
024164243/http://docs.python.org/faq/design.html#why-must-self-be-used-explicitly-in-meth
od-definitions-and-calls) from the original on 24 October 2012. Retrieved 19 February 2012.

116. Sweigart, Al (2020). Beyond the Basic Stuff with Python: Best Practices for Writing Clean

Code (https://books.google.com/books?id=7GUKEAAAQBAJ&pg=PA322). No Starch Press.
p. 322. ISBN 978-1-59327-966-0. Archived (https://web.archive.org/web/20210813194312/h
ttps://books.google.com/books?id=7GUKEAAAQBAJ&pg=PA322) from the original on 13
August 2021. Retrieved 7 July 2021.

117. "The Python Language Reference, section 3.3. New-style and classic classes, for release

2.7.1" (https://web.archive.org/web/20121026063834/http://docs.python.org/reference/data
model.html#new-style-and-classic-classes). Archived from the original (https://docs.python.o
rg/reference/datamodel.html#new-style-and-classic-classes) on 26 October 2012. Retrieved
12 January 2011.

118. "PEP 484 – Type Hints | peps.python.org" (https://peps.python.org/pep-0484/).

peps.python.org. Archived (https://web.archive.org/web/20231127205023/https://peps.pytho
n.org/pep-0484/) from the original on 27 November 2023. Retrieved 29 November 2023.

119. "typing — Support for type hints" (https://docs.python.org/3/library/typing.html). Python

documentation. Python Software Foundation. Archived (https://web.archive.org/web/202002
21184042/https://docs.python.org/3/library/typing.html) from the original on 21 February
2020. Retrieved 22 December 2023.

120. "mypy – Optional Static Typing for Python" (http://mypy-lang.org/). Archived (https://web.arc
hive.org/web/20200606192012/http://mypy-lang.org/) from the original on 6 June 2020.
Retrieved 28 January 2017.

121. "Introduction" (https://mypyc.readthedocs.io/en/latest/introduction.html).

mypyc.readthedocs.io. Archived (https://web.archive.org/web/20231222000457/https://mypy
c.readthedocs.io/en/latest/introduction.html) from the original on 22 December 2023.
Retrieved 22 December 2023.

122. "15. Floating Point Arithmetic: Issues and Limitations – Python 3.8.3 documentation" (https://
docs.python.org/3.8/tutorial/floatingpoint.html#representation-error). docs.python.org.
Archived (https://web.archive.org/web/20200606113842/https://docs.python.org/3.8/tutorial/f
loatingpoint.html#representation-error) from the original on 6 June 2020. Retrieved 6 June
2020. "Almost all machines today (November 2000) use IEEE-754 floating point arithmetic,
and almost all platforms map Python floats to IEEE-754 "double precision"."

123. Zadka, Moshe; van Rossum, Guido (11 March 2001). "PEP 237 – Unifying Long Integers
and Integers" (https://www.python.org/dev/peps/pep-0237/). Python Enhancement
Proposals. Python Software Foundation. Archived (https://web.archive.org/web/2020052806
3237/https://www.python.org/dev/peps/pep-0237/) from the original on 28 May 2020.
Retrieved 24 September 2011.

124. "Built-in Types" (https://docs.python.org/3/library/stdtypes.html#typesseq-range). Archived (h
ttps://web.archive.org/web/20200614194325/https://docs.python.org/3/library/stdtypes.html#
typesseq-range) from the original on 14 June 2020. Retrieved 3 October 2019.

125. "PEP 465 – A dedicated infix operator for matrix multiplication" (https://legacy.python.org/de
v/peps/pep-0465/). python.org. Archived (https://web.archive.org/web/20200529200310/http
s://legacy.python.org/dev/peps/pep-0465/) from the original on 29 May 2020. Retrieved
3 July 2018.

126. Zadka, Moshe; van Rossum, Guido (11 March 2001). "PEP 238 – Changing the Division

Operator" (https://www.python.org/dev/peps/pep-0238/). Python Enhancement Proposals.
Python Software Foundation. Archived (https://web.archive.org/web/20200528115550/http
s://www.python.org/dev/peps/pep-0238/) from the original on 28 May 2020. Retrieved
23 October 2013.

127. "Why Python's Integer Division Floors" (https://python-history.blogspot.com/2010/08/why-pyt
hons-integer-division-floors.html). 24 August 2010. Archived (https://web.archive.org/web/20
200605151500/https://python-history.blogspot.com/2010/08/why-pythons-integer-division-flo
ors.html) from the original on 5 June 2020. Retrieved 25 August 2010.

128. "round" (https://docs.python.org/py3k/library/functions.html#round), The Python standard

library, release 3.2, §2: Built-in functions, archived (https://web.archive.org/web/2012102514
1808/http://docs.python.org/py3k/library/functions.html#round) from the original on 25
October 2012, retrieved 14 August 2011

129. "round" (https://docs.python.org/library/functions.html#round), The Python standard library,

release 2.7, §2: Built-in functions, archived (https://web.archive.org/web/20121027081602/ht
tp://docs.python.org/library/functions.html#round) from the original on 27 October 2012,
retrieved 14 August 2011

130. Beazley, David M. (2009). Python Essential Reference (https://archive.org/details/pythoness
entialr00beaz_036) (4th ed.). Addison-Wesley Professional. p. 66 (https://archive.org/details/
pythonessentialr00beaz_036/page/n90). ISBN 9780672329784.

131. Kernighan, Brian W.; Ritchie, Dennis M. (1988). The C Programming Language (2nd ed.).

p. 206 (https://archive.org/details/cprogramminglang00bria/page/206).

132. Batista, Facundo (17 October 2003). "PEP 327 – Decimal Data Type" (https://www.python.or
g/dev/peps/pep-0327/). Python Enhancement Proposals. Python Software Foundation.
Archived (https://web.archive.org/web/20200604234830/https://www.python.org/dev/peps/p
ep-0327/) from the original on 4 June 2020. Retrieved 24 November 2008.

133. "What's New in Python 2.6" (https://docs.python.org/2.6/whatsnew/2.6.html). Python v2.6.9

documentation. 29 October 2013. Archived (https://web.archive.org/web/20191223213856/h
ttps://docs.python.org/2.6/whatsnew/2.6.html) from the original on 23 December 2019.
Retrieved 26 September 2015.

134. "10 Reasons Python Rocks for Research (And a Few Reasons it Doesn't) – Hoyt Koepke"

(https://web.archive.org/web/20200531211840/https://www.stat.washington.edu/~hoytak/blo
g/whypython.html). University of Washington Department of Statistics. Archived from the
original (https://www.stat.washington.edu/~hoytak/blog/whypython.html) on 31 May 2020.
Retrieved 3 February 2019.

135. Shell, Scott (17 June 2014). "An introduction to Python for scientific computing" (https://engi
neering.ucsb.edu/~shell/che210d/python.pdf) (PDF). Archived (https://web.archive.org/web/
20190204014642/https://engineering.ucsb.edu/~shell/che210d/python.pdf) (PDF) from the
original on 4 February 2019. Retrieved 3 February 2019.

136. Piotrowski, Przemyslaw (July 2006). "Build a Rapid Web Development Environment for

Python Server Pages and Oracle" (http://www.oracle.com/technetwork/articles/piotrowski-py
thoncore-084049.html). Oracle Technology Network. Oracle. Archived (https://web.archive.o
rg/web/20190402124435/https://www.oracle.com/technetwork/articles/piotrowski-pythoncore
-084049.html) from the original on 2 April 2019. Retrieved 12 March 2012.

137. Eby, Phillip J. (7 December 2003). "PEP 333 – Python Web Server Gateway Interface v1.0"
(https://www.python.org/dev/peps/pep-0333/). Python Enhancement Proposals. Python
Software Foundation. Archived (https://web.archive.org/web/20200614170344/https://www.p
ython.org/dev/peps/pep-0333/) from the original on 14 June 2020. Retrieved 19 February
2012.

138. "PyPI" (https://pypi.org/). PyPI. 13 March 2025. Archived (https://web.archive.org/web/20250

222013445/https://pypi.org/) from the original on 22 February 2025.

139. Enthought, Canopy. "Canopy" (https://web.archive.org/web/20170715151703/https://www.en

thought.com/products/canopy/). www.enthought.com. Archived from the original (https://ww
w.enthought.com/products/canopy/) on 15 July 2017. Retrieved 20 August 2016.

140. "Project Jupyter" (https://jupyter.org). Jupyter.org. Archived (https://web.archive.org/web/202
31012055917/https://jupyter.org/) from the original on 12 October 2023. Retrieved 2 April
2025.

141. "PEP 7 – Style Guide for C Code | peps.python.org" (https://peps.python.org/pep-0007/).

peps.python.org. Archived (https://web.archive.org/web/20220424202827/https://peps.pytho
n.org/pep-0007/) from the original on 24 April 2022. Retrieved 28 April 2022.

142. "4. Building C and C++ Extensions – Python 3.9.2 documentation" (https://docs.python.org/
3/extending/building.html). docs.python.org. Archived (https://web.archive.org/web/2021030
3002519/https://docs.python.org/3/extending/building.html) from the original on 3 March
2021. Retrieved 1 March 2021.

143. van Rossum, Guido (5 June 2001). "PEP 7 – Style Guide for C Code" (https://www.python.o
rg/dev/peps/pep-0007/). Python Enhancement Proposals. Python Software Foundation.
Archived (https://web.archive.org/web/20200601203908/https://www.python.org/dev/peps/p
ep-0007/) from the original on 1 June 2020. Retrieved 24 November 2008.

144. "CPython byte code" (https://docs.python.org/3/library/dis.html#python-bytecode-instruction
s). Docs.python.org. Archived (https://web.archive.org/web/20200605151542/https://docs.py
thon.org/3/library/dis.html#python-bytecode-instructions) from the original on 5 June 2020.
Retrieved 16 February 2016.

145. "Python 2.5 internals" (http://www.troeger.eu/teaching/pythonvm08.pdf) (PDF). Archived (htt
ps://web.archive.org/web/20120806094951/http://www.troeger.eu/teaching/pythonvm08.pdf)
(PDF) from the original on 6 August 2012. Retrieved 19 April 2011.

146. "Changelog – Python 3.9.0 documentation" (https://docs.python.org/release/3.9.0/whatsne

w/changelog.html#changelog). docs.python.org. Archived (https://web.archive.org/web/2021
0207001142/https://docs.python.org/release/3.9.0/whatsnew/changelog.html#changelog)
from the original on 7 February 2021. Retrieved 8 February 2021.

147. "Download Python" (https://www.python.org/downloads/release/python-391). Python.org.

Archived (https://web.archive.org/web/20201208045225/https://www.python.org/downloads/r
elease/python-391/) from the original on 8 December 2020. Retrieved 13 December 2020.

148. "history [vmspython]" (https://www.vmspython.org/doku.php?id=history).

www.vmspython.org. Archived (https://web.archive.org/web/20201202194743/https://www.v
mspython.org/doku.php?id=history) from the original on 2 December 2020. Retrieved
4 December 2020.

149. "An Interview with Guido van Rossum" (http://www.oreilly.com/pub/a/oreilly/frank/rossum_10
99.html). Oreilly.com. Archived (https://web.archive.org/web/20140716222652/http://oreilly.c
om/pub/a/oreilly/frank/rossum_1099.html) from the original on 16 July 2014. Retrieved
24 November 2008.

150. "Download Python for Other Platforms" (https://www.python.org/download/other/).

Python.org. Archived (https://web.archive.org/web/20201127015815/https://www.python.org/
download/other/) from the original on 27 November 2020. Retrieved 4 December 2020.
151. "PyPy compatibility" (https://pypy.org/compat.html). Pypy.org. Archived (https://web.archive.

org/web/20200606041845/https://www.pypy.org/compat.html) from the original on 6 June
2020. Retrieved 3 December 2012.

152. Team, The PyPy (28 December 2019). "Download and Install" (https://www.pypy.org/downlo
ad.html). PyPy. Archived (https://web.archive.org/web/20220108212951/https://www.pypy.or
g/download.html) from the original on 8 January 2022. Retrieved 8 January 2022.

153. "speed comparison between CPython and Pypy" (https://speed.pypy.org/). Speed.pypy.org.

Archived (https://web.archive.org/web/20210510014902/https://speed.pypy.org/) from the
original on 10 May 2021. Retrieved 3 December 2012.

154. "Codon: Differences with Python" (https://docs.exaloop.io/codon/general/differences).

Archived (https://web.archive.org/web/20230525002540/https://docs.exaloop.io/codon/gener
al/differences) from the original on 25 May 2023. Retrieved 28 August 2023.

155. Lawson, Loraine (14 March 2023). "MIT-Created Compiler Speeds up Python Code" (https://
thenewstack.io/mit-created-compiler-speeds-up-python-code/). The New Stack. Archived (ht
tps://web.archive.org/web/20230406054200/https://thenewstack.io/mit-created-compiler-spe
eds-up-python-code/) from the original on 6 April 2023. Retrieved 28 August 2023.

156. "Python-for-EV3" (https://education.lego.com/en-us/support/mindstorms-ev3/python-for-ev

3). LEGO Education. Archived (https://web.archive.org/web/20200607234814/https://educati
on.lego.com/en-us/support/mindstorms-ev3/python-for-ev3) from the original on 7 June
2020. Retrieved 17 April 2019.

157. Yegulalp, Serdar (29 October 2020). "Pyston returns from the dead to speed Python" (http

s://www.infoworld.com/article/3587591/pyston-returns-from-the-dead-to-speed-python.html).
InfoWorld. Archived (https://web.archive.org/web/20210127113233/https://www.infoworld.co
m/article/3587591/pyston-returns-from-the-dead-to-speed-python.html) from the original on
27 January 2021. Retrieved 26 January 2021.

158. "cinder: Instagram's performance-oriented fork of CPython" (https://github.com/facebookincu
bator/cinder). GitHub. Archived (https://web.archive.org/web/20210504112500/https://github.
com/facebookincubator/cinder) from the original on 4 May 2021. Retrieved 4 May 2021.
159. Aroca, Rafael (7 August 2021). "Snek Lang: feels like Python on Arduinos" (https://rafaelaro
ca.wordpress.com/2021/08/07/snek-lang-feels-like-python-on-arduinos/). Yet Another
Technology Blog. Archived (https://web.archive.org/web/20240105001031/https://rafaelaroc
a.wordpress.com/2021/08/07/snek-lang-feels-like-python-on-arduinos/) from the original on
5 January 2024. Retrieved 4 January 2024.

160. Aufranc (CNXSoft), Jean-Luc (16 January 2020). "Snekboard Controls LEGO Power

Functions with CircuitPython or Snek Programming Languages (Crowdfunding) – CNX
Software" (https://www.cnx-software.com/2020/01/16/snekboard-controls-lego-power-functio
ns-with-circuitpython-or-snek-programming-languages/). CNX Software – Embedded
Systems News. Archived (https://web.archive.org/web/20240105001031/https://www.cnx-sof
tware.com/2020/01/16/snekboard-controls-lego-power-functions-with-circuitpython-or-snek-
programming-languages/) from the original on 5 January 2024. Retrieved 4 January 2024.

161. Kennedy (@mkennedy), Michael. "Ready to find out if you're git famous?" (https://pythonbyt
es.fm/episodes/show/187/ready-to-find-out-if-youre-git-famous). pythonbytes.fm. Archived (h
ttps://web.archive.org/web/20240105001031/https://pythonbytes.fm/episodes/show/187/rea
dy-to-find-out-if-youre-git-famous) from the original on 5 January 2024. Retrieved 4 January
2024.

162. Packard, Keith (20 December 2022). "The Snek Programming Language: A Python-inspired
Embedded Computing Language" (https://sneklang.org/doc/snek.pdf) (PDF). Archived (http
s://web.archive.org/web/20240104162458/https://sneklang.org/doc/snek.pdf) (PDF) from the
original on 4 January 2024. Retrieved 4 January 2024.

163. "Application-level Stackless features – PyPy 2.0.2 documentation" (http://doc.pypy.org/en/lat
est/stackless.html). Doc.pypy.org. Archived (https://web.archive.org/web/20200604231513/h
ttps://doc.pypy.org/en/latest/stackless.html) from the original on 4 June 2020. Retrieved
17 July 2013.

164. "Plans for optimizing Python" (https://code.google.com/p/unladen-swallow/wiki/ProjectPlan).
Google Project Hosting. 15 December 2009. Archived (https://web.archive.org/web/2016041
1181848/https://code.google.com/p/unladen-swallow/wiki/ProjectPlan) from the original on
11 April 2016. Retrieved 24 September 2011.

165. "Python on the Nokia N900" (http://www.stochasticgeometry.ie/2010/04/29/python-on-the-no
kia-n900/). Stochastic Geometry. 29 April 2010. Archived (https://web.archive.org/web/2019
0620000053/http://www.stochasticgeometry.ie/2010/04/29/python-on-the-nokia-n900/) from
the original on 20 June 2019. Retrieved 9 July 2015.

166. "Brython" (https://brython.info/). brython.info. Archived (https://web.archive.org/web/2018080
3065954/http://brython.info/) from the original on 3 August 2018. Retrieved 21 January
2021.

167. "Transcrypt – Python in the browser" (https://www.transcrypt.org). transcrypt.org. Archived
(https://web.archive.org/web/20180819133303/http://www.transcrypt.org/) from the original
on 19 August 2018. Retrieved 22 December 2020.

168. "Transcrypt: Anatomy of a Python to JavaScript Compiler" (https://www.infoq.com/articles/tra
nscrypt-python-javascript-compiler/). InfoQ. Archived (https://web.archive.org/web/20201205
193339/https://www.infoq.com/articles/transcrypt-python-javascript-compiler/) from the
original on 5 December 2020. Retrieved 20 January 2021.

169. "Nuitka Home | Nuitka Home" (http://nuitka.net/). nuitka.net. Archived (https://web.archive.or
g/web/20200530211233/https://nuitka.net/) from the original on 30 May 2020. Retrieved
18 August 2017.

170. Guelton, Serge; Brunet, Pierrick; Amini, Mehdi; Merlini, Adrien; Corbillon, Xavier; Raynaud,
Alan (16 March 2015). "Pythran: enabling static optimization of scientific Python programs"
(https://doi.org/10.1088%2F1749-4680%2F8%2F1%2F014001). Computational Science &
Discovery. 8 (1). IOP Publishing: 014001. Bibcode:2015CS&D....8a4001G (https://ui.adsab
s.harvard.edu/abs/2015CS&D....8a4001G). doi:10.1088/1749-4680/8/1/014001 (https://doi.o
rg/10.1088%2F1749-4680%2F8%2F1%2F014001). ISSN 1749-4699 (https://search.worldc
at.org/issn/1749-4699).

171. "The Python → 11l → C++ transpiler" (https://11l-lang.org/transpiler). Archived (https://web.
archive.org/web/20220924233728/https://11l-lang.org/transpiler/) from the original on 24
September 2022. Retrieved 17 July 2022.

172. "google/grumpy" (https://github.com/google/grumpy). 10 April 2020. Archived (https://web.ar

chive.org/web/20200415054919/https://github.com/google/grumpy) from the original on 15
April 2020. Retrieved 25 March 2020 – via GitHub.

173. "Projects" (https://opensource.google/projects/). opensource.google. Archived (https://web.a

rchive.org/web/20200424191248/https://opensource.google/projects/) from the original on
24 April 2020. Retrieved 25 March 2020.

174. Francisco, Thomas Claburn in San. "Google's Grumpy code makes Python Go" (https://ww
w.theregister.com/2017/01/05/googles_grumpy_makes_python_go/). www.theregister.com.
Archived (https://web.archive.org/web/20210307165521/https://www.theregister.com/2017/0
1/05/googles_grumpy_makes_python_go/) from the original on 7 March 2021. Retrieved
20 January 2021.

175. "IronPython.net /" (https://ironpython.net/). ironpython.net. Archived (https://web.archive.org/

web/20210417064418/https://ironpython.net/) from the original on 17 April 2021.

176. "GitHub – IronLanguages/ironpython3: Implementation of Python 3.x for .NET Framework

that is built on top of the Dynamic Language Runtime" (https://github.com/IronLanguages/iro
npython3). GitHub. Archived (https://web.archive.org/web/20210928101250/https://github.co
m/IronLanguages/ironpython3) from the original on 28 September 2021.
177. "Jython FAQ" (https://www.jython.org/jython-old-sites/archive/22/userfaq.html).

www.jython.org. Archived (https://web.archive.org/web/20210422055726/https://www.jython.
org/jython-old-sites/archive/22/userfaq.html) from the original on 22 April 2021. Retrieved
22 April 2021.

178. Murri, Riccardo (2013). Performance of Python runtimes on a non-numeric scientific code.

European Conference on Python in Science (EuroSciPy). arXiv:1404.6388 (https://arxiv.org/
abs/1404.6388). Bibcode:2014arXiv1404.6388M (https://ui.adsabs.harvard.edu/abs/2014ar
Xiv1404.6388M).

179. "The Computer Language Benchmarks Game" (https://benchmarksgame-team.pages.debia
n.net/benchmarksgame/fastest/python.html). Archived (https://web.archive.org/web/2020061
4210246/https://benchmarksgame-team.pages.debian.net/benchmarksgame/fastest/python.
html) from the original on 14 June 2020. Retrieved 30 April 2020.

180. Warsaw, Barry; Hylton, Jeremy; Goodger, David (13 June 2000). "PEP 1 – PEP Purpose
and Guidelines" (https://www.python.org/dev/peps/pep-0001/). Python Enhancement
Proposals. Python Software Foundation. Archived (https://web.archive.org/web/2020060604
2011/https://www.python.org/dev/peps/pep-0001/) from the original on 6 June 2020.
Retrieved 19 April 2011.

181. "PEP 8 – Style Guide for Python Code" (https://www.python.org/dev/peps/pep-0008/).

Python.org. Archived (https://web.archive.org/web/20190417223549/https://www.python.org/
dev/peps/pep-0008/) from the original on 17 April 2019. Retrieved 26 March 2019.

182. Cannon, Brett. "Guido, Some Guys, and a Mailing List: How Python is Developed" (https://w
eb.archive.org/web/20090601134342/http://www.python.org/dev/intro/). python.org. Python
Software Foundation. Archived from the original (https://www.python.org/dev/intro/) on 1
June 2009. Retrieved 27 June 2009.

183. "Moving Python's bugs to GitHub [LWN.net]" (https://lwn.net/Articles/885854/). Archived (htt

ps://web.archive.org/web/20221002183818/https://lwn.net/Articles/885854/) from the original
on 2 October 2022. Retrieved 2 October 2022.

184. "Python Developer's Guide – Python Developer's Guide" (https://devguide.python.org/).

devguide.python.org. Archived (https://web.archive.org/web/20201109032501/https://devgui
de.python.org/) from the original on 9 November 2020. Retrieved 17 December 2019.

185. Hughes, Owen (24 May 2021). "Programming languages: Why Python 4.0 might never

arrive, according to its creator" (https://www.techrepublic.com/article/programming-language
s-why-python-4-0-will-probably-never-arrive-according-to-its-creator/). TechRepublic.
Archived (https://web.archive.org/web/20220714201302/https://www.techrepublic.com/articl
e/programming-languages-why-python-4-0-will-probably-never-arrive-according-to-its-creato
r/) from the original on 14 July 2022. Retrieved 16 May 2022.

186. "PEP 602 – Annual Release Cycle for Python" (https://www.python.org/dev/peps/pep-0602/).
Python.org. Archived (https://web.archive.org/web/20200614202755/https://www.python.org/
dev/peps/pep-0602/) from the original on 14 June 2020. Retrieved 6 November 2019.

187. "Changing the Python release cadence [LWN.net]" (https://lwn.net/Articles/802777/).

lwn.net. Archived (https://web.archive.org/web/20191106170153/https://lwn.net/Articles/802
777/) from the original on 6 November 2019. Retrieved 6 November 2019.

188. Norwitz, Neal (8 April 2002). "[Python-Dev] Release Schedules (was Stability & change)" (ht
tps://mail.python.org/pipermail/python-dev/2002-April/022739.html). Archived (https://web.ar
chive.org/web/20181215122750/https://mail.python.org/pipermail/python-dev/2002-April/022
739.html) from the original on 15 December 2018. Retrieved 27 June 2009.

189. Aahz; Baxter, Anthony (15 March 2001). "PEP 6 – Bug Fix Releases" (https://www.python.or
g/dev/peps/pep-0006/). Python Enhancement Proposals. Python Software Foundation.
Archived (https://web.archive.org/web/20200605001318/https://www.python.org/dev/peps/p
ep-0006/) from the original on 5 June 2020. Retrieved 27 June 2009.

190. "Python Buildbot" (https://www.python.org/dev/buildbot/). Python Developer's Guide. Python
Software Foundation. Archived (https://web.archive.org/web/20200605001322/https://www.p
ython.org/dev/buildbot/) from the original on 5 June 2020. Retrieved 24 September 2011.

191. "Documentation Tools" (https://wiki.python.org/moin/DocumentationTools). Python.org.

Archived (https://web.archive.org/web/20201111173635/https://wiki.python.org/moin/Docum
entationTools) from the original on 11 November 2020. Retrieved 22 March 2021.

192. "Whetting Your Appetite" (https://docs.python.org/tutorial/appetite.html). The Python Tutorial.
Python Software Foundation. Archived (https://web.archive.org/web/20121026063559/http://
docs.python.org/tutorial/appetite.html) from the original on 26 October 2012. Retrieved
20 February 2012.

193. "In Python, should I use else after a return in an if block?" (https://stackoverflow.com/questio
ns/5033906/in-python-should-i-use-else-after-a-return-in-an-if-block). Stack Overflow. Stack
Exchange. 17 February 2011. Archived (https://web.archive.org/web/20190620000050/http
s://stackoverflow.com/questions/5033906/in-python-should-i-use-else-after-a-return-in-an-if-
block) from the original on 20 June 2019. Retrieved 6 May 2011.

194. Lutz, Mark (2009). Learning Python: Powerful Object-Oriented Programming (https://books.

google.com/books?id=1HxWGezDZcgC&pg=PA17). O'Reilly Media, Inc. p. 17.
ISBN 9781449379322. Archived (https://web.archive.org/web/20170717044012/https://book
s.google.com/books?id=1HxWGezDZcgC&pg=PA17) from the original on 17 July 2017.
Retrieved 9 May 2017.

195. Fehily, Chris (2002). Python (https://books.google.com/books?id=carqdIdfVlYC&pg=PR15).
Peachpit Press. p. xv. ISBN 9780201748840. Archived (https://web.archive.org/web/201707
17044040/https://books.google.com/books?id=carqdIdfVlYC&pg=PR15) from the original on
17 July 2017. Retrieved 9 May 2017.

196. Lubanovic, Bill (2014). Introducing Python (http://archive.org/details/introducingpytho0000lu

ba). Sebastopol, CA : O'Reilly Media. p. 305. ISBN 978-1-4493-5936-2. Retrieved 31 July
2023.

197. Blake, Troy (18 January 2021). "TIOBE Index for January 2021" (https://seniordba.wordpres
s.com/2021/01/18/tiobe-index-for-january-2021/). Technology News and Information by
SeniorDBA. Archived (https://web.archive.org/web/20210321143253/https://seniordba.word
press.com/2021/01/18/tiobe-index-for-january-2021/) from the original on 21 March 2021.
Retrieved 26 February 2021.

198. "TIOBE Index" (https://www.tiobe.com/tiobe-index/). TIOBE. Retrieved 31 March 2025.
199. "Quotes about Python" (https://www.python.org/about/quotes/). Python Software

Foundation. Archived (https://web.archive.org/web/20200603135201/https://www.python.or
g/about/quotes/) from the original on 3 June 2020. Retrieved 8 January 2012.

200. "Organizations Using Python" (https://wiki.python.org/moin/OrganizationsUsingPython).

Python Software Foundation. Archived (https://web.archive.org/web/20180821075931/http
s://wiki.python.org/moin/OrganizationsUsingPython) from the original on 21 August 2018.
Retrieved 15 January 2009.

201. "Python : the holy grail of programming" (http://cdsweb.cern.ch/journal/CERNBulletin/2006/3

1/News%20Articles/974627?ln=en). CERN Bulletin (31/2006). CERN Publications. 31 July
2006. Archived (https://archive.today/20130115191843/http://cdsweb.cern.ch/journal/CERN
Bulletin/2006/31/News%20Articles/974627?ln=en) from the original on 15 January 2013.
Retrieved 11 February 2012.

202. Shafer, Daniel G. (17 January 2003). "Python Streamlines Space Shuttle Mission Design" (h
ttps://www.python.org/about/success/usa/). Python Software Foundation. Archived (https://w
eb.archive.org/web/20200605093424/https://www.python.org/about/success/usa/) from the
original on 5 June 2020. Retrieved 24 November 2008.

203. "Tornado: Facebook's Real-Time Web Framework for Python – Facebook for Developers" (h

ttps://developers.facebook.com/blog/post/301). Facebook for Developers. Archived (https://
web.archive.org/web/20190219031313/https://developers.facebook.com/blog/post/301) from
the original on 19 February 2019. Retrieved 19 June 2018.

204. "What Powers Instagram: Hundreds of Instances, Dozens of Technologies" (https://instagra
m-engineering.com/what-powers-instagram-hundreds-of-instances-dozens-of-technologies-
adf2e22da2ad). Instagram Engineering. 11 December 2016. Archived (https://web.archive.o
rg/web/20200615183410/https://instagram-engineering.com/what-powers-instagram-hundre
ds-of-instances-dozens-of-technologies-adf2e22da2ad) from the original on 15 June 2020.
Retrieved 27 May 2019.

205. "How we use Python at Spotify" (https://labs.spotify.com/2013/03/20/how-we-use-python-at-
spotify/). Spotify Labs. 20 March 2013. Archived (https://web.archive.org/web/20200610005
143/https://labs.spotify.com/2013/03/20/how-we-use-python-at-spotify/) from the original on
10 June 2020. Retrieved 25 July 2018.

206. Fortenberry, Tim (17 January 2003). "Industrial Light & Magic Runs on Python" (https://www.
python.org/about/success/ilm/). Python Software Foundation. Archived (https://web.archive.
org/web/20200606042020/https://www.python.org/about/success/ilm/) from the original on 6
June 2020. Retrieved 11 February 2012.

207. Taft, Darryl K. (5 March 2007). "Python Slithers into Systems" (http://www.eweek.com/c/a/Ap
plication-Development/Python-Slithers-into-Systems/). eWeek.com. Ziff Davis Holdings.
Archived (https://web.archive.org/web/20210813194304/https://www.eweek.com/developme
nt/python-slithers-into-systems/) from the original on 13 August 2021. Retrieved
24 September 2011.

208. GitHub – reddit-archive/reddit: historical code from reddit.com. (https://github.com/reddit-arc
hive/reddit), The Reddit Archives, archived (https://web.archive.org/web/20200601104939/ht
tps://github.com/reddit-archive/reddit) from the original on 1 June 2020, retrieved 20 March
2019

209. "Real time communication at scale with Elixir at Discord" (https://elixir-lang.org/blog/2020/1

0/08/real-time-communication-at-scale-with-elixir-at-discord/). 8 October 2020.

210. "What Programming Language is Baidu Built In?" (https://www.freelancinggig.com/blog/201
8/07/05/what-programming-language-is-baidu-built-in/#:~:text=Even%20though%20Baidu%
20has%20used,part%20JavaScript%20has%20been%20applied). 5 July 2018.

211. "Usage statistics and market share of Python for websites" (http://w3techs.com/technologie
s/details/pl-python/all/all). 2012. Archived (https://web.archive.org/web/20210813194305/htt
ps://w3techs.com/technologies/details/pl-python) from the original on 13 August 2021.
Retrieved 18 December 2012.

212. Oliphant, Travis (2007). "Python for Scientific Computing" (https://www.h2desk.com/blog/pyt

hon-scientific-computing/). Computing in Science and Engineering. 9 (3): 10–20.
Bibcode:2007CSE.....9c..10O (https://ui.adsabs.harvard.edu/abs/2007CSE.....9c..10O).
CiteSeerX 10.1.1.474.6460 (https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.474.
6460). doi:10.1109/MCSE.2007.58 (https://doi.org/10.1109%2FMCSE.2007.58).
ISSN 1521-9615 (https://search.worldcat.org/issn/1521-9615). S2CID 206457124 (https://ap
i.semanticscholar.org/CorpusID:206457124). Archived (https://web.archive.org/web/202006
15193226/https://www.h2desk.com/blog/python-scientific-computing/) from the original on
15 June 2020. Retrieved 10 April 2015.

213. Millman, K. Jarrod; Aivazis, Michael (2011). "Python for Scientists and Engineers" (http://ww
w.computer.org/csdl/mags/cs/2011/02/mcs2011020009.html). Computing in Science and
Engineering. 13 (2): 9–12. Bibcode:2011CSE....13b...9M (https://ui.adsabs.harvard.edu/abs/
2011CSE....13b...9M). doi:10.1109/MCSE.2011.36 (https://doi.org/10.1109%2FMCSE.2011.
36). Archived (https://web.archive.org/web/20190219031439/https://www.computer.org/csdl/
mags/cs/2011/02/mcs2011020009.html) from the original on 19 February 2019. Retrieved
7 July 2014.

214. Science education with SageMath (https://web.archive.org/web/20200615180428/http://visu
al.icse.us.edu.pl/methodology/why_Sage.html), Innovative Computing in Science Education,
archived from the original (http://visual.icse.us.edu.pl/methodology/why_Sage.html) on 15
June 2020, retrieved 22 April 2019

215. "OpenCV: OpenCV-Python Tutorials" (https://docs.opencv.org/3.4.9/d6/d00/tutorial_py_root.
html). docs.opencv.org. Archived (https://web.archive.org/web/20200923063145/https://doc
s.opencv.org/3.4.9/d6/d00/tutorial_py_root.html) from the original on 23 September 2020.
Retrieved 14 September 2020.

216. Dean, Jeff; Monga, Rajat; et al. (9 November 2015). "TensorFlow: Large-scale machine

learning on heterogeneous systems" (http://download.tensorflow.org/paper/whitepaper2015.
pdf) (PDF). TensorFlow.org. Google Research. Archived (https://web.archive.org/web/20151
120004649/http://download.tensorflow.org/paper/whitepaper2015.pdf) (PDF) from the
original on 20 November 2015. Retrieved 10 November 2015.

217. Piatetsky, Gregory. "Python eats away at R: Top Software for Analytics, Data Science,

Machine Learning in 2018: Trends and Analysis" (https://www.kdnuggets.com/2018/05/poll-t
ools-analytics-data-science-machine-learning-results.html/2). KDnuggets. Archived (https://
web.archive.org/web/20191115234216/https://www.kdnuggets.com/2018/05/poll-tools-analy
tics-data-science-machine-learning-results.html/2) from the original on 15 November 2019.
Retrieved 30 May 2018.

218. "Who is using scikit-learn? – scikit-learn 0.20.1 documentation" (https://scikit-learn.org/stabl
e/testimonials/testimonials.html). scikit-learn.org. Archived (https://web.archive.org/web/202
00506210716/https://scikit-learn.org/stable/testimonials/testimonials.html) from the original
on 6 May 2020. Retrieved 30 November 2018.

219. Jouppi, Norm. "Google supercharges machine learning tasks with TPU custom chip" (https://
cloudplatform.googleblog.com/2016/05/Google-supercharges-machine-learning-tasks-with-c
ustom-chip.html). Google Cloud Platform Blog. Archived (https://web.archive.org/web/20160
518201516/https://cloudplatform.googleblog.com/2016/05/Google-supercharges-machine-le
arning-tasks-with-custom-chip.html) from the original on 18 May 2016. Retrieved 19 May
2016.

220. De Raedt, Luc; Kimmig, Angelika (2015). "Probabilistic (logic) programming concepts" (http

s://doi.org/10.1007%2Fs10994-015-5494-z). Machine Learning. 100 (1): 5–47.
doi:10.1007/s10994-015-5494-z (https://doi.org/10.1007%2Fs10994-015-5494-z).
S2CID 3166992 (https://api.semanticscholar.org/CorpusID:3166992).

221. "Natural Language Toolkit – NLTK 3.5b1 documentation" (http://www.nltk.org/).

www.nltk.org. Archived (https://web.archive.org/web/20200613003911/http://www.nltk.org/)
from the original on 13 June 2020. Retrieved 10 April 2020.

222. Andersen, C. and Swift, T., 2023. The Janus System: a bridge to new prolog applications. In

Prolog: The Next 50 Years (pp. 93–104). Cham: Springer Nature Switzerland.

223. "SWI-Prolog Python interface" (https://www.swi-prolog.org/pldoc/doc_for?object=section(%2

7packages/janus.html%27)). Archived (https://web.archive.org/web/20240315162046/http
s://www.swi-prolog.org/pldoc/doc_for?object=section%28%27packages%2Fjanus.html%2
7%29) from the original on 15 March 2024. Retrieved 15 March 2024.

224. Tarau, P., 2023. Reflections on automation, learnability and expressiveness in logic-based
programming languages. In Prolog: The Next 50 Years (pp. 359–371). Cham: Springer
Nature Switzerland.

225. "Tkinter — Python interface to TCL/Tk" (https://docs.python.org/3/library/tkinter.html).

Archived (https://web.archive.org/web/20121018043136/http://docs.python.org/library/tkinte
r.html) from the original on 18 October 2012. Retrieved 9 June 2023.

226. "Python Tkinter Tutorial" (https://www.geeksforgeeks.org/python-tkinter-tutorial/). 3 June

2020. Archived (https://web.archive.org/web/20230609031631/https://www.geeksforgeeks.or
g/python-tkinter-tutorial/) from the original on 9 June 2023. Retrieved 9 June 2023.

227. "Installers for GIMP for Windows – Frequently Asked Questions" (https://web.archive.org/we

b/20130717070814/http://gimp-win.sourceforge.net/faq.html). 26 July 2013. Archived from
the original (http://gimp-win.sourceforge.net/faq.html) on 17 July 2013. Retrieved 26 July
2013.

228. "jasc psp9components" (https://web.archive.org/web/20080319061519/http://www.jasc.com/
support/customercare/articles/psp9components.asp). Archived from the original (http://www.j
asc.com/support/customercare/articles/psp9components.asp) on 19 March 2008.

229. "About getting started with writing geoprocessing scripts" (http://webhelp.esri.com/arcgisdes

ktop/9.2/index.cfm?TopicName=About_getting_started_with_writing_geoprocessing_script
s). ArcGIS Desktop Help 9.2. Environmental Systems Research Institute. 17 November
2006. Archived (https://web.archive.org/web/20200605144616/http://webhelp.esri.com/arcgi
sdesktop/9.2/index.cfm?TopicName=About_getting_started_with_writing_geoprocessing_sc
ripts) from the original on 5 June 2020. Retrieved 11 February 2012.

230. CCP porkbelly (24 August 2010). "Stackless Python 2.7" (https://community.eveonline.com/n

ews/dev-blogs/stackless-python-2.7/). EVE Community Dev Blogs. CCP Games. Archived
(https://web.archive.org/web/20140111155537/http://community.eveonline.com/news/dev-bl
ogs/stackless-python-2.7/) from the original on 11 January 2014. Retrieved 11 January
2014. "As you may know, EVE has at its core the programming language known as
Stackless Python."

231. Caudill, Barry (20 September 2005). "Modding Sid Meier's Civilization IV" (https://web.archiv
e.org/web/20101202164144/http://www.2kgames.com/civ4/blog_03.htm). Sid Meier's
Civilization IV Developer Blog. Firaxis Games. Archived from the original (http://www.2kgam
es.com/civ4/blog_03.htm) on 2 December 2010. "we created three levels of tools ... The
next level offers Python and XML support, letting modders with more experience manipulate
the game world and everything in it."

232. "Python Language Guide (v1.0)" (https://web.archive.org/web/20100715145616/http://code.

google.com/apis/documents/docs/1.0/developers_guide_python.html). Google Documents
List Data API v1.0. Archived from the original (https://code.google.com/apis/documents/doc
s/1.0/developers_guide_python.html) on 15 July 2010.

233. "4.0 New Features and Fixes" (http://www.libreoffice.org/download/4-0-new-features-and-fix
es/). LibreOffice.org. The Document Foundation. 2013. Archived (https://web.archive.org/we
b/20140209184807/http://www.libreoffice.org/download/4-0-new-features-and-fixes/) from
the original on 9 February 2014. Retrieved 25 February 2013.

234. "Python Setup and Usage" (https://docs.python.org/3/using/unix.html). Python Software

Foundation. Archived (https://web.archive.org/web/20200617143505/https://docs.python.or
g/3/using/unix.html) from the original on 17 June 2020. Retrieved 10 January 2020.

235. "What is Sugar?" (http://sugarlabs.org/go/Sugar). Sugar Labs. Archived (https://web.archive.
org/web/20090109025944/http://sugarlabs.org/go/Sugar) from the original on 9 January
2009. Retrieved 11 February 2012.

236. "Immunity: Knowing You're Secure" (https://web.archive.org/web/20090216134332/http://im

munitysec.com/products-immdbg.shtml). Archived from the original on 16 February 2009.

237. "Core Security" (https://www.coresecurity.com/). Core Security. Archived (https://web.archiv
e.org/web/20200609165041/http://www.coresecurity.com/) from the original on 9 June 2020.
Retrieved 10 April 2020.

238. "Gotchas for Python Users" (https://web.archive.org/web/20081211062108/http://boo.codeh

aus.org/Gotchas+for+Python+Users). boo.codehaus.org. Codehaus Foundation. Archived
from the original (http://boo.codehaus.org/Gotchas+for+Python+Users) on 11 December
2008. Retrieved 24 November 2008.

239. Esterbrook, Charles. "Acknowledgements" (https://web.archive.org/web/20080208141002/ht
tp://cobra-language.com/docs/acknowledgements/). cobra-language.com. Cobra Language.
Archived from the original (http://cobra-language.com/docs/acknowledgements/) on 8
February 2008. Retrieved 7 April 2010.

240. "Proposals: iterators and generators [ES4 Wiki]" (https://web.archive.org/web/20071020082

650/http://wiki.ecmascript.org/doku.php?id=proposals:iterators_and_generators).
wiki.ecmascript.org. Archived from the original (http://wiki.ecmascript.org/doku.php?id=propo
sals:iterators_and_generators) on 20 October 2007. Retrieved 24 November 2008.

241. "Frequently asked questions" (https://docs.godotengine.org/en/stable/about/faq.html). Godot

Engine documentation. Archived (https://web.archive.org/web/20210428053339/https://doc
s.godotengine.org/en/stable/about/faq.html) from the original on 28 April 2021. Retrieved
10 May 2021.

242. Kincaid, Jason (10 November 2009). "Google's Go: A New Programming Language That's

Python Meets C++" (https://techcrunch.com/2009/11/10/google-go-language/). TechCrunch.
Archived (https://web.archive.org/web/20100118014358/http://www.techcrunch.com/2009/1
1/10/google-go-language/) from the original on 18 January 2010. Retrieved 29 January
2010.

243. Strachan, James (29 August 2003). "Groovy – the birth of a new dynamic language for the

Java platform" (https://web.archive.org/web/20070405085722/http://radio.weblogs.com/0112
098/2003/08/29.html). Archived from the original (http://radio.weblogs.com/0112098/2003/0
8/29.html) on 5 April 2007. Retrieved 11 June 2007.

244. "Modular Docs – Why Mojo" (https://docs.modular.com/mojo/why-mojo.html).

docs.modular.com. Archived (https://web.archive.org/web/20230505083518/https://docs.mo
dular.com/mojo/why-mojo.html) from the original on 5 May 2023. Retrieved 5 May 2023.
"Mojo as a member of the Python family [..] Embracing Python massively simplifies our
design efforts, because most of the syntax is already specified. [..] we decided that the right
long-term goal for Mojo is to provide a superset of Python (i.e. be compatible with existing
programs) and to embrace the CPython immediately for long-tail ecosystem enablement. To
a Python programmer, we expect and hope that Mojo will be immediately familiar, while also
providing new tools for developing systems-level code that enable you to do things that
Python falls back to C and C++ for."

245. Spencer, Michael (4 May 2023). "What is Mojo Programming Language?" (https://datascien

celearningcenter.substack.com/p/what-is-mojo-programming-language).
datasciencelearningcenter.substack.com. Archived (https://web.archive.org/web/202305050
90408/https://datasciencelearningcenter.substack.com/p/what-is-mojo-programming-langua
ge) from the original on 5 May 2023. Retrieved 5 May 2023.

246. Yegulalp, Serdar (16 January 2017). "Nim language draws from best of Python, Rust, Go,

and Lisp" (https://www.infoworld.com/article/3157745/application-development/nim-languag
e-draws-from-best-of-python-rust-go-and-lisp.html). InfoWorld. Archived (https://web.archiv
e.org/web/20181013211847/https://www.infoworld.com/article/3157745/application-develop
ment/nim-language-draws-from-best-of-python-rust-go-and-lisp.html) from the original on 13
October 2018. Retrieved 7 June 2020. "Nim's syntax is strongly reminiscent of Python's, as
it uses indented code blocks and some of the same syntax (such as the way if/elif/then/else
blocks are constructed)."

247. "An Interview with the Creator of Ruby" (http://www.linuxdevcenter.com/pub/a/linux/2001/11/
29/ruby.html). Linuxdevcenter.com. Archived (https://web.archive.org/web/20180428150410/
http://www.linuxdevcenter.com/pub/a/linux/2001/11/29/ruby.html) from the original on 28
April 2018. Retrieved 3 December 2012.

248. Lattner, Chris (3 June 2014). "Chris Lattner's Homepage" (http://nondot.org/sabre). Chris
Lattner. Archived (https://web.archive.org/web/20151222150510/http://nondot.org/sabre/)
from the original on 22 December 2015. Retrieved 3 June 2014. "I started work on the Swift
Programming Language in July of 2010. I implemented much of the basic language
structure, with only a few people knowing of its existence. A few other (amazing) people
started contributing in earnest late in 2011, and it became a major focus for the Apple
Developer Tools group in July 2013 [...] drawing ideas from Objective-C, Rust, Haskell,
Ruby, Python, C#, CLU, and far too many others to list."

249. Jalan, Nishant Aanjaney (10 November 2022). "Programming in Kotlin" (https://medium.co

m/codex/programming-in-kotlin-934bdb3659cf). CodeX. Retrieved 29 April 2024.

250. Kupries, Andreas; Fellows, Donal K. (14 September 2000). "TIP #3: TIP Format" (http://ww
w.tcl.tk/cgi-bin/tct/tip/3.html). tcl.tk. Tcl Developer Xchange. Archived (https://web.archive.or
g/web/20170713233954/http://tcl.tk/cgi-bin/tct/tip/3.html) from the original on 13 July 2017.
Retrieved 24 November 2008.

251. Gustafsson, Per; Niskanen, Raimo (29 January 2007). "EEP 1: EEP Purpose and

Guidelines" (http://www.erlang.org/eeps/eep-0001.html). erlang.org. Archived (https://web.ar
chive.org/web/20200615153206/http://erlang.org/eeps/eep-0001.html) from the original on
15 June 2020. Retrieved 19 April 2011.

252. "Swift Evolution Process" (https://github.com/apple/swift-evolution/blob/master/process.md).

Swift Programming Language Evolution repository on GitHub. 18 February 2020. Archived
(https://web.archive.org/web/20200427182556/https://github.com/apple/swift-evolution/blob/
master/process.md) from the original on 27 April 2020. Retrieved 27 April 2020.

Sources

"Python for Artificial Intelligence" (https://web.archive.org/web/20121101045354/http://wiki.p
ython.org/moin/PythonForArtificialIntelligence). Python Wiki. 19 July 2012. Archived from the
original (https://wiki.python.org/moin/PythonForArtificialIntelligence) on 1 November 2012.
Retrieved 3 December 2012.
Paine, Jocelyn, ed. (August 2005). "AI in Python" (https://web.archive.org/web/2012032610
5810/http://www.ainewsletter.com/newsletters/aix_0508.htm#python_ai_ai). AI Expert
Newsletter. Amzi!. Archived from the original (http://www.ainewsletter.com/newsletters/aix_0
508.htm#python_ai_ai) on 26 March 2012. Retrieved 11 February 2012.
"PyAIML 0.8.5 : Python Package Index" (https://pypi.python.org/pypi/PyAIML).
Pypi.python.org. Retrieved 17 July 2013.
Russell, Stuart J. & Norvig, Peter (2009). Artificial Intelligence: A Modern Approach
(3rd ed.). Upper Saddle River, NJ: Prentice Hall. ISBN 978-0-13-604259-4.

Further reading

Downey, Allen (July 2024). Think Python: How to Think Like a Computer Scientist (https://all
endowney.github.io/ThinkPython/) (3rd ed.). O'Reilly Media. ISBN 978-1098155438.
Lutz, Mark (2013). Learning Python (5th ed.). O'Reilly Media. ISBN 978-0-596-15806-4.
Summerfield, Mark (2009). Programming in Python 3 (2nd ed.). Addison-Wesley
Professional. ISBN 978-0-321-68056-3.
Ramalho, Luciano (May 2022). Fluent Python (https://www.thoughtworks.com/insights/book
s/fluent-python-2nd-edition). O'Reilly Media. ISBN 978-1-4920-5632-4.

External links

Official website (https://www.python.org/)
The Python Tutorial (https://docs.python.org/3/tutorial/)

Retrieved from "https://en.wikipedia.org/w/index.php?title=Python_(programming_language)&oldid=1288970266"
Python, a high-level, dynamically typed programming language emphasizing readability through indentation, was created by Guido van Rossum at CWI in the Netherlands as a successor to ABC, releasing in 1991. It supports multiple paradigms, including object-oriented, procedural, and functional programming, and is known for its "batteries included" philosophy—a vast standard library (e.g., `itertools`, `re`) and tools like NumPy, TensorFlow, and Django. Python’s evolution saw the introduction of functional features (list comprehensions, generators) and major updates like Python 3.0 (2008), which broke backward compatibility, and modern additions such as type hints (PEP 484) and structural pattern matching (PEP 634). Despite its 2020 discontinuation of Python 2, the language remains a top-ranked choice (TIOBE, PYPL indices) for data science, AI, web development, and scientific computing, used by organizations like NASA, Instagram, and CERN. Its versatility extends to embedded systems, film production, and open-source projects (e.g., LibreOffice), while alternative implementations like PyPy (JIT-optimized) and performance-focused projects (e.g., Mojo) aim to address speed limitations. Governed by a steering council post-Guido van Rossum (2019), Python balances community-driven innovation with structured governance via Python Enhancement Proposals (PEPs), solidifying its role as a foundational language in tech and education.