Python Language

How To Learn A NEW Programming Language FAST! Learning a new programming language can seem like a challenging task. However, as it is with all types of learning, there are certain techniques and practices that will help you learn the programming language faster and more efficiently.

The programming language Python was conceived in the late 1980s,^[1] and its implementation was started in December 1989^[2] by Guido van Rossum at CWI in the Netherlands as a successor to ABC capable of exception handling and interfacing with the Amoeba operating system.^[3] Van Rossum is Python’s principal author, and his continuing central role in deciding the direction of Python is reflected in the title given to him by the Python community, Benevolent Dictator for Life (BDFL).^[4][5] (However, van Rossum stepped down as leader on July 12, 2018.^[6]) Python was named for the BBC TV show Monty Python’s Flying Circus.^[7]

Python 2.0 was released on October 16, 2000, with many major new features, including a cycle-detecting garbage collector (in addition to reference counting) for memory management and support for Unicode. However, the most important change was to the development process itself, with a shift to a more transparent and community-backed process.^[8]

Python 3.0, a major, backwards-incompatible release, was released on December 3, 2008^[9] after a long period of testing. Many of its major features have also been backported to the backwards-compatible, while by now unsupported, Python 2.6 and 2.7.^[10]

Early history[edit]

In February 1991, Van Rossum published the code (labeled version 0.9.0) to alt.sources.^[11] Already present at this stage in development were classes with inheritance, exception handling, functions, and the core datatypes of list, dict, str and so on. Also in this initial release was a module system borrowed from Modula-3; Van Rossum describes the module as “one of Python’s major programming units”.^[1] Python’s exception model also resembles Modula-3’s, with the addition of an else clause.^[3] In 1994 comp.lang.python, the primary discussion forum for Python, was formed, marking a milestone in the growth of Python’s userbase.^[1]

Version 1[edit]

Python reached version 1.0 in January 1994. The major new features included in this release were the functional programming tools lambda, map, filter and reduce. Van Rossum stated that “Python acquired lambda, reduce(), filter() and map(), courtesy of a Lisp hacker who missed them and submitted working patches”.^[12]

The last version released while Van Rossum was at CWI was Python 1.2. In 1995, Van Rossum continued his work on Python at the Corporation for National Research Initiatives (CNRI) in Reston, Virginia from where he released several versions.

Version 3[edit]

Python 3.0 (also called “Python 3000” or “Py3K”) was released on December 3, 2008.^[9] It was designed to rectify fundamental design flaws in the language—the changes required could not be implemented while retaining full backwards compatibility with the 2.x series, which necessitated a new major version number. The guiding principle of Python 3 was: “reduce feature duplication by removing old ways of doing things”.

Python 3.0 was developed with the same philosophy as in prior versions. However, as Python had accumulated new and redundant ways to program the same task, Python 3.0 had an emphasis on removing duplicative constructs and modules, in keeping with “There should be one— and preferably only one —obvious way to do it”.

Nonetheless, Python 3.0 remained a multi-paradigm language. Coders could still follow object-oriented, structured, and functional programming paradigms, among others, but within such broad choices, the details were intended to be more obvious in Python 3.0 than they were in Python 2.x.

Compatibility[edit]

Python 3.0 broke backward compatibility, and much Python 2 code does not run unmodified on Python 3. Python’s dynamic typing combined with the plans to change the semantics of certain methods of dictionaries, for example, made perfect mechanical translation from Python 2.x to Python 3.0 very difficult. A tool called “2to3” does the parts of translation that can be done automatically. At this, 2to3 appeared to be fairly successful, though an early review noted that there were aspects of translation that such a tool would never be able to handle.^[32] Prior to the roll-out of Python 3, projects requiring compatibility with both the 2.x and 3.x series were recommended to have one source (for the 2.x series), and produce releases for the Python 3.x platform using 2to3. Edits to the Python 3.x code were discouraged for so long as the code needed to run on Python 2.x.^[10] This is no longer recommended; as of 2012 the preferred approach was to create a single code base that can run under both Python 2 and 3 using compatibility modules.^[33]

Features[edit]

Some of the major changes included for Python 3.0 were:

• Changing print so that it is a built-in function, not a statement. This made it easier to change a module to use a different print function, as well as making the syntax more regular. In Python 2.6 and 2.7 print() is available as a builtin but is masked by the print statement syntax, which can be disabled by entering from __future__ import print_function at the top of the file^[34]
• Removal of the Python 2 input function, and the renaming of the raw_input function to input. Python 3’s input function behaves like Python 2’s raw_input function, in that the input is always returned as a string rather than being evaluated as an expression
• Moving reduce (but not map or filter) out of the built-in namespace and into functools (the rationale being code that uses reduce is less readable than code that uses a for loop and accumulator variable)^[35][36]
• Adding support for optional function annotations that can be used for informal type declarations or other purposes^[37]
• Unifying the str/unicode types, representing text, and introducing a separate immutable bytes type; and a mostly corresponding mutable bytearray type, both of which represent arrays of bytes^[38]
• Removing backward-compatibility features, including old-style classes, string exceptions, and implicit relative imports
• A change in integer division functionality: in Python 2, 5 / 2 is 2; in Python 3, 5 / 2 is 2.5. (In both Python 2 (2.2 onwards) and Python 3, a separate operator exists to provide the old behavior: 5 // 2 is 2)

Subsequent releases in the Python 3.x series have included additional, substantial new features; all ongoing development of the language is done in the 3.x series.