Cours

• d'opérateurs : +, *, // …
• de fonctions : len(), print() …
• ou de méthodes : .append(x), .upper() …

1. Les séquences

Exemple : x = "bonjour" ou x = [4, 6, 2, 7] ou x = (1, 7, 9).

• Une chaînes de caractères est encadrée par des doubles guillemets "..." ou des simples guillemets '...'.
• Une listes est encadrée par des crochets et ses éléments sont séparés par une virgule : [..., ..., ...].
• Un p-uples (ou tuples) est encadrés par des parenthèses et ses éléments sont séparés par une virgule : (..., ..., ...).

Opérations communes aux séquences

Dans le tableau suivant, x est une séquence (liste, tuple, chaîne de caractère ...).

Les chaînes de caractères

Dans le tableau suivant, x est une chaîne de caractère.

Les listes

En python, certains types de variables sont immuables. Ils ne peuvent être modifiés. Un nouvel objet (une nouvelle variable) doit être créé si une de ses valeurs doit être modifiées. C'est le cas des nombres (entiers et flottants), des chaînes de caractères et des p-uplets.

Les listes sont muables («mutable» en anglais) et permettent d'ajouter, de retirer, ou de réorganiser leurs éléments sur place au sein de l'objet. Il est alors inutile de définir une nouvelle variable si l'on souhaite apporter une modification.

Opérations sur les listes

Dans le tableau suivant, x est une liste.

Construire une liste par compréhension

[i for i in range(10)] génère une liste d'entier de 0 à 9. Cette instruction est équivalent à list(range(10)).
Exemple : a = [i*2 for i in range(5)]

Les p-uplets (ou tuples)

coord = (4, 2)  	# affectation du tuple (4, 2) à la variable coord

Affectation multiple

# affectation multiple :
a, b = 2, 3  		# a prend la valeur 2 et b la valeur 3
# échange de valeurs
b, a = a, b 		# a prend la valeur de b et b celle de a

Utilisation d'un tuple avec les fonctions

Pour le retour : Si une fonction a besoin de retourner plusieurs valeurs, il est possible de retourner un tuple. Dans ce cas, les parenthèses doivent/peuvent être omises. Il est alors possible d'utiliser plusieurs variables pour recevoir séparément les valeurs retournées par la fonction grâce à une affectation multiple, ou bien une seule variable qui sera alors un tuple.

def div_euclidienne(a, b):   # définition d'une fonction qui prend deux arguments
    return a//b, a%b         # et renvoi un tuple de deux valeurs (parenthèses omises)

arg = (10, 3)                # définition des arguments à donner à la fonction
x, y = div_euclidienne(*arg) # Affectation multiple du retour de la fonction
res = div_euclidienne(*arg)  # Affectation simple ()

print(x, type(x))
print(y, type(y))
print(res, type(res))

Les tableaux

# Création d'un tableau de 3 lignes et de 4 colonnes
# avec une liste de 3 listes contenant chacune 4 éléments
tab = [[0, 1, 1, 0],      # 1re ligne
       [1, 2, 2, 1],      # 2e ligne
       [3, 5, 5, 3]]      # 3e ligne

Accéder à un élément

a = tab[0][1]   # renvoi l'élément de la 1ère ligne et de la deuxième colonne

Créer un tableau par compréhension

[[0, 0, 0],
 [1, 1, 1]]

Parcourir un tableau

# Pour parcourir les valeurs
for ligne in tab:                  # parcourt les lignes du tableau, une à une
    for el in ligne:               # parcourt les éléments de la ligne, un par un

# Pour parcourir les valeurs avec leurs coordonnées
for y in range(len(tab)):          # y est l'indice de la ligne (en partant d'en haut)
    for x in range(len(tab[y])):   # x est l'indice de la colonne (en partant de la gauche)
        el = tab[y][x]             # el prend la valeur de la y-ième ligne et x-ième colonne

Les dictionnaires

Créer un dictionnaire

dico = {}                                 # crée un dictionnaire vide
dico = {"nom":"O'neill", "taille":1.76}   # crée un dictionnaire avec deux éléments :
                                          # une chaîne de caractère "O'neill" repéré par la clé "nom"
                                          # et un flottant 1.76 repéré par la clé "taille".
dico["prenom"] = "Jack"                   # ajoute la chaîne de caractère "Jack" avec la clé "prenom"

Obtenir la taille d'un dictionnaire (nombre d'éléments)

len(dico)			# renvoie le nombre d'élément dans le dictionnaire dico

Supprimer des éléments d'un dictionnaire

del dico["prenom"]        # supprime l'élément de la clé "prenom" du dictionnaire dico
b = dico.pop("taille")    # supprime l'élément de la clé "taille" du dictionnaire et affecte sa valeur à la variable b

Accéder aux éléments d'un dictionnaire

dico = {"taille":1.73, "masse":70}
dico["taille"]      # récupère la valeur de la clé "taille" du dictionnaire
dico.keys()         # renvoie une séquence avec les clés du dictionnaire : ["taille", "masse"]
dico.values()       # renvoie une séquence avec les valeurs du dictionnaire : [1.73, 70]
dico.items()        # renvoie une séquence de tuple (clé, valeur) : [("taille", 1.73), ("masse", 70)]
for cle, val in dico.items(): # boucle sur les clés et les valeurs
for val in dico.values():     # boucle sur les valeurs
for cle in dico:              # boucle sur les clés (équivalent à for cle in dico.keys():)
if "prenom" in dico	:         # vérifie la présence de la clé "prenom" dans le dictionnaire : False
if not "prenom" in dico	:     # vérifie l'absence de la clé "prenom" dans le dictionnaire : True

Dictionnaire de fonctions

def ma_fonction() :             # définition d'une fonction appelée ma_fonction
    print("Hello world!")       # qui écrit "Hello world!" dans la console

dico = {"saluer":ma_fonction}   # creation d'un dictionnaire contenant la fonction
dico["saluer"]()                # appel de la fonction ma_fonction

Convertir une liste de tuples en dictionnaire et inversement

liste = [("a",1), ("b",2)]    # définition d'une liste de tuples (clé, valeur)
dict(liste)                   # conversion en dictionnaire

dico = {"a":1, "b":2}         # EN SENS INVERSE : définition d'un dictionnaire
list(dico.items())            # conversion en liste de tuples (clé, valeur)

Utilisation d'un dictionnaire pour passer des arguments à une fonction

def div_eucl(a, b):     # définition d'une fonction qui prend deux arguments
    return a//b, a%b    # et renvoi un tuple de deux valeurs

arg = {"b":3, "a":10}   # définition des arguments nommés à donner à la fonction
div_eucl(**arg)         # appel de la fonction avec les arguments nommés du dictionnaire

Variables, alias, valeurs et références

a = [1, 2, 3]
b = a

print(id(a))
print(id(b))
print(a is b)

a[0] = 5
print(b[0])

a = [1, 2, 3]     # Création d'un objet liste. Sa référence (identifiant) est stockée dans a
b = a             # Création d'un alias pointant vers le même objet liste

print(id(a))      # a et b ont la même référence (identifiant)
print(id(b))
print(a is b)     # ils s'agit du même objet

a[0] = 5          # si on modifie une valeur dans la liste en utilisant l'alias a,
print(b[0])       # puisque c'est le même objet, elle est aussi modifiée en passant par l'alias b

b = a.copy()
b = a[::]

a = [[1, 2], 3]
b = a.copy()
a[1] = 100
a[0][0] = 200
print(b)          # affiche [[200, 2], 3]

from copy import deepcopy

a = [[1, 2], 3]
b = deepcopy(a)
a[1] = 100
a[0][0] = 200
print(b)          # affiche [[1, 2], 3]