Version du 18 mars 2020 à 23:48

(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

_NOTOC_

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 avec la 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

• Récupérer l'index, vous pouvez 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 vous changez 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 , vous pouvez utiliser la syntaxe suivante:

>>> mon_tuple = ()

Ajouter une valeur à un tuple

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

>>> 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):

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

Lorsque vous créez un tuple avec une seule valeur, n'oubliez pas d'y ajouter une virgule, sinon ce n'est pas un tuple.

>>> mon_tuple = ("ok") >>> type(mon_tuple) <type 'str'> >>> mon_tuple = ("ok",) >>> type(mon_tuple) <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.

>>> mon_tuple[0] 1

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

>>> mon_tuple[1] = "ok" Traceback (most recent call last):

 File "<stdin>", line 1, in <module>

TypeError: 'tuple' object does not support item assignment

A quoi sert un tuple alors?

Le tuple permet une affectation multiple:

>>> v1, v2 = 11, 22 >>> v1 11 >>> v2 22

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

>>> def donne_moi_ton_nom(): ... return "olivier", "engel" ... >>> donne_moi_ton_nom() ('olivier', 'engel')

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

Fonctions et Méthodes