Python Language
liste

Introduction

Syntaxe

• [valeur, valeur, ...]
• liste ([itérable])

Remarques

Accéder aux valeurs de la liste

Les listes Python sont indexées à zéro et agissent comme des tableaux dans d'autres langages.

lst = [1, 2, 3, 4]
lst[0]  # 1
lst[1]  # 2

Tenter d'accéder à un index en dehors des limites de la liste IndexError une IndexError .

lst[4]  # IndexError: list index out of range

Les indices négatifs sont interprétés comme comptant à partir de la fin de la liste.

lst[-1]  # 4
lst[-2]  # 3
lst[-5]  # IndexError: list index out of range

Ceci est fonctionnellement équivalent à

lst[len(lst)-1]  # 4

Les listes permettent d'utiliser la notation de tranche comme lst[start:end:step] . Le résultat de la notation de tranche est une nouvelle liste contenant des éléments du start index à la end-1 . Si les options sont omis start par défaut au début de la liste, end à la fin de la liste et l' step 1:

lst[1:]      # [2, 3, 4]
lst[:3]      # [1, 2, 3]
lst[::2]     # [1, 3]
lst[::-1]    # [4, 3, 2, 1] 
lst[-1:0:-1] # [4, 3, 2]
lst[5:8]     # [] since starting index is greater than length of lst, returns empty list
lst[1:10]    # [2, 3, 4] same as omitting ending index

Dans cette optique, vous pouvez imprimer une version inversée de la liste en appelant

lst[::-1]    # [4, 3, 2, 1]

Lorsque vous utilisez des longueurs d'étape de montants négatifs, l'index de départ doit être supérieur à l'index de fin, sinon le résultat sera une liste vide.

lst[3:1:-1] # [4, 3]

L'utilisation d'indices d'étape négatifs équivaut au code suivant:

reversed(lst)[0:2] # 0 = 1 -1
                   # 2 = 3 -1

Les indices utilisés sont inférieurs de 1 à ceux utilisés en indexation négative et sont inversés.

Tranchage avancé

Lorsque des listes sont découpées, la __getitem__() de l'objet liste est appelée, avec un objet slice . Python a une méthode de tranche intégrée pour générer des objets de tranche. Nous pouvons l'utiliser pour stocker une tranche et la réutiliser plus tard comme ça,

data = 'chandan purohit    22 2000'  #assuming data fields of fixed length 
name_slice = slice(0,19)
age_slice = slice(19,21)
salary_slice = slice(22,None)

#now we can have more readable slices
print(data[name_slice]) #chandan purohit     
print(data[age_slice]) #'22'
print(data[salary_slice]) #'2000'

Cela peut être très utile en fournissant des fonctionnalités de découpage à nos objets en __getitem__ dans notre classe.

Méthodes de liste et opérateurs pris en charge

En commençant par une liste donnée a :

a = [1, 2, 3, 4, 5]

1. append(value) - ajoute un nouvel élément à la fin de la liste.

   # Append values 6, 7, and 7 to the list
   a.append(6)
   a.append(7)
   a.append(7)
   # a: [1, 2, 3, 4, 5, 6, 7, 7]
   
   # Append another list
   b = [8, 9]
   a.append(b)
   # a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9]]
   
   # Append an element of a different type, as list elements do not need to have the same type
   my_string = "hello world"
   a.append(my_string)
   # a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9], "hello world"]
   

   Notez que la méthode append() ajoute uniquement un nouvel élément à la fin de la liste. Si vous ajoutez une liste à une autre liste, la liste que vous ajoutez devient un élément unique à la fin de la première liste.

   # Appending a list to another list
   a = [1, 2, 3, 4, 5, 6, 7, 7]
   b = [8, 9]
   a.append(b)
   # a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9]]
   a[8]
   # Returns: [8,9]
   

2. extend(enumerable) - étend la liste en ajoutant des éléments d'un autre énumérable.

   a = [1, 2, 3, 4, 5, 6, 7, 7]
   b = [8, 9, 10]
   
   # Extend list by appending all elements from b
   a.extend(b)
   # a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
   
   # Extend list with elements from a non-list enumerable:
   a.extend(range(3))
   # a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10, 0, 1, 2]
   

   Les listes peuvent également être concaténées avec l'opérateur + . Notez que cela ne modifie aucune des listes d'origine:

   a = [1, 2, 3, 4, 5, 6] + [7, 7] + b
   # a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
   

3. index(value, [startIndex]) - obtient l'index de la première occurrence de la valeur d'entrée. Si la valeur d'entrée n'est pas dans la liste, une exception ValueError est ValueError . Si un second argument est fourni, la recherche est lancée à cet index spécifié.

   a.index(7)
   # Returns: 6
   
   a.index(49) # ValueError, because 49 is not in a.
   
   a.index(7, 7)
   # Returns: 7
   
   a.index(7, 8) # ValueError, because there is no 7 starting at index 8
   

4. insert(index, value) - Insère une value juste avant l' index spécifié. Ainsi, après l’insertion, le nouvel élément occupe l’ index position.

   a.insert(0, 0)  # insert 0 at position 0
   a.insert(2, 5)  # insert 5 at position 2
   # a: [0, 1, 5, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
   

5. pop([index]) - supprime et retourne l'élément à l' index . Sans argument, il supprime et retourne le dernier élément de la liste.

   a.pop(2)
   # Returns: 5
   # a: [0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
   a.pop(8)
   # Returns: 7
   # a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   
   # With no argument:
   a.pop()
   # Returns: 10
   # a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
   

6. remove(value) - supprime la première occurrence de la valeur spécifiée. Si la valeur fournie est introuvable, une valeur ValueError est ValueError .

   a.remove(0)
   a.remove(9)
   # a: [1, 2, 3, 4, 5, 6, 7, 8]
   a.remove(10)
   # ValueError, because 10 is not in a
   

7. reverse() - inverse la liste sur place et renvoie None .

   a.reverse()
   # a: [8, 7, 6, 5, 4, 3, 2, 1]
   

   Il existe également d’ autres moyens d’inverser une liste .

8. count(value) - compte le nombre d'occurrences d'une certaine valeur dans la liste.

   a.count(7)
   # Returns: 2
   

9. sort() - trie la liste en ordre numérique et lexicographique et retourne None .

   a.sort()
   # a = [1, 2, 3, 4, 5, 6, 7, 8]
   # Sorts the list in numerical order
   

   Les listes peuvent également être inversées lorsqu'elles sont triées à l'aide de l'indicateur reverse=True dans la méthode sort() .

   a.sort(reverse=True)
   # a = [8, 7, 6, 5, 4, 3, 2, 1]
   

   Si vous voulez trier les attributs d'objets, vous pouvez utiliser la key argument de mot clé:

   import datetime
   
   class Person(object):
       def __init__(self, name, birthday, height):
           self.name = name
           self.birthday = birthday
           self.height = height
   
       def __repr__(self):
           return self.name
   
   l = [Person("John Cena", datetime.date(1992, 9, 12), 175),
        Person("Chuck Norris", datetime.date(1990, 8, 28), 180),
        Person("Jon Skeet", datetime.date(1991, 7, 6), 185)]
   
   l.sort(key=lambda item: item.name)
   # l: [Chuck Norris, John Cena, Jon Skeet]
   
   l.sort(key=lambda item: item.birthday)
   # l: [Chuck Norris, Jon Skeet, John Cena]
   
   l.sort(key=lambda item: item.height)
   # l: [John Cena, Chuck Norris, Jon Skeet]
   

   En cas de liste de dicts, le concept est le même:

   import datetime
   
   l = [{'name':'John Cena', 'birthday': datetime.date(1992, 9, 12),'height': 175},
    {'name': 'Chuck Norris', 'birthday': datetime.date(1990, 8, 28),'height': 180},
    {'name': 'Jon Skeet', 'birthday': datetime.date(1991, 7, 6), 'height': 185}]
   
   l.sort(key=lambda item: item['name'])
   # l: [Chuck Norris, John Cena, Jon Skeet]
   
   l.sort(key=lambda item: item['birthday'])
   # l: [Chuck Norris, Jon Skeet, John Cena]
   
   l.sort(key=lambda item: item['height'])
   # l: [John Cena, Chuck Norris, Jon Skeet]
   

   Trier par sous dict:

   import datetime
   
   l = [{'name':'John Cena', 'birthday': datetime.date(1992, 9, 12),'size': {'height': 175, 'weight': 100}},
    {'name': 'Chuck Norris', 'birthday': datetime.date(1990, 8, 28),'size' : {'height': 180, 'weight': 90}},
    {'name': 'Jon Skeet', 'birthday': datetime.date(1991, 7, 6), 'size': {'height': 185, 'weight': 110}}]
   
   l.sort(key=lambda item: item['size']['height'])
   # l: [John Cena, Chuck Norris, Jon Skeet]
   

Meilleure façon de trier avec attrgetter et itemgetter

Les listes peuvent également être triées à l'aide des fonctions attrgetter et itemgetter du module opérateur. Ceux-ci peuvent aider à améliorer la lisibilité et la réutilisation. Voici quelques exemples,

from operator import itemgetter,attrgetter

people = [{'name':'chandan','age':20,'salary':2000},
          {'name':'chetan','age':18,'salary':5000},
          {'name':'guru','age':30,'salary':3000}]
by_age = itemgetter('age')
by_salary = itemgetter('salary')

people.sort(key=by_age) #in-place sorting by age
people.sort(key=by_salary) #in-place sorting by salary

itemgetter peut également recevoir un index. Ceci est utile si vous voulez trier en fonction des index d'un tuple.

list_of_tuples = [(1,2), (3,4), (5,0)]
list_of_tuples.sort(key=itemgetter(1))
print(list_of_tuples) #[(5, 0), (1, 2), (3, 4)]

Utilisez l' attrgetter si vous souhaitez trier par attributs d'un objet,

persons = [Person("John Cena", datetime.date(1992, 9, 12), 175),
           Person("Chuck Norris", datetime.date(1990, 8, 28), 180),
           Person("Jon Skeet", datetime.date(1991, 7, 6), 185)] #reusing Person class from above example

person.sort(key=attrgetter('name')) #sort by name
by_birthday = attrgetter('birthday')
person.sort(key=by_birthday) #sort by birthday

10. clear() - supprime tous les éléments de la liste

    a.clear()
    # a = []
    

11. Réplication - la multiplication d'une liste existante par un nombre entier produira une liste plus grande comprenant autant de copies de l'original. Cela peut être utile par exemple pour l'initialisation de la liste:

    b = ["blah"] * 3
    # b = ["blah", "blah", "blah"]
    b = [1, 3, 5] * 5
    # [1, 3, 5, 1, 3, 5, 1, 3, 5, 1, 3, 5, 1, 3, 5]
    

    Faites cela si votre liste contient des références à des objets (par exemple une liste de listes), voir Pièges courants - Multiplication des listes et références communes .

12. Suppression d'éléments - il est possible de supprimer plusieurs éléments de la liste en utilisant la notation del mot-clé et tranche:

    a = list(range(10))
    del a[::2]
    # a = [1, 3, 5, 7, 9]
    del a[-1]
    # a = [1, 3, 5, 7]
    del a[:]
    # a = []
    

13. Copier

    L'attribution par défaut "=" assigne une référence de la liste d'origine au nouveau nom. C'est-à-dire que le nom d'origine et le nouveau nom pointent tous deux vers le même objet de liste. Les modifications apportées par l'un d'entre eux seront reflétées dans une autre. Ce n'est souvent pas ce que vous vouliez.

    b = a
    a.append(6)
    # b: [1, 2, 3, 4, 5, 6]
    

    Si vous souhaitez créer une copie de la liste, vous disposez des options ci-dessous.

    Vous pouvez le couper en tranches:

    new_list = old_list[:]
    

    Vous pouvez utiliser la fonction list () intégrée:

    new_list = list(old_list)
    

    Vous pouvez utiliser copy.copy générique ():

    import copy
    new_list = copy.copy(old_list) #inserts references to the objects found in the original.
    

    C'est un peu plus lent que list () car il doit d'abord trouver le type de données de old_list.

    Si la liste contient des objets et que vous souhaitez les copier également, utilisez le fichier copy.deepcopy () générique:

    import copy
    new_list = copy.deepcopy(old_list) #inserts copies of the objects found in the original.
    

    Evidemment la méthode la plus lente et la plus gourmande en mémoire, mais parfois inévitable.

    aa = a.copy()
    # aa = [1, 2, 3, 4, 5]

Longueur d'une liste

Utilisez len() pour obtenir la longueur unidimensionnelle d'une liste.

len(['one', 'two'])  # returns 2

len(['one', [2, 3], 'four'])  # returns 3, not 4

len() fonctionne également sur les chaînes, les dictionnaires et autres structures de données similaires aux listes.

Notez que len() est une fonction intégrée et non une méthode d'objet de liste.

Notez également que le coût de len() est O(1) , ce qui signifie qu'il faudra le même temps pour obtenir la longueur d'une liste, quelle que soit sa longueur.

Itérer sur une liste

Python prend en charge l'utilisation d'une boucle for directement sur une liste:

my_list = ['foo', 'bar', 'baz']
for item in my_list:
    print(item)

# Output: foo
# Output: bar
# Output: baz

Vous pouvez également obtenir la position de chaque élément en même temps:

for (index, item) in enumerate(my_list):
    print('The item in position {} is: {}'.format(index, item))
 
# Output: The item in position 0 is: foo
# Output: The item in position 1 is: bar
# Output: The item in position 2 is: baz

L'autre façon d'itérer une liste en fonction de la valeur d'index:

for i in range(0,len(my_list)):
    print(my_list[i])
#output:
>>>
foo
bar
baz

Notez que la modification d'éléments dans une liste lors d'une itération peut avoir des résultats inattendus:

for item in my_list:
    if item == 'foo':
        del my_list[0]
    print(item)

# Output: foo
# Output: baz

Dans ce dernier exemple, nous avons supprimé le premier élément à la première itération, mais la bar été ignorée.

Vérifier si un article est dans une liste

Python facilite la vérification de la présence d’un élément dans une liste. Il suffit d' utiliser le in l' opérateur.

lst = ['test', 'twest', 'tweast', 'treast']

'test' in lst
# Out: True

'toast' in lst
# Out: False

Note: le in l' opérateur sur des ensembles est asymptotiquement plus rapide que sur les listes. Si vous devez l'utiliser à plusieurs reprises sur des listes potentiellement volumineuses, vous pouvez convertir votre list en un set et tester la présence d'éléments sur l' set .

slst = set(lst)
'test' in slst
# Out: True

Inverser les éléments de la liste

Vous pouvez utiliser la fonction reversed qui renvoie un itérateur à la liste inversée:

In [3]: rev = reversed(numbers)

In [4]: rev
Out[4]: [9, 8, 7, 6, 5, 4, 3, 2, 1]

Notez que la liste "numéros" reste inchangée par cette opération, et reste dans le même ordre qu’elle était à l’origine.

Pour inverser la position, vous pouvez également utiliser la méthode reverse .

Vous pouvez également inverser une liste (en réalité, obtenir une copie, la liste d'origine n'est pas affectée) en utilisant la syntaxe de découpage, en définissant le troisième argument (l'étape) comme étant égal à -1:

In [1]: numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]

In [2]: numbers[::-1]
Out[2]: [9, 8, 7, 6, 5, 4, 3, 2, 1]

Vérification si la liste est vide

La vacuité d'une liste est associée à la valeur booléenne False , vous n'avez donc pas à vérifier len(lst) == 0 , mais simplement lst ou not lst

lst = []
if not lst:
    print("list is empty")

# Output: list is empty

Concaténer et fusionner les listes

1. La façon la plus simple à concaténer list1 et list2 :

   merged = list1 + list2
   

2. zip renvoie une liste de tuples , où le i-ème tuple contient le i-ème élément de chacune des séquences d'arguments ou des itérables:

   alist = ['a1', 'a2', 'a3']
   blist = ['b1', 'b2', 'b3']
   
   for a, b in zip(alist, blist):
       print(a, b)
    
   # Output:
   # a1 b1
   # a2 b2
   # a3 b3
   

   Si les listes ont des longueurs différentes, le résultat n'inclura que le plus petit nombre d'éléments:

   alist = ['a1', 'a2', 'a3']
   blist = ['b1', 'b2', 'b3', 'b4']
   for a, b in zip(alist, blist):
       print(a, b)
   
   # Output:
   # a1 b1
   # a2 b2
   # a3 b3
   
   alist = []
   len(list(zip(alist, blist)))
   
   # Output:
   # 0
   

   Pour remplir des listes de longueur inégale à la plus longue avec None utilisez itertools.zip_longest ( itertools.izip_longest dans Python 2)

   alist = ['a1', 'a2', 'a3']
   blist = ['b1']
   clist = ['c1', 'c2', 'c3', 'c4']
   
   for a,b,c in itertools.zip_longest(alist, blist, clist):
       print(a, b, c)
   
   # Output: 
   # a1 b1 c1
   # a2 None c2
   # a3 None c3
   # None None c4
   

3. Insérer dans un index spécifique des valeurs:

    alist = [123, 'xyz', 'zara', 'abc']
    alist.insert(3, [2009])
    print("Final List :", alist)
   

   Sortie:

    Final List : [123, 'xyz', 'zara', 2009, 'abc']
   

Tout et tous

Vous pouvez utiliser all() pour déterminer si toutes les valeurs d'une itération sont évaluées sur True

nums = [1, 1, 0, 1]
all(nums)
# False
chars = ['a', 'b', 'c', 'd']
all(chars)
# True

De même, any() détermine si une ou plusieurs valeurs dans une itération sont évaluées sur True

nums = [1, 1, 0, 1]
any(nums)
# True
vals = [None, None, None, False]
any(vals)
# False

Bien que cet exemple utilise une liste, il est important de noter que ces éléments intégrés fonctionnent avec tous les itérables, y compris les générateurs.

vals = [1, 2, 3, 4]
any(val > 12 for val in vals)
# False
any((val * 2) > 6 for val in vals)
# True

Supprimer les valeurs en double dans la liste

La suppression des valeurs en double dans une liste peut être effectuée en convertissant la liste en un set (c'est-à-dire une collection non ordonnée d'objets distincts). Si une structure de données de list est nécessaire, alors l'ensemble peut être reconverti en une liste à l'aide de la list() fonctions list() :

names = ["aixk", "duke", "edik", "tofp", "duke"]
list(set(names))
# Out: ['duke', 'tofp', 'aixk', 'edik']

Notez qu'en convertissant une liste en un ensemble, la commande d'origine est perdue.

Pour conserver l'ordre de la liste, on peut utiliser un OrderedDict

import collections
>>> collections.OrderedDict.fromkeys(names).keys()
# Out: ['aixk', 'duke', 'edik', 'tofp']

Accès aux valeurs dans la liste imbriquée

En commençant par une liste en trois dimensions:

alist = [[[1,2],[3,4]], [[5,6,7],[8,9,10], [12, 13, 14]]]

Accéder aux éléments de la liste:

print(alist[0][0][1])
#2
#Accesses second element in the first list in the first list

print(alist[1][1][2])
#10
#Accesses the third element in the second list in the second list

Effectuer des opérations de support:

alist[0][0].append(11)
print(alist[0][0][2])
#11
#Appends 11 to the end of the first list in the first list

Utilisation de boucles imbriquées pour imprimer la liste:

for row in alist: #One way to loop through nested lists
    for col in row:
        print(col)
#[1, 2, 11]
#[3, 4]
#[5, 6, 7]
#[8, 9, 10]
#[12, 13, 14]

Notez que cette opération peut être utilisée dans une compréhension de liste ou même en tant que générateur pour produire des efficacités, par exemple:

[col for row in alist for col in row]
#[[1, 2, 11], [3, 4], [5, 6, 7], [8, 9, 10], [12, 13, 14]]

Tous les éléments des listes externes ne doivent pas être eux-mêmes des listes:

alist[1].insert(2, 15)
#Inserts 15 into the third position in the second list

Une autre façon d'utiliser les boucles imbriquées. L'autre façon est meilleure mais j'ai eu besoin de l'utiliser à l'occasion:

for row in range(len(alist)): #A less Pythonic way to loop through lists
    for col in range(len(alist[row])):
       print(alist[row][col])

#[1, 2, 11]
#[3, 4]
#[5, 6, 7]
#[8, 9, 10]
#15
#[12, 13, 14]

Utilisation de tranches dans la liste imbriquée:

print(alist[1][1:])
#[[8, 9, 10], 15, [12, 13, 14]]
#Slices still work

La liste finale:

print(alist)
#[[[1, 2, 11], [3, 4]], [[5, 6, 7], [8, 9, 10], 15, [12, 13, 14]]]

Comparaison de listes

Il est possible de comparer des listes et d'autres séquences lexicographiquement en utilisant des opérateurs de comparaison. Les deux opérandes doivent être du même type.

[1, 10, 100] < [2, 10, 100]
# True, because 1 < 2
[1, 10, 100] < [1, 10, 100]
# False, because the lists are equal
[1, 10, 100] <= [1, 10, 100]
# True, because the lists are equal
[1, 10, 100] < [1, 10, 101]
# True, because 100 < 101
[1, 10, 100] < [0, 10, 100]
# False, because 0 < 1

Si l'une des listes est contenue au début de l'autre, la liste la plus courte l'emporte.

[1, 10] < [1, 10, 100]
# True

Initialisation d'une liste à un nombre fixe d'éléments

Pour les éléments immuables (par exemple, None , littéraux de chaîne, etc.):

my_list = [None] * 10
my_list = ['test'] * 10

Pour les éléments mutables , la même construction se traduira par tous les éléments de la liste faisant référence au même objet, par exemple, pour un ensemble:

>>> my_list=[{1}] * 10
>>> print(my_list)
[{1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}]
>>> my_list[0].add(2)
>>> print(my_list)
[{1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}]

Au lieu de cela, pour initialiser la liste avec un nombre fixe d'objets différents mutables , utilisez:

my_list=[{1} for _ in range(10)]