opérateurs

un survol des opérateurs pour construire les expressions

rappels¶

• appel de fonction avec () comme dans foo(0)

• indexation avec [] comme dans L[0]

• attribut avec . comme dans S.upper()

arithmétiques¶

• arithmétiques: + | - | * | /

  • pas que sur les nombres

'on peut juste juxtaposer' ' deux chaines'

'ou les' + ' additioner'

['et', 'les'] + ['listes', 'aussi']

4 * '-00-'

4 * [1, 2]

dépendants du type¶

digression: tous les opérateurs du langage sont dépendants du type des opérandes

10 + 20

"10" + "20"

et comme on le verra, chaque type (y compris les classes qui sont des types définis par l’utilisateur) peut redéfinir le comportement des opérateurs

par exemple

• une classe Vector donnera du sens à v1 + v2

• une classe Path donnera du sens à path / file

quotient et reste // et %¶

• rappel division entière: quotient et reste: // et %

# avec des entiers
19 // 3

19 % 3

puissance **¶

• $x^y$ : x ** y

2 ** 100

opérateurs logiques¶

• opérateurs logiques: and - or - not

• opérateurs d’appartenance: in et not in

comparaison¶

• comparaison: == et is - déjà mentionnés

• négation: != et is not respectivement

• comparaisons dans espaces ordonnés:

  • >=, >, <=, <

  • curiosité: on peut les chainer

def est_moyenne(note):
    return 10 <= note <= 12

est_moyenne(11)

évaluation paresseuse (avancé)¶

• and et or sont opérateurs short-circuit

  • on évalue les opérandes de gauche à droite

  • et on s’arrête dès que le résultat est connu

• A and B

  • Si A est False,
    B ne sera pas évalué

• A or B

  • Si A est True,
    B ne sera pas évalué

# une fonction avec side-effect
counter = 0

def greater(a, b):
    global counter
    counter += 1 
    return a >= b

# ceci n'imprime rien
note = 11.5

if (greater(note, 10) and greater(note, 12)
    and greater(note, 14) and greater(note, 16)):
    print("excellent")

# ce qui intéressant, c'est 
# combien de fois on a appelé greater
counter

opérateurs bitwise¶

• opérateurs dits bitwise:

  • & - | : et et ou logique, respectivement

  • ^ : xor

  • ~ : not

• on les a aussi déjà rencontrés avec les ensembles

````{admonition} important pour pandas :class: attention

ça semble anecdotique, mais ces opérateurs sont super utilisés notamment en pandas !

```{code-cell} ipython3
:tags: [gridwidth-1-2]

a = 0b111100 
b = 0b110011
```

```{code-cell} ipython3
:tags: [gridwidth-1-2]

bin(a | b)
```

```{code-cell} ipython3
:tags: [gridwidth-1-2]

bin(a & b)
```

## POO : opérateurs redéfinis 

tous ces opérateurs peuvent être **redéfinis**

* c'est le propos des 'méthodes magiques' 
* que l'on verra à propos des classes
* exemple intéressant, la classe `Path`

+++ {"slideshow": {"slide_type": "slide"}}

### ex:  `/` sur la classe `Path`

```{code-cell} ipython3
# la classe Path nous a montré 
# un bel exemple d'opérateur redéfini 

from pathlib import Path
```

```{code-cell} ipython3
home = Path.home()

# l'opérateur / est défini sur Path
# et bien sûr ici CE N'EST PAS une division !

subdir = home / "git"

if subdir.exists():
    print(f"le répertoire {subdir} existe")
```