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


Exemple

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
    
  1. 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]
    
  1. 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]
    
  2. 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
    
  3. 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 .

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

    a.count(7)
    # Returns: 2
    
  5. 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
  1. clear() - supprime tous les éléments de la liste

    a.clear()
    # a = []
    
  2. 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 .

  3. 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 = []
    
  4. 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.

Python 3.x 3.0

copy() - Retourne une copie peu profonde de la liste

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