Python Language
Lista

Introduktion

Syntax

• [värde, värde, ...]
• lista ([iterable])

Anmärkningar

Öppnar listvärden

Python-listor är nollindexade och fungerar som matriser på andra språk.

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

Att försöka få tillgång till ett index utanför listans gränser kommer att höja ett IndexError .

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

Negativa index tolkas som räkna från slutet av listan.

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

Detta är funktionellt motsvarande

lst[len(lst)-1]  # 4

Listor tillåter att använda skivanotation som lst[start:end:step] . Utsignalen från skiva notation är en ny lista som innehåller element från index start till end-1 . Om alternativ utelämnas start standard till listans början, listan från end till slutet och step till 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

Med detta i åtanke kan du skriva ut en omvänd version av listan genom att ringa

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

När du använder steglängder med negativa belopp måste startindexet vara större än slutindexet, annars blir resultatet en tom lista.

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

Att använda negativa stegindex motsvarar följande kod:

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

De använda indexen är 1 mindre än de som används vid negativ indexering och återförs.

Avancerad skivning

När listor skivas __getitem__() -metoden för __getitem__() med ett slice . Python har en inbyggd skivmetod för att generera skivobjekt. Vi kan använda detta för att lagra ett segment och återanvända det senare,

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'

Detta kan vara till stor nytta genom att tillhandahålla skivfunktioner till våra objekt genom att åsidosätta __getitem__ i vår klass.

Lista metoder och operatörer som stöds

Börjar med en given lista a :

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

1. append(value) - lägger till ett nytt element i slutet av listan.

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

   Observera att metoden append append() lägger till bara ett nytt element i slutet av listan. Om du lägger till en lista till en annan lista blir listan som du lägger till ett enda element i slutet av den första listan.

   # 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) - utökar listan genom att lägga till element från en annan uppräknbar.

   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]
   

   Listor kan också sammanlänkas med operatören + . Observera att detta inte ändrar någon av de ursprungliga listorna:

   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]) - får indexet för den första förekomsten av ingångsvärdet. Om ingångsvärdet inte finns i listan ValueError undantag från ValueError . Om ett andra argument anges startas sökningen vid det angivna indexet.

   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) - sätter in value precis före det angivna index . Således efter insättningen det nya elementet upptar positionen 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]) - tar bort och returnerar objektet vid index . Utan argument tas bort och returnerar det sista elementet i listan.

   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) - tar bort den första förekomsten av det angivna värdet. Om det angivna värdet inte kan hittas ValueError en 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() - vänder listan på plats och returnerar None .

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

   Det finns också andra sätt att vända en lista på .

8. count(value) - räknar antalet händelser av något värde i listan.

   a.count(7)
   # Returns: 2
   

9. sort() - sorterar listan i numerisk och leksikografisk ordning och returnerar None .

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

   Listor kan också vändas när de sorteras med reverse=True flagga i metoden sort() .

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

   Om du vill sortera efter attribut objekt, kan du använda key sökordet argument:

   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]
   

   I fallet med listor över avbildningar är konceptet detsamma:

   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]
   

   Sortera efter 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]
   

Bättre sätt att sortera med hjälp av attrgetter och itemgetter

Listor kan också sorteras med hjälp av attrgetter och itemgetter från operatörsmodulen. Dessa kan bidra till att förbättra läsbarheten och återanvändbarheten. Här är några exempel,

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 också ges ett index. Detta är användbart om du vill sortera baserat på index för en tupel.

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

Använd attrgetter om du vill sortera efter attribut för ett objekt,

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() - tar bort alla objekt från listan

    a.clear()
    # a = []
    

11. Replikation - att multiplicera en befintlig lista med ett heltal ger en större lista som består av så många kopior av originalet. Detta kan vara användbart till exempel för listinitialisering:

    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]
    

    Se till att göra detta om din lista innehåller referenser till objekt (t.ex. en lista med listor), se Vanliga fallgropar - Lista multiplikation och vanliga referenser .

12. Elementborttagning - det är möjligt att radera flera element i listan med hjälp av del nyckelord och skiva:

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

    Standardtilldelningen "=" tilldelar en referens till originallistan till det nya namnet. Det vill säga att det ursprungliga namnet och det nya namnet båda pekar på samma listaobjekt. Ändringar som gjorts genom någon av dem kommer att återspeglas i en annan. Det är ofta inte vad du tänkte.

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

    Om du vill skapa en kopia av listan har du alternativ nedan.

    Du kan skära det:

    new_list = old_list[:]
    

    Du kan använda den inbyggda listan () -funktionen:

    new_list = list(old_list)
    

    Du kan använda generic copy.copy ():

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

    Detta är lite långsammare än listan () eftersom det måste ta reda på datatypen för old_list först.

    Om listan innehåller objekt och du också vill kopiera dem använder du generic copy.deepcopy ():

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

    Uppenbarligen den långsammaste och mest minnesbehovsmetoden, men ibland oundviklig.

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

Listans längd

Använd len() att få en endimensionell längd på en lista.

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

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

len() fungerar också på strängar, ordböcker och andra datastrukturer som liknar listor.

Observera att len() är en inbyggd funktion, inte en metod för ett listobjekt.

Observera också att kostnaden för len() är O(1) , vilket innebär att det tar samma tid att få längden på en lista oavsett längd.

Iterera över en lista

Python stöder användning av en for loop direkt på en lista:

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

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

Du kan också få positionen för varje artikel på samma gång:

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

Det andra sättet att upprepa en lista baserat på indexvärdet:

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

Observera att ändra objekt i en lista medan du upprepar den kan ha oväntade resultat:

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

# Output: foo
# Output: baz

I det senaste exemplet raderade vi det första objektet vid den första iterationen, men det orsakade att bar hoppades över.

Kontrollera om ett objekt finns i en lista

Python gör det mycket enkelt att kontrollera om ett objekt finns i en lista. Använd bara in operatören.

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

'test' in lst
# Out: True

'toast' in lst
# Out: False

Anmärkning: in operatören på uppsättningar är asymptotiskt snabbare än på listor. Om du behöver använda den många gånger på potentiellt stora listor, kanske du vill konvertera din list till en set och testa förekomsten av element i set .

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

Omvända listelement

Du kan använda den reversed funktionen som returnerar en iterator till den omvända listan:

In [3]: rev = reversed(numbers)

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

Observera att listan "siffror" förblir oförändrad med denna operation och förblir i samma ordning som den ursprungligen var.

För att vända på plats kan du också använda reverse metod .

Du kan också vända en lista (faktiskt få en kopia, den ursprungliga listan påverkas inte) genom att använda skärningssyntaxen och ställa in det tredje argumentet (steget) som -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]

Kontrollera om listan är tom

En listas tomhet är förknippad med boolean False , så du behöver inte kontrollera len(lst) == 0 , utan bara lst eller not lst

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

# Output: list is empty

Sammanhängande och sammanfoga listor

1. Det enklaste sättet att sammanfoga list1 och list2 :

   merged = list1 + list2
   

2. zip returnerar en lista med tuples , där i-th-tupeln innehåller det i-th-elementet från varje argumentsekvens eller iterables:

   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
   

   Om listorna har olika längder kommer resultatet endast att inkludera så många element som det kortaste:

   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 att fylla listor med ojämn längd till den längsta med None använd itertools.zip_longest ( itertools.izip_longest i 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. Infoga till ett specifikt indexvärde:

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

   Produktion:

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

Alla och alla

Du kan använda all() att avgöra om alla värden i en iterable utvärdering till True

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

På samma sätt bestämmer any() om ett eller flera värden i en iterable utvärdering till True

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

Medan detta exempel använder en lista är det viktigt att notera dessa inbyggda arbeten med alla iterbara, inklusive generatorer.

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

Ta bort duplicerade värden i listan

Att ta bort dubbla värden i en lista kan göras genom att konvertera listan till en set (det vill säga en oordnad samling av distinkta objekt). Om en list behövs datastruktur, då den inställda kan omvandlas tillbaka till en lista med funktionen list() :

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

Observera att genom att konvertera en lista till en uppsättning förloras den ursprungliga beställningen.

För att bevara listan på listan kan man använda en OrderedDict

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

Öppna värden i kapslad lista

Börjar med en tredimensionell lista:

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

Öppna objekt i listan:

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

Utföra supportåtgärder:

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

Använda kapslade för slingor för att skriva ut listan:

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]

Observera att denna operation kan användas i en listaförståelse eller till och med som en generator för att producera effektivitet, t.ex.

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

Inte alla artiklar i de yttre listorna måste själva vara listor:

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

Ett annat sätt att använda kapslade för slingor. Det andra sättet är bättre men jag har behövt använda detta ibland:

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]

Använda skivor i kapslad lista:

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

Den sista listan:

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

Jämförelse av listor

Det är möjligt att jämföra listor och andra sekvenser leksikografiskt med jämförelseoperatörer. Båda operanderna måste vara av samma typ.

[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

Om en av listorna finns i början av den andra vinner den kortaste listan.

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

Initiera en lista till ett fast antal element

För oföränderliga element (t.ex. None , strängbokstäver etc.):

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

För muterbara element kommer samma konstruktion att resultera i att alla element i listan hänvisar till samma objekt, till exempel för en uppsättning:

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

För att initialisera listan med ett fast antal olika muterbara objekt använder du:

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