1 2.. _expressions: 3 4*********** 5Expressions 6*********** 7 8.. index:: single: expression 9 10This chapter explains the meaning of the elements of expressions in Python. 11 12.. index:: single: BNF 13 14**Syntax Notes:** In this and the following chapters, extended BNF notation will 15be used to describe syntax, not lexical analysis. When (one alternative of) a 16syntax rule has the form 17 18.. productionlist:: * 19 name: `othername` 20 21.. index:: single: syntax 22 23and no semantics are given, the semantics of this form of ``name`` are the same 24as for ``othername``. 25 26 27.. _conversions: 28 29Arithmetic conversions 30====================== 31 32.. index:: pair: arithmetic; conversion 33 34When a description of an arithmetic operator below uses the phrase "the numeric 35arguments are converted to a common type," the arguments are coerced using the 36coercion rules listed at :ref:`coercion-rules`. If both arguments are standard 37numeric types, the following coercions are applied: 38 39* If either argument is a complex number, the other is converted to complex; 40 41* otherwise, if either argument is a floating point number, the other is 42 converted to floating point; 43 44* otherwise, if either argument is a long integer, the other is converted to 45 long integer; 46 47* otherwise, both must be plain integers and no conversion is necessary. 48 49Some additional rules apply for certain operators (e.g., a string left argument 50to the '%' operator). Extensions can define their own coercions. 51 52 53.. _atoms: 54 55Atoms 56===== 57 58.. index:: single: atom 59 60Atoms are the most basic elements of expressions. The simplest atoms are 61identifiers or literals. Forms enclosed in reverse quotes or in parentheses, 62brackets or braces are also categorized syntactically as atoms. The syntax for 63atoms is: 64 65.. productionlist:: 66 atom: `identifier` | `literal` | `enclosure` 67 enclosure: `parenth_form` | `list_display` 68 : | `generator_expression` | `dict_display` | `set_display` 69 : | `string_conversion` | `yield_atom` 70 71 72.. _atom-identifiers: 73 74Identifiers (Names) 75------------------- 76 77.. index:: 78 single: name 79 single: identifier 80 81An identifier occurring as an atom is a name. See section :ref:`identifiers` 82for lexical definition and section :ref:`naming` for documentation of naming and 83binding. 84 85.. index:: exception: NameError 86 87When the name is bound to an object, evaluation of the atom yields that object. 88When a name is not bound, an attempt to evaluate it raises a :exc:`NameError` 89exception. 90 91.. index:: 92 pair: name; mangling 93 pair: private; names 94 95**Private name mangling:** When an identifier that textually occurs in a class 96definition begins with two or more underscore characters and does not end in two 97or more underscores, it is considered a :dfn:`private name` of that class. 98Private names are transformed to a longer form before code is generated for 99them. The transformation inserts the class name, with leading underscores 100removed and a single underscore inserted, in front of the name. For example, 101the identifier ``__spam`` occurring in a class named ``Ham`` will be transformed 102to ``_Ham__spam``. This transformation is independent of the syntactical 103context in which the identifier is used. If the transformed name is extremely 104long (longer than 255 characters), implementation defined truncation may happen. 105If the class name consists only of underscores, no transformation is done. 106 107 108 109.. _atom-literals: 110 111Literals 112-------- 113 114.. index:: single: literal 115 116Python supports string literals and various numeric literals: 117 118.. productionlist:: 119 literal: `stringliteral` | `integer` | `longinteger` 120 : | `floatnumber` | `imagnumber` 121 122Evaluation of a literal yields an object of the given type (string, integer, 123long integer, floating point number, complex number) with the given value. The 124value may be approximated in the case of floating point and imaginary (complex) 125literals. See section :ref:`literals` for details. 126 127.. index:: 128 triple: immutable; data; type 129 pair: immutable; object 130 131All literals correspond to immutable data types, and hence the object's identity 132is less important than its value. Multiple evaluations of literals with the 133same value (either the same occurrence in the program text or a different 134occurrence) may obtain the same object or a different object with the same 135value. 136 137 138.. _parenthesized: 139 140Parenthesized forms 141------------------- 142 143.. index:: single: parenthesized form 144 145A parenthesized form is an optional expression list enclosed in parentheses: 146 147.. productionlist:: 148 parenth_form: "(" [`expression_list`] ")" 149 150A parenthesized expression list yields whatever that expression list yields: if 151the list contains at least one comma, it yields a tuple; otherwise, it yields 152the single expression that makes up the expression list. 153 154.. index:: pair: empty; tuple 155 156An empty pair of parentheses yields an empty tuple object. Since tuples are 157immutable, the rules for literals apply (i.e., two occurrences of the empty 158tuple may or may not yield the same object). 159 160.. index:: 161 single: comma 162 pair: tuple; display 163 164Note that tuples are not formed by the parentheses, but rather by use of the 165comma operator. The exception is the empty tuple, for which parentheses *are* 166required --- allowing unparenthesized "nothing" in expressions would cause 167ambiguities and allow common typos to pass uncaught. 168 169 170.. _lists: 171 172List displays 173------------- 174 175.. index:: 176 pair: list; display 177 pair: list; comprehensions 178 179A list display is a possibly empty series of expressions enclosed in square 180brackets: 181 182.. productionlist:: 183 list_display: "[" [`expression_list` | `list_comprehension`] "]" 184 list_comprehension: `expression` `list_for` 185 list_for: "for" `target_list` "in" `old_expression_list` [`list_iter`] 186 old_expression_list: `old_expression` [("," `old_expression`)+ [","]] 187 old_expression: `or_test` | `old_lambda_expr` 188 list_iter: `list_for` | `list_if` 189 list_if: "if" `old_expression` [`list_iter`] 190 191.. index:: 192 pair: list; comprehensions 193 object: list 194 pair: empty; list 195 196A list display yields a new list object. Its contents are specified by 197providing either a list of expressions or a list comprehension. When a 198comma-separated list of expressions is supplied, its elements are evaluated from 199left to right and placed into the list object in that order. When a list 200comprehension is supplied, it consists of a single expression followed by at 201least one :keyword:`for` clause and zero or more :keyword:`for` or :keyword:`if` 202clauses. In this case, the elements of the new list are those that would be 203produced by considering each of the :keyword:`for` or :keyword:`if` clauses a 204block, nesting from left to right, and evaluating the expression to produce a 205list element each time the innermost block is reached [#]_. 206 207 208.. _comprehensions: 209 210Displays for sets and dictionaries 211---------------------------------- 212 213For constructing a set or a dictionary Python provides special syntax 214called "displays", each of them in two flavors: 215 216* either the container contents are listed explicitly, or 217 218* they are computed via a set of looping and filtering instructions, called a 219 :dfn:`comprehension`. 220 221Common syntax elements for comprehensions are: 222 223.. productionlist:: 224 comprehension: `expression` `comp_for` 225 comp_for: "for" `target_list` "in" `or_test` [`comp_iter`] 226 comp_iter: `comp_for` | `comp_if` 227 comp_if: "if" `expression_nocond` [`comp_iter`] 228 229The comprehension consists of a single expression followed by at least one 230:keyword:`for` clause and zero or more :keyword:`for` or :keyword:`if` clauses. 231In this case, the elements of the new container are those that would be produced 232by considering each of the :keyword:`for` or :keyword:`if` clauses a block, 233nesting from left to right, and evaluating the expression to produce an element 234each time the innermost block is reached. 235 236Note that the comprehension is executed in a separate scope, so names assigned 237to in the target list don't "leak" in the enclosing scope. 238 239 240.. _genexpr: 241 242Generator expressions 243--------------------- 244 245.. index:: pair: generator; expression 246 object: generator 247 248A generator expression is a compact generator notation in parentheses: 249 250.. productionlist:: 251 generator_expression: "(" `expression` `comp_for` ")" 252 253A generator expression yields a new generator object. Its syntax is the same as 254for comprehensions, except that it is enclosed in parentheses instead of 255brackets or curly braces. 256 257Variables used in the generator expression are evaluated lazily when the 258:meth:`__next__` method is called for generator object (in the same fashion as 259normal generators). However, the leftmost :keyword:`for` clause is immediately 260evaluated, so that an error produced by it can be seen before any other possible 261error in the code that handles the generator expression. Subsequent 262:keyword:`for` clauses cannot be evaluated immediately since they may depend on 263the previous :keyword:`for` loop. For example: ``(x*y for x in range(10) for y 264in bar(x))``. 265 266The parentheses can be omitted on calls with only one argument. See section 267:ref:`calls` for the detail. 268 269.. _dict: 270 271Dictionary displays 272------------------- 273 274.. index:: pair: dictionary; display 275 key, datum, key/datum pair 276 object: dictionary 277 278A dictionary display is a possibly empty series of key/datum pairs enclosed in 279curly braces: 280 281.. productionlist:: 282 dict_display: "{" [`key_datum_list` | `dict_comprehension`] "}" 283 key_datum_list: `key_datum` ("," `key_datum`)* [","] 284 key_datum: `expression` ":" `expression` 285 dict_comprehension: `expression` ":" `expression` `comp_for` 286 287A dictionary display yields a new dictionary object. 288 289If a comma-separated sequence of key/datum pairs is given, they are evaluated 290from left to right to define the entries of the dictionary: each key object is 291used as a key into the dictionary to store the corresponding datum. This means 292that you can specify the same key multiple times in the key/datum list, and the 293final dictionary's value for that key will be the last one given. 294 295A dict comprehension, in contrast to list and set comprehensions, needs two 296expressions separated with a colon followed by the usual "for" and "if" clauses. 297When the comprehension is run, the resulting key and value elements are inserted 298in the new dictionary in the order they are produced. 299 300.. index:: pair: immutable; object 301 hashable 302 303Restrictions on the types of the key values are listed earlier in section 304:ref:`types`. (To summarize, the key type should be :term:`hashable`, which excludes 305all mutable objects.) Clashes between duplicate keys are not detected; the last 306datum (textually rightmost in the display) stored for a given key value 307prevails. 308 309 310.. _set: 311 312Set displays 313------------ 314 315.. index:: pair: set; display 316 object: set 317 318A set display is denoted by curly braces and distinguishable from dictionary 319displays by the lack of colons separating keys and values: 320 321.. productionlist:: 322 set_display: "{" (`expression_list` | `comprehension`) "}" 323 324A set display yields a new mutable set object, the contents being specified by 325either a sequence of expressions or a comprehension. When a comma-separated 326list of expressions is supplied, its elements are evaluated from left to right 327and added to the set object. When a comprehension is supplied, the set is 328constructed from the elements resulting from the comprehension. 329 330An empty set cannot be constructed with ``{}``; this literal constructs an empty 331dictionary. 332 333 334.. _string-conversions: 335 336String conversions 337------------------ 338 339.. index:: 340 pair: string; conversion 341 pair: reverse; quotes 342 pair: backward; quotes 343 single: back-quotes 344 345A string conversion is an expression list enclosed in reverse (a.k.a. backward) 346quotes: 347 348.. productionlist:: 349 string_conversion: "`" `expression_list` "`" 350 351A string conversion evaluates the contained expression list and converts the 352resulting object into a string according to rules specific to its type. 353 354If the object is a string, a number, ``None``, or a tuple, list or dictionary 355containing only objects whose type is one of these, the resulting string is a 356valid Python expression which can be passed to the built-in function 357:func:`eval` to yield an expression with the same value (or an approximation, if 358floating point numbers are involved). 359 360(In particular, converting a string adds quotes around it and converts "funny" 361characters to escape sequences that are safe to print.) 362 363.. index:: object: recursive 364 365Recursive objects (for example, lists or dictionaries that contain a reference 366to themselves, directly or indirectly) use ``...`` to indicate a recursive 367reference, and the result cannot be passed to :func:`eval` to get an equal value 368(:exc:`SyntaxError` will be raised instead). 369 370.. index:: 371 builtin: repr 372 builtin: str 373 374The built-in function :func:`repr` performs exactly the same conversion in its 375argument as enclosing it in parentheses and reverse quotes does. The built-in 376function :func:`str` performs a similar but more user-friendly conversion. 377 378 379.. _yieldexpr: 380 381Yield expressions 382----------------- 383 384.. index:: 385 keyword: yield 386 pair: yield; expression 387 pair: generator; function 388 389.. productionlist:: 390 yield_atom: "(" `yield_expression` ")" 391 yield_expression: "yield" [`expression_list`] 392 393.. versionadded:: 2.5 394 395The :keyword:`yield` expression is only used when defining a generator function, 396and can only be used in the body of a function definition. Using a 397:keyword:`yield` expression in a function definition is sufficient to cause that 398definition to create a generator function instead of a normal function. 399 400When a generator function is called, it returns an iterator known as a 401generator. That generator then controls the execution of a generator function. 402The execution starts when one of the generator's methods is called. At that 403time, the execution proceeds to the first :keyword:`yield` expression, where it 404is suspended again, returning the value of :token:`expression_list` to 405generator's caller. By suspended we mean that all local state is retained, 406including the current bindings of local variables, the instruction pointer, and 407the internal evaluation stack. When the execution is resumed by calling one of 408the generator's methods, the function can proceed exactly as if the 409:keyword:`yield` expression was just another external call. The value of the 410:keyword:`yield` expression after resuming depends on the method which resumed 411the execution. 412 413.. index:: single: coroutine 414 415All of this makes generator functions quite similar to coroutines; they yield 416multiple times, they have more than one entry point and their execution can be 417suspended. The only difference is that a generator function cannot control 418where should the execution continue after it yields; the control is always 419transferred to the generator's caller. 420 421.. index:: object: generator 422 423 424Generator-iterator methods 425^^^^^^^^^^^^^^^^^^^^^^^^^^ 426 427This subsection describes the methods of a generator iterator. They can 428be used to control the execution of a generator function. 429 430Note that calling any of the generator methods below when the generator 431is already executing raises a :exc:`ValueError` exception. 432 433.. index:: exception: StopIteration 434 435 436.. method:: generator.next() 437 438 Starts the execution of a generator function or resumes it at the last executed 439 :keyword:`yield` expression. When a generator function is resumed with a 440 :meth:`~generator.next` method, the current :keyword:`yield` expression 441 always evaluates to 442 :const:`None`. The execution then continues to the next :keyword:`yield` 443 expression, where the generator is suspended again, and the value of the 444 :token:`expression_list` is returned to :meth:`~generator.next`'s caller. 445 If the generator 446 exits without yielding another value, a :exc:`StopIteration` exception is 447 raised. 448 449.. method:: generator.send(value) 450 451 Resumes the execution and "sends" a value into the generator function. The 452 ``value`` argument becomes the result of the current :keyword:`yield` 453 expression. The :meth:`send` method returns the next value yielded by the 454 generator, or raises :exc:`StopIteration` if the generator exits without 455 yielding another value. When :meth:`send` is called to start the generator, it 456 must be called with :const:`None` as the argument, because there is no 457 :keyword:`yield` expression that could receive the value. 458 459 460.. method:: generator.throw(type[, value[, traceback]]) 461 462 Raises an exception of type ``type`` at the point where generator was paused, 463 and returns the next value yielded by the generator function. If the generator 464 exits without yielding another value, a :exc:`StopIteration` exception is 465 raised. If the generator function does not catch the passed-in exception, or 466 raises a different exception, then that exception propagates to the caller. 467 468.. index:: exception: GeneratorExit 469 470 471.. method:: generator.close() 472 473 Raises a :exc:`GeneratorExit` at the point where the generator function was 474 paused. If the generator function then raises :exc:`StopIteration` (by exiting 475 normally, or due to already being closed) or :exc:`GeneratorExit` (by not 476 catching the exception), close returns to its caller. If the generator yields a 477 value, a :exc:`RuntimeError` is raised. If the generator raises any other 478 exception, it is propagated to the caller. :meth:`close` does nothing if the 479 generator has already exited due to an exception or normal exit. 480 481Here is a simple example that demonstrates the behavior of generators and 482generator functions:: 483 484 >>> def echo(value=None): 485 ... print "Execution starts when 'next()' is called for the first time." 486 ... try: 487 ... while True: 488 ... try: 489 ... value = (yield value) 490 ... except Exception, e: 491 ... value = e 492 ... finally: 493 ... print "Don't forget to clean up when 'close()' is called." 494 ... 495 >>> generator = echo(1) 496 >>> print generator.next() 497 Execution starts when 'next()' is called for the first time. 498 1 499 >>> print generator.next() 500 None 501 >>> print generator.send(2) 502 2 503 >>> generator.throw(TypeError, "spam") 504 TypeError('spam',) 505 >>> generator.close() 506 Don't forget to clean up when 'close()' is called. 507 508 509.. seealso:: 510 511 :pep:`342` - Coroutines via Enhanced Generators 512 The proposal to enhance the API and syntax of generators, making them usable as 513 simple coroutines. 514 515 516.. _primaries: 517 518Primaries 519========= 520 521.. index:: single: primary 522 523Primaries represent the most tightly bound operations of the language. Their 524syntax is: 525 526.. productionlist:: 527 primary: `atom` | `attributeref` | `subscription` | `slicing` | `call` 528 529 530.. _attribute-references: 531 532Attribute references 533-------------------- 534 535.. index:: pair: attribute; reference 536 537An attribute reference is a primary followed by a period and a name: 538 539.. productionlist:: 540 attributeref: `primary` "." `identifier` 541 542.. index:: 543 exception: AttributeError 544 object: module 545 object: list 546 547The primary must evaluate to an object of a type that supports attribute 548references, e.g., a module, list, or an instance. This object is then asked to 549produce the attribute whose name is the identifier. If this attribute is not 550available, the exception :exc:`AttributeError` is raised. Otherwise, the type 551and value of the object produced is determined by the object. Multiple 552evaluations of the same attribute reference may yield different objects. 553 554 555.. _subscriptions: 556 557Subscriptions 558------------- 559 560.. index:: single: subscription 561 562.. index:: 563 object: sequence 564 object: mapping 565 object: string 566 object: tuple 567 object: list 568 object: dictionary 569 pair: sequence; item 570 571A subscription selects an item of a sequence (string, tuple or list) or mapping 572(dictionary) object: 573 574.. productionlist:: 575 subscription: `primary` "[" `expression_list` "]" 576 577The primary must evaluate to an object of a sequence or mapping type. 578 579If the primary is a mapping, the expression list must evaluate to an object 580whose value is one of the keys of the mapping, and the subscription selects the 581value in the mapping that corresponds to that key. (The expression list is a 582tuple except if it has exactly one item.) 583 584If the primary is a sequence, the expression (list) must evaluate to a plain 585integer. If this value is negative, the length of the sequence is added to it 586(so that, e.g., ``x[-1]`` selects the last item of ``x``.) The resulting value 587must be a nonnegative integer less than the number of items in the sequence, and 588the subscription selects the item whose index is that value (counting from 589zero). 590 591.. index:: 592 single: character 593 pair: string; item 594 595A string's items are characters. A character is not a separate data type but a 596string of exactly one character. 597 598 599.. _slicings: 600 601Slicings 602-------- 603 604.. index:: 605 single: slicing 606 single: slice 607 608.. index:: 609 object: sequence 610 object: string 611 object: tuple 612 object: list 613 614A slicing selects a range of items in a sequence object (e.g., a string, tuple 615or list). Slicings may be used as expressions or as targets in assignment or 616:keyword:`del` statements. The syntax for a slicing: 617 618.. productionlist:: 619 slicing: `simple_slicing` | `extended_slicing` 620 simple_slicing: `primary` "[" `short_slice` "]" 621 extended_slicing: `primary` "[" `slice_list` "]" 622 slice_list: `slice_item` ("," `slice_item`)* [","] 623 slice_item: `expression` | `proper_slice` | `ellipsis` 624 proper_slice: `short_slice` | `long_slice` 625 short_slice: [`lower_bound`] ":" [`upper_bound`] 626 long_slice: `short_slice` ":" [`stride`] 627 lower_bound: `expression` 628 upper_bound: `expression` 629 stride: `expression` 630 ellipsis: "..." 631 632.. index:: pair: extended; slicing 633 634There is ambiguity in the formal syntax here: anything that looks like an 635expression list also looks like a slice list, so any subscription can be 636interpreted as a slicing. Rather than further complicating the syntax, this is 637disambiguated by defining that in this case the interpretation as a subscription 638takes priority over the interpretation as a slicing (this is the case if the 639slice list contains no proper slice nor ellipses). Similarly, when the slice 640list has exactly one short slice and no trailing comma, the interpretation as a 641simple slicing takes priority over that as an extended slicing. 642 643The semantics for a simple slicing are as follows. The primary must evaluate to 644a sequence object. The lower and upper bound expressions, if present, must 645evaluate to plain integers; defaults are zero and the ``sys.maxint``, 646respectively. If either bound is negative, the sequence's length is added to 647it. The slicing now selects all items with index *k* such that ``i <= k < j`` 648where *i* and *j* are the specified lower and upper bounds. This may be an 649empty sequence. It is not an error if *i* or *j* lie outside the range of valid 650indexes (such items don't exist so they aren't selected). 651 652.. index:: 653 single: start (slice object attribute) 654 single: stop (slice object attribute) 655 single: step (slice object attribute) 656 657The semantics for an extended slicing are as follows. The primary must evaluate 658to a mapping object, and it is indexed with a key that is constructed from the 659slice list, as follows. If the slice list contains at least one comma, the key 660is a tuple containing the conversion of the slice items; otherwise, the 661conversion of the lone slice item is the key. The conversion of a slice item 662that is an expression is that expression. The conversion of an ellipsis slice 663item is the built-in ``Ellipsis`` object. The conversion of a proper slice is a 664slice object (see section :ref:`types`) whose :attr:`~slice.start`, 665:attr:`~slice.stop` and :attr:`~slice.step` attributes are the values of the 666expressions given as lower bound, upper bound and stride, respectively, 667substituting ``None`` for missing expressions. 668 669 670.. index:: 671 object: callable 672 single: call 673 single: argument; call semantics 674 675.. _calls: 676 677Calls 678----- 679 680A call calls a callable object (e.g., a :term:`function`) with a possibly empty 681series of :term:`arguments <argument>`: 682 683.. productionlist:: 684 call: `primary` "(" [`argument_list` [","] 685 : | `expression` `genexpr_for`] ")" 686 argument_list: `positional_arguments` ["," `keyword_arguments`] 687 : ["," "*" `expression`] ["," `keyword_arguments`] 688 : ["," "**" `expression`] 689 : | `keyword_arguments` ["," "*" `expression`] 690 : ["," "**" `expression`] 691 : | "*" `expression` ["," `keyword_arguments`] ["," "**" `expression`] 692 : | "**" `expression` 693 positional_arguments: `expression` ("," `expression`)* 694 keyword_arguments: `keyword_item` ("," `keyword_item`)* 695 keyword_item: `identifier` "=" `expression` 696 697A trailing comma may be present after the positional and keyword arguments but 698does not affect the semantics. 699 700.. index:: 701 single: parameter; call semantics 702 703The primary must evaluate to a callable object (user-defined functions, built-in 704functions, methods of built-in objects, class objects, methods of class 705instances, and certain class instances themselves are callable; extensions may 706define additional callable object types). All argument expressions are 707evaluated before the call is attempted. Please refer to section :ref:`function` 708for the syntax of formal :term:`parameter` lists. 709 710If keyword arguments are present, they are first converted to positional 711arguments, as follows. First, a list of unfilled slots is created for the 712formal parameters. If there are N positional arguments, they are placed in the 713first N slots. Next, for each keyword argument, the identifier is used to 714determine the corresponding slot (if the identifier is the same as the first 715formal parameter name, the first slot is used, and so on). If the slot is 716already filled, a :exc:`TypeError` exception is raised. Otherwise, the value of 717the argument is placed in the slot, filling it (even if the expression is 718``None``, it fills the slot). When all arguments have been processed, the slots 719that are still unfilled are filled with the corresponding default value from the 720function definition. (Default values are calculated, once, when the function is 721defined; thus, a mutable object such as a list or dictionary used as default 722value will be shared by all calls that don't specify an argument value for the 723corresponding slot; this should usually be avoided.) If there are any unfilled 724slots for which no default value is specified, a :exc:`TypeError` exception is 725raised. Otherwise, the list of filled slots is used as the argument list for 726the call. 727 728.. impl-detail:: 729 730 An implementation may provide built-in functions whose positional parameters 731 do not have names, even if they are 'named' for the purpose of documentation, 732 and which therefore cannot be supplied by keyword. In CPython, this is the 733 case for functions implemented in C that use :c:func:`PyArg_ParseTuple` to 734 parse their arguments. 735 736If there are more positional arguments than there are formal parameter slots, a 737:exc:`TypeError` exception is raised, unless a formal parameter using the syntax 738``*identifier`` is present; in this case, that formal parameter receives a tuple 739containing the excess positional arguments (or an empty tuple if there were no 740excess positional arguments). 741 742If any keyword argument does not correspond to a formal parameter name, a 743:exc:`TypeError` exception is raised, unless a formal parameter using the syntax 744``**identifier`` is present; in this case, that formal parameter receives a 745dictionary containing the excess keyword arguments (using the keywords as keys 746and the argument values as corresponding values), or a (new) empty dictionary if 747there were no excess keyword arguments. 748 749.. index:: 750 single: *; in function calls 751 752If the syntax ``*expression`` appears in the function call, ``expression`` must 753evaluate to an iterable. Elements from this iterable are treated as if they 754were additional positional arguments; if there are positional arguments 755*x1*, ..., *xN*, and ``expression`` evaluates to a sequence *y1*, ..., *yM*, this 756is equivalent to a call with M+N positional arguments *x1*, ..., *xN*, *y1*, 757..., *yM*. 758 759A consequence of this is that although the ``*expression`` syntax may appear 760*after* some keyword arguments, it is processed *before* the keyword arguments 761(and the ``**expression`` argument, if any -- see below). So:: 762 763 >>> def f(a, b): 764 ... print a, b 765 ... 766 >>> f(b=1, *(2,)) 767 2 1 768 >>> f(a=1, *(2,)) 769 Traceback (most recent call last): 770 File "<stdin>", line 1, in ? 771 TypeError: f() got multiple values for keyword argument 'a' 772 >>> f(1, *(2,)) 773 1 2 774 775It is unusual for both keyword arguments and the ``*expression`` syntax to be 776used in the same call, so in practice this confusion does not arise. 777 778.. index:: 779 single: **; in function calls 780 781If the syntax ``**expression`` appears in the function call, ``expression`` must 782evaluate to a mapping, the contents of which are treated as additional keyword 783arguments. In the case of a keyword appearing in both ``expression`` and as an 784explicit keyword argument, a :exc:`TypeError` exception is raised. 785 786Formal parameters using the syntax ``*identifier`` or ``**identifier`` cannot be 787used as positional argument slots or as keyword argument names. Formal 788parameters using the syntax ``(sublist)`` cannot be used as keyword argument 789names; the outermost sublist corresponds to a single unnamed argument slot, and 790the argument value is assigned to the sublist using the usual tuple assignment 791rules after all other parameter processing is done. 792 793A call always returns some value, possibly ``None``, unless it raises an 794exception. How this value is computed depends on the type of the callable 795object. 796 797If it is--- 798 799a user-defined function: 800 .. index:: 801 pair: function; call 802 triple: user-defined; function; call 803 object: user-defined function 804 object: function 805 806 The code block for the function is executed, passing it the argument list. The 807 first thing the code block will do is bind the formal parameters to the 808 arguments; this is described in section :ref:`function`. When the code block 809 executes a :keyword:`return` statement, this specifies the return value of the 810 function call. 811 812a built-in function or method: 813 .. index:: 814 pair: function; call 815 pair: built-in function; call 816 pair: method; call 817 pair: built-in method; call 818 object: built-in method 819 object: built-in function 820 object: method 821 object: function 822 823 The result is up to the interpreter; see :ref:`built-in-funcs` for the 824 descriptions of built-in functions and methods. 825 826a class object: 827 .. index:: 828 object: class 829 pair: class object; call 830 831 A new instance of that class is returned. 832 833a class instance method: 834 .. index:: 835 object: class instance 836 object: instance 837 pair: class instance; call 838 839 The corresponding user-defined function is called, with an argument list that is 840 one longer than the argument list of the call: the instance becomes the first 841 argument. 842 843a class instance: 844 .. index:: 845 pair: instance; call 846 single: __call__() (object method) 847 848 The class must define a :meth:`__call__` method; the effect is then the same as 849 if that method was called. 850 851 852.. _power: 853 854The power operator 855================== 856 857The power operator binds more tightly than unary operators on its left; it binds 858less tightly than unary operators on its right. The syntax is: 859 860.. productionlist:: 861 power: `primary` ["**" `u_expr`] 862 863Thus, in an unparenthesized sequence of power and unary operators, the operators 864are evaluated from right to left (this does not constrain the evaluation order 865for the operands): ``-1**2`` results in ``-1``. 866 867The power operator has the same semantics as the built-in :func:`pow` function, 868when called with two arguments: it yields its left argument raised to the power 869of its right argument. The numeric arguments are first converted to a common 870type. The result type is that of the arguments after coercion. 871 872With mixed operand types, the coercion rules for binary arithmetic operators 873apply. For int and long int operands, the result has the same type as the 874operands (after coercion) unless the second argument is negative; in that case, 875all arguments are converted to float and a float result is delivered. For 876example, ``10**2`` returns ``100``, but ``10**-2`` returns ``0.01``. (This last 877feature was added in Python 2.2. In Python 2.1 and before, if both arguments 878were of integer types and the second argument was negative, an exception was 879raised). 880 881Raising ``0.0`` to a negative power results in a :exc:`ZeroDivisionError`. 882Raising a negative number to a fractional power results in a :exc:`ValueError`. 883 884 885.. _unary: 886 887Unary arithmetic and bitwise operations 888======================================= 889 890.. index:: 891 triple: unary; arithmetic; operation 892 triple: unary; bitwise; operation 893 894All unary arithmetic and bitwise operations have the same priority: 895 896.. productionlist:: 897 u_expr: `power` | "-" `u_expr` | "+" `u_expr` | "~" `u_expr` 898 899.. index:: 900 single: negation 901 single: minus 902 903The unary ``-`` (minus) operator yields the negation of its numeric argument. 904 905.. index:: single: plus 906 907The unary ``+`` (plus) operator yields its numeric argument unchanged. 908 909.. index:: single: inversion 910 911The unary ``~`` (invert) operator yields the bitwise inversion of its plain or 912long integer argument. The bitwise inversion of ``x`` is defined as 913``-(x+1)``. It only applies to integral numbers. 914 915.. index:: exception: TypeError 916 917In all three cases, if the argument does not have the proper type, a 918:exc:`TypeError` exception is raised. 919 920 921.. _binary: 922 923Binary arithmetic operations 924============================ 925 926.. index:: triple: binary; arithmetic; operation 927 928The binary arithmetic operations have the conventional priority levels. Note 929that some of these operations also apply to certain non-numeric types. Apart 930from the power operator, there are only two levels, one for multiplicative 931operators and one for additive operators: 932 933.. productionlist:: 934 m_expr: `u_expr` | `m_expr` "*" `u_expr` | `m_expr` "//" `u_expr` | `m_expr` "/" `u_expr` 935 : | `m_expr` "%" `u_expr` 936 a_expr: `m_expr` | `a_expr` "+" `m_expr` | `a_expr` "-" `m_expr` 937 938.. index:: single: multiplication 939 940The ``*`` (multiplication) operator yields the product of its arguments. The 941arguments must either both be numbers, or one argument must be an integer (plain 942or long) and the other must be a sequence. In the former case, the numbers are 943converted to a common type and then multiplied together. In the latter case, 944sequence repetition is performed; a negative repetition factor yields an empty 945sequence. 946 947.. index:: 948 exception: ZeroDivisionError 949 single: division 950 951The ``/`` (division) and ``//`` (floor division) operators yield the quotient of 952their arguments. The numeric arguments are first converted to a common type. 953Plain or long integer division yields an integer of the same type; the result is 954that of mathematical division with the 'floor' function applied to the result. 955Division by zero raises the :exc:`ZeroDivisionError` exception. 956 957.. index:: single: modulo 958 959The ``%`` (modulo) operator yields the remainder from the division of the first 960argument by the second. The numeric arguments are first converted to a common 961type. A zero right argument raises the :exc:`ZeroDivisionError` exception. The 962arguments may be floating point numbers, e.g., ``3.14%0.7`` equals ``0.34`` 963(since ``3.14`` equals ``4*0.7 + 0.34``.) The modulo operator always yields a 964result with the same sign as its second operand (or zero); the absolute value of 965the result is strictly smaller than the absolute value of the second operand 966[#]_. 967 968The integer division and modulo operators are connected by the following 969identity: ``x == (x/y)*y + (x%y)``. Integer division and modulo are also 970connected with the built-in function :func:`divmod`: ``divmod(x, y) == (x/y, 971x%y)``. These identities don't hold for floating point numbers; there similar 972identities hold approximately where ``x/y`` is replaced by ``floor(x/y)`` or 973``floor(x/y) - 1`` [#]_. 974 975In addition to performing the modulo operation on numbers, the ``%`` operator is 976also overloaded by string and unicode objects to perform string formatting (also 977known as interpolation). The syntax for string formatting is described in the 978Python Library Reference, section :ref:`string-formatting`. 979 980.. deprecated:: 2.3 981 The floor division operator, the modulo operator, and the :func:`divmod` 982 function are no longer defined for complex numbers. Instead, convert to a 983 floating point number using the :func:`abs` function if appropriate. 984 985.. index:: single: addition 986 987The ``+`` (addition) operator yields the sum of its arguments. The arguments 988must either both be numbers or both sequences of the same type. In the former 989case, the numbers are converted to a common type and then added together. In 990the latter case, the sequences are concatenated. 991 992.. index:: single: subtraction 993 994The ``-`` (subtraction) operator yields the difference of its arguments. The 995numeric arguments are first converted to a common type. 996 997 998.. _shifting: 999 1000Shifting operations 1001=================== 1002 1003.. index:: pair: shifting; operation 1004 1005The shifting operations have lower priority than the arithmetic operations: 1006 1007.. productionlist:: 1008 shift_expr: `a_expr` | `shift_expr` ( "<<" | ">>" ) `a_expr` 1009 1010These operators accept plain or long integers as arguments. The arguments are 1011converted to a common type. They shift the first argument to the left or right 1012by the number of bits given by the second argument. 1013 1014.. index:: exception: ValueError 1015 1016A right shift by *n* bits is defined as division by ``pow(2, n)``. A left shift 1017by *n* bits is defined as multiplication with ``pow(2, n)``. Negative shift 1018counts raise a :exc:`ValueError` exception. 1019 1020.. note:: 1021 1022 In the current implementation, the right-hand operand is required 1023 to be at most :attr:`sys.maxsize`. If the right-hand operand is larger than 1024 :attr:`sys.maxsize` an :exc:`OverflowError` exception is raised. 1025 1026.. _bitwise: 1027 1028Binary bitwise operations 1029========================= 1030 1031.. index:: triple: binary; bitwise; operation 1032 1033Each of the three bitwise operations has a different priority level: 1034 1035.. productionlist:: 1036 and_expr: `shift_expr` | `and_expr` "&" `shift_expr` 1037 xor_expr: `and_expr` | `xor_expr` "^" `and_expr` 1038 or_expr: `xor_expr` | `or_expr` "|" `xor_expr` 1039 1040.. index:: pair: bitwise; and 1041 1042The ``&`` operator yields the bitwise AND of its arguments, which must be plain 1043or long integers. The arguments are converted to a common type. 1044 1045.. index:: 1046 pair: bitwise; xor 1047 pair: exclusive; or 1048 1049The ``^`` operator yields the bitwise XOR (exclusive OR) of its arguments, which 1050must be plain or long integers. The arguments are converted to a common type. 1051 1052.. index:: 1053 pair: bitwise; or 1054 pair: inclusive; or 1055 1056The ``|`` operator yields the bitwise (inclusive) OR of its arguments, which 1057must be plain or long integers. The arguments are converted to a common type. 1058 1059 1060.. _comparisons: 1061.. _is: 1062.. _is not: 1063.. _in: 1064.. _not in: 1065 1066Comparisons 1067=========== 1068 1069.. index:: single: comparison 1070 1071.. index:: pair: C; language 1072 1073Unlike C, all comparison operations in Python have the same priority, which is 1074lower than that of any arithmetic, shifting or bitwise operation. Also unlike 1075C, expressions like ``a < b < c`` have the interpretation that is conventional 1076in mathematics: 1077 1078.. productionlist:: 1079 comparison: `or_expr` ( `comp_operator` `or_expr` )* 1080 comp_operator: "<" | ">" | "==" | ">=" | "<=" | "<>" | "!=" 1081 : | "is" ["not"] | ["not"] "in" 1082 1083Comparisons yield boolean values: ``True`` or ``False``. 1084 1085.. index:: pair: chaining; comparisons 1086 1087Comparisons can be chained arbitrarily, e.g., ``x < y <= z`` is equivalent to 1088``x < y and y <= z``, except that ``y`` is evaluated only once (but in both 1089cases ``z`` is not evaluated at all when ``x < y`` is found to be false). 1090 1091Formally, if *a*, *b*, *c*, ..., *y*, *z* are expressions and *op1*, *op2*, ..., 1092*opN* are comparison operators, then ``a op1 b op2 c ... y opN z`` is equivalent 1093to ``a op1 b and b op2 c and ... y opN z``, except that each expression is 1094evaluated at most once. 1095 1096Note that ``a op1 b op2 c`` doesn't imply any kind of comparison between *a* and 1097*c*, so that, e.g., ``x < y > z`` is perfectly legal (though perhaps not 1098pretty). 1099 1100The forms ``<>`` and ``!=`` are equivalent; for consistency with C, ``!=`` is 1101preferred; where ``!=`` is mentioned below ``<>`` is also accepted. The ``<>`` 1102spelling is considered obsolescent. 1103 1104The operators ``<``, ``>``, ``==``, ``>=``, ``<=``, and ``!=`` compare the 1105values of two objects. The objects need not have the same type. If both are 1106numbers, they are converted to a common type. Otherwise, objects of different 1107types *always* compare unequal, and are ordered consistently but arbitrarily. 1108You can control comparison behavior of objects of non-built-in types by defining 1109a ``__cmp__`` method or rich comparison methods like ``__gt__``, described in 1110section :ref:`specialnames`. 1111 1112(This unusual definition of comparison was used to simplify the definition of 1113operations like sorting and the :keyword:`in` and :keyword:`not in` operators. 1114In the future, the comparison rules for objects of different types are likely to 1115change.) 1116 1117Comparison of objects of the same type depends on the type: 1118 1119* Numbers are compared arithmetically. 1120 1121* Strings are compared lexicographically using the numeric equivalents (the 1122 result of the built-in function :func:`ord`) of their characters. Unicode and 1123 8-bit strings are fully interoperable in this behavior. [#]_ 1124 1125* Tuples and lists are compared lexicographically using comparison of 1126 corresponding elements. This means that to compare equal, each element must 1127 compare equal and the two sequences must be of the same type and have the same 1128 length. 1129 1130 If not equal, the sequences are ordered the same as their first differing 1131 elements. For example, ``cmp([1,2,x], [1,2,y])`` returns the same as 1132 ``cmp(x,y)``. If the corresponding element does not exist, the shorter sequence 1133 is ordered first (for example, ``[1,2] < [1,2,3]``). 1134 1135* Mappings (dictionaries) compare equal if and only if their sorted (key, value) 1136 lists compare equal. [#]_ Outcomes other than equality are resolved 1137 consistently, but are not otherwise defined. [#]_ 1138 1139* Most other objects of built-in types compare unequal unless they are the same 1140 object; the choice whether one object is considered smaller or larger than 1141 another one is made arbitrarily but consistently within one execution of a 1142 program. 1143 1144.. _membership-test-details: 1145 1146The operators :keyword:`in` and :keyword:`not in` test for collection 1147membership. ``x in s`` evaluates to true if *x* is a member of the collection 1148*s*, and false otherwise. ``x not in s`` returns the negation of ``x in s``. 1149The collection membership test has traditionally been bound to sequences; an 1150object is a member of a collection if the collection is a sequence and contains 1151an element equal to that object. However, it make sense for many other object 1152types to support membership tests without being a sequence. In particular, 1153dictionaries (for keys) and sets support membership testing. 1154 1155For the list and tuple types, ``x in y`` is true if and only if there exists an 1156index *i* such that either ``x is y[i]`` or ``x == y[i]`` is true. 1157 1158For the Unicode and string types, ``x in y`` is true if and only if *x* is a 1159substring of *y*. An equivalent test is ``y.find(x) != -1``. Note, *x* and *y* 1160need not be the same type; consequently, ``u'ab' in 'abc'`` will return 1161``True``. Empty strings are always considered to be a substring of any other 1162string, so ``"" in "abc"`` will return ``True``. 1163 1164.. versionchanged:: 2.3 1165 Previously, *x* was required to be a string of length ``1``. 1166 1167For user-defined classes which define the :meth:`__contains__` method, ``x in 1168y`` is true if and only if ``y.__contains__(x)`` is true. 1169 1170For user-defined classes which do not define :meth:`__contains__` but do define 1171:meth:`__iter__`, ``x in y`` is true if some value ``z`` with ``x == z`` is 1172produced while iterating over ``y``. If an exception is raised during the 1173iteration, it is as if :keyword:`in` raised that exception. 1174 1175Lastly, the old-style iteration protocol is tried: if a class defines 1176:meth:`__getitem__`, ``x in y`` is true if and only if there is a non-negative 1177integer index *i* such that ``x == y[i]``, and all lower integer indices do not 1178raise :exc:`IndexError` exception. (If any other exception is raised, it is as 1179if :keyword:`in` raised that exception). 1180 1181.. index:: 1182 operator: in 1183 operator: not in 1184 pair: membership; test 1185 object: sequence 1186 1187The operator :keyword:`not in` is defined to have the inverse true value of 1188:keyword:`in`. 1189 1190.. index:: 1191 operator: is 1192 operator: is not 1193 pair: identity; test 1194 1195The operators :keyword:`is` and :keyword:`is not` test for object identity: ``x 1196is y`` is true if and only if *x* and *y* are the same object. ``x is not y`` 1197yields the inverse truth value. [#]_ 1198 1199 1200.. _booleans: 1201.. _and: 1202.. _or: 1203.. _not: 1204 1205Boolean operations 1206================== 1207 1208.. index:: 1209 pair: Conditional; expression 1210 pair: Boolean; operation 1211 1212.. productionlist:: 1213 or_test: `and_test` | `or_test` "or" `and_test` 1214 and_test: `not_test` | `and_test` "and" `not_test` 1215 not_test: `comparison` | "not" `not_test` 1216 1217In the context of Boolean operations, and also when expressions are used by 1218control flow statements, the following values are interpreted as false: 1219``False``, ``None``, numeric zero of all types, and empty strings and containers 1220(including strings, tuples, lists, dictionaries, sets and frozensets). All 1221other values are interpreted as true. (See the :meth:`~object.__nonzero__` 1222special method for a way to change this.) 1223 1224.. index:: operator: not 1225 1226The operator :keyword:`not` yields ``True`` if its argument is false, ``False`` 1227otherwise. 1228 1229.. index:: operator: and 1230 1231The expression ``x and y`` first evaluates *x*; if *x* is false, its value is 1232returned; otherwise, *y* is evaluated and the resulting value is returned. 1233 1234.. index:: operator: or 1235 1236The expression ``x or y`` first evaluates *x*; if *x* is true, its value is 1237returned; otherwise, *y* is evaluated and the resulting value is returned. 1238 1239(Note that neither :keyword:`and` nor :keyword:`or` restrict the value and type 1240they return to ``False`` and ``True``, but rather return the last evaluated 1241argument. This is sometimes useful, e.g., if ``s`` is a string that should be 1242replaced by a default value if it is empty, the expression ``s or 'foo'`` yields 1243the desired value. Because :keyword:`not` has to invent a value anyway, it does 1244not bother to return a value of the same type as its argument, so e.g., ``not 1245'foo'`` yields ``False``, not ``''``.) 1246 1247 1248Conditional Expressions 1249======================= 1250 1251.. versionadded:: 2.5 1252 1253.. index:: 1254 pair: conditional; expression 1255 pair: ternary; operator 1256 1257.. productionlist:: 1258 conditional_expression: `or_test` ["if" `or_test` "else" `expression`] 1259 expression: `conditional_expression` | `lambda_expr` 1260 1261Conditional expressions (sometimes called a "ternary operator") have the lowest 1262priority of all Python operations. 1263 1264The expression ``x if C else y`` first evaluates the condition, *C* (*not* *x*); 1265if *C* is true, *x* is evaluated and its value is returned; otherwise, *y* is 1266evaluated and its value is returned. 1267 1268See :pep:`308` for more details about conditional expressions. 1269 1270 1271.. _lambdas: 1272.. _lambda: 1273 1274Lambdas 1275======= 1276 1277.. index:: 1278 pair: lambda; expression 1279 pair: anonymous; function 1280 1281.. productionlist:: 1282 lambda_expr: "lambda" [`parameter_list`]: `expression` 1283 old_lambda_expr: "lambda" [`parameter_list`]: `old_expression` 1284 1285Lambda expressions (sometimes called lambda forms) have the same syntactic position as 1286expressions. They are a shorthand to create anonymous functions; the expression 1287``lambda arguments: expression`` yields a function object. The unnamed object 1288behaves like a function object defined with :: 1289 1290 def name(arguments): 1291 return expression 1292 1293See section :ref:`function` for the syntax of parameter lists. Note that 1294functions created with lambda expressions cannot contain statements. 1295 1296 1297.. _exprlists: 1298 1299Expression lists 1300================ 1301 1302.. index:: pair: expression; list 1303 1304.. productionlist:: 1305 expression_list: `expression` ( "," `expression` )* [","] 1306 1307.. index:: object: tuple 1308 1309An expression list containing at least one comma yields a tuple. The length of 1310the tuple is the number of expressions in the list. The expressions are 1311evaluated from left to right. 1312 1313.. index:: pair: trailing; comma 1314 1315The trailing comma is required only to create a single tuple (a.k.a. a 1316*singleton*); it is optional in all other cases. A single expression without a 1317trailing comma doesn't create a tuple, but rather yields the value of that 1318expression. (To create an empty tuple, use an empty pair of parentheses: 1319``()``.) 1320 1321 1322.. _evalorder: 1323 1324Evaluation order 1325================ 1326 1327.. index:: pair: evaluation; order 1328 1329Python evaluates expressions from left to right. Notice that while evaluating an 1330assignment, the right-hand side is evaluated before the left-hand side. 1331 1332In the following lines, expressions will be evaluated in the arithmetic order of 1333their suffixes:: 1334 1335 expr1, expr2, expr3, expr4 1336 (expr1, expr2, expr3, expr4) 1337 {expr1: expr2, expr3: expr4} 1338 expr1 + expr2 * (expr3 - expr4) 1339 expr1(expr2, expr3, *expr4, **expr5) 1340 expr3, expr4 = expr1, expr2 1341 1342 1343.. _operator-summary: 1344 1345Operator precedence 1346=================== 1347 1348.. index:: pair: operator; precedence 1349 1350The following table summarizes the operator precedences in Python, from lowest 1351precedence (least binding) to highest precedence (most binding). Operators in 1352the same box have the same precedence. Unless the syntax is explicitly given, 1353operators are binary. Operators in the same box group left to right (except for 1354comparisons, including tests, which all have the same precedence and chain from 1355left to right --- see section :ref:`comparisons` --- and exponentiation, which 1356groups from right to left). 1357 1358+-----------------------------------------------+-------------------------------------+ 1359| Operator | Description | 1360+===============================================+=====================================+ 1361| :keyword:`lambda` | Lambda expression | 1362+-----------------------------------------------+-------------------------------------+ 1363| :keyword:`if` -- :keyword:`else` | Conditional expression | 1364+-----------------------------------------------+-------------------------------------+ 1365| :keyword:`or` | Boolean OR | 1366+-----------------------------------------------+-------------------------------------+ 1367| :keyword:`and` | Boolean AND | 1368+-----------------------------------------------+-------------------------------------+ 1369| :keyword:`not` ``x`` | Boolean NOT | 1370+-----------------------------------------------+-------------------------------------+ 1371| :keyword:`in`, :keyword:`not in`, | Comparisons, including membership | 1372| :keyword:`is`, :keyword:`is not`, ``<``, | tests and identity tests | 1373| ``<=``, ``>``, ``>=``, ``<>``, ``!=``, ``==`` | | 1374+-----------------------------------------------+-------------------------------------+ 1375| ``|`` | Bitwise OR | 1376+-----------------------------------------------+-------------------------------------+ 1377| ``^`` | Bitwise XOR | 1378+-----------------------------------------------+-------------------------------------+ 1379| ``&`` | Bitwise AND | 1380+-----------------------------------------------+-------------------------------------+ 1381| ``<<``, ``>>`` | Shifts | 1382+-----------------------------------------------+-------------------------------------+ 1383| ``+``, ``-`` | Addition and subtraction | 1384+-----------------------------------------------+-------------------------------------+ 1385| ``*``, ``/``, ``//``, ``%`` | Multiplication, division, remainder | 1386| | [#]_ | 1387+-----------------------------------------------+-------------------------------------+ 1388| ``+x``, ``-x``, ``~x`` | Positive, negative, bitwise NOT | 1389+-----------------------------------------------+-------------------------------------+ 1390| ``**`` | Exponentiation [#]_ | 1391+-----------------------------------------------+-------------------------------------+ 1392| ``x[index]``, ``x[index:index]``, | Subscription, slicing, | 1393| ``x(arguments...)``, ``x.attribute`` | call, attribute reference | 1394+-----------------------------------------------+-------------------------------------+ 1395| ``(expressions...)``, | Binding or tuple display, | 1396| ``[expressions...]``, | list display, | 1397| ``{key: value...}``, | dictionary display, | 1398| ```expressions...``` | string conversion | 1399+-----------------------------------------------+-------------------------------------+ 1400 1401.. rubric:: Footnotes 1402 1403.. [#] In Python 2.3 and later releases, a list comprehension "leaks" the control 1404 variables of each ``for`` it contains into the containing scope. However, this 1405 behavior is deprecated, and relying on it will not work in Python 3. 1406 1407.. [#] While ``abs(x%y) < abs(y)`` is true mathematically, for floats it may not be 1408 true numerically due to roundoff. For example, and assuming a platform on which 1409 a Python float is an IEEE 754 double-precision number, in order that ``-1e-100 % 1410 1e100`` have the same sign as ``1e100``, the computed result is ``-1e-100 + 1411 1e100``, which is numerically exactly equal to ``1e100``. The function 1412 :func:`math.fmod` returns a result whose sign matches the sign of the 1413 first argument instead, and so returns ``-1e-100`` in this case. Which approach 1414 is more appropriate depends on the application. 1415 1416.. [#] If x is very close to an exact integer multiple of y, it's possible for 1417 ``floor(x/y)`` to be one larger than ``(x-x%y)/y`` due to rounding. In such 1418 cases, Python returns the latter result, in order to preserve that 1419 ``divmod(x,y)[0] * y + x % y`` be very close to ``x``. 1420 1421.. [#] While comparisons between unicode strings make sense at the byte 1422 level, they may be counter-intuitive to users. For example, the 1423 strings ``u"\u00C7"`` and ``u"\u0043\u0327"`` compare differently, 1424 even though they both represent the same unicode character (LATIN 1425 CAPITAL LETTER C WITH CEDILLA). To compare strings in a human 1426 recognizable way, compare using :func:`unicodedata.normalize`. 1427 1428.. [#] The implementation computes this efficiently, without constructing lists or 1429 sorting. 1430 1431.. [#] Earlier versions of Python used lexicographic comparison of the sorted (key, 1432 value) lists, but this was very expensive for the common case of comparing for 1433 equality. An even earlier version of Python compared dictionaries by identity 1434 only, but this caused surprises because people expected to be able to test a 1435 dictionary for emptiness by comparing it to ``{}``. 1436 1437.. [#] Due to automatic garbage-collection, free lists, and the dynamic nature of 1438 descriptors, you may notice seemingly unusual behaviour in certain uses of 1439 the :keyword:`is` operator, like those involving comparisons between instance 1440 methods, or constants. Check their documentation for more info. 1441 1442.. [#] The ``%`` operator is also used for string formatting; the same 1443 precedence applies. 1444 1445.. [#] The power operator ``**`` binds less tightly than an arithmetic or 1446 bitwise unary operator on its right, that is, ``2**-1`` is ``0.5``. 1447