Écrire du code python

On va lister les concepts fondamentaux qui permettent d'écrire du code python que l'on pourra faire exécuter par l'interpréteur python. Ces concepts sont identiques pour tous (ou quasi tous) les langages de programmation objet.

>>> 21 * 2
42

x = 21 * 2
print(x)

• Dans Spyder, la console est une console Ipython, elle ne commence donc pas par >>> mais par In suivi d'un numéro entre crochet, par exemple : In [42]. Son fonctionnement est cependant identique.
• pour exécuter du code avec spyder, on utilise soit :
  • le triangle vert sur l'interface
  • le menu run > run
  • F5

Commentaires

Commençons par ne pas écrire du python. Dans une ligne de code python, tout ce qui suit un # n'est pas lu.

Par exemple, le code suivant écrit dans une console ne produit pas d'erreur (il n'est même pas lu...) :

>>> # coucou python !

Alors que le même code sans # est interprété par python et comme ce n'est pas du python cela produit une erreur :

>>> coucou python !
  File "<stdin>", line 1
    coucou python !
           ^
SyntaxError: invalid syntax

Objets

Les objets de python correspondent à tout ce qui est manipulé : le but d'un programme python est de créer et de rendre des objets.

Types d'objets

Python connaît 6 types d'objets de base qui permettent de faire la grande majorité des programmes.

• Chaînes de caractères
  • exemple : "python" ou 'python'
  • quelque chose qui commence et fini par " ou qui commence et fini par ' ou encore qui commence et fini par """.
• Réels
  • exemple : 2.91 ou 2.0
  • un nombre avec une décimale (qui peut être nulle) notée par un .
• Entiers
  • exemple : 42 ou 0
  • un nombre sans décimale
• Complexes (la notation utilise j à la place de i)
  • exemple : 3+2j, 1j
  • un réel ou entier avec une partie imaginaire, notée j, entière ou imaginaire.
• Booléens
  • exemple : True ou False
  • que 2 possibilités, True ou False
• le vide, utilisé pour noter l'absence de valeur
  • ne contient qu'un unique élément noté None

Pour connaître le type d'un objet, on peut utiliser la fonction type. Par exemple :

>>> type(42)
<class 'int'>

Les entiers sont donc de type class 'int', ce que l'on traduit par : l'entier 42 est objet de la classe entier :

À vous :

>>> type("2")
<class 'str'>
>>> type(2.0)
<class 'float'>
>>> type(2)
<class 'int'>
>>> type(2+0j)
<class 'complex'>
>>> type(True)
<class 'bool'>

Conversion de type

Le type d'un objet n'est pas modifiable : par exemple un entier (3) n'est pas un réel (3.0) et réciproquement. Il est en revanche possible de créer un nouvel objet du type choisi à partir d'un objet d'un autre type. Pr exemple pour créer un objet te type réel depuis un entier 3, on peut écrire : float(3). Ceci se généralise :

<un type>(<un objet>)

On ne peut bien sur pas faire n'importe quoi int("deux") ne crée pas un entier valant 2, mais beaucoup des choses sont possibles.

Conversion entre réels, entiers et chaînes de caractères

On peut par exemple transformer un réel en entier :

int(3.1415)

>>> int(3.1415)
3

Ou en entier en réel :

float(3)

>>> float(3)
3.0

On peut aussi transformer une chaîne de caractères en entier ou en réel. Par exemple :

float("3.1415")

Va rendre un objet réel valant 3.1415 à partir d'une chaîne de caractère avec le caractère "3.1415".

La conversion de chaînes de caractères en entier ou en réel est très courante lorsque l'on récupère des entrées tapées par un utilisateur. jen effet :

Conversion de booléens

On effectue souvent ce genre d'opération de façon implicite pour les booléens. Ainsi, un entier est vrai s'il est non nul.

>>> bool(42)
True
>>> bool(0)
False

>>> bool(-42)
True

Tous les objets peuvent être converti sen booléen.

>>> bool("")
False
>>> bool("False")
True

On peut aussi faire le contraire :

>>> int(True)
1
>>> int(False)
0

Variables

Les variables permettent à l'interpréteur de se rappeler d'objets qu'il a crée lors d'exécutions précédentes. Sans elles, on ne pourrait exécuter que des lignes indépendantes les unes entre elles : bref, on ne pourrait rien faire d'intéressant.

Affecter une variable

<un nom> = <un objet>

A gauche de l’opérateur d'affection = se trouve une variable (en gros, un nom ne pouvant commencer par un nombre) et à droite un objet. Après affectation, dans toute la suite du programme l'interpréteur python remplacera la variable par l'objet à chaque fois qu'elle la rencontrera.

Il est important de comprendre que l’opérateur d’affectation = n’est pas symétrique. À gauche, des variables et à droite, des objets.

Attardons nous un moment sur le processus d'affectation car il est seront crucial pour appréhender les possibilités offertes par les objets.

Considérons le programme suivant :

x = 1
y = 1
y = 3

Et regardons ce qu'il se passe au niveaux des variables et des objets après chaque instruction.

Au départ, avant l'exécution par l'interpréteur de la première ligne le programme ne possède aucune variable ni aucun objet. On possède cependant deux espaces distincts pour les accueillir :

Après l'exécution de la ligne 1, nous sommes dans la situation suivante :

La variable de nom x est affectée à un objet entier valant 1. Notez bien que la variable et l'objet sont deux choses différentes et sont uniquement mis en relation par la flèche. De plus :

L'exécution de la deuxième instruction procède de la même manière, à l'issue de celle-ci on se trouve dans l'état suivant :

Notez bien que les objets mis en relations ne sont pas les mêmes, ce sont deux objets de type entier valant 1.

L'instruction de la ligne 3 est identique aux deux précédentes : on associe un objet à une variable. Que cette variables était précédemment n'a pas d'importance : on l'associe à l'objet à droite de l'opérateur d'affectation = :

L'objet précédemment assigné à y n'est plus associé à aucune variable : il n'y a plus aucun moyen d'y acceder. Ces objets non assignés sont supprimés à intervalles réguliers (c’est ce qu’on appelle le garbage collector).

Le même mécanisme est à l'oeuvre si on a une variable à droite de l'opérateur d'affectation =. Considérons le programme suivant :

x = 1
y = 1
y = x

L'instruction de la ligne 3 commence par trouver l'objet à droite de l'opérateur d'affectation = via la variable : c'est l'objet et non la variable qui est associé. Une fois l'objet trouvé, il est assigné à la variable à gauche de l'opérateur d'assignation = :

Pour exécuter une instruction, on commence toujours par remplacer les variables par les objets qu'elles référencent.

Ce mécanisme d'affectation est puissant, il permet par exemple d'affecter plusieurs variables en même temps, comme le montre l’exemple suivant qui échange les objets des noms i et j :

x = 2
y = 3
x, y = y, x

Enfin, il est possible d'affecter plusieurs noms à un même objet. Par exemple l'exemple suivant affecte le même entier 1 aux noms x et y :

x = y = 1

Supprimer une variable

On peut supprimer un nom en utilisant le mot clé del.

Dans une console :

>>> x = 2
>>> print(x)
2
>>> del x
>>> print(x)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'x' is not defined

Notez bien que seule la variable est supprimée, pas l'objet associé. Considérons par exemple le code suivant, qui affecte le même objet aux variables x et y :

>>> x = 1
>>> y = x

Si on supprime la variable x cela ne supprime pas l'objet (il est aussi affecté à la variable y) :

>>> del x
>>> y
1

L'objet est toujours associé au nom y. Supprimons ce nom :

>>> del y

L'objet n'est plus accessible !

Python utilise un mécanisme nommé ramasse-miettes qui supprime les objets qui ne sont plus accessible via des noms, ce qui permet de gagner de la place mémoire. Une fois le ramasse-miettes passé on se retrouve alors dans l'état :

À vous (certains exercices sont liés : utilisez toujours le même interpréteur) :

>>> a=3
>>> print(a)
3

>>> a=6
>>> print(a)
6

>>> A = 2
>>> print(a)
6
>>> print(A)
2

>>> b = 4
>>> c = (a + b)/2
>>> print(b)
4
>>> print(c)
5.0

>>> i, j = 3, 12

>>> x = y = z = 3

Opérations sur les objets

Créer de nouveaux objets avec d'autres objets. Les opérations sur les objets vont des opérations arithmétiques (a + b, a - b, ...) aux tests (a < b) en passant par les opérations logiques (a et b).

Nombres

Les opérations peuvent s'effectuer sur les trois types numériques que sont les entier (classe int), les réels (classe float) et les complexes (classe complex)

Opérateurs

Outre les classiques opérations :

• + (addition)
• - (soustraction)
• / (division)
• * (multiplication)

python possède aussi :

• // division entière
• % reste de la division entière
• ** exposant.

>>> 4538 // 23
197
>>> 4538 % 23
7
>>> (4538 // 23) * 23 + 7
4538

Raccourcis d'affectation

Python permet aussi de faire l'opération et de procéder immédiatement à sa réaffectation avec les opérateurs :

• x += 1 est équivalent à x = x + 1
• x -= 1 est équivalent à x = x - 1
• x /= 3 est équivalent à x = x / 3
• x *= 2 est équivalent à x = x * 2

Chaînes de caractères

Trois opérateur sont courants pour les chaînes de caractères :

• la concaténation avec l'opérateur +
• la multiplication avec l'opérateur *
• test de présence avec l'opérateur in

Concatenation et multiplication

Les chaînes de caractères possèdent 2 opérateurs :

• l'addition qui concatène deux chaînes
• la multiplication d'un entier $i$ par une chaîne $c$ qui concatène $i$ fois $c$ à elle même.

Par exemple :

>>> "x" + "y"
'xy'
>>> 3 * "x"
'xxx'

>>> 10 * "J'aime bien faire du python. "
"J'aime bien faire du python. J'aime bien faire du python. J'aime bien faire du python. J'aime bien faire du python. J'aime bien faire du python. J'aime bien faire du python. J'aime bien faire du python. J'aime bien faire du python. J'aime bien faire du python. J'aime bien faire du python. "

>>> x = "J'aime bien faire du"
>>> x += " python."
>>> print(x)
J'aime bien faire du python.

Test de présence

Une chaîne de caractère peut être vue comme un conteneur (ordonné) de caractères. Savoir si un caractère ou une sous-chaîne est présent dans une chaîne peut se faire alors avec l'opérateur in, qui rend un booléen :

• "c" in "coucou" rendra True
• "cou" in "coucou" rendra True
• "cc" in "coucou" rendra False

Booléens

Comparaisons

Comparateurs classiques :

• < : strictement plus petit
• <= : plus petit ou égal
• > : strictement plus grand
• >= : plus grand ou égal
• == : égal
• != : différent
• is : égalité d'objets (en pratique uniquement utilisé pour comparer à None)

Les comparaisons rendent un booléen. Par exemple : 2 <= 3 rend le booléen True.

Opérations logiques

• not : négation
• or : ou logique
• and : et logique

Notez que les opérateurs logiques s'appliquent à tous les objets, python va comparer leurs représentations sous la forme de booléen. Par exemple not 2 va rendre True (l'entier 2 est True représenté comme un booléen).

De même, les opérateurs or et and vont rendre des objets comparé, dont les représentation binaires correspondent aux opérateurs logiques :

• x or y rendra :
  • x si la représentation sous la forme d'un booléen de de x est True
  • y si la représentation sous la forme d'un booléen de de x est False
• x and y rendra :
  • y si la représentation sous la forme d'un booléen de de x est True
  • x si la représentation sous la forme d'un booléen de de x est False

Cela ne change rien à l'utilisation classique des opérations logiques puisque la représentation sous forme de booléen de l'objet rendu est conforme à ce qu'on attend :

• True si un des deux paramètres est considéré comme vrai pour or, False sinon.
• True si un des les deux paramètres sont considérés comme vrai pour and, False sinon.

Immutabilité des objets

Notez que tous les objets basique de python sont non modifiables. Ainsi, si x = 41, on est dans la situation suivante :

En incrémentant x :

x = x + 1

On crée un nouvel objet (un entier valant 42) et l'ancien objet qui n'est plus accessible va disparaître sous l'action du ramasse-miettes :

Fonctions

Une fonction est un type d'objet pouvant être exécuté. Par exemple la fonction print.

C'est un objet :

>>> type(print)
<class 'builtin_function_or_method'>

<nom de la fonction>()

Par exemple :

>>> print()

>>> 

Va exécuter la fonction print de python qui affiche à l'écran le caractère retour à la ligne ce qui a pour effet d'aller à la ligne.

<nom de la fonction>(<paramètre 1>, <paramètre 2>, ..., <paramètre n>)

Prenons par exemple la fonction print de python :

>>> print("coucou", "les gens", "!")
coucou les gens !

L'exécution de la fonction print avec les trois paramètres "coucou", "les gens" et "!" affichera à l'écran les 3 paramètres espacé d'un caractère (séparé par un caractère espace " ") puis ira à la ligne.

Toutes les fonctions de python sont documentées. On peut y accéder :

• via le site de python. L'aide de la fonction print est là : https://docs.python.org/fr/3/library/functions.html#print
• en console en utilisant la fonction help : help(print) donne l'aide de print

>>> help(print)
Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

Les fonctions sont des objets pouvant être exécutés, c'est à dire que faire suivre l'objet de parenthèses va effectuer une action. Tout comme pour les variables, le nom de la fonction n'est qu'un moyen d'y accéder. On peut par exemple tout à fait écrire :

>>> écrire = print
>>> écrire("coucou")
coucou
>>>

Retour de fonction

L'exécution de toute fonction va retourner un objet.

<nom de variable> = <nom de la fonction>(<paramètre 1>, <paramètre 2>, ..., <paramètre n>)

C'est parfois utile (comme abs) :

>>> x = abs(-10)
>>> print(x)
10

Parfois inutile (comme avec la fonction print) et dans ce cas là on a coutume de renvoyer l'objet vide, None :

>>> x = print("coucou")
coucou
>>> print(x)
None

Notez bien que l'exécution de la fonction print qui affiche quelque chose à l'écran (ici coucou) est différent de son résultat (ici None)

Enfin, comme ici on exécute notre code directement dans l'interpréteur python, le résultat de chaque fonction est également affiché à l'écran, sauf :

• si l'instruction est une affectation (c'est pour ça que l'interpréteur n'affiche pas -10 après l'instruction x = abs(-10) alors qu'il l'affiche après l'instruction abs(-10))
• si le résultat est None (c'est pour ça que l'interpréteur n'affiche rien après l'instruction None ni après après avoir affiché coucou après l'exécution de la fonction print("coucou"))

Paramètres d'une fonction

En regardant la documentation de la fonction print, on remarque que les premiers paramètres sont sans noms (value, ...) puis les paramètres ont des noms (sep, end, file, flush) suivi d'une valeur. Ce sont des paramètres qui ont une valeur par défaut (par défaut sep vaut " ").

On cependant bien sur utiliser, en le nommant, un paramètre ayant une valeur par défaut :

>>> print("coucou", "les gens", "!", sep="***")
coucou***les gens***!

Expérimentons ça sur un exercice.

Nom d'une classe comme fonction

int, float, complex, str et bool permettent de créer des objets du nom du type. Ces classes peuvent être exécutées.

On a déjà vu cette possibilité dans la partie objets types et types d'objets, c'est très utile pour changer un objet de classe. Mais utilisons ce qu'on a vu maintenant pour aller plus loin :

>>> int("1001100011", base=2)
611

Allez, un dernier pour la route :

>>> len(str(2 ** 11213 - 1))
3376

Fonctions usuelles

Certaines sont plus utiles que d'autres. Nous allons en citer certaines, parmi les plus utilisées.

Fonction print

Affiche à l'écran ses paramètres.

Fonction type

Donne le type d'un objet.

Fonction len

Rend le nombre d'éléments d'une chaîne de caractères (et plus généralement d'un conteneur que l'on verra plus tard).

>>> len("anticonstitutionnellement")
25

Fonction input

Permet de demander une chaîne de caractère à un utilisateur. Par exemple :

>>> x = input()
23
>>> x
'23'

On demande à l'utilisateur de taper quelque chose puis d'appuyer sur la touche entrée. Ce qu'à taper l'utilisateur est rendu sous la forme d'une chaîne de caractère.

Méthodes

Les méthodes sont un autre moyen d'agir sur un objet :

<retour de la méthode> = <un objet>.<nom de la méthode>(<paramètre 1>, <paramètre 2>, ..., <paramètre n>)

Prenez le temps de regarder les différentes méthodes des classes de base de python. Souvent elle vous permettent de faire rapidement une opération compliquée. C'est en particulier vrai pour les chaînes de caractères et les listes.

Certaines méthodes vont rendre des objets utiles (comme les méthodes de chaîne de caractères), d'autre vont modifier les objets appelants et leur retour sera None (comme beaucoup de méthodes de liste que l'on verra bientôt).

Exemple : méthodes des chaînes de caractères

Chaque classe vient avec ses méthodes. Si les nombres et les booléens ont peu de méthodes, les chaines de caractères par exemple en ont tout un tas.

Essayons de les apprendre avec ces petits exercices :

>>> x = str(2 ** 11213 - 1)

>>> x.count("0")
348

>>> y = int(x.replace("2", "7"))

>>> mot.count("ou")
2
>>> mot.index("e")
9
>>> mot.rindex("e")
16

On peut chaîner les méthodes, la sortie d'une méthode devenant l'entrée de la prochaine. Par exemple, avec 2 méthodes :

<un objet>.<nom de la méthode 1>().<nom de la méthode 2>()

Signifie que <nom de la méthode 2> est appliquée à l'objet rendu par l'exécution de <nom de la méthode 2> sur <un objet>.

<un objet>.<nom de la méthode 1>().<nom de la méthode 2>()

(<un objet>.<nom de la méthode 1>()).<nom de la méthode 2>()

Ceci se généralise avec $n$ méthodes :

<un objet>.<nom de la méthode 1>().<nom de la méthode 2>(). ... .<nom de la méthode n>()

La méthode <nom de la méthode n> est appliquée au résultat de <un objet>.<nom de la méthode 1>().<nom de la méthode 2>(). ... .<nom de la méthode n-1>()

str(2 ** 11213 - 1).replace("2","x").replace("7","2").replace("x","7")

((str(2 ** 11213 - 1).replace("2","x")).replace("7","2")).replace("x","7")

Fonctions vs. méthodes

Ne confondez pas fonctions et méthodes. Une fonction s'exécute toute seule alors qu'une méthode a besoin d'un objet sur lequel elle s'applique (celui avant le .). Vous pouvez voir ça comme un 1er paramètre indispensable à l'exécution d'une méthode. Considérez le programme suivant :

>>> ma_chaîne = "coucou !"
>>> en_majuscules = ma_chaîne.upper()
>>> print(en_majuscules)
COUCOU !

La première ligne crée une chaîne de caractères. La seconde instruction est une méthode (upper) qui s'applique à l'objet de nom ma_chaîne et qui n'a pas de paramètre.

Attributs d'un objet

C'est plus rare, mais certaines classes possèdent des également des attributs en plus des méthodes.

<retour de la méthode> = <un objet>.<nom de l'attribut>

Ce sont des valeurs associées à l'objet.

Par exemple les objets de la classe complex qui possède les attributs real et imag pour rendre la partie réelle et imaginaire d'un complexe.

>>> (1+2j).real
1.0
>>> (1+2j).imag
2.0

Les attributs d'un complexes sont en lecture seule, ce sont des variables que l'on peut lire mais qu'on ne peut pas affecter :

>>> x = 3 + 2j
>>> x.real
3.0
>>> x.real = 12
Traceback (most recent call last):
  File "<python-input-10>", line 1, in <module>
    x.real = 12
    ^^^^^^
AttributeError: readonly attribute