Python (programming language)

From Wikipedia, the free encyclopedia

Jump to navigationJump to search

Python

Paradigm Multi-paradigm: functional, imperative, object-

oriented, structured, reflective

Designed by Guido van Rossum

Developer Python Software Foundation

First appeared 1990; 30 years ago[1]

Stable release 3.8.2 / 24 February 2020; 2 months ago[2]

Preview release 3.9.0a6 / 28 April 2020; 5 days ago[3]

Typing Duck, dynamic, gradual (since 3.5)[4]

discipline

OS Linux, macOS, Windows Vista (and newer) and

more

License Python Software Foundation License

Filename .py, .pyi, .pyc, .pyd, .pyo (prior to 3.5),[5] .pyw, .pyz

extensions (since 3.5)[6]

Website www.python.org

Major implementations
 CPython, PyPy, Stackless

Python, MicroPython, CircuitPython, IronPython, Jython, RustPython

Dialects

Cython, RPython, Starlark[7]

Influenced by

ABC,[8] Ada,[9] ALGOL 68,[10] APL,[11] C,[12] C++,[13] CLU,[14] Dylan,
[15]
 Haskell,[16] Icon,[17] Java,[18] Lisp,[19] Modula-3,[13] Perl, Standard ML[11]

Influenced

Apache Groovy, Boo, Cobra, CoffeeScript,[20] D, F#, Genie,
[21]
 Go, JavaScript,[22][23] Julia,[24] Nim, Ring,[25] Ruby,[26] Swift[27]

  Python Programming at Wikibooks

Python is an interpreted, high-level, general-purpose programming language. Created

by Guido van Rossum and first released in 1991, Python's design philosophy
emphasizes code readability with its notable use of significant whitespace. Its language
constructs and object-oriented approach aim to help programmers write clear, logical
code for small and large-scale projects.[28]
Python is dynamically typed and garbage-collected. It supports multiple programming
paradigms, including structured (particularly, procedural), object-oriented, and functional
programming. Python is often described as a "batteries included" language due to its
comprehensive standard library.[29]
Python was conceived in the late 1980s as a successor to the ABC language. The
Python 2 language was officially discontinued in 2020 (first planned for 2015), and
"Python 2.7.18 is the last Python 2.7 release and therefore the last Python 2
release."[30] No more security patches or other improvements will be released for it. [31]
[32]
 With Python 2's end-of-life, only Python 3.5.x[33] and later are supported.
Python interpreters are available for many operating systems. A global community of
programmers develops and maintains CPython, an open source[34] reference
implementation. A non-profit organization, the Python Software Foundation, manages
and directs resources for Python and CPython development.
 Contents

 13See also
 14References
o 14.1Sources
 15Further reading
 16External links

History[edit]

Guido van Rossum at OSCON 2006

Main article: History of Python

Python was conceived in the late 1980s[35] by Guido van Rossum at Centrum Wiskunde
& Informatica (CWI) in the Netherlands as a successor to the ABC language (itself
inspired by SETL),[36] capable of exception handling and interfacing with
the Amoeba operating system.[8] Its implementation began in December 1989.[37] 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. [38] He now
shares his leadership as a member of a five-person steering council. [39][40][41] In January
2019, active Python core developers elected Brett Cannon, Nick Coghlan, Barry
Warsaw, Carol Willing and Van Rossum to a five-member "Steering Council" to lead the
project.[42]
Python 2.0 was released on 16 October 2000 with many major new features, including
a cycle-detecting garbage collector and support for Unicode.[43]
Python 3.0 was released on 3 December 2008. It was a major revision of the language
that is not completely backward-compatible.[44] Many of its major features
were backported to Python 2.6.x[45] 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.[46]
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.[47][48]

Features and philosophy[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[49] and metaobjects (magic methods)).[50] Many other paradigms are
supported via extensions, including design by contract[51][52] and logic programming.[53]
Python uses dynamic typing and a combination of reference counting and a cycle-
detecting garbage collector for memory management. 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.[54] The standard library has two modules (itertools and
functools) that implement functional tools borrowed from Haskell and Standard ML.[55]
The language's core philosophy is summarized in the document The Zen of
Python (PEP 20), which includes aphorisms such as:[56]

 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. 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. [35]
. 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.[56] 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."[57]
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. [58] 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.
An important goal of Python's developers is keeping it fun to use. This is reflected in the
language's name—a tribute to the British comedy group Monty Python[59]—and in
occasionally playful approaches to tutorials and reference materials, such as examples
that refer to spam and eggs (from a famous Monty Python sketch) instead of the
standard foo and bar.[60][61]
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.
Users and admirers of Python, especially those considered knowledgeable or
experienced, are often referred to as Pythonistas.[62][63]

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 optional. It has fewer syntactic exceptions and special cases
than C or Pascal.[64]
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. [65] Thus, the program's visual structure
accurately represents the program's semantic structure.[1] This feature is sometimes
termed the off-side rule, which some other languages share, but in most languages
indentation doesn't have any semantic meaning.
Statements and control flow[edit]
Python's statements include (among others):

 The assignment statement (token '=', the equals sign). This operates differently
than in traditional imperative programming languages, and this fundamental
mechanism (including the nature of Python's version of variables) illuminates many
other features of the language. Assignment in C, e.g.,  x = 2 , translates to "typed
variable name x receives a copy of numeric value 2". The (right-hand) value is
copied into an allocated storage location for which the (left-hand) variable name is
the symbolic address. The memory allocated to the variable is large enough
(potentially quite large) for the declared type. In the simplest case of Python
 assignment, using the same example,  x = 2 , translates to "(generic) name x
receives a reference to a separate, dynamically allocated object of numeric (int) type
of value 2." This is termed binding the name to the object. Since the name's storage
location doesn't contain the indicated value, it is improper to call it a variable. Names
may be subsequently rebound at any time to objects of greatly varying types,
including strings, procedures, complex objects with data and methods, etc.
Successive assignments of a common value to multiple names, e.g.,  x = 2 ;  y =
2 ;  z = 2  result in allocating storage to (at most) three names and one numeric
object, to which all three names are bound. Since a name is a generic reference
holder it is unreasonable to associate a fixed data type with it. However at a given
time a name will be bound to some object, which will have a type; thus there
is dynamic typing.
 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, from Python 2.5 released in September 2006, [66] 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. [67]
 The  break  statement, exits from the loop.
 The  continue  statement, skips this iteration and continues with the next item.
 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 ought
to apply.
 The  yield  statement, which returns a value from a generator function. From
Python 2.5,  yield  is also an operator. This form is used to implement coroutines.
 The  import  statement, which is used to import modules whose functions or
variables can be used in the current program. There are three ways of using
 import:  import <module name> [as <alias>]  or  from <module name> import
*  or  from <module name> import <definition 1> [as <alias 1>], <definition
2> [as <alias 2>], ... .
 The  print  statement was changed to the  print()  function in Python 3.
Python does not support tail call optimization or first-class continuations, and, according
to Guido van Rossum, it never will.[68][69] However, better support for coroutine-like
functionality is provided in 2.5, by extending Python's generators.[70] 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.[71]
Expressions[edit]
Some Python expressions are similar to 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.[72] Python also added 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.[73][74]
 From Python 3.8, the syntax  := , called the 'walrus operator' was introduced. It
assigns values to variables as part of a larger expression. [75]
 In Python,  ==  compares by value, versus Java, which compares numerics by
value[76] and objects by reference.[77] (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. Python 2.4
extended list comprehensions into a more general expression termed
a generator expression.[54]
 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 [78] (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. [79]
 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 the 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. [80]
 Python has a "string format" operator  % . This functions analogous
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}' .[81]
 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".[81]
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).[82]
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.[83] 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[84] 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.[85]

Summary of Python 3's built-in types

Mutabilit
Type Description Syntax examples
y

True
bool immutable Boolean value
False

bytearray (b'Some ASCII')

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

b'Some ASCII'
bytes immutable Sequence of bytes b"Some ASCII"
bytes([119, 105, 107, 105])
 Complex
complex immutable number with real and 3+2.7 j
imaginary parts

Associative array (or
dictionary) of key
and value pairs; can { 'key1': 1.0, 3: False}
dict mutable contain mixed types
{}
(keys and values),
keys must be a
hashable type

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

Double
precision floating
point number. The
float immutable precision is machine 3.1415927
dependent but in
practice is 64 bits.
[citation needed]

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

int Integer of unlimited 42

immutable
magnitude[86]

List, can contain [ 4.0, 'string', True]

list mutable
mixed types []

NoneType a immutable An object None

representing the
absence of a value,
often called Null in
 other languages

A placeholder that
can be returned
NotImplementedTyp from overloaded
immutable NotImplemented
ea operators to indicate
unsupported operand
types.

A Sequence of
numbers commonly range (1, 10)
range immutable used for looping
specific number of range(10, -5, -2)
times in  for  loops[87]

Unordered set,
contains no { 4.0, 'string', True}
set mutable duplicates; can
set()
contain mixed types,
if hashable

'Wikipedia'
"Wikipedia"
A character string:
str immutable sequence of Unicode
codepoints """Spanning
multiple
lines"""

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

^a Not directly accessible by name

Mathematics[edit]
Python has the usual symbols for arithmetic operators ( + ,  - ,  * ,  / ), the floor division
operator  //  and the remainder operator  %  (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  @  .[88] 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).
Division between integers produces floating point results. The behavior of division has
changed significantly over time:[89]

 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 .
 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 3.0 changed  /  to always be floating-point division, e.g.  5/2 == 2.5 .
In Python terms,  /  is true division (or simply division), and  //  is floor division.  /  before
version 3.0 is classic division.[89]
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.[90]
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 .
[91]
 Versions before 3 used round-away-from-zero:  round(0.5)  is  1.0 ,  round(-
0.5)  is  −1.0 .[92]

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 .[93] 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 .[94]
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. [95] The  Fraction  class
in the  fractions  module provides arbitrary precision for rational numbers.[96]
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. [97][98]

Libraries[edit]
Some parts of the standard library are covered by specifications (for example, the Web
Server Gateway Interface (WSGI) implementation  wsgiref  follows PEP 333[101]), 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.

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.[104]

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.[105] It compiles Python programs into
an intermediate bytecode[106] which is then executed by its virtual machine.[107] 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 (Vista and later; supported Windows
XP and older, with by now unsupported Python 2.7) and most modern Unix-
like systems. Platform portability was one of its earliest priorities, [108] in Python 1 and 2
time-frame, even supporting VMS and OS/2, while since support has been dropped for
a lot of platforms.
Other implementations[edit]
PyPy is a fast, compliant interpreter of Python 2.7 and 3.6. [109] Its just-in-time
compiler brings a significant speed improvement over CPython but several libraries
written in C cannot be used with it.[110][111]
Stackless Python is a significant fork of CPython that implements microthreads; it does
not use the C memory stack, thus allowing massively concurrent programs. PyPy also
has a stackless version.[112]
MicroPython and CircuitPython are Python 3 variants optimized for microcontrollers.
This includes Lego Mindstorms EV3.[113]
Unsupported implementations[edit]
Other just-in-time Python compilers have been developed, but are now unsupported:
 Google began a project named Unladen Swallow in 2009, with the aim of
speeding up the Python interpreter five-fold by using the LLVM, and of improving its
multithreading ability to scale to thousands of cores, [114] while ordinary
implementations suffer from the global interpreter lock.
 Psyco was a just-in-time specializing compiler that 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.
In 2005, Nokia released a Python interpreter for the Series 60 mobile phones
named PyS60. It includes many of the modules from the CPython implementations and
some additional modules to integrate with the Symbian operating system. The project
has been kept up-to-date to run on all variants of the S60 platform, and several third-
party modules are available. The Nokia N900 also supports Python with GTK widget
libraries, enabling programs to be written and run on the target device. [115]
Cross-compilers to other languages[edit]
There are several compilers to high-level object languages, with either unrestricted
Python, a restricted subset of Python, or a language similar to Python as the source
language:

 Cython compiles Python to C and C++.

 Google's Grumpy compiles Python to Go.[116][117]
 IronPython follows a similar approach in order to run Python programs on the
.NET Common Language Runtime.
 Jython enables the use of the Java class library from a Python program.
 MyHDL compiles Python to VHDL.
 Nuitka compiles Python into C++.[118]
 Numba uses LLVM to compile Python to machine code.
 Pyjs compiles Python to JavaScript.
 Pyrex (latest release in 2010) and Shed Skin (latest release in 2013) compile to
C and C++ respectively.
 Pythran compiles Python to C++.[119][120]
 RPython can be compiled to C, and is used to build the PyPy interpreter of
Python.
Performance[edit]
A performance comparison of various Python implementations on a non-numerical
(combinatorial) workload was presented at EuroSciPy '13. [121] Python's performance
compared to other programming languages has also been benchmarked by The
Computer Language Benchmarks Game.[122]

Development[edit]
Python's development is conducted largely through the Python Enhancement
Proposal (PEP) process, the primary mechanism for proposing major new features,
collecting community input on issues and documenting Python design decisions.
[123]
 Python coding style is covered in PEP 8.[124] Outstanding PEPs are reviewed and
commented on by the Python community and the steering council. [123]
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 are discussed in the Roundup bug tracker hosted
at bugs.python.org.[125] Development originally took place on a self-hosted source-code
repository running Mercurial, until Python moved to GitHub in January 2017.[126]
CPython's public releases come in three types, distinguished by which part of the
version number is incremented:

 Backward-incompatible versions, where code is expected to break and need to

be manually ported. The first part of the version number is incremented. These
releases happen infrequently—for example, version 3.0 was released 8 years after
2.0.
 Major or "feature" releases, about every 18 months, are largely compatible but
introduce new features. The second part of the version number is incremented.
Each major version is supported by bugfixes for several years after its release. [127]
 Bugfix releases, which introduce no new features, occur about every 3 months
and 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. [128]
Python 3.9 alpha1 was announced in November 2019 [129] and with the adoption of a new
yearly release cadence,[130][131] the first release of 3.9 is slated for November 2020. [132]
Many alpha, beta, and release-candidates are also released as previews and for testing
before final releases. Although there is a rough schedule for each release, they are
often delayed if the code is not ready. Python's development team monitors the state of
the code by running the large unit test suite during development, and using
the BuildBot continuous integration system.[133]
The major academic conference on Python is PyCon. There are also special Python
mentoring programmes, such as Pyladies.

Naming[edit]
;[134] for example, the metasyntactic variables often used in Python literature
are spam  and  eggs instead of the traditional foo  and  bar.[134][135] The official Python
documentation also contains various references to Monty Python routines. [136][137]

Uses[edit]
Main article: List of Python software

L SageMath is a mathematical software with a notebook interface programmable in

Python: its library covers many aspects of mathematics,
including algebra, combinatorics, numerical mathematics, number theory, and calculus.
[154]

Python has been successfully embedded in many software products as a scripting

language, including in finite element method software such as Abaqus, 3D parametric
modeler like 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 like GIMP,[155] Inkscape, Scribus and Paint Shop
Pro,[156] and musical notation programs like scorewriter and capella. 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.[157] It
has also been used in several video games,[158][159] and has been adopted as first of the
three available programming languages in Google App Engine, the other two
being Java and Go.[160]
. It ships with most Linux distributions,[166] AmigaOS 4 (using Python 2.7), FreeBSD (as a
package), NetBSD, OpenBSD (as a package) and macOS and 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 use
the Anaconda installer. Gentoo Linux uses Python in its package management
system, Portage.
Python is used extensively in the information security industry, including in exploit
development.[167][168]
Most of the Sugar software for the One Laptop per Child XO, now developed at Sugar
Labs, is written in Python.[169] The Raspberry Pi single-board computer project has
adopted Python as its main user-programming language.

Languages influenced by Python[edit]

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

 Boo uses indentation, a similar syntax, and a similar object model. [171]

 Cobra uses indentation and a similar syntax, and
its Acknowledgements document lists Python first among languages that influenced
it.[172]
 CoffeeScript, a programming language that cross-compiles to JavaScript, has
Python-inspired syntax.
 ECMAScript/JavaScript borrowed iterators and generators from Python.[173]
 GDScript, a scripting language very similar to Python, built-in to the Godot game
engine.[174]
 Go is designed for the "speed of working in a dynamic language like
Python"[175] and shares the same syntax for slicing arrays.
 Groovy was motivated by the desire to bring the Python design philosophy
to Java.[176]
 Julia was designed to be "as usable for general programming as Python". [24]
 Nim uses indentation and a similar syntax.[citation needed]
 Ruby's creator, Yukihiro Matsumoto, has said: "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."[177]
 Swift, a programming language developed by Apple, has some Python-inspired
syntax.[178]
Python's development practices have also been emulated by other languages. For
example, the practice of requiring a document describing the rationale for, and issues
surrounding, a change to the language (in Python, a PEP) is also used in Tcl,[179] Erlang,
[180]
 and Swift.[181]