Bases de Python

Commentaires

Les commentaires sont ajoutés grâce au caractère #.

# Ceci est un commentaire.
x = 2  # Ceci est aussi un commentaire.

Affichage à la console

La fonction print permet d'afficher une valeur dans la console. La fonction prend en argument la valeur à afficher.

print("Hello World !")  # Affiche Hello World !.
print(1 + 1)  # Affiche 2.

Types de données

Opérateurs

Opérations arithmétiques

Opérations de comparaison

Opérations booléennes

Variables

On utilise le signe = pour assigner une valeur à une variable.

x = 3 + 4

Dans une expression, une variable a pour valeur la dernière valeur qui lui a été assignée.

x = 3 + 4
print(x)  # Affiche 7.

À noter qu'il est possible d'assigner une variable plusieurs fois, et même de faire référence à la valeur courante d'une variable pour déterminer la valeur à affecter.

x = 3 + 4
x = x + 1
print(x)  # Affiche 8.

Raccourci de notation

Souvent, on se retrouve à assigner à une variable une valeur qui est simplement le résultat d'une opération sur la valeur courrante et un autre argument. Par exemple :

x = x + 1
y = y // 2

Dans ce genre de cas, il est possible d'utiliser un raccourci de notation :

x += 1
y //= 2

Structures de contrôle

Si

La structure if permet d'exécuter des instructions uniquement lorsqu'une expression de condition évalue à True.

if x == 1:
    x += 1
    print(x)

Il est possible d'utiliser le mot clé else pour indiquer les instructions à effectuer dans le cas contraire :

if x % 2 == 0:
    x //= 2
else:
    x *= 3
    x += 1

Le mot clé elif permet de tester une autre condition en cas d'échec des conditions précédentes :

if langue == "fr":
    print("Bonjour !")
elif langue == "en":
    print("Hello!")
elif langue == "de":
    print("Guten Tag!")
elif langue == "it":
    print("Buongiorno!")
else:
    print("???")

Tant que

La boucle while permet d'exécuter en boucle un bloc d'instruction tant qu'une condition est vraie. Entre chaque exécution du bloc, la condition est réévaluée: en cas de valeur True la boucle continue, en cas de valeur False la boucle se termine.

# Affiche les entiers de 100 à 1.
x = 100
while x > 0:
    print(x)
    x -= 1

Si initialement la condition est fausse, alors aucune itération n'est effectuée.

# N'affiche rien du tout.
x = -4
while x > 0:
    print(x)
    x -= 1

Lorsque que la condition de la boucle while est toujours vraie, la boucle s'exécute sans arrêt. On parle dans ce cas de boucle infinie.

# Affiche Encore ! en boucle.
while True:
    print("Encore !")

Pour stopper l'exécution d'un programme pris dans une boucle infinie, il est possible d'utiliser la combinaison de touches ctrl-c.

Pour tout

La boucle for peut être utilisée pour exécuter un bloc d'instruction pour chaque entier compris entre 0 et une borne supérieure. Le bloc est exécuté pour la borne inférieure (ici 0), mais pas pour la borne supérieure.

# Affiche les nombres de 0 (compris) à 10 (non compris).
for i in range(10):
    print(i)

Il est aussi possible de donner une valeur à la borne inférieure.

# Affiche les nombres de 10 (compris) à 20 (non compris).
for j in range(10, 20):
    print(j)

La boucle for peut aussi être utilisée pour parcourir tous les éléments d'une liste.

animaux = ["Chiens", "Chats", "Tortues", "Hamsters"]
for animal in animaux:
    print(animal)

Fonctions

Il est possible de définir ses propres fonctions en faisant appel au mot clé def. Lors de la définition de fonction, on indique aussi les paramètres de la fonction.

def dit_bonjour(prenom, poli):
    if poli:
        print("Bonjour " + prenom + " !")
    else:
        print("Yo !")

La fonction contient une série d'instructions qui seront exécutée à l'appel de la fonction. Lors de l'appel de la fonction, chaque paramètre est renseigné :

# Affiche Bonjour Amélie !
dit_bonjour("Amélie", True)

# Affiche Yo !
dit_bonjour("Bruno", False)

La fonction peut contenir une instruction return, qui termine immédiatement l'exécution de la fonction et indique la valeur de retour.

def valeur_absolue(x):
    if x < 0:
        return -x
    else:
        return x

La valeur de retour détermine la valeur l'appel de la fonction dans l'expression dans laquelle elle apparaît.

# Affiche 6.
print(valeur_absolue(-4) + 2)

Modules

On utilise les mots clés from et import pour importer des définitions d'un module.

from state import play

Il est aussi possible d'importer toutes les définitions d'un module sans les lister explicitement.

from state import *

Il est aussi possible d'utiliser import seul. Dans ce cas, les définitions issues du modules doivent être référée en les préfixant du nom du module suivant d'un point (.).

import sys
# Quitte le programme.
sys.exit(0)

Séquences

Les chaînes de caractères, les listes et les tuples représentent des séquences de valeur.

Longueur

La longueur d'une séquence s'obtient grâce à la fonction len.

coords = (4, 5)
print(len(coords))  # Affiche 2.

animaux = ["Chiens", "Chats", "Tortues", "Hamsters"]
print(len(animaux))  # Affiche 4.

message = "Bonjour !"
print(len(message))  # Affiche 8.

Indexation

Il est possible de faire référence à une certaine valeur dans la séquence via son index. Le premier index est 0, le dernier correspond à la taille de la séquence moins 1.

animaux = ["Chiens", "Chats", "Tortues", "Hamsters"]

animal_prefere = animaux[1]

print(animal_prefere)  # Affiche Chats.
print(animal_prefere[0])  # Affiche C.

Pour les listes (mais pas pour les chaînes de caractères ni pour les tuples), il est possible de réassigner la valeur contenue à un certain index.

animaux = ["Chiens", "Chats", "Tortues", "Hamsters"]

animaux[3] = "Lapins"

print(animaux[0])  # Affiche Chiens.
print(animaux[3])  # Affiche Lapins.

Agrégation

Il existe de nombreuses méthodes disponibles de base en Python pour agréger une séquence de valeurs en une unique valeur. Un tableau des plus courantes est donné ci-dessous.

Programmation orientée objet

Définition d'une classe

Pour définir une classe, on utilise le mot-clé class, suivi du nom de la classe. Enfin, on indique la classe de base entre parenthèse. Dans notre cas, il s'agira souvent de object. Considérez l'exemple suivant d'une classe en Python. La classe représente une porte, qui peut être ouverte ou fermée.

class Door(object):
   
   def __init__(self, closed):
       self.closed = closed
   
   def set_closed(self, closed):
       self.closed = closed
       
   def is_closed(self):
       return self.closed
   
   def open(self):
       self.closed = False
   
   def close(self):
       self.closed = True

Méthodes

Le corps de la classe consiste en des définitions de méthodes. Le premier paramètre de chaque méthode fait toujours référence à l'objet sur lequel la méthode est appelée. Par convention, on nomme ce paramètre self.

Constructeur

La méthode __init__ est une méthode magique de Python. Elle est appelée automatiquement à la construction de l'objet. On parle généralement du constructeur de la classe.

Champs

Dans les méthodes (et même en dehors) il est possible de lire ou de modifier les champs de l'objet, c'est-à-dire des variables stockées dans l'objet. Pour cela, on fait référence à l'objet (généralement self dans le contexte d'une méthode), on continue par un point (.) et finalement on note le nom du champ.

Utilisation d'une classe

Pour utiliser une classe, on instancie des objets issus de la classe. Pour cela, on appelle la classe comme une fonction. Comme arguments, on note ce qui sera passé aux paramètres du constructeur (sans le self).

# Crée une porte ouverte
my_door = Door(False)

# Crée une seconde porte, fermée cette fois
my_other_door = Door(True)

Une classe peut être instanciée à multiple reprise et chaque instance (chaque objet) a ses propres champs.

Appel de méthodes

Pour appeler une méthode d'un objet, on fait référence à l'objet, suivi d'un point (.), suivi du nom de la méthode et des arguments.

print(my_door.is_closed())
my_door.set_closed(True)
print(my_door.is_closed())

Les appels de méthodes peuvent changer l'état interne d'un objet, c'est-à-dire la valeur de ses champs.

Accès au champs

En Python, les champs d'un objet sont aussi accessible directement depuis l'extérieur de la classe.

print(my_door.closed)

Par convention, on utilise un underscore _ au début du nom d'un champ qui n'est pas sensé être accédé directement depuis l'extérieur de sa classe.