text stringlengths 0 7.07k |
|---|
Explicit is better than implicit
|
Simple is better than complex
|
Complex is better than complicated
|
Readability counts
|
Rather than requiring all desired functionality to be built into the language 's core , Python was designed to be highly extensible . Python can also be embedded in existing applications that need a programmable interface . This design of a small core language with a large standard library and an easily extensible int... |
While offering choice in coding methodology , the Python philosophy rejects exuberant syntax , such as in Perl , in favor of a sparser , less @-@ cluttered grammar . As Alex Martelli put it : " To describe something as clever is not considered a compliment in the Python culture . " Python 's philosophy rejects the Per... |
Python 's developers strive to avoid premature optimization , and moreover , reject patches to non @-@ critical parts of CPython that would offer a marginal increase in speed at the cost of clarity . When speed is important , a Python programmer can move time @-@ critical functions to extension modules written in lang... |
An important goal of Python 's developers is making it fun to use . This is reflected in the origin of the name , which comes from Monty Python , and in an occasionally playful approach to tutorials and reference materials , such as using examples that refer to spam and eggs instead of the standard foo and bar .
|
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 o... |
Users and admirers of Python , especially those considered knowledgeable or experienced , are often referred to as Pythonists , Pythonistas , and Pythoneers .
|
= = Syntax and semantics = =
|
Python is intended to be a highly readable language . It is designed to have an uncluttered visual layout , often using English keywords where other languages use punctuation . Further , Python has fewer syntactic exceptions and special cases than C or Pascal .
|
= = = Indentation = = =
|
Python uses whitespace indentation , rather than curly braces or keywords , to delimit blocks ; this feature is also termed the off @-@ side rule . An increase in indentation comes after certain statements ; a decrease in indentation signifies the end of the current block .
|
= = = Statements and control flow = = =
|
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 d... |
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 s... |
= 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 ; t... |
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 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 ) , 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 .
|
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 .
|
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 . However , better support for coroutine @-@ like functionality is provided in 2 @.@ 5 , by extending Python 's generators . Before 2 @.@ 5 , generators were lazy iterators ; informatio... |
= = = Expressions = = =
|
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 ( see Mathematics for details ) . Python also added the * * operator for exponentiation .
|
As of Python 3 @.@ 5 , it supports matrix multiplication directly with the @ operator , versus C and Java , which implement these as library functions . Earlier versions of Python also used methods instead of an infix operator .
|
In Python , = = compares by value , versus Java , which compares numerics by value and objects by reference . ( 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 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 .
|
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 ( 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 e... |
y , x can be used to swap two variables .
|
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 } "... |
Python has various kinds of string literals :
|
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 and there is no implicit string interpolation such as " $ spam " .
|
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 .
|
Raw string varieties , denoted by prefixing the string literal with an r . No escape sequences are 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 par... |
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 valid C code but if c = 1 : ... causes a syntax error in Python .
|
= = = Methods = = =
|
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 th... |
= = = Typing = = =
|
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 ... |
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 o... |
Before version 3 @.@ 0 , Python had two kinds of classes : old @-@ style and new @-@ style . Old @-@ style classes were eliminated in Python 3 @.@ 0 , making all classes new @-@ style . In versions between 2 @.@ 2 and 3 @.@ 0 , both kinds of classes could be used . The syntax of both styles is the same , the differenc... |
= = = Mathematics = = =
|
Python has the usual C arithmetic operators ( + , - , * , / , % ) . It also has * * for exponentiation , e.g. 5 * * 3
|
= = 125 and 9 * * 0 @.@ 5 = =
|
3 @.@ 0 , and a new matrix multiply @ operator is included in version 3 @.@ 5 .
|
The behavior of division has changed significantly over time :
|
Python 2 @.@ 1 and earlier use the C 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 changes integer division to round towards negative infinity , e.g. 7 / 3
|
= = 2 and -7 / 3 = =
|
-3 . The floor division / / operator is 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 changes / to be always floating @-@ point division . In Python terms , the pre @-@ 3 @.@ 0 / is classic division , the version @-@ 3 @.@ 0 / is real division , and / / is floor division .
|
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 .
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.