Version du 19 mars 2020 à 13:07

(Opérateurs:Magenta)
(Méthodes:Green)
(Fonctions:Red)

Accueil
Connexion
Déconnexion
Aide
Admin

• Python
  • INDEX
  • Initiation
  • Programmation objet
  • Perfectionnement
  • En pratique

Réferences:
Doctor Python
Pythonnerie
sdz.tdct.org
Python en ligne

Python

Les bases

Les variables par l'exemple

• Affectons une valeur à la variable age

1 >>> age = 30
2 >>> age
3 30

• On va ensuite ajouter 10 à la valeur de cette variable

1 >>> age = 30
2 >>> age = age + 10
3 >>> age
4 40

• Il est possible de mettre une variable dans une autre variable.

1 >>> age = 30
2 >>> age2 = age
3 >>> age2
4 30

• On peut mettre à peu près tout ce qu'on veut dans la variable, y compris du texte:

1 >>> age = "J'ai 30 ans"
2 >>> age
3 "J'ai 30 ans"

• Il est possible de concaténer, c'est à dire d'ajouter du texte à du texte:

1 >>> age = age + " et je suis encore jeune!"
2 >>> age
3 "J'ai 30 ans et je suis encore jeune!"

• On peut même multiplier une chaine de caractères.

1 >>> age = "jeune"
2 >>> age * 3
3 'jeunejeunejeune'

• Evidemment, si on essaie de faire des additions avec des variables qui sont des chiffres et d'autres qui sont du texte, l'interpréteur va hurler

1 >>> age = "J'ai 30 ans"
2 >>> age
3 "J'ai 30 ans"
4 >>> age + 1
5 Traceback (most recent call last):
6   File "<stdin>", line 1, in <module>
7 TypeError: cannot concatenate 'str' and 'int' objects

• On remarquera que l'interpréteur est sympa puisqu'il dit ce qui ne va pas: Il ne peut pas concaténer str et int .

Les listes

• Les listes (ou list / array ) en python sont une variable dans laquelle on peut mettre plusieurs variables.

Créer une liste en python

1  >>> liste = []

Voir le contenu de la liste en l'appelant

1  >>> liste
2  <type 'list'>

Ajouter une valeur à une liste python

1  >>> liste = [1,2,3]
2  >>> liste
3  [1, 2, 3]

Ajouter après la création de la liste

méthode append

1  >>> liste = []
2  >>> liste
3  []
4  >>> liste.append(1)
5  >>> liste
6  [1]
7  >>> liste.append("ok")
8  >>> liste
9  [1, 'ok']

• Il est possible de mélanger dans une même liste des variables de type différent. On peut d'ailleurs mettre une liste dans une liste.

Afficher un item d'une liste

1  >>> liste = ["a","d","m"]
2  >>> liste[0]
3  'a'
4  >>> liste[2]
5  'm'

Modifier une valeur avec son index

1  >>> liste = ["a","d","m"]
2  >>> liste[0]
3  'a'
4  >>> liste[2]
5  'm'
6  >>> liste[2] = "z"
7  >>> liste
8  ['a', 'd', 'z']

Supprimer une entrée avec un index

• Fonction del .

1  >>> liste = ["a", "b", "c"]
2  >>> del liste[1]
3  >>> liste
4  ['a', 'c']

Supprimer une entrée avec sa valeur

• Supprimer une entrée d'une liste avec sa valeur avec la méthode remove .

1  >>> liste = ["a", "b", "c"]
2  >>> liste.remove("a")
3  >>> liste
4  ['b', 'c']

Inverser les valeurs d'une liste

• Inverser les items d'une liste avec la méthode reverse .

1  >>> liste = ["a", "b", "c"]
2  >>> liste.reverse()
3  >>> liste
4  ['c', 'b', 'a']

Compter le nombre d'items d'une liste

Il est possible de compter le nombre d'items d'une liste avec la fonction len .

1  >>> liste = [1,2,3,5,10]
2  >>> len(liste)
3  5

Compter le nombre d'occurences d'une valeur

• Méthode count .

1  >>> liste = ["a","a","a","b","c","c"]
2  >>> liste.count("a")
3  3
4  >>> liste.count("c")
5  2

Trouver l'index d'une valeur

• méthode index.

1  >>> liste = ["a","a","a","b","c","c"]
2  >>> liste.index("b")
3  3

Manipuler une liste

 1  >>> liste = [1, 10, 100, 250, 500]
 2  >>> liste[0]
 3  1
 4  >>> liste[-1] # Cherche la dernière occurence
 5  500
 6  >>> liste[-4:] # Affiche les 4 dernières occurrences
 7  [500, 250, 100, 10]
 8  >>> liste[:] # Affiche toutes les occurences
 9  [1, 10, 100, 250, 500]
10  >>> liste[2:4] = [69, 70]
11  [1, 10, 69, 70, 500]
12  >>> liste[:] = [] # vide la liste
13  []

Boucler sur une liste

• Pour afficher les valeurs d'une liste, on peut utiliser une boucle:

1  >>> liste = ["a","d","m"]
2  >>> for lettre in liste:
3  ...     print lettre
4  ... 
5  a
6  d
7  m

• Pour récupérer l'index, utiliser la fonction enumerate .

1  >>> for lettre in enumerate(liste):
2  ...     print lettre
3  ... 
4  (0, 'a')
5  (1, 'd')
6  (2, 'm')

Les valeurs retournées par la boucle sont des tuples.

Copier une liste

• Beaucoup de débutants font l'erreur de copier une liste de cette manière

1  >>> x = [1,2,3]
2  >>> y = x

• Or si on change une valeur de la liste y , la liste x sera elle aussi affectée par cette modification:

1  >>> x = [1,2,3]
2  >>> y = x
3  >>> y[0] = 4
4  >>> x
5  [4, 2, 3]

• En fait cette syntaxe permet de travailler sur un même élément nommé différemment

• Alors comment copier une liste qui sera indépendante?

1  >>> x = [1,2,3]
2  >>> y = x[:]
3  >>> y[0] = 9
4  >>> x
5  [1, 2, 3]
6  >>> y
7  [9, 2, 3]

• Pour des données plus complexes, utiliser la fonction deepcopy du module copy

1  >>> import copy
2  >>> x = [[1,2], 2]
3  >>> y = copy.deepcopy(x)
4  >>> y[1] = [1,2,3]
5  >>> x
6  [[1, 2], 2]
7  >>> y
8  [[1, 2], [1, 2, 3]]

Transformer une string en liste

• Transformer une chaine de caractère en liste. Méthode split .

1  >>> ma_chaine = "Olivier:ENGEL:Strasbourg"
2  >>> ma_chaine.split(":")
3  ['Olivier', 'ENGEL', 'Strasbourg']

Transformer une liste en string

• Méthode " join ".

1  >>> liste = ["Olivier","ENGEL","Strasbourg"]
2  >>> ":".join(liste)
3  'Olivier:ENGEL:Strasbourg'

Trouver un item dans une liste

• Pour savoir si un élément est dans une liste, utiliser le mot clé in de cette manière:

1  >>> liste = [1,2,3,5,10]
2  >>> 3 in liste
3  True
4  >>> 11 in liste
5  False

La fonction range

• La fonction range génère une liste composée d'une simple suite arithmétique.

1  >>> range(10)
2  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Agrandir une liste par une liste

• Pour mettre bout à bout deux listes, utiliser la méthode extend

1  >>> x = [1, 2, 3, 4]
2  >>> y = [4, 5, 1, 0]
3  >>> x.extend(y)
4  >>> print x
5  [1, 2, 3, 4, 4, 5, 1, 0]

Permutations

• La permutation d'un ensemble d'éléments est une liste de tous les cas possibles. Si vous avez besoin de cette fonctionnalité, inutile de réinventer la roue, itertools s'en occupe pour vous.

1  >>> from itertools import permutations
2  >>> list(permutations(['a', 'b', 'c']))
3  [('a', 'b', 'c'), ('a', 'c', 'b'), ('b', 'a', 'c'), ('b', 'c', 'a'), ('c', 'a', 'b'), ('c', 'b', 'a')]

Permutation d'une liste de liste

• Afficher tous les cas possibles d'une liste elle-même composée de liste?
• Outil product de itertools :

1  >>> from itertools import product
2  >>> list(product(['a', 'b'], ['c', 'd']))
3  [('a', 'c'), ('a', 'd'), ('b', 'c'), ('b', 'd')]

Astuces

• Afficher les 2 premiers éléments d'une liste

1  >>> liste = [1,2,3,4,5]
2  >>> liste[:2]
3  [1, 2]

• Afficher le dernier item d'une liste:

1  >>> liste = [1, 2, 3, 4, 5, 6]
2  >>> liste[-1]
3  6

• Afficher le 3ème élément en partant de la fin:

1  >>> liste = [1, 2, 3, 4, 5, 6]
2  >>> liste[-3]
3  4

• Afficher les 3 derniers éléments d'une liste:

1  >>> liste = [1, 2, 3, 4, 5, 6]
2  >>> liste[-3:]
3  [4, 5, 6]

• Additionner deux listes pour les combiner ensemble en utilisant l'opérateur + :

1  >>> x = [1, 2, 3]
2  >>> y = [4, 5, 6]
3  >>> x + y
4  [1, 2, 3, 4, 5, 6]

• Mutiplier une liste:

1  >>> x = [1, 2]
2  >>> x*5
3  [1, 2, 1, 2, 1, 2, 1, 2, 1, 2]

• Utile pour initialiser une liste:

1  >>> [0] * 5
2  [0, 0, 0, 0, 0]

Les Tuples

• Un tuple est une liste qui ne peut plus être modifiée.

Créer un tuple

• Pour créer un tuple, utiliser la syntaxe suivante:

1  >>> mon_tuple = ()

Ajouter une valeur à un tuple

• Pour créer un tuple avec des valeurs, on peut le faire de cette façon:

1  >>> mon_tuple = (1, "ok", "olivier")

• Les parenthèses ne sont pas obligatoires mais facilite la lisibilité du code (rappelons que la force de python est sa simplicité de lecture):

1  >>> mon_tuple = 1, 2, 3
2  >>> type(mon_tuple)
3  <type 'tuple'>

• Lorsqu'on créé un tuple avec une seule valeur, ne pas oublier d'y ajouter une virgule, sinon ce n'est pas un tuple.

1  >>> mon_tuple = ("ok")
2  >>> type(mon_tuple)
3  <type 'str'>
4  >>> mon_tuple = ("ok",)
5  >>> type(mon_tuple)
6  <type 'tuple'>

Afficher une valeur d'un tuple

• Le tuple est une sorte de liste, on peut donc utiliser la même syntaxe pour lire les données du tuple.

1  >>> mon_tuple[0]
2  1

• Et évidemment si on essaie de changer la valeur d'un index, l'interpreteur nous insulte copieusement:

1  >>> mon_tuple[1] = "ok"
2  Traceback (most recent call last):
3   File "<stdin>", line 1, in <module>
4  TypeError: 'tuple' object does not support item assignment

A quoi sert un tuple alors?

• Le tuple permet une affectation multiple:

1  >>> v1, v2 = 11, 22
2  >>> v1
3  11
4  >>> v2
5  22

• Il permet également de renvoyer plusieurs valeurs lors d'un appel d'une fonction:

1  >>> def donne_moi_ton_nom():
2  ...     return "olivier", "engel"
3  ... 
4  >>> donne_moi_ton_nom()
5  ('olivier', 'engel')

• On utilisera un tuple pour définir des sortes de constantes qui n'ont donc pas vocation à changer.

Fonctions et Méthodes