Python Language
Liste

Einführung

Syntax

• [Wert, Wert, ...]
• Liste ([iterable])

Bemerkungen

Auf Listenwerte zugreifen

Python-Listen sind nullindiziert und verhalten sich wie Arrays in anderen Sprachen.

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

IndexError versuchen, auf einen Index außerhalb der Grenzen der Liste IndexError wird ein IndexError .

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

Negative Indizes werden vom Ende der Liste aus gezählt.

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

Dies ist funktional äquivalent zu

lst[len(lst)-1]  # 4

Listen erlauben die Verwendung der Slice-Notation als lst[start:end:step] . Der Ausgang der slice Notation ist ein neues Listenelement aus dem Index enthält start bis end-1 . Wenn Optionen weggelassen werden, beginnt der start standardmäßig mit dem Anfang der Liste, end bis Ende der Liste und 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

Aus diesem Grund können Sie eine umgekehrte Version der Liste durch Aufrufen ausdrucken

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

Wenn Sie Schrittlängen mit negativen Beträgen verwenden, muss der Startindex größer als der Endindex sein. Andernfalls wird eine leere Liste angezeigt.

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

Die Verwendung von negativen Schrittindizes entspricht dem folgenden Code:

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

Die verwendeten Indizes sind um 1 niedriger als diejenigen, die bei der negativen Indexierung verwendet werden, und sind umgekehrt.

Erweitertes Schneiden

Wenn Listen in Scheiben geschnitten werden, wird die __getitem__() Methode des __getitem__() mit einem slice Objekt aufgerufen. Python verfügt über eine integrierte Slice-Methode zum Generieren von Slice-Objekten. Wir können dies verwenden, um ein Slice zu speichern und es später wiederzuverwenden.

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'

Dies kann von großem Nutzen sein, indem Sie unseren Objekten Slicing-Funktionen bereitstellen, indem Sie __getitem__ in unserer Klasse überschreiben.

Listen Sie Methoden und unterstützte Operatoren auf

Beginnend mit einer gegebenen Liste a :

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

1. append(value) - fügt ein neues Element an das Ende der Liste an.

   # 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"]
   

   Beachten Sie, dass die append() -Methode nur ein neues Element an das Ende der Liste anfügt. Wenn Sie eine Liste an eine andere Liste anhängen, wird die Liste, die Sie anfügen, am Ende der ersten Liste zu einem einzelnen Element.

   # 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) - erweitert die Liste, indem Elemente aus einem anderen Enumerable angehängt werden.

   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]
   

   Listen können auch mit dem Operator + verkettet werden. Beachten Sie, dass dadurch keine der ursprünglichen Listen geändert wird:

   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]) - index(value, [startIndex]) den Index des ersten Vorkommens des Eingabewerts. Wenn der Eingabewert nicht in der Liste enthalten ist, wird eine ValueError Ausnahme ValueError . Wenn ein zweites Argument angegeben wird, wird die Suche an dem angegebenen Index gestartet.

   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) - fügt den value unmittelbar vor dem angegebenen index . Somit nach dem Einsetzen das neue Element einnimmt index .

   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]) - Entfernt das Element am index und gibt es zurück. Ohne Argument wird das letzte Element der Liste entfernt und zurückgegeben.

   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) - Entfernt das erste Vorkommen des angegebenen Werts. Wenn der angegebene Wert nicht gefunden werden kann, wird ein 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() - kehrt die Liste um und gibt None .

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

   Es gibt auch andere Möglichkeiten, eine Liste umzukehren .

8. count(value) - zählt die Anzahl der Vorkommen eines Wertes in der Liste.

   a.count(7)
   # Returns: 2
   

9. sort() - Sortiert die Liste in numerischer und lexikografischer Reihenfolge und gibt None .

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

   Listen können auch umgekehrt werden, wenn sie mit dem reverse=True Flag in der sort() -Methode sortiert werden.

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

   Wenn Sie nach Attributen von Elementen sortieren möchten, können Sie das key :

   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]
   

   Im Falle einer Liste von Diktaten ist das Konzept dasselbe:

   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]
   

   Sortieren nach Subdikt:

   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]
   

Besser kann man mit attrgetter und itemgetter

Listen können auch mit attrgetter und itemgetter Funktionen des Bedienermoduls sortiert werden. Diese können zur Verbesserung der Lesbarkeit und Wiederverwendbarkeit beitragen. Hier sind einige Beispiele,

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 kann auch einen Index erhalten. Dies ist hilfreich, wenn Sie nach Indizes eines Tupels sortieren möchten.

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

Verwenden Sie den attrgetter wenn Sie nach Attributen eines Objekts sortieren möchten.

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() - entfernt alle Elemente aus der Liste

    a.clear()
    # a = []
    

11. Replikation - Durch Multiplizieren einer vorhandenen Liste mit einer ganzen Zahl wird eine größere Liste erstellt, die aus diesen vielen Kopien des Originals besteht. Dies kann zum Beispiel für die Listeninitialisierung nützlich sein:

    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]
    

    Seien Sie vorsichtig, wenn Ihre Liste Verweise auf Objekte enthält (z. B. eine Liste von Listen). Weitere Informationen finden Sie unter Häufige Fallstricke - Listenmultiplikation und allgemeine Verweise .

12. Element löschen - Es ist möglich, mehrere Elemente in der Liste mit dem Schlüsselwort del und der Slice-Notation zu löschen:

    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. Kopieren

    Die Standardzuordnung "=" weist dem neuen Namen eine Referenz der ursprünglichen Liste zu. Das heißt, sowohl der ursprüngliche Name als auch der neue Name zeigen auf dasselbe Listenobjekt. Änderungen, die über eines von ihnen vorgenommen werden, werden in einem anderen angezeigt. Dies ist oft nicht das, was Sie beabsichtigten.

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

    Wenn Sie eine Kopie der Liste erstellen möchten, haben Sie die folgenden Optionen.

    Sie können es schneiden:

    new_list = old_list[:]
    

    Sie können die eingebaute list () - Funktion verwenden:

    new_list = list(old_list)
    

    Sie können generic copy.copy () verwenden:

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

    Dies ist etwas langsamer als list (), da zuerst der Datentyp von old_list ermittelt werden muss.

    Wenn die Liste Objekte enthält und Sie diese auch kopieren möchten, verwenden Sie generic copy.deepcopy ():

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

    Offensichtlich die langsamste und am meisten Speicher benötigende Methode, aber manchmal unvermeidlich.

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

Länge einer Liste

Verwenden Sie len() , um die eindimensionale Länge einer Liste abzurufen.

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

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

len() funktioniert auch mit Strings, Wörterbüchern und anderen Datenstrukturen, die Listen ähneln.

Beachten Sie, dass len() eine integrierte Funktion ist, keine Methode eines Listenobjekts.

Beachten Sie auch, dass die Kosten für len() O(1) sind. Dies bedeutet, dass die Länge einer Liste unabhängig von ihrer Länge gleich lang dauert.

Iteration über eine Liste

Python unterstützt die Verwendung einer for Schleife direkt in einer Liste:

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

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

Sie können auch die Position jedes Artikels gleichzeitig ermitteln:

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

Die andere Möglichkeit, eine Liste basierend auf dem Indexwert zu durchlaufen:

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

Beachten Sie, dass das Ändern von Elementen in einer Liste während des Iterierens zu unerwarteten Ergebnissen führen kann:

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

# Output: foo
# Output: baz

In diesem letzten Beispiel haben wir das erste Element bei der ersten Iteration gelöscht. Dies führte jedoch dazu, dass die bar übersprungen wurde.

Prüfen, ob ein Element in einer Liste enthalten ist

Python macht es sehr einfach zu prüfen, ob ein Element in einer Liste enthalten ist. Verwenden Sie einfach den in Operator.

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

'test' in lst
# Out: True

'toast' in lst
# Out: False

Hinweis: Der in Operator on Sets ist asymptotisch schneller als auf Listen. Wenn Sie die list mehrmals für potenziell große Listen verwenden müssen, können Sie Ihre list in einen set konvertieren und das Vorhandensein von Elementen im set testen.

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

Listenelemente umkehren

Sie können die reversed Funktion verwenden, die einen Iterator an die stornierte Liste zurückgibt:

In [3]: rev = reversed(numbers)

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

Beachten Sie, dass die Liste "Zahlen" durch diese Operation unverändert bleibt und in derselben Reihenfolge bleibt, in der sie ursprünglich war.

Zum Umkehren können Sie auch die reverse Methode verwenden .

Sie können eine Liste auch umkehren (tatsächlich erhalten Sie eine Kopie, die ursprüngliche Liste ist davon nicht betroffen), indem Sie die Slicing-Syntax verwenden und das dritte Argument (den Schritt) auf -1 setzen:

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]

Überprüfen, ob die Liste leer ist

Die Leere einer Liste ist mit dem booleschen False verknüpft. Sie müssen also nicht len(lst) == 0 überprüfen, sondern nur lst oder not lst

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

# Output: list is empty

Listen verketten und zusammenführen

1. Die einfachste Möglichkeit, list1 und list2 zu verketten :

   merged = list1 + list2
   

2. zip gibt eine Liste von Tupeln zurück , wobei das i-te Tupel das i-te Element aus jeder der Argumentsequenzen oder iterierbaren Elemente enthält:

   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
   

   Wenn die Listen unterschiedliche Längen haben, enthält das Ergebnis nur so viele Elemente wie das kürzeste:

   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
   

   Für itertools.zip_longest mit ungleicher Länge bis zur längsten mit None s verwenden Sie itertools.zip_longest ( itertools.izip_longest in 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. Einfügen in einen bestimmten Indexwert:

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

   Ausgabe:

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

Alle und alle

Sie können all() , um zu bestimmen, ob alle Werte in einer iterierbaren Komponente als "True" ausgewertet werden

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

In ähnlicher Weise bestimmt any() , ob ein oder mehrere Werte in einem iterierbaren Wert True ergeben

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

Während dieses Beispiel eine Liste verwendet, ist es wichtig zu beachten, dass diese eingebauten Ins mit beliebigen Iteratoren, einschließlich Generatoren, funktionieren.

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

Entfernen Sie doppelte Werte in der Liste

Das Entfernen doppelter Werte in einer Liste kann durch Konvertieren der Liste in eine set (dh eine ungeordnete Sammlung verschiedener Objekte) erfolgen. Wenn eine list benötigt wird, kann der Satz mithilfe der Funktionsliste list() wieder in eine Liste konvertiert werden:

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

Beachten Sie, dass durch das Konvertieren einer Liste in einen Satz die ursprüngliche Reihenfolge verloren geht.

Um die Reihenfolge der Liste zu erhalten, kann ein OrderedDict

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

Zugriff auf Werte in der verschachtelten Liste

Beginnend mit einer dreidimensionalen Liste:

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

Zugriff auf Elemente in der 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

Unterstützungsvorgänge durchführen:

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

Verschachtelte for-Schleifen verwenden, um die Liste zu drucken:

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]

Beachten Sie, dass diese Operation in einem Listenverständnis oder sogar als Generator zur Erzeugung von Wirkungsgraden verwendet werden kann, z.

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

Nicht alle Elemente in den äußeren Listen müssen selbst Listen sein:

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

Eine andere Möglichkeit, verschachtelte for-Schleifen zu verwenden. Der andere Weg ist besser, aber ich musste dies gelegentlich verwenden:

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]

Verwenden von Slices in einer verschachtelten Liste:

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

Die endgültige Liste:

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

Listenvergleich

Es ist möglich, Listen und andere Sequenzen mit Vergleichsoperatoren lexikographisch zu vergleichen. Beide Operanden müssen vom gleichen Typ sein.

[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

Wenn eine der Listen am Anfang der anderen enthalten ist, gewinnt die kürzeste Liste.

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

Initialisieren einer Liste mit einer festen Anzahl von Elementen

Für unveränderliche Elemente (z. B. None , String-Literale usw.):

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

Bei veränderlichen Elementen führt das gleiche Konstrukt dazu, dass sich alle Elemente der Liste auf dasselbe Objekt beziehen, beispielsweise für eine Menge:

>>> 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}]

Um die Liste mit einer festen Anzahl verschiedener veränderlicher Objekte zu initialisieren, verwenden Sie Folgendes :

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