Python > Le langage > Expressions et opérateurs

Expressions

Une expression :

• est un ensemble de variables, de littéraux, d'appels de fonction et d'opérateurs,
• peut être très simple ou infiniment compliquée,
• peut être évaluée, elle a une valeur (et une seule !).

2	                 # Une expression très simple
nom + " " + prenom	 # Une autre...
(1 + math.sqrt(5))/2 # un peu moins simple

Lorsqu'une expression est complexe, il est préférable de la décomposer pour améliorer la lisibilité du code :

tarif_jeune = utilisateur.age < 26
if tarif_jeune:
    ...

Opérateurs

• Un opérateur peut être unaire ou binaire.
• Un opérateur fonctionne avec des opérandes.
• Un opérateur est lié à un type de données.

Opérateurs arithmétiques

Lorsque les opérandes sont d'un type numérique :

x + y  # Addition
x - y  # Soustraction
x * y  # Multiplication
x / y  # Division
x // y # Division entière
x % y  # Modulo (reste)
-x     # Opposé - opérateur unaire
abs(x) # Valeur absolue - opérateur unaire
x ** y # Puissance

Opérateurs comparatifs

Pour former des expressions booléennes :

x < y      # Inférieur
x <= y     # Inférieur ou égal
x > y      # Supérieur
x >= y     # Supérieur ou égal
x == y     # Égal (attention !)
x != y     # Différent
x <> y     # Différent
x is y     # Identité
x is not y # Non identité

Opérateurs logiques

Pour réunir des expressions booléennes :

x and y # Intersection
x or y  # Union
not y   # Négation

Opérateurs sur les séquences

Pour manipuler les séquences :

x in s     # Inclusion - Vrai si x est dans s
x not in s # Non inclusion - Vrai si x n'est pas dans s
s1 + s2    # Concaténation
s[i]       # Accès - Renvoie l'élément d'indice i
s[i:j]     # Accès - Renvoie les éléments d'indice i à j non inclu
s[-1]      # Accès - Renvoie le dernier élément
s[-2]      # Accès - Renvoie l'avant dernier élément
len(s)     # Longueur - Renvoie le nombre d'éléments
min(s)     # Minimum - Renvoie le plus petit élément
max(s)     # Maximum - Renvoie le plus grand élément

Conversion de type

• Le comportement d'un opérateur dépend du type de ses opérandes.

  9 / 4    # Vaut 2
  9 / 4.0  # Vaut 2.25 !
  

• Habituellement, Python détermine automatiquement le type des opérandes.
• Python opère des conversions de type implicite lorsque c'est nécessaire et possible

  2 + 2.0  # Vaut 4.0
  2 + '2'  # Déclenche une erreur !
  

• On peut forcer le type d'une opérande avec des fonctions de conversion :

  int(9.876) # Vaut 9
  long(670)  # Vaut 670L
  float(6)   # Vaut 6.0
  float('6') # Vaut 6.0
  str(87)    # Vaut '87'
  bool('')   # Vaut False
  bool(87)   # Vaut True
  

• Dans une expression booléenne, une opérande valant 0, None ou tout type complexe vide ((), [], {}, ...) sera converti en False.