# 5. Expressions

Ce chapitre explique la signification des éléments des expressions en Python.

Notes sur la syntaxe : dans ce chapitre et le suivant, nous utilisons la notation BNF étendue pour décrire la syntaxe, pas l’analyse lexicale. Quand une règle de syntaxe est de la forme

    name ::=  othername

et qu’aucune sémantique n’est donnée, la sémantique de `name` est la même que celle de `othername`.

## 5.1. Conversions arithmétiques

When a description of an arithmetic operator below uses the phrase « the numeric arguments are converted to a common type, » the arguments are coerced using the coercion rules listed at Coercion rules. If both arguments are standard numeric types, the following coercions are applied:

- Si l’un des deux arguments est du type nombre complexe, l’autre est converti en nombre complexe ;

- sinon, si l’un des arguments est un nombre à virgule flottante, l’autre est converti en nombre à virgule flottante ;

- otherwise, if either argument is a long integer, the other is converted to long integer;

- otherwise, both must be plain integers and no conversion is necessary.

Some additional rules apply for certain operators (e.g., a string left argument to the “%” operator). Extensions can define their own coercions.

## 5.2. Atomes

Atoms are the most basic elements of expressions. The simplest atoms are identifiers or literals. Forms enclosed in reverse quotes or in parentheses, brackets or braces are also categorized syntactically as atoms. The syntax for atoms is:

    atom      ::=  identifier | literal | enclosure
    enclosure ::=  parenth_form | list_display
                   | generator_expression | dict_display | set_display
                   | string_conversion | yield_atom

### 5.2.1. Identifiants (noms)

Un identifiant qui apparaît en tant qu’atome est un nom. Lisez la section Identifiants et mots-clés pour la définition lexicale et la section Noms et liaisons pour la documentation sur les noms et les liaisons afférentes.

Quand un nom est lié à un objet, l’évaluation de l’atome produit cet objet. Quand le nom n’est pas lié, toute tentative de l’évaluer lève une exception `NameError`.

Transformation des noms privés : lorsqu’un identificateur qui apparaît textuellement dans la définition d’une classe commence par deux (ou plus) caractères de soulignement et ne se termine pas par deux (ou plus) caractères de soulignement, il est considéré comme un nom privé <private name> de cette classe. Les noms privés sont transformés en une forme plus longue avant que le code ne soit généré pour eux. La transformation insère le nom de la classe, avec les soulignés enlevés et un seul souligné inséré devant le nom. Par exemple, l’identificateur `__spam` apparaissant dans une classe nommée `Ham` est transformé en `_Ham__spam`. Cette transformation est indépendante du contexte syntaxique dans lequel l’identificateur est utilisé. Si le nom transformé est extrêmement long (plus de 255 caractères), l’implémentation peut le tronquer. Si le nom de la classe est constitué uniquement de traits de soulignement, aucune transformation n’est effectuée.

### 5.2.2. Littéraux

Python supports string literals and various numeric literals:

    literal ::=  stringliteral | integer | longinteger
                 | floatnumber | imagnumber

Evaluation of a literal yields an object of the given type (string, integer, long integer, floating point number, complex number) with the given value. The value may be approximated in the case of floating point and imaginary (complex) literals. See section Littéraux for details.

Tous les littéraux sont de types immuables et donc l’identifiant de l’objet est moins important que sa valeur. Des évaluations multiples de littéraux avec la même valeur (soit la même occurrence dans le texte du programme, soit une autre occurrence) résultent dans le même objet ou un objet différent avec la même valeur.

### 5.2.3. Formes parenthésées

Une forme parenthésée est une liste d’expressions (cette liste est en fait optionnelle) placée à l’intérieur de parenthèses :

    parenth_form ::=  "(" [expression_list] ")"

Une liste d’expressions entre parenthèses produit ce que la liste de ces expressions produirait : si la liste contient au moins une virgule, elle produit un n-uplet (type tuple) ; sinon, elle produit l’expression elle-même (qui constitue donc elle-même la liste d’expressions).

Une paire de parenthèses vide produit un objet tuple vide. Comme les tuples sont immuables, la règle pour les littéraux s’applique (c’est-à-dire que deux occurrences du tuple vide peuvent, ou pas, produire le même objet).

Notez que les tuples ne sont pas créés par les parenthèses mais par l’utilisation de la virgule. L’exception est le tuple vide, pour lequel les parenthèses sont requises (autoriser que « rien » ne soit pas parenthésé dans les expressions aurait généré des ambigüités et aurait permis à certaines coquilles de passer inaperçu).

### 5.2.4. Agencements de listes

Un agencement de liste est une suite (possiblement vide) d’expressions à l’intérieur de crochets :

    list_display        ::=  "[" [expression_list | list_comprehension] "]"
    list_comprehension  ::=  expression list_for
    list_for            ::=  "for" target_list "in" old_expression_list [list_iter]
    old_expression_list ::=  old_expression [("," old_expression)+ [","]]
    old_expression      ::=  or_test | old_lambda_expr
    list_iter           ::=  list_for | list_if
    list_if             ::=  "if" old_expression [list_iter]

A list display yields a new list object. Its contents are specified by providing either a list of expressions or a list comprehension. When a comma-separated list of expressions is supplied, its elements are evaluated from left to right and placed into the list object in that order. When a list comprehension is supplied, it consists of a single expression followed by at least one `for` clause and zero or more `for` or `if` clauses. In this case, the elements of the new list are those that would be produced by considering each of the `for` or `if` clauses a block, nesting from left to right, and evaluating the expression to produce a list element each time the innermost block is reached 1.

### 5.2.5. Displays for sets and dictionaries

For constructing a set or a dictionary Python provides special syntax called « displays », each of them in two flavors:

- soit le contenu du conteneur est listé explicitement,

- soit il est calculé à l’aide de la combinaison d’une boucle et d’instructions de filtrage, appelée une compréhension (dans le sens de ce qui sert à définir un concept, par opposition à extension).

Les compréhensions sont constituées des éléments de syntaxe communs suivants :

    comprehension ::=  expression comp_for
    comp_for      ::=  "for" target_list "in" or_test [comp_iter]
    comp_iter     ::=  comp_for | comp_if
    comp_if       ::=  "if" expression_nocond [comp_iter]

Une compréhension est constituée par une seule expression suivie par au moins une clause `for` et zéro ou plus clauses `for` ou `if`. Dans ce cas, les éléments du nouveau conteneur sont ceux qui auraient été produits si l’on avait considéré toutes les clauses `for` ou `if` comme des blocs, imbriqués de la gauche vers la droite, et évalué l’expression pour produire un élément à chaque fois que le bloc le plus imbriqué était atteint.

Note that the comprehension is executed in a separate scope, so names assigned to in the target list don’t « leak » in the enclosing scope.

### 5.2.6. Générateurs (expressions)

Une expression générateur est une notation concise pour un générateur, entourée de parenthèses :

    generator_expression ::=  "(" expression comp_for ")"

Une expression générateur produit un nouvel objet générateur. Sa syntaxe est la même que celle des compréhensions, sauf qu’elle est entourée de parenthèses au lieu de crochets ou d’accolades.

Variables used in the generator expression are evaluated lazily when the `__next__()` method is called for generator object (in the same fashion as normal generators). However, the leftmost `for` clause is immediately evaluated, so that an error produced by it can be seen before any other possible error in the code that handles the generator expression. Subsequent `for` clauses cannot be evaluated immediately since they may depend on the previous `for` loop. For example: `(x*y for x in range(10) for y in bar(x))`.

The parentheses can be omitted on calls with only one argument. See section Appels for the detail.

### 5.2.7. Agencements de dictionnaires

Un agencement de dictionnaire est une série (possiblement vide) de couples clés-valeurs entourée par des accolades :

    dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
    key_datum_list     ::=  key_datum ("," key_datum)* [","]
    key_datum          ::=  expression ":" expression
    dict_comprehension ::=  expression ":" expression comp_for

Un agencement de dictionnaire produit un nouvel objet dictionnaire.

Si une séquence (dont les éléments sont séparés par des virgules) de couples clés-valeurs est fournie, les couples sont évalués de la gauche vers la droite pour définir les entrées du dictionnaire : chaque objet clé est utilisé comme clé dans le dictionnaire pour stocker la donnée correspondante. Cela signifie que vous pouvez spécifier la même clé plusieurs fois dans la liste des couples clés-valeurs et, dans ce cas, la valeur finalement stockée dans le dictionnaire est la dernière donnée.

Une compréhension de dictionnaire, au contraire des compréhensions de listes ou d’ensembles, requiert deux expressions séparées par une virgule et suivies par les clauses usuelles « for » et « if ». Quand la compréhension est exécutée, les éléments clés-valeurs sont insérés dans le nouveau dictionnaire dans l’ordre dans lequel ils sont produits.

Les restrictions relatives aux types des clés sont données dans la section Hiérarchie des types standards (pour résumer, le type de la clé doit être hachable, ce qui exclut tous les objets muables). Les collisions entre les clés dupliquées ne sont pas détectées ; la dernière valeur (celle qui apparaît le plus à droite dans l’agencement) stockée prévaut pour une clé donnée.

### 5.2.8. Agencements d’ensembles

Un agencement d’ensemble (type set) est délimité par des accolades et se distingue de l’agencement d’un dictionnaire par le fait qu’il n’y a pas de « deux points » `:` pour séparer les clés et les valeurs :

    set_display ::=  "{" (expression_list | comprehension) "}"

Un agencement d’ensemble produit un nouvel objet ensemble muable, le contenu étant spécifié soit par une séquence d’expression, soit par une compréhension. Quand une liste (dont les éléments sont séparés par des virgules) est fournie, ses éléments sont évalués de la gauche vers la droite et ajoutés à l’objet ensemble. Quand une compréhension est fournie, l’ensemble est construit à partir des éléments produits par la compréhension.

Un ensemble vide ne peut pas être construit par `{}` ; cette écriture construit un dictionnaire vide.

### 5.2.9. String conversions

A string conversion is an expression list enclosed in reverse (a.k.a. backward) quotes:

    string_conversion ::=  "`" expression_list "`"

A string conversion evaluates the contained expression list and converts the resulting object into a string according to rules specific to its type.

If the object is a string, a number, `None`, or a tuple, list or dictionary containing only objects whose type is one of these, the resulting string is a valid Python expression which can be passed to the built-in function `eval()` to yield an expression with the same value (or an approximation, if floating point numbers are involved).

(In particular, converting a string adds quotes around it and converts « funny » characters to escape sequences that are safe to print.)

Recursive objects (for example, lists or dictionaries that contain a reference to themselves, directly or indirectly) use `...` to indicate a recursive reference, and the result cannot be passed to `eval()` to get an equal value (`SyntaxError` will be raised instead).

The built-in function `repr()` performs exactly the same conversion in its argument as enclosing it in parentheses and reverse quotes does. The built-in function `str()` performs a similar but more user-friendly conversion.

### 5.2.10. Expressions `yield`

    yield_atom       ::=  "(" yield_expression ")"
    yield_expression ::=  "yield" [expression_list]

Nouveau dans la version 2.5.

The `yield` expression is only used when defining a generator function, and can only be used in the body of a function definition. Using a `yield` expression in a function definition is sufficient to cause that definition to create a generator function instead of a normal function.

When a generator function is called, it returns an iterator known as a generator. That generator then controls the execution of a generator function. The execution starts when one of the generator’s methods is called. At that time, the execution proceeds to the first `yield` expression, where it is suspended again, returning the value of `expression_list` to generator’s caller. By suspended we mean that all local state is retained, including the current bindings of local variables, the instruction pointer, and the internal evaluation stack. When the execution is resumed by calling one of the generator’s methods, the function can proceed exactly as if the `yield` expression was just another external call. The value of the `yield` expression after resuming depends on the method which resumed the execution.

All of this makes generator functions quite similar to coroutines; they yield multiple times, they have more than one entry point and their execution can be suspended. The only difference is that a generator function cannot control where should the execution continue after it yields; the control is always transferred to the generator’s caller.

#### 5.2.10.1. Méthodes des générateurs-itérateurs

Cette sous-section décrit les méthodes des générateurs-itérateurs. Elles peuvent être utilisées pour contrôler l’exécution des fonctions générateurs.

Notez que l’appel à une méthode ci-dessous d’un générateur alors que le générateur est déjà en cours d’exécution lève une exception `ValueError`.

`generator.``next`()

  Starts the execution of a generator function or resumes it at the last executed `yield` expression. When a generator function is resumed with a `next()` method, the current `yield` expression always evaluates to `None`. The execution then continues to the next `yield` expression, where the generator is suspended again, and the value of the `expression_list` is returned to `next()`”s caller. If the generator exits without yielding another value, a `StopIteration` exception is raised.

`generator.``send`(value)

  Resumes the execution and « sends » a value into the generator function. The `value` argument becomes the result of the current `yield` expression. The `send()` method returns the next value yielded by the generator, or raises `StopIteration` if the generator exits without yielding another value. When `send()` is called to start the generator, it must be called with `None` as the argument, because there is no `yield` expression that could receive the value.

`generator.``throw`(type[, value[, traceback]])

  Raises an exception of type `type` at the point where generator was paused, and returns the next value yielded by the generator function. If the generator exits without yielding another value, a `StopIteration` exception is raised. If the generator function does not catch the passed-in exception, or raises a different exception, then that exception propagates to the caller.

`generator.``close`()

  Raises a `GeneratorExit` at the point where the generator function was paused. If the generator function then raises `StopIteration` (by exiting normally, or due to already being closed) or `GeneratorExit` (by not catching the exception), close returns to its caller. If the generator yields a value, a `RuntimeError` is raised. If the generator raises any other exception, it is propagated to the caller. `close()` does nothing if the generator has already exited due to an exception or normal exit.

Voici un exemple simple qui montre le comportement des générateurs et des fonctions générateurs :

    >>> def echo(value=None):
    ...     print "Execution starts when 'next()' is called for the first time."
    ...     try:
    ...         while True:
    ...             try:
    ...                 value = (yield value)
    ...             except Exception, e:
    ...                 value = e
    ...     finally:
    ...         print "Don't forget to clean up when 'close()' is called."
    ...
    >>> generator = echo(1)
    >>> print generator.next()
    Execution starts when 'next()' is called for the first time.
    1
    >>> print generator.next()
    None
    >>> print generator.send(2)
    2
    >>> generator.throw(TypeError, "spam")
    TypeError('spam',)
    >>> generator.close()
    Don't forget to clean up when 'close()' is called.

Voir aussi

PEP 342 – Coroutines via des générateurs améliorés

  Proposition d’améliorer l’API et la syntaxe des générateurs, de manière à pouvoir les utiliser comme de simples coroutines.

## 5.3. Primaires

Les primaires (primary dans la grammaire formelle ci-dessous) représentent les opérations qui se lient au plus proche dans le langage. Leur syntaxe est :

    primary ::=  atom | attributeref | subscription | slicing | call

### 5.3.1. Références à des attributs

Une référence à un attribut (attributeref dans la grammaire formelle ci-dessous) est une primaire suivie par un point et un nom :

    attributeref ::=  primary "." identifier

The primary must evaluate to an object of a type that supports attribute references, e.g., a module, list, or an instance. This object is then asked to produce the attribute whose name is the identifier. If this attribute is not available, the exception `AttributeError` is raised. Otherwise, the type and value of the object produced is determined by the object. Multiple evaluations of the same attribute reference may yield different objects.

### 5.3.2. Sélections

Une sélection (subscription dans la grammaire formelle ci-dessous) désigne un élément dans un objet séquence (chaîne, n-uplet ou liste) ou tableau de correspondances (dictionnaire) :

    subscription ::=  primary "[" expression_list "]"

The primary must evaluate to an object of a sequence or mapping type.

Si la primaire est un tableau de correspondances, la liste d’expressions (expression_list dans la grammaire formelle ci-dessous) doit pouvoir être évaluée comme un objet dont la valeur est une des clés du tableau de correspondances et la sélection désigne la valeur qui correspond à cette clé (la liste d’expressions est un n-uplet sauf si elle comporte exactement un élément).

If the primary is a sequence, the expression list must evaluate to a plain integer. If this value is negative, the length of the sequence is added to it (so that, e.g., `x[-1]` selects the last item of `x`.) The resulting value must be a nonnegative integer less than the number of items in the sequence, and the subscription selects the item whose index is that value (counting from zero).

Les éléments des chaînes sont des caractères. Un caractère n’est pas un type en tant que tel, c’est une chaîne de longueur un.

### 5.3.3. Tranches

Une tranche (slicing dans la grammaire formelle ci-dessous) sélectionne un intervalle d’éléments d’un objet séquence (par exemple une chaîne, un n-uplet ou une liste, respectivement les types string, tuple et list). Les tranches peuvent être utilisées comme des expressions ou des cibles dans les assignations ou les instructions `del`. La syntaxe est la suivante :

    slicing          ::=  simple_slicing | extended_slicing
    simple_slicing   ::=  primary "[" short_slice "]"
    extended_slicing ::=  primary "[" slice_list "]"
    slice_list       ::=  slice_item ("," slice_item)* [","]
    slice_item       ::=  expression | proper_slice | ellipsis
    proper_slice     ::=  short_slice | long_slice
    short_slice      ::=  [lower_bound] ":" [upper_bound]
    long_slice       ::=  short_slice ":" [stride]
    lower_bound      ::=  expression
    upper_bound      ::=  expression
    stride           ::=  expression
    ellipsis         ::=  "..."

There is ambiguity in the formal syntax here: anything that looks like an expression list also looks like a slice list, so any subscription can be interpreted as a slicing. Rather than further complicating the syntax, this is disambiguated by defining that in this case the interpretation as a subscription takes priority over the interpretation as a slicing (this is the case if the slice list contains no proper slice nor ellipses). Similarly, when the slice list has exactly one short slice and no trailing comma, the interpretation as a simple slicing takes priority over that as an extended slicing.

The semantics for a simple slicing are as follows. The primary must evaluate to a sequence object. The lower and upper bound expressions, if present, must evaluate to plain integers; defaults are zero and the `sys.maxint`, respectively. If either bound is negative, the sequence’s length is added to it. The slicing now selects all items with index k such that `i <= k < j` where i and j are the specified lower and upper bounds. This may be an empty sequence. It is not an error if i or j lie outside the range of valid indexes (such items don’t exist so they aren’t selected).

The semantics for an extended slicing are as follows. The primary must evaluate to a mapping object, and it is indexed with a key that is constructed from the slice list, as follows. If the slice list contains at least one comma, the key is a tuple containing the conversion of the slice items; otherwise, the conversion of the lone slice item is the key. The conversion of a slice item that is an expression is that expression. The conversion of an ellipsis slice item is the built-in `Ellipsis` object. The conversion of a proper slice is a slice object (see section Hiérarchie des types standards) whose `start`, `stop` and `step` attributes are the values of the expressions given as lower bound, upper bound and stride, respectively, substituting `None` for missing expressions.

### 5.3.4. Appels

Un appel (call dans la grammaire ci-dessous) appelle un objet appelable (par exemple, une fonction) avec, possiblement, une liste d”arguments :

    call                 ::=  primary "(" [argument_list [","]
                              | expression genexpr_for] ")"
    argument_list        ::=  positional_arguments ["," keyword_arguments]
                                ["," "*" expression] ["," keyword_arguments]
                                ["," "**" expression]
                              | keyword_arguments ["," "*" expression]
                                ["," "**" expression]
                              | "*" expression ["," keyword_arguments] ["," "**" expression]
                              | "**" expression
    positional_arguments ::=  expression ("," expression)*
    keyword_arguments    ::=  keyword_item ("," keyword_item)*
    keyword_item         ::=  identifier "=" expression

A trailing comma may be present after the positional and keyword arguments but does not affect the semantics.

The primary must evaluate to a callable object (user-defined functions, built-in functions, methods of built-in objects, class objects, methods of class instances, and certain class instances themselves are callable; extensions may define additional callable object types). All argument expressions are evaluated before the call is attempted. Please refer to section Définition de fonctions for the syntax of formal parameter lists.

Si des arguments par mots-clés sont présents, ils sont d’abord convertis en arguments positionnels, comme suit. Pour commencer, une liste de slots vides est créée pour les paramètres formels. S’il y a N arguments positionnels, ils sont placés dans les N premiers slots. Ensuite, pour chaque argument par mot-clé, l’identifiant est utilisé pour déterminer le slot correspondant (si l’identifiant est le même que le nom du premier paramètre formel, le premier slot est utilisé, et ainsi de suite). Si le slot est déjà rempli, une exception `TypeError` est levée. Sinon, la valeur de l’argument est placée dans le slot, ce qui le remplit (même si l’expression est `None`, cela remplit le slot). Quand tous les arguments ont été traités, les slots qui sont toujours vides sont remplis avec la valeur par défaut correspondante dans la définition de la fonction (les valeurs par défaut sont calculées, une seule fois, lorsque la fonction est définie ; ainsi, un objet mutable tel qu’une liste ou un dictionnaire utilisé en tant valeur par défaut sera partagé entre tous les appels qui ne spécifient pas de valeur d argument pour ce slot ; on évite généralement de faire ça). S’il reste des slots pour lesquels aucune valeur par défaut n’est définie, une exception `TypeError` est levée. Sinon, la liste des slots remplie est utilisée en tant que liste des arguments pour l’appel.

Une implémentation peut fournir des fonctions natives dont les paramètres positionnels n’ont pas de nom, même s’ils sont « nommés » pour les besoins de la documentation. Ils ne peuvent donc pas être spécifiés par mot-clé. En CPython, les fonctions implémentées en C qui utilisent `PyArg_ParseTuple()` pour analyser leurs arguments en font partie.

S’il y a plus d’arguments positionnels que de slots de paramètres formels, une exception `TypeError` est levée, à moins qu’un paramètre formel n’utilise la syntaxe `*identifier` ; dans ce cas, le paramètre formel reçoit un n-uplet contenant les arguments positionnels en supplément (ou un n-uplet vide s’il n’y avait pas d’arguments positionnel en trop).

Si un argument par mot-clé ne correspond à aucun nom de paramètre formel, une exception `TypeError` est levée, à moins qu’un paramètre formel n’utilise la syntaxe `**identifier` ; dans ce cas, le paramètre formel reçoit un dictionnaire contenant les arguments par mot-clé en trop (en utilisant les mots-clés comme clés et les arguments comme valeurs pour ce dictionnaire), ou un (nouveau) dictionnaire vide s’il n’y a pas d’argument par mot-clé en trop.

If the syntax `*expression` appears in the function call, `expression` must evaluate to an iterable. Elements from this iterable are treated as if they were additional positional arguments; if there are positional arguments x1, …, xN, and `expression` evaluates to a sequence y1, …, yM, this is equivalent to a call with M+N positional arguments x1, …, xN, y1, …, yM.

A consequence of this is that although the `*expression` syntax may appear after some keyword arguments, it is processed before the keyword arguments (and the `**expression` argument, if any – see below). So:

    >>> def f(a, b):
    ...     print a, b
    ...
    >>> f(b=1, *(2,))
    2 1
    >>> f(a=1, *(2,))
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: f() got multiple values for keyword argument 'a'
    >>> f(1, *(2,))
    1 2

Il est inhabituel que les syntaxes d’arguments par mots-clés et `*expression` soient utilisés simultanément dans un même appel, ce qui fait que la confusion reste hypothétique.

If the syntax `**expression` appears in the function call, `expression` must evaluate to a mapping, the contents of which are treated as additional keyword arguments. In the case of a keyword appearing in both `expression` and as an explicit keyword argument, a `TypeError` exception is raised.

Formal parameters using the syntax `*identifier` or `**identifier` cannot be used as positional argument slots or as keyword argument names. Formal parameters using the syntax `(sublist)` cannot be used as keyword argument names; the outermost sublist corresponds to a single unnamed argument slot, and the argument value is assigned to the sublist using the usual tuple assignment rules after all other parameter processing is done.

Un appel renvoie toujours une valeur, possiblement `None`, à moins qu’il ne lève une exception. La façon dont celle valeur est calculée dépend du type de l’objet appelable.

Si c’est —

une fonction définie par l’utilisateur :

  le bloc de code de la fonction est exécuté, il reçoit la liste des arguments. La première chose que le bloc de code fait est de lier les paramètres formels aux arguments ; ceci est décrit dans la section Définition de fonctions. Quand le bloc de code exécute l’instruction `return`, cela spécifie la valeur de retour de l’appel de la fonction.

une fonction ou une méthode native :

  le résultat dépend de l’interpréteur ; lisez Fonctions natives pour une description des fonctions et méthodes natives.

un objet classe :

  une nouvelle instance de cette classe est renvoyée.

une méthode d’instance de classe :

  la fonction correspondante définie par l’utilisateur est appelée, avec la liste d’arguments qui est plus grande d’un élément que la liste des arguments de l’appel : l’instance est placée en tête des arguments.

une instance de classe :

  la classe doit définir une méthode `__call__()` ; l’effet est le même que si cette méthode était appelée.

## 5.4. L’opérateur puissance

L’opérateur puissance est plus prioritaire que les opérateurs unaires sur sa gauche ; il est moins prioritaire que les opérateurs unaires sur sa droite. La syntaxe est :

    power ::=  primary ["**" u_expr]

Ainsi, dans une séquence sans parenthèse de puissance et d’opérateurs unaires, les opérateurs sont évalués de droite à gauche (ceci ne contraint pas l’ordre d’évaluation des opérandes) : `-1**2` donne `-1`.

The power operator has the same semantics as the built-in `pow()` function, when called with two arguments: it yields its left argument raised to the power of its right argument. The numeric arguments are first converted to a common type. The result type is that of the arguments after coercion.

With mixed operand types, the coercion rules for binary arithmetic operators apply. For int and long int operands, the result has the same type as the operands (after coercion) unless the second argument is negative; in that case, all arguments are converted to float and a float result is delivered. For example, `10**2` returns `100`, but `10**-2` returns `0.01`. (This last feature was added in Python 2.2. In Python 2.1 and before, if both arguments were of integer types and the second argument was negative, an exception was raised).

Raising `0.0` to a negative power results in a `ZeroDivisionError`. Raising a negative number to a fractional power results in a `ValueError`.

## 5.5. Arithmétique unaire et opérations sur les bits

Toute l’arithmétique unaire et les opérations sur les bits ont la même priorité :

    u_expr ::=  power | "-" u_expr | "+" u_expr | "~" u_expr

L’opérateur unaire `-` (moins) produit l’opposé de son argument numérique.

L’opérateur unaire `+` (plus) produit son argument numérique inchangé.

The unary `~` (invert) operator yields the bitwise inversion of its plain or long integer argument. The bitwise inversion of `x` is defined as `-(x+1)`. It only applies to integral numbers.

Dans ces trois cas, si l’argument n’est pas du bon type, une exception `TypeError` est levée.

## 5.6. Opérations arithmétiques binaires

Les opérations arithmétiques binaires suivent les conventions pour les priorités. Notez que certaines de ces opérations s’appliquent aussi à des types non numériques. À part l’opérateur puissance, il n’y a que deux niveaux, le premier pour les opérateurs multiplicatifs et le second pour les opérateurs additifs :

    m_expr ::=  u_expr | m_expr "*" u_expr | m_expr "//" u_expr | m_expr "/" u_expr
                | m_expr "%" u_expr
    a_expr ::=  m_expr | a_expr "+" m_expr | a_expr "-" m_expr

The `*` (multiplication) operator yields the product of its arguments. The arguments must either both be numbers, or one argument must be an integer (plain or long) and the other must be a sequence. In the former case, the numbers are converted to a common type and then multiplied together. In the latter case, sequence repetition is performed; a negative repetition factor yields an empty sequence.

The `/` (division) and `//` (floor division) operators yield the quotient of their arguments. The numeric arguments are first converted to a common type. Plain or long integer division yields an integer of the same type; the result is that of mathematical division with the “floor” function applied to the result. Division by zero raises the `ZeroDivisionError` exception.

L’opérateur `%` (modulo) produit le reste de la division entière du premier argument par le second. Les arguments numériques sont d’abord convertis vers un type commun. Un zéro en second argument lève une exception `ZeroDivisionError`. Les arguments peuvent être des nombres à virgule flottante, par exemple `3.14%0.7` vaut `0.34` (puisque `3.14` égale `4*0.7+0.34`). L’opérateur modulo produit toujours un résultat du même signe que le second opérande (ou zéro) ; la valeur absolue du résultat est strictement inférieure à la valeur absolue du second opérande 2.

The integer division and modulo operators are connected by the following identity: `x == (x/y)*y + (x%y)`. Integer division and modulo are also connected with the built-in function `divmod()`: `divmod(x, y) == (x/y, x%y)`. These identities don’t hold for floating point numbers; there similar identities hold approximately where `x/y` is replaced by `floor(x/y)` or `floor(x/y) - 1` 3.

In addition to performing the modulo operation on numbers, the `%` operator is also overloaded by string and unicode objects to perform string formatting (also known as interpolation). The syntax for string formatting is described in the Python Library Reference, section String Formatting Operations.

Obsolète depuis la version 2.3: The floor division operator, the modulo operator, and the `divmod()` function are no longer defined for complex numbers. Instead, convert to a floating point number using the `abs()` function if appropriate.

The `+` (addition) operator yields the sum of its arguments. The arguments must either both be numbers or both sequences of the same type. In the former case, the numbers are converted to a common type and then added together. In the latter case, the sequences are concatenated.

L’opérateur `-` (soustraction) produit la différence entre ses arguments. Les arguments numériques sont d’abord convertis vers un type commun.

## 5.7. Opérations de décalage

Les opérations de décalage sont moins prioritaires que les opérations arithmétiques :

    shift_expr ::=  a_expr | shift_expr ( "<<" | ">>" ) a_expr

These operators accept plain or long integers as arguments. The arguments are converted to a common type. They shift the first argument to the left or right by the number of bits given by the second argument.

A right shift by n bits is defined as division by `pow(2, n)`. A left shift by n bits is defined as multiplication with `pow(2, n)`. Negative shift counts raise a `ValueError` exception.

Note

Dans l’implémentation actuelle, l’opérande de droite doit être au maximum `sys.maxsize`. Si l’opérande de droite est plus grand que `sys.maxsize`, une exception `OverflowError` est levée.

## 5.8. Opérations binaires bit à bit

Chacune des trois opérations binaires bit à bit possède une priorité différente :

    and_expr ::=  shift_expr | and_expr "&" shift_expr
    xor_expr ::=  and_expr | xor_expr "^" and_expr
    or_expr  ::=  xor_expr | or_expr "|" xor_expr

The `&` operator yields the bitwise AND of its arguments, which must be plain or long integers. The arguments are converted to a common type.

The `^` operator yields the bitwise XOR (exclusive OR) of its arguments, which must be plain or long integers. The arguments are converted to a common type.

The `|` operator yields the bitwise (inclusive) OR of its arguments, which must be plain or long integers. The arguments are converted to a common type.

## 5.9. Comparaisons

Au contraire du C, toutes les opérations de comparaison en Python possèdent la même priorité, qui est plus faible que celle des opérations arithmétiques, décalages ou binaires bit à bit. Toujours contrairement au C, les expressions telles que `a < b < c` sont interprétées comme elles le seraient conventionnellement en mathématiques :

    comparison    ::=  or_expr ( comp_operator or_expr )*
    comp_operator ::=  "<" | ">" | "==" | ">=" | "<=" | "<>" | "!="
                       | "is" ["not"] | ["not"] "in"

Les comparaisons produisent des valeurs booléennes : `True` ou `False`.

Les comparaisons peuvent être enchaînées arbitrairement, par exemple `x < y <= z` est équivalent à `x < y and y <= z`, sauf que `y` est évalué seulement une fois (mais dans les deux cas, `z` n’est pas évalué du tout si `x < y` s’avère être faux).

Formellement, si a, b, c, …, y, z sont des expressions et op1, op2, …, opN sont des opérateurs de comparaison, alors `a op1 b op2 c ... y opN z` est équivalent à `a op1 b and b op2 c and ... y opN z`, sauf que chaque expression est évaluée au maximum une fois.

Notez que `a op1 b op2 c` n’implique aucune comparaison entre a et c. Ainsi, par exemple, `x < y > z` est parfaitement légal (mais peut-être pas très élégant).

The forms `<>` and `!=` are equivalent; for consistency with C, `!=` is preferred; where `!=` is mentioned below `<>` is also accepted. The `<>` spelling is considered obsolescent.

### 5.9.1. Value comparisons

The operators `<`, `>`, `==`, `>=`, `<=`, and `!=` compare the values of two objects. The objects do not need to have the same type.

Chapter Objets, valeurs et types states that objects have a value (in addition to type and identity). The value of an object is a rather abstract notion in Python: For example, there is no canonical access method for an object’s value. Also, there is no requirement that the value of an object should be constructed in a particular way, e.g. comprised of all its data attributes. Comparison operators implement a particular notion of what the value of an object is. One can think of them as defining the value of an object indirectly, by means of their comparison implementation.

Types can customize their comparison behavior by implementing a `__cmp__()` method or rich comparison methods like `__lt__()`, described in Personnalisation de base.

The default behavior for equality comparison (`==` and `!=`) is based on the identity of the objects. Hence, equality comparison of instances with the same identity results in equality, and equality comparison of instances with different identities results in inequality. A motivation for this default behavior is the desire that all objects should be reflexive (i.e. `x is y` implies `x == y`).

The default order comparison (`<`, `>`, `<=`, and `>=`) gives a consistent but arbitrary order.

(This unusual definition of comparison was used to simplify the definition of operations like sorting and the `in` and `not in` operators. In the future, the comparison rules for objects of different types are likely to change.)

The behavior of the default equality comparison, that instances with different identities are always unequal, may be in contrast to what types will need that have a sensible definition of object value and value-based equality. Such types will need to customize their comparison behavior, and in fact, a number of built-in types have done that.

The following list describes the comparison behavior of the most important built-in types.

- Numbers of built-in numeric types (Numeric Types — int, float, long, complex) and of the standard library types `fractions.Fraction` and `decimal.Decimal` can be compared within and across their types, with the restriction that complex numbers do not support order comparison. Within the limits of the types involved, they compare mathematically (algorithmically) correct without loss of precision.

- Strings (instances of `str` or `unicode`) compare lexicographically using the numeric equivalents (the result of the built-in function `ord()`) of their characters. 4 When comparing an 8-bit string and a Unicode string, the 8-bit string is converted to Unicode. If the conversion fails, the strings are considered unequal.

- Instances of `tuple` or `list` can be compared only within each of their types. Equality comparison across these types results in unequality, and ordering comparison across these types gives an arbitrary order.

  These sequences compare lexicographically using comparison of corresponding elements, whereby reflexivity of the elements is enforced.

  In enforcing reflexivity of elements, the comparison of collections assumes that for a collection element `x`, `x == x` is always true. Based on that assumption, element identity is compared first, and element comparison is performed only for distinct elements. This approach yields the same result as a strict element comparison would, if the compared elements are reflexive. For non-reflexive elements, the result is different than for strict element comparison.

  Lexicographical comparison between built-in collections works as follows:

  - For two collections to compare equal, they must be of the same type, have the same length, and each pair of corresponding elements must compare equal (for example, `[1,2] == (1,2)` is false because the type is not the same).

  - Collections are ordered the same as their first unequal elements (for example, `cmp([1,2,x], [1,2,y])` returns the same as `cmp(x,y)`). If a corresponding element does not exist, the shorter collection is ordered first (for example, `[1,2] < [1,2,3]` is true).

- Mappings (instances of `dict`) compare equal if and only if they have equal (key, value) pairs. Equality comparison of the keys and values enforces reflexivity.

  Outcomes other than equality are resolved consistently, but are not otherwise defined. 5

- Most other objects of built-in types compare unequal unless they are the same object; the choice whether one object is considered smaller or larger than another one is made arbitrarily but consistently within one execution of a program.

User-defined classes that customize their comparison behavior should follow some consistency rules, if possible:

- Equality comparison should be reflexive. In other words, identical objects should compare equal:

  > `x is y` implies `x == y`

- Comparison should be symmetric. In other words, the following expressions should have the same result:

  > `x == y` and `y == x`

  > `x != y` and `y != x`

  > `x < y` and `y > x`

  > `x <= y` and `y >= x`

- Comparison should be transitive. The following (non-exhaustive) examples illustrate that:

  > `x > y and y > z` implies `x > z`

  > `x < y and y <= z` implies `x < z`

- Inverse comparison should result in the boolean negation. In other words, the following expressions should have the same result:

  > `x == y` and `not x != y`

  > `x < y` and `not x >= y` (for total ordering)

  > `x > y` and `not x <= y` (for total ordering)

  The last two expressions apply to totally ordered collections (e.g. to sequences, but not to sets or mappings). See also the `total_ordering()` decorator.

- The `hash()` result should be consistent with equality. Objects that are equal should either have the same hash value, or be marked as unhashable.

Python does not enforce these consistency rules.

### 5.9.2. Membership test operations

The operators `in` and `not in` test for membership. `x in s` evaluates to `True` if x is a member of s, and `False` otherwise. `x not in s` returns the negation of `x in s`. All built-in sequences and set types support this as well as dictionary, for which `in` tests whether the dictionary has a given key. For container types such as list, tuple, set, frozenset, dict, or collections.deque, the expression `x in y` is equivalent to `any(x is e or x == e for e in y)`.

For the string and bytes types, `x in y` is `True` if and only if x is a substring of y. An equivalent test is `y.find(x) != -1`. Empty strings are always considered to be a substring of any other string, so `"" in "abc"` will return `True`.

For user-defined classes which define the `__contains__()` method, `x in y` returns `True` if `y.__contains__(x)` returns a true value, and `False` otherwise.

For user-defined classes which do not define `__contains__()` but do define `__iter__()`, `x in y` is `True` if some value `z` with `x == z` is produced while iterating over `y`. If an exception is raised during the iteration, it is as if `in` raised that exception.

Lastly, the old-style iteration protocol is tried: if a class defines `__getitem__()`, `x in y` is `True` if and only if there is a non-negative integer index i such that `x == y[i]`, and all lower integer indices do not raise `IndexError` exception. (If any other exception is raised, it is as if `in` raised that exception).

L’opérateur `not in` est défini comme produisant le contraire de `in`.

### 5.9.3. Identity comparisons

The operators `is` and `is not` test for object identity: `x is y` is true if and only if x and y are the same object. `x is not y` yields the inverse truth value. 6

## 5.10. Opérations booléennes

    or_test  ::=  and_test | or_test "or" and_test
    and_test ::=  not_test | and_test "and" not_test
    not_test ::=  comparison | "not" not_test

In the context of Boolean operations, and also when expressions are used by control flow statements, the following values are interpreted as false: `False`, `None`, numeric zero of all types, and empty strings and containers (including strings, tuples, lists, dictionaries, sets and frozensets). All other values are interpreted as true. (See the `__nonzero__()` special method for a way to change this.)

L’opérateur `not` produit `True` si son argument est faux, `False` sinon.

L’expression `x and y` commence par évaluer x ; si x est faux, sa valeur est renvoyée ; sinon, y est évalué et la valeur résultante est renvoyée.

L’expression `x or y` commence par évaluer x ; si x est vrai, sa valeur est renvoyée ; sinon, y est évalué et la valeur résultante est renvoyée.

(Note that neither `and` nor `or` restrict the value and type they return to `False` and `True`, but rather return the last evaluated argument. This is sometimes useful, e.g., if `s` is a string that should be replaced by a default value if it is empty, the expression `s or 'foo'` yields the desired value. Because `not` has to invent a value anyway, it does not bother to return a value of the same type as its argument, so e.g., `not 'foo'` yields `False`, not `''`.)

## 5.11. Conditional Expressions

Nouveau dans la version 2.5.

    conditional_expression ::=  or_test ["if" or_test "else" expression]
    expression             ::=  conditional_expression | lambda_expr

Les expressions conditionnelles (parfois appelées « opérateur ternaire ») sont les moins prioritaires de toutes les opérations Python.

The expression `x if C else y` first evaluates the condition, C (not x); if C is true, x is evaluated and its value is returned; otherwise, y is evaluated and its value is returned.

Voir la PEP 308 pour plus de détails sur les expressions conditionnelles.

## 5.12. Expressions lambda

    lambda_expr     ::=  "lambda" [parameter_list]: expression
    old_lambda_expr ::=  "lambda" [parameter_list]: old_expression

Lambda expressions (sometimes called lambda forms) have the same syntactic position as expressions. They are a shorthand to create anonymous functions; the expression `lambda parameters: expression` yields a function object. The unnamed object behaves like a function object defined with

    def <lambda>(parameters):
        return expression

See section Définition de fonctions for the syntax of parameter lists. Note that functions created with lambda expressions cannot contain statements.

## 5.13. Listes d’expressions

    expression_list ::=  expression ( "," expression )* [","]

An expression list containing at least one comma yields a tuple. The length of the tuple is the number of expressions in the list. The expressions are evaluated from left to right.

La virgule finale est nécessaire pour créer un singleton (c’est-à-dire un n-uplet composé d’un seul élément) : elle est optionnelle dans tous les autres cas. Une expression seule sans virgule finale ne crée pas un n-uplet mais produit la valeur de cette expression (pour créer un tuple vide, utilisez une paire de parenthèses vide : `()`).

## 5.14. Ordre d’évaluation

Python evaluates expressions from left to right. Notice that while evaluating an assignment, the right-hand side is evaluated before the left-hand side.

Dans les lignes qui suivent, les expressions sont évaluées suivant l’ordre arithmétique de leurs suffixes :

    expr1, expr2, expr3, expr4
    (expr1, expr2, expr3, expr4)
    {expr1: expr2, expr3: expr4}
    expr1 + expr2 * (expr3 - expr4)
    expr1(expr2, expr3, *expr4, **expr5)
    expr3, expr4 = expr1, expr2

## 5.15. Priorités des opérateurs

The following table summarizes the operator precedences in Python, from lowest precedence (least binding) to highest precedence (most binding). Operators in the same box have the same precedence. Unless the syntax is explicitly given, operators are binary. Operators in the same box group left to right (except for comparisons, including tests, which all have the same precedence and chain from left to right — see section Comparaisons — and exponentiation, which groups from right to left).

Opérateur | Description
--- | ---
`lambda` | Expression lambda
`if` – `else` | Expressions conditionnelle
`or` | OR (booléen)
`and` | AND (booléen)
`not` `x` | NOT (booléen)
`in`, `not in`, `is`, `is not`, `<`, `<=`, `>`, `>=`, `<>`, `!=`, `==` | Comparaisons, y compris les tests d’appartenance et les tests d’identifiants
`|` | OR (bit à bit)
`^` | XOR (bit à bit)
`&` | AND (bit à bit)
`<<`, `>>` | décalages
`+`, `-` | Addition et soustraction
`*`, `/`, `//`, `%` | Multiplication, division, remainder 7
`+x`, `-x`, `~x` | NOT (positif, négatif, bit à bit)
`**` | Puissance 8
`x[indice]`, `x[indice:indice]`, `x(arguments...)`, `x.attribut` | indiçage, tranches, appel, référence à un attribut
`(expressions...)`, `[expressions...]`, `{key: value...}`, ``expressions...`` | Binding or tuple display, list display, dictionary display, string conversion

Notes

1

  In Python 2.3 and later releases, a list comprehension « leaks » the control variables of each `for` it contains into the containing scope. However, this behavior is deprecated, and relying on it will not work in Python 3.

2

  Bien que `abs(x%y) < abs(y)` soit vrai mathématiquement, ce n’est pas toujours vrai pour les nombres à virgule flottante en raison des arrondis. Par exemple, en supposant que Python tourne sur une plateforme où les float sont des nombres à double précision IEEE 754, afin que `-1e-100 % 1e100` soit du même signe que `1e100`, le résultat calculé est `-1e-100 + 1e100`, qui vaut exactement `1e100` dans ce standard. Or, la fonction `math.fmod()` renvoie un résultat dont le signe est le signe du premier argument, c’est-à-dire `-1e-100` dans ce cas. La meilleure approche dépend de l’application.

3

  If x is very close to an exact integer multiple of y, it’s possible for `floor(x/y)` to be one larger than `(x-x%y)/y` due to rounding. In such cases, Python returns the latter result, in order to preserve that `divmod(x,y)[0] * y + x % y` be very close to `x`.

4

  The Unicode standard distinguishes between code points (e.g. U+0041) and abstract characters (e.g. « LATIN CAPITAL LETTER A »). While most abstract characters in Unicode are only represented using one code point, there is a number of abstract characters that can in addition be represented using a sequence of more than one code point. For example, the abstract character « LATIN CAPITAL LETTER C WITH CEDILLA » can be represented as a single precomposed character at code position U+00C7, or as a sequence of a base character at code position U+0043 (LATIN CAPITAL LETTER C), followed by a combining character at code position U+0327 (COMBINING CEDILLA).

  The comparison operators on unicode strings compare at the level of Unicode code points. This may be counter-intuitive to humans. For example, `u"\u00C7" == u"\u0043\u0327"` is `False`, even though both strings represent the same abstract character « LATIN CAPITAL LETTER C WITH CEDILLA ».

  To compare strings at the level of abstract characters (that is, in a way intuitive to humans), use `unicodedata.normalize()`.

5

  Earlier versions of Python used lexicographic comparison of the sorted (key, value) lists, but this was very expensive for the common case of comparing for equality. An even earlier version of Python compared dictionaries by identity only, but this caused surprises because people expected to be able to test a dictionary for emptiness by comparing it to `{}`.

6

  En raison du ramasse-miettes automatique et de la nature dynamique des descripteurs, vous pouvez être confronté à un comportement semblant bizarre lors de certaines utilisations de l’opérateur `is`, par exemple si cela implique des comparaisons entre des méthodes d’instances ou des constantes. Allez vérifier dans la documentation pour plus d’informations.

7

  L’opérateur `%` est aussi utilisé pour formater les chaînes de caractères ; il y possède la même priorité.

8

  L’opérateur puissance `**` est moins prioritaire qu’un opérateur unaire arithmétique ou bit à bit sur sa droite. Ainsi, `2**-1` vaut `0.5`.