Python Language
Lista

Wprowadzenie

Składnia

• [wartość, wartość, ...]
• lista ([iterowalna])

Uwagi

Dostęp do wartości listy

Listy w języku Python są indeksowane od zera i działają jak tablice w innych językach.

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

Próba uzyskania dostępu do indeksu poza granicami listy spowoduje błąd IndexError .

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

Wskaźniki ujemne są interpretowane jako liczenie od końca listy.

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

Jest to funkcjonalnie równoważne z

lst[len(lst)-1]  # 4

Listy pozwalają na stosowanie notacji plastra jako lst[start:end:step] . Dane wyjściowe notacji wycinka to nowa lista zawierająca elementy od start indeksu do end-1 . Jeśli opcje są pomijane start ustawienia domyślne na początek listy, end do końca listy i step do 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

Mając to na uwadze, możesz wydrukować odwróconą wersję listy, dzwoniąc

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

Podczas korzystania z długości kroków o wartości ujemnej indeks początkowy musi być większy niż indeks końcowy, w przeciwnym razie wynikiem będzie pusta lista.

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

Użycie ujemnych wskaźników kroków jest równoważne z następującym kodem:

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

Zastosowane wskaźniki są o 1 mniejsze niż te stosowane w indeksowaniu ujemnym i są odwrócone.

Zaawansowane krojenie

Podczas __getitem__() list wywoływana jest metoda __getitem__() obiektu listy z obiektem slice . Python ma wbudowaną metodę wycinania do generowania obiektów wycinków. Możemy to wykorzystać do przechowywania plastra i ponownego użycia go później,

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'

Może to być bardzo przydatne, zapewniając funkcję krojenia naszych obiektów, zastępując __getitem__ w naszej klasie.

Wymień metody i obsługiwane operatory

Zaczynając z danej listy a :

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

1. append(value) - dołącza nowy element na końcu listy.

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

   Zauważ, że metoda append() dołącza tylko jeden nowy element na końcu listy. Jeśli dodasz listę do innej listy, dołączana lista stanie się pojedynczym elementem na końcu pierwszej listy.

   # 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) - rozszerza listę poprzez dodanie elementów z innego enumerable.

   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]
   

   Listy można również łączyć z operatorem + . Pamiętaj, że nie zmienia to żadnej z oryginalnych list:

   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]) - pobiera indeks pierwszego wystąpienia wartości wejściowej. Jeśli wartości wejściowej nie ma na liście, ValueError jest wyjątek ValueError . Jeśli podany zostanie drugi argument, wyszukiwanie rozpocznie się od określonego indeksu.

   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) - wstawia value tuż przed określonym index . Zatem po wstawieniu nowy element zajmuje index pozycji.

   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]) - usuwa i zwraca element o index . Bez argumentu usuwa i zwraca ostatni element listy.

   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) - usuwa pierwsze wystąpienie określonej wartości. Jeśli nie można znaleźć podanej wartości, ValueError jest błąd 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() - odwraca listę w miejscu i zwraca None .

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

   Istnieją również inne sposoby cofania listy .

8. count(value) - zlicza liczbę wystąpień pewnej wartości na liście.

   a.count(7)
   # Returns: 2
   

9. sort() - sortuje listę w kolejności numerycznej i leksykograficznej i zwraca None .

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

   Listy można również odwrócić podczas sortowania przy użyciu flagi reverse=True w metodzie sort() .

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

   Jeśli chcesz, aby posortować według atrybutów elementów, można użyć key argumentu słowa kluczowego:

   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]
   

   W przypadku listy nagrań koncepcja jest taka sama:

   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]
   

   Sortuj według słownika:

   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]
   

Lepszy sposób sortowania za pomocą attrgetter i itemgetter

Listy można również sortować za pomocą funkcji attrgetter i itemgetter z modułu operatora. Mogą one pomóc poprawić czytelność i możliwość ponownego użycia. Oto kilka przykładów

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 może również otrzymać indeks. Jest to pomocne, jeśli chcesz sortować na podstawie indeksów krotki.

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

Użyj attrgetter jeśli chcesz sortować według atrybutów obiektu,

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() - usuwa wszystkie elementy z listy

    a.clear()
    # a = []
    

11. Replikacja - pomnożenie istniejącej listy przez liczbę całkowitą spowoduje utworzenie większej listy składającej się z tylu kopii oryginału. Może to być przydatne na przykład do inicjowania listy:

    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]
    

    Zachowaj ostrożność, jeśli twoja lista zawiera odniesienia do obiektów (np. Listę list), zobacz Często spotykane pułapki - Mnożenie list i wspólne odniesienia .

12. Usuwanie elementu - możliwe jest usunięcie wielu elementów z listy za pomocą słowa kluczowego del i notacji plastra:

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

    Domyślne przypisanie „=” przypisuje odwołanie oryginalnej listy do nowej nazwy. Oznacza to, że pierwotna nazwa i nowa nazwa wskazują ten sam obiekt listy. Zmiany dokonane za pomocą jednego z nich zostaną odzwierciedlone w innym. Często to nie jest to, co zamierzałeś.

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

    Jeśli chcesz utworzyć kopię listy, masz poniższe opcje.

    Możesz pokroić:

    new_list = old_list[:]
    

    Możesz użyć wbudowanej funkcji list ():

    new_list = list(old_list)
    

    Możesz użyć ogólnego copy.copy ():

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

    Jest to trochę wolniejsze niż list (), ponieważ najpierw musi znaleźć typ danych old_list.

    Jeśli lista zawiera obiekty, a także chcesz je skopiować, użyj standardowego copy.deepcopy ():

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

    Oczywiście najwolniejsza i najbardziej wymagająca pamięci metoda, ale czasem nieunikniona.

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

Długość listy

Użyj len() aby uzyskać jednowymiarową długość listy.

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

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

len() działa również na ciągi, słowniki i inne struktury danych podobne do list.

Zauważ, że len() jest wbudowaną funkcją, a nie metodą obiektu listy.

Zauważ też, że koszt len() wynosi O(1) , co oznacza, że uzyskanie takiej samej liczby zajmie tyle samo czasu, niezależnie od jego długości.

Iterowanie po liście

Python obsługuje używanie pętli for bezpośrednio na liście:

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

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

Możesz także uzyskać pozycję każdego elementu w tym samym czasie:

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

Inny sposób iteracji listy na podstawie wartości indeksu:

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

Pamiętaj, że zmiana elementów na liście podczas iteracji na niej może mieć nieoczekiwane rezultaty:

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

# Output: foo
# Output: baz

W tym ostatnim przykładzie usunęliśmy pierwszy element przy pierwszej iteracji, ale spowodowało to pominięcie bar .

Sprawdzanie, czy element znajduje się na liście

W Pythonie bardzo łatwo jest sprawdzić, czy element znajduje się na liście. Wystarczy użyć operatora in .

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

'test' in lst
# Out: True

'toast' in lst
# Out: False

Uwaga: operator in na zestawach jest asymptotycznie szybszy niż na listach. Jeśli musisz go używać wiele razy na potencjalnie dużych listach, możesz przekonwertować list na set i przetestować obecność elementów na set .

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

Elementy listy cofania

Możesz użyć funkcji reversed która zwraca iterator do odwróconej listy:

In [3]: rev = reversed(numbers)

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

Zauważ, że lista „liczb” pozostaje niezmieniona przez tę operację i pozostaje w tej samej kolejności, w jakiej była pierwotnie.

Aby odwrócić na miejscu, możesz również użyć metody reverse .

Możesz także odwrócić listę (faktycznie uzyskując kopię, oryginalna lista pozostaje nienaruszona), używając składni krojenia, ustawiając trzeci argument (krok) na -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]

Sprawdzanie, czy lista jest pusta

Pustka listy jest powiązana z wartością logiczną False , więc nie musisz sprawdzać len(lst) == 0 , ale tylko lst czy not lst

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

# Output: list is empty

Listy konkatenacji i scalania

1. Najprostszy sposób na konkatenację list1 i list2 :

   merged = list1 + list2
   

2. zip zwraca listę krotek , w których i-ta krotka zawiera i-ty element z każdej sekwencji argumentów lub iterable:

   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
   

   Jeśli listy mają różne długości, wynik będzie zawierał tylko tyle elementów, co najkrótszy:

   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
   

   Aby uzupełnić listy o nierównej długości do najdłuższej z None użyj itertools.zip_longest ( itertools.izip_longest w Pythonie 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. Wstaw do określonych wartości indeksu:

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

   Wynik:

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

Dowolni i wszyscy

Możesz użyć all() aby ustalić, czy wszystkie wartości w iterowalnej wartości mają wartość True

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

Podobnie any() określa, czy jedna lub więcej wartości w iterowalnej wartości ma wartość True

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

Chociaż w tym przykładzie użyto listy, ważne jest, aby pamiętać, że te wbudowane funkcje działają z dowolnym iterowalnym, w tym z generatorami.

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

Usuń zduplikowane wartości z listy

Usuwanie zduplikowanych wartości z listy można wykonać, przekształcając listę w set (czyli nieuporządkowaną kolekcję różnych obiektów). Jeśli potrzebna jest struktura danych list , zestaw można przekonwertować z powrotem na listę za pomocą funkcji list() :

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

Zauważ, że po przekonwertowaniu listy na zestaw oryginalne zamówienie zostaje utracone.

Aby zachować porządek na liście, można użyć polecenia OrderedDict

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

Dostęp do wartości z listy zagnieżdżonej

Zaczynając od trójwymiarowej listy:

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

Dostęp do pozycji na liście:

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

Wykonywanie operacji wsparcia:

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

Używanie zagnieżdżonych pętli do drukowania listy:

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]

Należy pamiętać, że ta operacja może być używana w zrozumieniu listy, a nawet jako generator do zwiększania wydajności, np .:

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

Nie wszystkie pozycje na listach zewnętrznych muszą być same listami:

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

Kolejny sposób użycia zagnieżdżonego dla pętli. Drugi sposób jest lepszy, ale musiałem skorzystać z tej okazji:

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]

Używanie plasterków na liście zagnieżdżonej:

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

Ostateczna lista:

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

Porównanie list

Możliwe jest porównywanie list i innych sekwencji leksykograficznie za pomocą operatorów porównania. Oba operandy muszą być tego samego typu.

[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

Jeśli jedna z list znajduje się na początku drugiej, wygrywa najkrótsza lista.

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

Inicjowanie listy do stałej liczby elementów

W przypadku elementów niezmiennych (np. None , literały łańcuchowe itp.):

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

W przypadku zmiennych elementów ta sama konstrukcja spowoduje, że wszystkie elementy listy będą odnosić się do tego samego obiektu, na przykład dla zestawu:

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

Zamiast tego, aby zainicjować listę za pomocą stałej liczby różnych zmiennych obiektów, użyj:

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