Python Language
Lijst

Invoering

Syntaxis

• [waarde, waarde, ...]
• lijst ([iterable])

Opmerkingen

Toegang tot lijstwaarden

Python-lijsten zijn op nul geïndexeerd en werken als arrays in andere talen.

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

Als u probeert toegang te krijgen tot een index buiten de grenzen van de lijst, wordt er een IndexError .

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

Negatieve indices worden geïnterpreteerd als vanaf het einde van de lijst.

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

Dit is functioneel gelijk aan

lst[len(lst)-1]  # 4

Lijsten laten slice notatie gebruiken lst[start:end:step] . De uitgang van het deel notatie is een nieuwe lijst bevat elementen index start tot end-1 . Als opties worden weggelaten, start standaard met het begin van de lijst, van end tot einde van de lijst en step naar 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

Met dit in gedachten kunt u een omgekeerde versie van de lijst afdrukken door te bellen

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

Wanneer u staplengten van negatieve bedragen gebruikt, moet de startindex groter zijn dan de eindindex, anders is het resultaat een lege lijst.

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

Het gebruik van negatieve stapindexen is gelijk aan de volgende code:

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

De gebruikte indices zijn 1 minder dan die voor negatieve indexering en zijn omgekeerd.

Geavanceerd snijden

Wanneer lijsten worden gesneden, wordt de methode __getitem__() van het __getitem__() aangeroepen, met een slice . Python heeft een ingebouwde slice-methode om slice-objecten te genereren. We kunnen dit gebruiken om een schijfje op te slaan en later opnieuw te gebruiken,

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'

Dit kan van groot nut zijn door onze objecten te snijden door __getitem__ in onze klasse te overschrijven.

Lijst methoden en ondersteunde operatoren

Beginnend met een gegeven lijst a :

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

1. append(value) - voegt een nieuw element toe aan het einde van de lijst.

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

   Merk op dat de methode append() slechts één nieuw element aan het einde van de lijst toevoegt. Als u een lijst aan een andere lijst toevoegt, wordt de lijst die u toevoegt een enkel element aan het einde van de eerste lijst.

   # 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) - breidt de lijst uit door elementen van een andere opsombare toe te voegen.

   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]
   

   Lijsten kunnen ook worden samengevoegd met de operator + . Merk op dat dit geen enkele van de originele lijsten wijzigt:

   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]) - haalt de index op van de eerste keer dat de invoerwaarde voorkomt. Als de invoerwaarde niet in de lijst staat, wordt een uitzondering ValueError . Als een tweede argument wordt gegeven, wordt de zoekopdracht gestart op die opgegeven index.

   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) - voegt value net voor de opgegeven index . Dus na het invoegen bezet het nieuwe element positie- 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]) - verwijdert en retourneert het item bij index . Zonder argument verwijdert het en retourneert het laatste element van de lijst.

   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) - verwijdert het eerste exemplaar van de opgegeven waarde. Als de opgegeven waarde niet kan worden gevonden, wordt een ValueError verhoogd.

   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() - keert de lijst op zijn plaats om en geeft None terug.

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

   Er zijn ook andere manieren om een lijst om te keren .

8. count(value) - telt het aantal keren dat een bepaalde waarde in de lijst voorkomt.

   a.count(7)
   # Returns: 2
   

9. sort() - sorteert de lijst in numerieke en lexicografische volgorde en retourneert None .

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

   Lijsten kunnen ook worden omgekeerd wanneer ze worden gesorteerd met de vlag reverse=True in de methode sort() .

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

   Als u wilt sorteren op attributen van items, kunt u het key trefwoordargument gebruiken:

   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]
   

   In het geval van een lijst met dictaten is het concept hetzelfde:

   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]
   

   Sorteer op sub 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]
   

Betere manier om te sorteren met behulp van attrgetter en itemgetter

Lijsten kunnen ook worden gesorteerd met behulp van attrgetter en itemgetter functies uit de operatormodule. Deze kunnen de leesbaarheid en herbruikbaarheid helpen verbeteren. Hier zijn enkele voorbeelden,

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 kan ook een index krijgen. Dit is handig als u wilt sorteren op basis van indices van een 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)]

Gebruik de attrgetter als u wilt sorteren op attributen van een object,

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() - verwijdert alle items uit de lijst

    a.clear()
    # a = []
    

11. Replicatie - het vermenigvuldigen van een bestaande lijst met een geheel getal zal een grotere lijst produceren die uit zoveel exemplaren van het origineel bestaat. Dit kan bijvoorbeeld handig zijn voor het initialiseren van de lijst:

    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]
    

    Doe dit zorgvuldig als uw lijst verwijzingen naar objecten bevat (bijvoorbeeld een lijst met lijsten), zie Veelvoorkomende valkuilen - Lijstvermenigvuldiging en gemeenschappelijke verwijzingen .

12. Element verwijderen - het is mogelijk om meerdere elementen in de lijst te verwijderen met behulp van het sleutelwoord del en de segmentnotatie:

    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. kopiëren

    De standaardtoewijzing "=" wijst een verwijzing van de oorspronkelijke lijst toe aan de nieuwe naam. Dat wil zeggen dat de oorspronkelijke naam en de nieuwe naam beide naar hetzelfde lijstobject verwijzen. Wijzigingen die u via een van deze wijzigingen aanbrengt, worden weergegeven in een andere. Dit is vaak niet wat je bedoelde.

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

    Als u een kopie van de lijst wilt maken, hebt u onderstaande opties.

    Je kunt het snijden:

    new_list = old_list[:]
    

    U kunt de ingebouwde lijst () functie gebruiken:

    new_list = list(old_list)
    

    U kunt generieke copy.copy () gebruiken:

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

    Dit is iets langzamer dan list () omdat het eerst het datatype van old_list moet achterhalen.

    Als de lijst objecten bevat en u wilt deze ook kopiëren, gebruik dan generieke copy.deepcopy ():

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

    Uiteraard de langzaamste en meest geheugenbehoevende methode, maar soms onvermijdelijk.

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

Lengte van een lijst

Gebruik len() om de eendimensionale lengte van een lijst te krijgen.

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

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

len() werkt ook op strings, woordenboeken en andere gegevensstructuren die vergelijkbaar zijn met lijsten.

Merk op dat len() een ingebouwde functie is, geen methode voor een lijstobject.

Merk ook op dat de kosten van len() O(1) , wat betekent dat het even lang duurt om de lengte van een lijst te krijgen, ongeacht de lengte.

Een lijst doornemen

Python ondersteunt het gebruik van een for lus rechtstreeks in een lijst:

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

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

U kunt ook de positie van elk item tegelijkertijd ophalen:

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

De andere manier om een lijst te herhalen op basis van de indexwaarde:

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

Merk op dat het wijzigen van items in een lijst terwijl deze wordt herhaald, onverwachte resultaten kan hebben:

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

# Output: foo
# Output: baz

In dit laatste voorbeeld hebben we het eerste item bij de eerste iteratie verwijderd, maar dat zorgde ervoor dat de bar werd overgeslagen.

Controleren of een item in een lijst staat

Python maakt het heel eenvoudig om te controleren of een item in een lijst staat. Gebruik gewoon de in operator.

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

'test' in lst
# Out: True

'toast' in lst
# Out: False

Opmerking: de in operator op sets is asymptotisch sneller dan op lijsten. Als u het vaak op potentieel grote lijsten moet gebruiken, wilt u uw list mogelijk omzetten naar een set en de aanwezigheid van elementen op de set testen.

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

Lijstelementen omkeren

U kunt de reversed functie gebruiken die een iterator terugbrengt naar de omgekeerde lijst:

In [3]: rev = reversed(numbers)

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

Merk op dat de lijst "nummers" door deze bewerking ongewijzigd blijft en in dezelfde volgorde blijft als oorspronkelijk.

Om op zijn plaats te keren, kunt u ook de reverse methode gebruiken .

U kunt een lijst ook omkeren (in feite een kopie verkrijgen, de oorspronkelijke lijst wordt niet beïnvloed) met behulp van de syntaxis van de segmentering, waarbij het derde argument (de stap) wordt ingesteld op -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]

Controleren of de lijst leeg is

De leegte van een lijst is gekoppeld aan de boolean False , dus u hoeft len(lst) == 0 niet aan te vinken, maar alleen lst of not lst

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

# Output: list is empty

Lijsten samenvoegen en samenvoegen

1. De eenvoudigste manier om list1 en list2 :

   merged = list1 + list2
   

2. zip retourneert een lijst met tupels , waarbij de i-de tuple het i-de element uit elk van de argumentreeksen of iterables bevat:

   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
   

   Als de lijsten verschillende lengtes hebben, bevat het resultaat slechts zoveel elementen als de kortste:

   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
   

   Voor opvullijsten van ongelijke lengte tot de langste met None gebruikt u 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. Invoegen in een specifieke indexwaarde:

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

   Output:

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

Alles en iedereen

U kunt all() om te bepalen of alle waarden in een itereerbare waarde worden geëvalueerd als True

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

Evenzo bepaalt any() of een of meer waarden in een iterabele waarde als True worden geëvalueerd

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

Hoewel dit voorbeeld een lijst gebruikt, is het belangrijk op te merken dat deze ingebouwde werken werken met elke iterabele, inclusief generatoren.

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

Verwijder dubbele waarden in de lijst

Het verwijderen van dubbele waarden in een lijst kan worden gedaan door de lijst om te zetten in een set (dat is een ongeordende verzameling van afzonderlijke objecten). Als een datastructuur van de list nodig is, kan de set worden teruggezet in een lijst met behulp van de functielijst list() :

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

Merk op dat door het omzetten van een lijst naar een set de oorspronkelijke volgorde verloren gaat.

Om de volgorde van de lijst te behouden, kan men een OrderedDict

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

Toegang tot waarden in geneste lijst

Beginnend met een driedimensionale lijst:

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

Toegang tot items in de lijst:

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

Ondersteunende bewerkingen uitvoeren:

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

Geneste for-lussen gebruiken om de lijst af te drukken:

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]

Merk op dat deze bewerking kan worden gebruikt in een lijstbegrip of zelfs als een generator om efficiëntie te produceren, bijvoorbeeld:

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

Niet alle items in de buitenste lijsten moeten zelf lijsten zijn:

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

Een andere manier om genest voor lussen te gebruiken. De andere manier is beter, maar ik moest dit af en toe gebruiken:

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]

Segmenten gebruiken in geneste lijst:

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

De definitieve lijst:

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

Vergelijking van lijsten

Het is mogelijk om lijsten en andere reeksen lexicografisch te vergelijken met behulp van vergelijkingsoperatoren. Beide operanden moeten van hetzelfde type zijn.

[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

Als een van de lijsten aan het begin van de andere staat, wint de kortste lijst.

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

Een lijst initialiseren naar een vast aantal elementen

Voor onveranderlijke elementen (bijv. None , stringliteralen etc.):

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

Voor veranderlijke elementen heeft hetzelfde construct tot gevolg dat alle elementen van de lijst verwijzen naar hetzelfde object, bijvoorbeeld voor een set:

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

Gebruik in plaats daarvan om de lijst te initialiseren met een vast aantal verschillende veranderlijke objecten:

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