Introduction
Les séquences Python sont des collections ordonnées d'éléments. Elles sont indexées par des entiers.
This tutorial is from open-source community. Access the source code
💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici
Les séquences Python sont des collections ordonnées d'éléments. Elles sont indexées par des entiers.
Python dispose de trois types de données séquence.
'Hello'
. Une chaîne de caractères est une séquence de caractères.[1, 4, 5]
.('GOOG', 100, 490.1)
.Toutes les séquences sont ordonnées, indexées par des entiers et ont une longueur.
a = 'Hello' ## Chaîne de caractères
b = [1, 4, 5] ## Liste
c = ('GOOG', 100, 490.1) ## Tuple
## Ordre d'indexation
a[0] ## 'H'
b[-1] ## 5
c[1] ## 100
## Longueur de la séquence
len(a) ## 5
len(b) ## 3
len(c) ## 3
Les séquences peuvent être replicées : s * n
.
>>> a = 'Hello'
>>> a * 3
'HelloHelloHello'
>>> b = [1, 2, 3]
>>> b * 2
[1, 2, 3, 1, 2, 3]
>>>
Les séquences du même type peuvent être concaténées : s + t
.
>>> a = (1, 2, 3)
>>> b = (4, 5)
>>> a + b
(1, 2, 3, 4, 5)
>>>
>>> c = [1, 5]
>>> a + c
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can only concatenate tuple (not "list") to tuple
L'extraction de segments consiste à extraire une sous-séquence d'une séquence. La syntaxe est s[start:end]
. start
et end
sont les index de la sous-séquence que vous souhaitez.
a = [0,1,2,3,4,5,6,7,8]
a[2:5] ## [2,3,4]
a[-5:] ## [4,5,6,7,8]
a[:3] ## [0,1,2]
start
et end
doivent être des entiers.Sur les listes, les segments peuvent être réaffectés et supprimés.
## Réaffectation
a = [0,1,2,3,4,5,6,7,8]
a[2:4] = [10,11,12] ## [0,1,10,11,12,4,5,6,7,8]
Nota : Le segment réaffecté n'a pas besoin d'avoir la même longueur.
## Suppression
a = [0,1,2,3,4,5,6,7,8]
del a[2:4] ## [0,1,4,5,6,7,8]
Il existe quelques fonctions communes pour réduire une séquence à une seule valeur.
>>> s = [1, 2, 3, 4]
>>> sum(s)
10
>>> min(s)
1
>>> max(s)
4
>>> t = ['Hello', 'World']
>>> max(t)
'World'
>>>
La boucle for
itère sur les éléments d'une séquence.
>>> s = [1, 4, 9, 16]
>>> for i in s:
... print(i)
...
1
4
9
16
>>>
À chaque itération de la boucle, vous obtenez un nouvel élément avec lequel travailler. Cette nouvelle valeur est placée dans la variable d'itération. Dans cet exemple, la variable d'itération est x
:
for x in s: ## `x` est une variable d'itération
...statements
À chaque itération, la valeur précédente de la variable d'itération est écrasée (le cas échéant). Après que la boucle ait fini, la variable conserve la dernière valeur.
break
Vous pouvez utiliser l'instruction break
pour sortir d'une boucle prématurément.
for name in namelist:
if name == 'Jake':
break
...
...
statements
Lorsque l'instruction break
est exécutée, elle sort de la boucle et passe aux statements
suivants. L'instruction break
ne s'applique qu'à la boucle la plus interne. Si cette boucle se trouve à l'intérieur d'une autre boucle, elle n'arrêtera pas la boucle externe.
continue
Pour sauter un élément et passer au suivant, utilisez l'instruction continue
.
for line in lines:
if line == '\n': ## Sauter les lignes vides
continue
## Plus d'instructions
...
Cela est utile lorsque l'élément actuel n'est pas d'intérêt ou doit être ignoré dans le traitement.
Si vous avez besoin de compter, utilisez range()
.
for i in range(100):
## i = 0,1,...,99
La syntaxe est range([start,] end [,step])
for i in range(100):
## i = 0,1,...,99
for j in range(10,20):
## j = 10,11,..., 19
for k in range(10,50,2):
## k = 10,12,...,48
## Remarquez comment il compte par pas de 2, et non de 1.
start
est facultatif. Valeur par défaut : 0
.step
est facultatif. Valeur par défaut : 1
.range()
calcule les valeurs au fur et à mesure. Il ne stocke pas réellement une plage large de nombres.enumerate()
La fonction enumerate
ajoute une valeur de compteur supplémentaire à une itération.
names = ['Elwood', 'Jake', 'Curtis']
for i, name in enumerate(names):
## Boucle avec i = 0, name = 'Elwood'
## i = 1, name = 'Jake'
## i = 2, name = 'Curtis'
La forme générale est enumerate(sequence [, start = 0])
. start
est facultatif. Un bon exemple d'utilisation de enumerate()
est le suivi des numéros de ligne lors de la lecture d'un fichier :
with open(filename) as f:
for lineno, line in enumerate(f, start=1):
...
En fin de compte, enumerate
n'est qu'un raccourci pratique pour :
i = 0
for x in s:
statements
i += 1
Utiliser enumerate
nécessite moins de frappe et est légèrement plus rapide.
for
et tuplesVous pouvez itérer avec plusieurs variables d'itération.
points = [
(1, 4),(10, 40),(23, 14),(5, 6),(7, 8)
]
for x, y in points:
## Boucle avec x = 1, y = 4
## x = 10, y = 40
## x = 23, y = 14
## ...
Lorsque vous utilisez plusieurs variables, chaque tuple est déballé en un ensemble de variables d'itération. Le nombre de variables doit correspondre au nombre d'éléments de chaque tuple.
zip()
La fonction zip
prend plusieurs séquences et crée un itérateur qui les combine.
columns = ['name','shares', 'price']
values = ['GOOG', 100, 490.1 ]
pairs = zip(columns, values)
## ('name','GOOG'), ('shares',100), ('price',490.1)
Pour obtenir le résultat, vous devez itérer. Vous pouvez utiliser plusieurs variables pour déballer les tuples comme montré précédemment.
for column, value in pairs:
...
Une utilisation courante de zip
est de créer des paires clé/valeur pour construire des dictionnaires.
d = dict(zip(columns, values))
Essayez quelques exemples de comptage de base :
>>> for n in range(10): ## Comptez de 0... 9
print(n, end=' ')
0 1 2 3 4 5 6 7 8 9
>>> for n in range(10,0,-1): ## Comptez de 10... 1
print(n, end=' ')
10 9 8 7 6 5 4 3 2 1
>>> for n in range(0,10,2): ## Comptez 0, 2,... 8
print(n, end=' ')
0 2 4 6 8
>>>
Expérimentez de manière interactive certaines des opérations de réduction de séquence.
>>> data = [4, 9, 1, 25, 16, 100, 49]
>>> min(data)
1
>>> max(data)
100
>>> sum(data)
204
>>>
Essayez de parcourir les données.
>>> for x in data:
print(x)
4
9
...
>>> for n, x in enumerate(data):
print(n, x)
0 4
1 9
2 1
...
>>>
Parfois, les débutants utilisent la structure for
, la fonction len()
et la fonction range()
dans un fragment de code horrible qui semble sortir des profondeurs d'un programme C rouillé.
>>> for n in range(len(data)):
print(data[n])
4
9
1
...
>>>
Ne faites pas ça! Non seulement ça fait mal aux yeux de tout le monde de le lire, mais c'est inefficace en termes de mémoire et ça exécute beaucoup plus lentement. Utilisez simplement une boucle for
normale si vous voulez parcourir des données. Utilisez enumerate()
si vous avez besoin de l'index pour une raison quelconque.
enumerate()
Rappelez-vous que le fichier missing.csv
contient des données pour un portefeuille d'actions, mais a quelques lignes avec des données manquantes. En utilisant enumerate()
, modifiez votre programme pcost.py
de sorte qu'il affiche un numéro de ligne avec le message d'avertissement lorsqu'il rencontre des données incorrectes.
>>> cost = portfolio_cost('/home/labex/project/missing.csv')
Ligne 4: Impossible de convertir : ['MSFT', '', '51.23']
Ligne 7: Impossible de convertir : ['IBM', '', '70.44']
>>>
Pour ce faire, vous devrez modifier quelques parties de votre code.
...
for rowno, row in enumerate(rows, start=1):
try:
...
except ValueError:
print(f'Ligne {rowno} : Mauvaise ligne : {row}')
zip()
Dans le fichier portfolio.csv
, la première ligne contient les en-têtes de colonne. Dans tout le code précédent, nous les avons ignorés.
>>> f = open('/home/labex/project/portfolio.csv')
>>> rows = csv.reader(f)
>>> headers = next(rows)
>>> headers
['name','shares', 'price']
>>>
Cependant, que se passe-t-il si vous pouvez utiliser les en-têtes pour quelque chose de pratique? C'est là que la fonction zip()
entre en jeu. Essayez d'abord ceci pour associer les en-têtes de fichier à une ligne de données :
>>> row = next(rows)
>>> row
['AA', '100', '32.20']
>>> list(zip(headers, row))
[ ('name', 'AA'), ('shares', '100'), ('price', '32.20') ]
>>>
Remarquez comment zip()
a associé les en-têtes de colonne aux valeurs de colonne. Nous avons utilisé list()
ici pour convertir le résultat en une liste afin que vous puissiez le voir. Normalement, zip()
crée un itérateur qui doit être consommé par une boucle for
.
Cette association est une étape intermédiaire pour construire un dictionnaire. Maintenant, essayez ceci :
>>> record = dict(zip(headers, row))
>>> record
{'price': '32.20', 'name': 'AA','shares': '100'}
>>>
Cette transformation est l'un des trucs les plus utiles à connaître lorsqu'il s'agit de traiter de nombreux fichiers de données. Par exemple, supposons que vous vouliez faire en sorte que le programme pcost.py
fonctionne avec différents fichiers d'entrée, mais sans vous soucier du numéro réel de colonne où apparaissent le nom, le nombre d'actions et le prix.
Modifiez la fonction portfolio_cost()
dans pcost.py
de sorte qu'elle ressemble à ceci :
## pcost.py
def portfolio_cost(filename):
...
for rowno, row in enumerate(rows, start=1):
record = dict(zip(headers, row))
try:
nshares = int(record['shares'])
price = float(record['price'])
total_cost += nshares * price
## Cela capture les erreurs dans les conversions de int() et float() ci-dessus
except ValueError:
print(f'Ligne {rowno} : Mauvaise ligne : {row}')
...
Maintenant, essayez votre fonction sur un fichier de données complètement différent portfoliodate.csv
qui ressemble à ceci :
name,date,time,shares,price
"AA","6/11/2007","9:50am",100,32.20
"IBM","5/13/2007","4:20pm",50,91.10
"CAT","9/23/2006","1:30pm",150,83.44
"MSFT","5/17/2007","10:30am",200,51.23
"GE","2/1/2006","10:45am",95,40.37
"MSFT","10/31/2006","12:05pm",50,65.10
"IBM","7/9/2006","3:15pm",100,70.44
>>> portfolio_cost('/home/labex/project/portfoliodate.csv')
44671.15
>>>
Si vous avez fait cela correctement, vous constaterez que votre programme fonctionne toujours même si le fichier de données a un format de colonne complètement différent de celui d'avant. C'est génial!
Le changement apporté ici est subtil, mais important. Au lieu que portfolio_cost()
soit codé en dur pour lire un seul format de fichier fixe, la nouvelle version lit n'importe quel fichier CSV et extrait les valeurs d'intérêt. Tant que le fichier a les colonnes requises, le code fonctionnera.
Modifiez le programme report.py
que vous avez écrit dans la section 2.3 de sorte qu'il utilise la même technique pour extraire les en-têtes de colonne.
Essayez d'exécuter le programme report.py
sur le fichier portfoliodate.csv
et constatez qu'il produit la même réponse qu'auparavant.
Un dictionnaire associe des clés à des valeurs. Par exemple, un dictionnaire de prix d'actions.
>>> prices = {
'GOOG' : 490.1,
'AA' : 23.45,
'IBM' : 91.1,
'MSFT' : 34.23
}
>>>
Si vous utilisez la méthode items()
, vous pouvez obtenir des paires (clé,valeur)
:
>>> prices.items()
dict_items([('GOOG', 490.1), ('AA', 23.45), ('IBM', 91.1), ('MSFT', 34.23)])
>>>
Cependant, que se passe-t-il si vous voulez obtenir une liste de paires (valeur, clé)
à la place? Indice : utilisez zip()
.
>>> pricelist = list(zip(prices.values(),prices.keys()))
>>> pricelist
[(490.1, 'GOOG'), (23.45, 'AA'), (91.1, 'IBM'), (34.23, 'MSFT')]
>>>
Pourquoi feriez-vous cela? Pour commencer, cela vous permet de réaliser certains types de traitement de données sur les données du dictionnaire.
>>> min(pricelist)
(23.45, 'AA')
>>> max(pricelist)
(490.1, 'GOOG')
>>> sorted(pricelist)
[(23.45, 'AA'), (34.23, 'MSFT'), (91.1, 'IBM'), (490.1, 'GOOG')]
>>>
Cela illustre également une caractéristique importante des tuples. Lorsqu'ils sont utilisés dans des comparaisons, les tuples sont comparés élément par élément, en commençant par le premier élément. De la même manière que les chaînes de caractères sont comparées caractère par caractère.
zip()
est souvent utilisé dans des situations comme celle-ci où vous devez associer des données provenant de différents emplacements. Par exemple, en associant les noms de colonnes aux valeurs de colonne afin de créer un dictionnaire de valeurs nommées.
Notez que zip()
n'est pas limité à des paires. Par exemple, vous pouvez l'utiliser avec n'importe quel nombre de listes d'entrée :
>>> a = [1, 2, 3, 4]
>>> b = ['w', 'x', 'y', 'z']
>>> c = [0.2, 0.4, 0.6, 0.8]
>>> list(zip(a, b, c))
[(1, 'w', 0.2), (2, 'x', 0.4), (3, 'y', 0.6), (4, 'z', 0.8))]
>>>
De plus, sachez que zip()
s'arrête une fois que la plus courte séquence d'entrée est épuisée.
>>> a = [1, 2, 3, 4, 5, 6]
>>> b = ['x', 'y', 'z']
>>> list(zip(a,b))
[(1, 'x'), (2, 'y'), (3, 'z')]
>>>
Félicitations! Vous avez terminé le laboratoire sur les séquences. Vous pouvez pratiquer d'autres laboratoires sur LabEx pour améliorer vos compétences.