History[edit]

The designer of Python, Guido van Rossum, at OSCON 2006

Main article: History of Python

Python was conceived in the late 1980s [38] by Guido van Rossum at Centrum Wiskunde &
Informatica (CWI) in the Netherlands as a successor to ABC programming language, which was
inspired by SETL,[39] capable of exception handling and interfacing with the Amoeba operating
system.[10] Its implementation began in December 1989. [40] Van Rossum shouldered sole
responsibility for the project, as the lead developer, until 12 July 2018, when he announced his
"permanent vacation" from his responsibilities as Python's Benevolent Dictator For Life, a title the
Python community bestowed upon him to reflect his long-term commitment as the project's chief
decision-maker.[41] In January 2019, active Python core developers elected a 5-member "Steering
Council" to lead the project.[42] As of 2021, the current members of this council are Barry Warsaw,
Brett Cannon, Carol Willing, Thomas Wouters, and Pablo Galindo Salgado. [43]
Python 2.0 was released on 16 October 2000, with many major new features, including a cycle-
detecting garbage collector and support for Unicode.[44]
Python 3.0 was released on 3 December 2008. It was a major revision of the language that is not
completely backward-compatible.[45] Many of its major features were backported to
Python 2.6.x[46] and 2.7.x version series. Releases of Python 3 include the  2to3  utility, which
automates (at least partially) the translation of Python 2 code to Python 3.[47]
Python 2.7's end-of-life date was initially set at 2015 then postponed to 2020 out of concern that a
large body of existing code could not easily be forward-ported to Python 3.[48][49] No more security
patches or other improvements will be released for it. [50][51] With Python 2's end-of-life, only
Python 3.6.x[52] and later are supported.
Python 3.9.2 and 3.8.8 were expedited[53] as all versions of Python (including 2.7[54]) had security
issues, leading to possible remote code execution[55] and web cache poisoning.[56]

Design philosophy and features[edit]

Python is a multi-paradigm programming language. Object-oriented programming and structured
programming are fully supported, and many of its features support functional programming
and aspect-oriented programming (including by metaprogramming[57] and metaobjects (magic
methods)).[58] Many other paradigms are supported via extensions, including design by contract[59]
[60]
 and logic programming.[61]
Python uses dynamic typing and a combination of reference counting and a cycle-detecting garbage
collector for memory management.[62] It also features 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 , map and reduce  functions; list comprehensions, dictionaries, sets,
and generator expressions.[63] The standard library has two modules (itertools and functools) that
implement functional tools borrowed from Haskell and Standard ML.[64]
The language's core philosophy is summarized in the document The Zen of Python (PEP 20), which
includes aphorisms such as:[65]

 Beautiful is better than ugly.

 Explicit is better than implicit.
 Simple is better than complex.
 Complex is better than complicated.
 Readability counts.
Rather than having all of its functionality built into its core, Python was designed to be
highly extensible (with 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 espoused the opposite approach.[38]
Python strives for a simpler, less-cluttered syntax and grammar while giving developers a choice in
their coding methodology. In contrast to Perl's "there is more than one way to do it" motto, Python
embraces a "there should be one— and preferably only one —obvious way to do it" design
philosophy.[65] Alex Martelli, a Fellow at the Python Software Foundation and Python book author,
writes that "To describe something as 'clever' is not considered a compliment in the Python
culture."[66]
Python's developers strive to avoid premature optimization, and reject patches to non-critical parts of
the CPython reference implementation that would offer marginal increases in speed at the cost of
clarity.[67] When speed is important, a Python programmer can move time-critical functions to
extension modules written in languages such as C, or use PyPy, a just-in-time compiler. Cython is
also available, which translates a Python script into C and makes direct C-level API calls into the
Python interpreter.
Python's developers aim to keep the language fun to use. This is reflected in its name—a tribute to
the British comedy group Monty Python[68]—and in occasionally playful approaches to tutorials and
reference materials, such as examples that refer to spam and eggs (a reference to a Monty Python
sketch) instead of the standard foo and bar.[69][70]
A common neologism in the Python community is pythonic, which can have a wide range of
meanings related to program style. To say that code is pythonic is to say that it uses Python idioms
well, that it is natural or shows fluency in the language, that it conforms with Python's minimalist
philosophy and emphasis on readability. In contrast, code that is difficult to understand or reads like
a rough transcription from another programming language is called unpythonic.[71][72]
Users and admirers of Python, especially those considered knowledgeable or experienced, are often
referred to as Pythonistas.[73][74]

Syntax and semantics[edit]

Main article: Python syntax and semantics
Python is meant to be an easily readable language. Its formatting is visually uncluttered, and it 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 are
rarely, if ever, used. It has fewer syntactic exceptions and special cases than C or Pascal.[75]

Indentation[edit]
Main article: Python syntax and semantics §  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.[76] Thus, the program's visual structure accurately represents the program's
semantic structure.[77] This feature is sometimes termed the off-side rule, which some other
languages share, but in most languages indentation does not have any semantic meaning. The
recommended indent size is four spaces.[78]

Statements and control flow[edit]

Python's statements include (among others):

 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.
 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; it also ensures that clean-up code in
a  finally  block will always be 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 (for
example, acquiring a lock before the block of code is run and releasing the lock
afterwards, or opening a file and then closing it), allowing resource-acquisition-is-
initialization (RAII)-like behavior and replaces a common try/finally idiom. [79]
 The  break  statement, exits from a loop.
 The  continue  statement, skips this iteration and continues with the next item.
 The  del  statement, removes a variable, which means the reference from the name to
the value is deleted and trying to use that variable will cause an error. A deleted variable
can be reassigned.
 The  pass  statement, which serves as a NOP. It is syntactically needed to create an
empty code block.
 The  assert  statement, used during debugging to check for conditions that should
apply.
 The  yield  statement, which returns a value from a generator function and  yield  is
also an operator. This form is used to implement coroutines.
  The  return  statement, used to return a value from a function.
 The  import  statement, which is used to import modules whose functions or variables
can be used in the current program.
The assignment statement ( = ) operates by binding a name as a reference to a separate,
dynamically-allocated object. Variables may be subsequently rebound at any time to any object. In
Python, a variable name is a generic reference holder and does not have a fixed data
type associated with it. However, at a given time, a variable will refer to some object, which will have
a type. This is referred to as dynamic typing and is contrasted with statically-typed programming
languages, where each variable may only contain values of a certain type.
Python does not support tail call optimization or first-class continuations, and, according to Guido
van Rossum, it never will.[80][81] However, better support for coroutine-like functionality is provided, by
extending Python's generators.[82] Before 2.5, generators were lazy iterators; information was passed
unidirectionally out of the generator. From Python 2.5, it is possible to pass information back into a
generator function, and from Python 3.3, the information can be passed through multiple stack
levels.[83]

Expressions[edit]
Some Python expressions are similar to those found in languages such as C and Java, while some
are not:

 Addition, subtraction, and multiplication are the same, but the behavior of division differs.
There are two types of divisions in Python. They are floor division (or integer
division)  //  and floating-point / division.[84] Python also uses the  **  operator for
exponentiation.
 From Python 3.5, the new  @  infix operator was introduced. It is intended to be used by
libraries such as NumPy for matrix multiplication.[85][86]
 From Python 3.8, the syntax  := , called the 'walrus operator' was introduced. It assigns
values to variables as part of a larger expression. [87]
 In Python,  ==  compares by value, versus Java, which compares numerics by
value[88] and objects by reference.[89] (Value comparisons in Java on objects can be
performed with the  equals()  method.) Python's  is  operator may be used to compare
object identities (comparison by reference). In Python, comparisons may be chained, for
example  a <= b <= c .
 Python uses the words  and ,  or ,  not  for its boolean operators rather than the
symbolic  && ,  || ,  !  used in Java and C.
 Python has a type of expression termed a list comprehension as well as a more general
expression termed a generator expression.[63]
 Anonymous functions are implemented using lambda expressions; however, these are
limited in that the body can only be one expression.
 Conditional expressions in Python are written as  x if c else y [90] (different in order of
operands 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 (dictionary keys must
be immutable in Python). Tuples are written as  (1, 2, 3) , are immutable and thus can
be used as the keys of dictionaries, provided all elements of the tuple are immutable.
The  +  operator can be used to concatenate two tuples, which does not directly modify
their contents, but rather produces a new tuple containing the elements of both provided
 tuples. Thus, 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) , which 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.[91]
 Python features sequence unpacking wherein multiple expressions, each evaluating to
anything that can be assigned to (a variable, a writable property, etc.), are associated in
an identical manner to that forming tuple literals and, as a whole, are put on the left-hand
side of the equal sign in an assignment statement. The statement expects
an iterable object on the right-hand side of the equal sign that produces the same
number of values as the provided writable expressions when iterated through and will
iterate through it, assigning each of the produced values to the corresponding
expression on the left.[92]
 Python has a "string format" operator  % . This functions analogously to  printf  format
strings in C, e.g.  "spam=%s eggs=%d" % ("blah", 2)  evaluates to  "spam=blah
eggs=2" . In Python 3 and 2.6+, this 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":  blah = "blah"; eggs = 2; f'spam={blah} eggs={eggs}' .[93]
 Strings in Python can be concatenated, by "adding" them (same operator as for adding
integers and floats). E.g.  "spam" + "eggs"  returns  "spameggs" . Even if your strings
contain numbers, they are still added as strings rather than integers.
E.g.  "2" + "2"  returns  "22" .
 Python has various kinds of string literals:
o Strings delimited by single or double quote marks. Unlike in Unix
shells, Perl and Perl-influenced languages, single quote marks and double
quote marks function identically. Both kinds of string use the backslash ( \ )
as an escape character. String interpolation became available in Python 3.6
as "formatted string literals".[93]
o Triple-quoted strings, which begin and end with a series of three single or
double quote marks. They may span multiple lines and function like here
documents in shells, Perl and Ruby.
o Raw string varieties, denoted by prefixing the string literal with an  r . Escape
sequences are not interpreted; hence raw strings are useful where literal
backslashes are common, such as regular expressions and Windows-style
paths. Compare " @ -quoting" in C#.
 Python has array index and array slicing expressions on lists, denoted
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 third slice parameter, called step or stride, allows
elements to be skipped and 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 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 is for expressions, the latter is for statements.
Statements cannot be a part of an expression, so list and other comprehensions or lambda
expressions, all being expressions, cannot contain statements. A particular case of this is that an
assignment statement such as  a = 1  cannot form part of the conditional expression of a conditional
statement. This has the advantage of avoiding a classic C error of mistaking an assignment
operator  =  for an equality operator  ==  in conditions:  if (c = 1) { ... }  is syntactically valid
(but probably unintended) C code but  if c = 1: ...  causes a syntax error in Python.

Methods[edit]
Methods on objects are functions attached to the object's class; the
syntax  instance.method(argument)  is, for normal methods and functions, 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 ) in some
other object-oriented programming languages (e.g., C++, Java, Objective-C, or Ruby).[94] Apart from
this Python also provides methods, sometimes called dunder methods due to their names beginning
and ending with double-underscores, to extend the functionality of custom class to support native
functions such as print, length, comparison, support for arithmetic operations, type conversion, and
many more.[95]

Typing[edit]

The standard type hierarchy in Python 3

Python uses duck typing and has typed objects but untyped variable names. Type constraints are
not checked at compile time; rather, operations on an object may fail, signifying that the given object
is not of a suitable type. Despite being dynamically-typed, Python is strongly-typed, forbidding
operations that are not well-defined (for example, adding a number to a string) rather than silently
attempting to make sense of them.
Python allows programmers to define their own types using classes, which are most often used
for object-oriented programming. New instances of classes are constructed by calling the class (for
example,  SpamClass()  or  EggsClass() ), and the classes are instances of
the metaclass  type  (itself an instance of itself), allowing metaprogramming and reflection.
Before version 3.0, Python had two kinds of classes: old-style and new-style.[96] The syntax of both
styles is the same, the difference being whether the class  object  is inherited from, directly or
indirectly (all new-style classes inherit from  object  and are instances of  type ). In versions of
Python 2 from Python 2.2 onwards, both kinds of classes can be used. Old-style classes were
eliminated in Python 3.0.
The long-term plan is to support gradual typing[97] and from Python 3.5, the syntax of the language
allows specifying static types but they are not checked in the default implementation, CPython. An
experimental optional static type checker named mypy supports compile-time type checking. [98]

Summary of Python 3's built-in types

Mutabilit
Type Description Syntax examples
y

immutabl True
bool Boolean value
e False

bytearray (b'Some ASCII')

bytearray(b"Some ASCII")
bytearray mutable Sequence of bytes
bytearray([119, 105, 107, 105
])

b'Some ASCII'
immutabl
bytes Sequence of bytes b"Some ASCII"
e
bytes([119, 105, 107, 105])

Complex 3+2.7 j
complex immutabl
number with real
e 3 + 2.7j
and imaginary parts

dict mutable Associative array (or { 'key1': 1.0, 3: False}

dictionary) of key {}
and value pairs; can
contain mixed types
(keys and values),
keys must be a
 hashable type

An ellipsis placehold
immutabl er to be used as an ...
ellipsis a
e index Ellipsis
in NumPy arrays

Double-precision flo
ating-point number.
The precision is
machine-dependent
float immutabl but in practice is 1.414
e generally
implemented as a
64-bit IEEE
754 number with 53
bits of precision.[99]

Unordered set,
contains no frozenset ([4.0, 'string', Tr
frozenset immutabl
duplicates; can
e ue])
contain mixed types,
if hashable

int immutabl Integer of unlimited 42

e magnitude[100]
List, can contain [ 4.0, 'string', True]
list mutable
mixed types []

An object
representing the
immutabl
NoneType a absence of a value, None
e
often called null in
other languages
A placeholder that
can be returned
NotImplementedTyp immutabl from overloaded NotImplemented
ea e operators to indicate
unsupported
operand types.
A Sequence of
numbers commonly
immutabl used for looping range (1, 10)
range
e specific number of range(10, -5, -2)
times
in  for  loops[101]
set mutable Unordered set, { 4.0, 'string', True}
 contains no
duplicates; can set ()
contain mixed types,
if hashable
'Wikipedia'
"Wikipedia"
A character string:
immutabl
str sequence of """Spanning
e
Unicode codepoints multiple
lines"""

( 4.0, 'string', True)
tuple immutabl Can contain mixed ('single element',)
e types
()

^a Not directly accessible by name

Arithmetic operations[edit]
Python has the usual symbols for arithmetic operators ( + ,  - ,  * ,  / ), the floor division
operator  //  and the modulo operation  %  (where the remainder can be negative, e.g.  4 % -3 ==
-2 ). It also has  **  for exponentiation, e.g.  5**3 == 125  and  9**0.5 == 3.0 , and a matrix
multiply operator  @  .[102] These operators work like in traditional math; with the same precedence
rules, the operators infix ( +  and  -  can also be unary to represent positive and negative numbers
respectively).
The division between integers produces floating-point results. The behavior of division has changed
significantly over time:[103]

 Current Python (i.e. since 3.0) changed  /  to always be floating-point division,
e.g.  5/2 == 2.5 .
 Python 2.2 changed integer division to round towards negative infinity, e.g.  7/3 ==
2  and  -7/3 == -3 . The floor division  //  operator was introduced. So  7//3 == 2 ,  -
7//3 == -3 ,  7.5//3 == 2.0  and  -7.5//3 == -3.0 .
Adding  from __future__ import division  causes a module to use Python 3.0
rules for division (see next).
 Python 2.1 and earlier used C's division behavior. The  /  operator is integer division if
both operands are integers, and floating-point division otherwise. Integer division rounds
towards 0, e.g.  7/3 == 2  and  -7/3 == -2 .
In Python terms,  /  is true division (or simply division), and  //  is floor division.  /  before version 3.0
is classic division.[103]
Rounding towards negative infinity, though different from most languages, adds consistency. For
instance, it means that the equation  (a + b)//b == a//b + 1  is always true. It also means that
the equation  b*(a//b) + a%b == a  is valid for both positive and negative values of  a . However,
maintaining the validity of this equation means that while the result of  a%b  is, as expected, in
the half-open interval [0, b), where  b  is a positive integer, it has to lie in the interval (b, 0] when  b  is
negative.[104]
Python provides a  round  function for rounding a float to the nearest integer. For tie-breaking,
Python 3 uses round to even:  round(1.5)  and  round(2.5)  both produce  2 .[105] Versions before 3
used round-away-from-zero:  round(0.5)  is  1.0 ,  round(-0.5)  is  −1.0 .[106]
Python allows boolean expressions with multiple equality relations in a manner that is consistent with
general use in mathematics. For example, the expression  a < b < c  tests whether  a  is less
than  b  and  b  is less than  c .[107] 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 .[108]
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
and several rounding modes.[109] The  Fraction  class in the  fractions  module provides arbitrary
precision for rational numbers.[110]
Due to Python's extensive mathematics library, and the third-party library NumPy that further
extends the native capabilities, it is frequently used as a scientific scripting language to aid in
problems such as numerical data processing and manipulation. [111][112]

Programming examples[edit]
Hello world program:

print('Hello, world!')

Program to calculate the factorial of a positive integer:

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[edit]
Python's large standard library, commonly cited as one of its greatest strengths, [113] provides tools
suited to many tasks. For Internet-facing applications, many standard formats and protocols such
as MIME and HTTP are supported. It includes modules for creating graphical user interfaces,
connecting to relational databases, generating pseudorandom numbers, arithmetic with arbitrary-
precision decimals,[114] 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[115]), but most modules are not.
They 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 need altering or rewriting for
variant implementations.
As of March 2021, the Python Package Index (PyPI), the official repository for third-party Python
software, contains over 290,000[116] packages with a wide range of functionality, including:

 Automation
 Data analytics
 Databases
 Documentation
 Graphical user interfaces
 Image processing
 Machine learning
 Mobile App
 Multimedia
 Computer networking
 Scientific computing
 System administration
 Test frameworks
 Text processing
 Web frameworks
 Web scraping

Development environments[edit]
See also: Comparison of integrated development environments §  Python
Most Python implementations (including CPython) include a read–eval–print loop (REPL), permitting
them to function as a command line interpreter for which the user enters statements sequentially and
receives results immediately.
Other shells, including IDLE and IPython, add further abilities such as improved auto-completion,
session state retention and syntax highlighting.
As well as standard desktop integrated development environments, there are Web browser-based
IDEs; SageMath (intended for developing science and math-related Python
programs); PythonAnywhere, a browser-based IDE and hosting environment; and Canopy IDE, a
commercial Python IDE emphasizing scientific computing.[117]

Implementations[edit]
See also: List of Python software §  Python implementations

Reference implementation[edit]
CPython is the reference implementation of Python. It is written in C, meeting the C89 standard with
several select C99 features (with later C versions out, it's considered outdated; [118][119] CPython
includes its own C extensions, but third-party extensions are not limited to older C versions, can e.g.
be implemented with C11 or C++[120]).[121] It compiles Python programs into an
intermediate bytecode[122] which is then executed by its virtual machine.[123] CPython is distributed with
a large standard library written in a mixture of C and native Python. It is available for many platforms,
including Windows (starting with Python 3.9, the Python installer deliberately fails to install
on Windows 7 and 8;[124][125] Windows XP was supported until Python 3.5) and most modern Unix-
like systems, including macOS (and Apple M1 Macs, since Python 3.9.1, with experimental installer)
and unofficial support for e.g. VMS.[126] Platform portability was one of its earliest priorities, [127] during
the Python 1 and 2 time-frame, even OS/2 and Solaris were supported;[128] support has since been
dropped for a lot of platforms.

Other implementations[edit]
 PyPy is a fast, compliant interpreter of Python 2.7 and 3.6.[129] Its just-in-time
compiler brings a significant speed improvement over CPython but several libraries
written in C cannot be used with it.[130]
 Stackless Python is a significant fork of CPython that implements microthreads; it does
not use the call stack in the same way, thus allowing massively concurrent programs.
PyPy also has a stackless version.[131]
 MicroPython and CircuitPython are Python 3 variants optimized for microcontrollers,
including Lego Mindstorms EV3.[132]
 Pyston is a variant of the Python runtime that uses just-in-time compilation to speed up
the execution of Python programs.[133]
 Cinder is a performance-oriented fork of CPython 3.8 that contains a number of
optimizations including bytecode inline caching, eager evaluation of coroutines, a
method-at-a-time JIT and an experimental bytecode compiler. [134]