It so lacks C-style complex for, the clean...when, though naturally equivalents may be expressed. Also, it has merely whenever...elif...else for branching—there are no switch or even labelled goto (goto was [http://www.entrian.com/goto/ implemented] as a joke for April First 2004, around an add-in module).

Syntactical significance of indentation

Of these unusual aspect of Python's syntax is its utilise of the off-side rule to delimit program blocks. Another time termed "the whitespace thing", these are a single aspect of Python syntax that numbers of software engineer otherwise unacquainted with Python stand heard of, since it is about unique among presently far flung languages.

Within and then-supposed "free-format" languages, that utilize a prevent structure at long last from either ALGOL, blocks of code come placed polish off sustaining braces () or even keywords. All told these languages, even so, computer programmer conventionally indent a code in a prevent, to let it run bump off visually from either the encompassing code.

Python, instead, borrows a feature from either the lesser-known language ABC—instead of punctuation or keywords, it utilizes this indentation itself to suggest the rerun of a prevent. The brief case will make this clear. On text come C & Python recursive functions which do a equivalent tool—computing a factorial of an integer:

Factorial work inside C: int factorial(int x) else }

Factorial work within Python: def factorial(ten): whenever x == Cipher: link to 1 else: link to x * factorial(x-One)

A select few coder utilized to ALGOL-style languages, where whitespace is semantically empty, initially buy this confusing or offense. Two or three develop drawn uncomplimentary comparisin to the column-oriented style utilized on punched-card Fortran systems. While ALGOL was freshly, it was the major development to keep around "free-form" languages where single symbols mattered & non their position on the line.

To Python software engineer, still, "the whitespace thing" is just the enforcement of a convention that computer programmer inside ALGOL-style languages already watch anyway. It too point out that a free-form syntax has a disadvantage that, since indentation is ignored, proficient indentation can't become enforced. So, incorrectly indented code can be misleading, since the human being reader & the compiler may interpret it other than.

A whitespace tool has minor disadvantages. Two space characters & tab characters come presently accepted when forms of indentation. Since it is non visually distinct (around numbers of information), mixing spaces & tabs may produce bugs that come particularly hard to call for (the perennial guide among Python users hwhen been removing tabs as prevent markers—except, naturally, among people Python users world health organization propound removing spaces instead).

Because whitespace is syntactically important, these are nin universally conceivable for even a program to automatically right the indentation on Python code every bit may be done by owning C or Lisp code. What is more, formatting routines which dislodge whitespace—for instance,Numerous Internet forums—can wholly kill the syntax of the Python program, whereas the program within a bracketed language would but be supplementary hard to page through.

Comments and docstrings

Python has 2 slipway to annotate Python code. 1 is by applying comments to imply what occasionally a portion of the code does.

def getline(): link to sys.stdin.readline() # Make their way a single line & link to it

Comments start out by having a hash character ("#") & come terminated per prevent of line. Python doesn't trend lines comments that span additional than of these line. A more way is to have docstrings (documentation string), that is the string that is placed alone forgoing assignment when a number one line inside a module, class, method or even work. Such strings may be delimited sustaining " or ' for single line strings, or may span multiple lines if delimited with either """ or ''' which is Python's notation for specifying multi-line strings. But, a style option for the language specifies that triple double quotes (""") are preferred for both single and multi-line docstrings.

Single line docstring: def getline(): """Develop of these line from either stdin & link to it.""" return sys.stdin.readline()

Multi-line docstring: def getline(): """Become of these line from either stdin & link to it.""" return sys.stdin.readline()

Docstrings can be as large as the programmer wants and contain line breaks (if multi-line strings are used). In contrast with comments, docstrings are themselves Python objects and are part of the interpreted code that Python runs. That means that a running program can retrieve its own docstrings and manipulate that information. But the normal usage is to give other programmers information about how to invoke the object being documented in the docstring.

There are tools available that can extract the docstrings to generate an API documentation from the code. Docstring documentation can also be accessed from the interpreter with the help() function, or from the shell with the pydoc command.

Functional programming

As mentioned above, another strength of Python is the availability of a functional programming style. As may be expected, this makes working with lists and other collections much more straightforward. One such construction is the list comprehension, as seen here in calculating the first five powers of two:

numbers = [1, 2, 3, 4, 5] powers_of_two = [2**n for n in numbers]

The Quicksort algorithm can be expressed elegantly using list comprehensions:

def qsort(L): if L == []: return [] return qsort([x for x in L[1:] if x< L[0] ]) + L[0:1] + \ qsort([x for x in L[1:] if x>=L[0] ])

Although execution of this naïve form of Quicksort is less space-efficient than forms which alter the sequence in-place, it is often cited as an example of the expressive power of list comprehensions.

First-class functions

In Python, functions are first-class objects that can be created and passed around dynamically. Because Python permits functions as arguments, it is also possible to partially simulate more subtle functional constructs, such as the continuation.

Python's lambda construct can be used to create anonymous functions within expressions. Lambdas are however limited to containing expressions; statements can only be used in named functions created with the def statement. (However, any type of control flow can in principle be implemented within lambda expressions[http://www-106.ibm.com/developerworks/linux/library/l-prog.html] by short-circuiting the and and or operators.)

Closures

Python has had support for lexical closures since version 2.2.

Python's syntax, though, sometimes leads programmers of other languages to think that closures are not supported. They might try the following, for example:

def foo(initial_value=0): var = initial_value def var_setter(newval): var = newval def var_getter(): return var return var_setter, var_getter setter, getter = foo() setter(19) getter() # <- would return 0

..and they then assume closures do not work in Python. The problem, however, is a misunderstanding of Python's naming and binding rules. When a name-binding operation occurs anywhere in a function body (e.g., an assignment), that name is made local to the function and can not be a free variable. However, the same functionality can be had by using part of a mutable object as the store, for example:

def foo(initial_value=0): varholder = [initial_value] # put the value into a list def var_setter(newval): varholder[0] = newval def var_getter(): return varholder[0] return var_setter, var_getter setter, getter = foo() setter(21) getter() # <- would return 21

Since the name of the variable from the enclosing scope (varholder) is not rebound in var_setter, varholder becomes a free variable in var_setter and var_setter becomes a closure.

Generators

Introduced in Python 2.2 as optional feature and finalized in version 2.3, generators are Python's mechanism for lazy evaluation of a function that would otherwise return a space-prohibitive or computationally intensive list.

This is an example to lazily generate the prime numbers:

import sys def generate_primes(max=sys.maxint): primes = [] n = 2 while n < max: composite = False for p in primes: if not n % p: composite = True break elif p**2 > n: break if not composite: primes.append(n) yield n n += 1

To use this function simply call, e.g.:

for i in generate_primes(): # iterate over ALL primes if i > 100: break print i,

The definition of a generator appears identical to that of a function, except the keyword yield is used in place of return. However, a generator is an object with persistent state, which can repeatedly enter and leave the same dynamic extent. A generator call can then be used in place of a list, or other structure whose elements will be iterated over. Whenever the for-loop in the example requires the next item, the generator is called, and yields the next item.

Generator expressions
Introduced in Python 2.4, generator expressions are the lazy evaluation equivalent of list comprehensions. Either you could write a specific generator for it def generate_ints(N): for i in xrange(N): yield i for x in generate_ints(100): print x or write a slightly more concise for x in (i for i in xrange(100)): print x

Note that the example given is purely to demonstrate generator expressions- since xrange is an iterable itself, for the example above for x in xrange(100): print x is actually simpler.

Logical operators

In Python 2.2 and earlier, the expressions "", 0, 0.0, 0e0, 0j, None, False, (), [], {}, etc. are false, and everything else is true. When using binary Boolean operators in Python, the syntax is to have the operator be in between the two statements in question. So to see if the statements x5 and 3 are true, one would write "10
Five & Three". To evaluate this, the interpreter would first check if x5 returned true. If it did not, it would return 0, but since it did, it goes on to the next statement. Next, it checks if 3 is true. Since 3 is true, 3 is returned. If three were not true, 0 would be returned. If the order of all of this were reversed to 3 and x
5, 1 would be returned because that is what x==5 evaluates to (because 1 is the default truth value). The or function works similarly. To find out if "2/3 or even Five" is true, the interpreter first finds the truth value of 2/3. Since 2/3 evaluates to 0, as described above, it would return false. If it had returned true, then its value would be returned. Next, the interpreter looks at the second expression. Since, in this case, it returns true, 5 would be returned. It is common in Python to write statements such as print p or q to take advantage of this feature.

Later in Python 2.2.1 the constants True and False were added and, as a result, all of the binary comparison operators (==, >, etc) return either True or False, while the rest of the aforementioned boolean operations (and, etc) still return the value that the last expression evaluated to. Thus the expression "Two Two" will return the value True and "Two
Two & Five" still returns the integer 5.

(Under the hood, in Python 2.3 and 2.4, True and False are builtin objects of type bool, a subclass of int. To keep backwards-compatibility, True and False only differ from 0 and 1 in type and string representation. Thus, statements treating the result of comparisons as ints still work. Ex. print intAsStr+(" "*(fieldWidth-len(intAsStr))) In 2.2.1–2.2.3, they are names for the int objects 1 and 0, respectively.)

Comparison operators

The basic comparison operators such as ==, <, >=, and so forth, are used on all manner of values. Numbers, strings, sequences, and mappings can all be compared. Objects of dissimilar type (such as a string and a number) can be compared; the result is arbitrary, but consistent.

Chained comparison expressions such as a < b < c have roughly the meaning that they have in mathematics, rather than the unusual meaning found in C and similar languages. The terms are evaluated and compared in order. The operation is short circuit, meaning that evaluation stops as soon as the expression is proven false: if a < b is false, c is never evaluated.

For expressions without side effects, a < b < c is equivalent to a < b and b < c. However, there is a substantial difference when the expressions have side effects. a < f(x) < b will evaluate f(x) exactly once, whereas a < f(x) and f(x) < b may evaluate it once or twice.

Object-oriented programming


Python's support for object oriented programming paradigm is vast. It supports polymorphism, not only within a class hierarchy but also by duck typing. Any object can be used for any type, and it will work so long as it has the proper methods and attributes. And everything in Python is an object, including classes, functions, numbers and modules. Python also has support for metaclasses, an advanced tool for enhancing classes' functionality. Naturally, inheritance, including multiple inheritance, is supported. It has limited support for private variables using name mangling. See [http://www.python.org/doc/current/tut/node11.html#SECTION0011600000000000000000 the "Classes" section of the tutorial] for details. Many Python users don't feel the need for private variables, though. The slogan "I personally're entirely consenting adults on text" is used to describe this attitude. Some consider information hiding to be unpythonic, in that it suggests that the class in question contains unaesthetic or ill-planned internals.

From the tutorial: As is true for modules, classes in Python do not put an absolute barrier between definition and user, but rather rely on the politeness of the user not to "break into a definition."

OOP doctrines such as the use of accessor methods to read data members are not enforced in Python. Just as Python offers functional-programming constructs but does not attempt to demand referential transparency, it offers (and extensively uses!) its object system but does not demand OOP behavior. Moreover, it is always possible to redefine the class using properties so that when a certain variable is set or retrieved in calling code, it really invokes a function call, so that foo.x = y might really invoke foo.set_x(y). This nullifies the practical advantage of accessor functions, and it remains OOP because the property 'x' becomes a legitimate part of the object's interface: it need not reflect an implementation detail.

In version 2.2 of Python, "future-style" classes were introduced. With new-style classes, objects and types were unified, allowing the subclassing of types. Even new types entirely can be defined, complete with custom behavior for infix operators. This allows for many radical things to be done syntactically within Python. A new multiple inheritance model was adopted with new-style classes, making a much more logical order of inheritance. The new method __getattribute__ was also defined for unconditional handling of attribute access.

Exception handling


Python supports (and extensively uses) exception handling as a means of testing for error conditions and other "exceptional" events in a program. Indeed, it is even possible to trap the exception caused by a syntax error.

Python style calls for the use of exceptions whenever an error condition might arise. Indeed, rather than testing for access to a file or resource before actually using it, it is conventional in Python to just go ahead and try to use it, catching the exception if access is rejected.

Exceptions can also be used as a more general means of non-local transfer of control, even when an error is not at issue. For instance, the Mailman mailing list software, written in Python, uses exceptions to jump out of deeply-nested message-handling logic when a decision has been made to reject a message or hold it for moderator approval.

Exceptions are often, especially in threaded situations, used as an alternative to the if-block. A commonly-invoked motto is EAFP, or "These are More comfortable to Invite Forgiveness than to ask for Permission." Consider these two equivalent pieces of code:

try: baz = foo.bar except AttributeError: handle_error()

if hasattr(foo, 'bar'): baz = foo.bar else: handle_error()

Standard library


Python has a large standard library, which makes it well suited to many tasks. This comes from a so-called "batteries involved" philosophy for Python modules. The modules of the standard library can be augmented with custom modules written in either C or Python. The standard library is particularly well tailored to writing Internet-facing applications, with a large number of standard formats and protocols (such as MIME and HTTP) supported. Modules for creating graphical user interfaces, connecting to relational databases, arithmetic with [http://www.python.org/peps/pep-0327.html arbitrarily precise decimals], and manipulating regular expressions are also included.

The standard library is one of Python's greatest strengths. The bulk of it is cross-platform compatible, meaning that even heavily leveraged Python programs can often run on Unix, Windows, Macintosh, and other platforms without change.

It is currently being debated whether or not third-party but open source Python modules such as Twisted, NumPy, or wxPython should be included in the standard library, in accordance with the batteries included philosophy.

Other features
The Python interpreter also supports an interactive mode in which expressions can be entered from the terminal and results seen immediately. This is a boon for those learning the language and experienced developers alike: snippets of code can be tested in interactive mode before integrating them into a program proper.

Python also includes a unit testing framework for creating exhaustive test suites. While static typing aficionados see this as a replacement for a static type-checking system, Python programmers largely do not share this view.

Standard Python does not support continuations (and never will, according to Guido van Rossum), but there is a variant known as Stackless Python that does. However, support for coroutines (based on generators) is planned, see [http://www.python.org/peps/pep-0342.html].

Neologisms


A few neologisms have come into common use within the Python community. One of the most common is "pythonic", which can have a wide range of meanings related to program style. To say that a piece of code is pythonic is to say that it uses Python idioms well; that it is natural or shows fluency in the language. Likewise, to say of an interface or language feature that it is pythonic is to say that it works well with Python idioms; that its use meshes well with the rest of the language.

In contrast, a mark of unpythonic code is that it attempts to "write C++ (or even even Lisp, or Perl) code around Python"—that is, provides a rough transcription rather than an idiomatic translation of forms from another language.

The prefix Py- can be used to show that something is related to Python. Examples of the use of this prefix in names of Python applications or libraries include Pygame, a binding of SDL to Python; [http://pyui.sourceforge.net/ PyUI], a GUI encoded entirely in Python; PySol, a series of card games programmed in Python; and PyAlaMode, an IDE for Python created by Orbtech, a company specializing in Python.

Users and admirers of Python—most especially those considered knowledgeable or experienced—are often referred to as Pythonists and occasionally as Pythoneers.

Supported platforms


The most popular (and therefore best maintained) platforms Python runs on are Linux, BSD, Mac OS X, Microsoft Windows and Java (this JVM version is a separate implementation). Other supported platforms include:

AIX operating system Amiga AROS AS/400 BeOS BSD FreeBSD Mac OS 9 NetBSD OpenBSD OS/2 OS/390 Other Unixes, e.g. Irix Palm OS Plan 9 PlayStation 2 Psion QNX RISC OS (formerly Acorn) Sharp Zaurus SPARC Solaris Symbian OS VMS VxWorks Windows CE/Pocket PC Xbox (Used primarily in the XBMC project) z/OS

Most of the third-party libraries for Python (and even some first-party ones) are only available on Windows, Linux, BSD, and Mac OS X.

Python was originally developed as a scripting language for the Amoeba operating system capable of making system calls; that version is no longer maintained.

Python usage
Python is actively used by many people, both in industry and academia for a wide variety of purposes. [http://pythonology.com/success Pythonology] lists numerous Python success stories in many types of application and problem domains.

Major organizations using Python
Google uses Python for many tasks including the backends of web apps such as Gmail and Google Maps and for many of its search-engine internals.

Software written in Python


BitTorrent, the original implementation and several derivatives. Chandler is a personal information manager including calendar, email, tasks and notes support. GNOME, the desktop environment, makes use of python for building graphical interfaces with the GTK toolkit. Mailman, one of the more popular packages for running email mailing lists. MoinMoin, a popular wiki engine in Python. OpenRPG provides a virtual table on which to play Role Playing Games over the internet. Portage, the heart of Gentoo Linux. An advanced package management system based on the *BSD style ports system. Solipsis, a system for massively shared virtual world. Trac - bug/issue tracking database, integrated with MoinMoin wiki and Subversion source version control ViewCVS, a web-based interface for browsing CVS repositories Zope, an object-oriented web-application platform. Zope includes an application server with an integrated object-oriented database and a built-in web-based management interface.

Packages for Python


The [http://www.python.org/pypi Python Cheese Shop] and [http://www.vex.net/parnassus/ Vaults of Parnassus] are two primary directories of hundreds of Python packages.

Cheetah, a Python-powered template engine and code-generation tool matplotlib, http://matplotlib.sf.net ,an extension providing matlab-like plotting and mathematical functions mod_python, an Apache module allowing direct integration of Python scripts with the Apache web server. Numeric Python, a language extension that adds support for large, multi-dimensional arrays and matrices. py2exe http://www.py2exe.org/ Convert python scripts into standalone windows programs Pygame http://www.pygame.org Python game development PyGTK, http://www.pygtk.org/, a popular cross-platform GUI library based on GTK+ Python Imaging Library, a module for working with images [http://www.riverbankcomputing.co.uk/pyqt/ PyQt], another popular cross-platform GUI library based on Qt [http://www.mems-exchange.org/software/quixote/ Quixote] a framework for developing Web applications in Python SciPy, a library of scientific and numerical routines Twisted, a networking framework for Python [http://www.wxpython.org/ wxPython], a port of wxWidgets and a popular cross-platform GUI library for Python [http://zope.org/Wikis/ZODB/FrontPage/guide/zodb.html ZODB] a Python-specific object-oriented database

Python Implementations
[http://www.python.org CPython] - Python default/reference implementation Jython - Python coded in Java IronPython - Python for .NET and Mono platforms Boo - Python-based but with static typing, for .NET and Mono [http://www.stackless.com/ Stackless Python] [http://codespeak.net/pypy/ PyPy] - Python coded in Python Parrot - Virtual machine being developed mainly as the runtime for Perl 6, but with the intent to also support dynamic languages like Python, Ruby, Tcl, etc. Can currently execute a subset of Python. [http://livelogix.net/logix/ Logix] - Python alternate front-end with macros

Python 3000


Python developers have an ongoing discussion of a future "Python 3000" that will allow backwards compatibility with the 2.x series to break in order to repair perceived flaws in the language. The guiding principle is to "reduce feature duplication by removing old ways of doing items". There is no definite schedule for Python 3000, but a Python Enhancement Proposal that details planned changes exists. [http://www.python.org/peps/pep-3000.html]

Among other changes, Python 3000 would not support functional programming constructs such as lambda, map, filter or reduce, the rationale being that map and filter are equivalent to list comprehensions in power, lambda is irrelevant with the advent of nested functions, and that reduce is incomprehensible to the majority of programmers who do not have a functional programming background. Also Python 3000 would add optional static typing, remove "classic classes", and usually replace immediate sequences with iterators.