Lesson 7
Listy

1. Listy

Większość programów działa nie tylko ze zmiennymi. Korzystają również z list zmiennych. Na przykład program może obsłużyć informacje o uczniach w klasie, czytając listę uczniów z klawiatury lub z pliku. Zmiana liczby uczniów w klasie nie może wymagać modyfikacji kodu źródłowego programu.

Wcześniej mieliśmy już do czynienia z przetwarzaniem elementów sekwencji - na przykład przy obliczaniu największego elementu sekwencji. Ale nie zachowaliśmy całej sekwencji w pamięci komputera. Jednak w wielu problemach konieczne jest zachowanie całej sekwencji, tak jakbyśmy musieli wydrukować wszystkie elementy sekwencji w porządku rosnącym ("sortuj sekwencję").

Aby przechowywać takie dane, w Pythonie można użyć struktury danych nazywanej listą (w większości języków programowania używany jest inny termin - "tablica"). Lista jest sekwencją elementów ponumerowanych od 0, podobnie jak znaki w łańcuchu. Listę można ustawić ręcznie, wyliczając elementy na liście w nawiasach kwadratowych, na przykład tutaj:

Primes = [2, 3, 5, 7, 11, 13]
Rainbow = ['Red', 'Orange', 'Yellow', 'Green', 'Blue', 'Indigo', 'Violet']

Lista Primes ma 6 elementów, a mianowicie: Primes[0] == 2 , Primes[1] == 3 , Primes[2] == 5 , Primes[3] == 7 , Primes[4] == 11 , Primes[5] == 13 . Lista Rainbow ma 7 elementów, z których każdy jest ciągiem.

Podobnie jak znaki w łańcuchu, elementy listy mogą również mieć indeks ujemny, na przykład: Primes[-1] == 13 , Primes[-6] == 2 . Indeks ujemny oznacza, że ​​zaczynamy od ostatniego elementu i przechodzimy w lewo podczas czytania listy.

Możesz uzyskać liczbę elementów na liście z funkcją len (oznaczającą długość listy ), np. len(Primes) == 6 liczby pierwsze len(Primes) == 6 .

W przeciwieństwie do łańcuchów elementy listy są zmienne; można je zmienić, przypisując im nowe wartości.

None

Rainbow = ['Red', 'Orange', 'Yellow', 'Green', 'Blue', 'Indigo', 'Violet']
print(Rainbow[0])
Rainbow[0] = 'red'
print('Print the rainbow')
for i in range(len(Rainbow)):
    print(Rainbow[i])

Rozważ kilka sposobów tworzenia i czytania list. Przede wszystkim możesz utworzyć pustą listę (lista bez pozycji, jej długość to 0), a możesz dodać pozycje na końcu listy używając append . Załóżmy na przykład, że program otrzymuje liczbę elementów na liście n , a następnie n elementów listy po kolei w osobnej linii. Oto przykład danych wejściowych w tym formacie:

5
1809
1854
1860
1891
1925

5
1809
1854
1860
1891
1925

a = [] # rozpocząć pustą listę
n = int(input()) # odczytać numer elementu na liście
for i in range(n): 
    new_element = int(input()) # przeczytaj następny element
    a.append(new_element) # dodaj go do listy
    # dwie ostatnie linie można zastąpić jedną:
    # a.append (int (input ()))
print(a)

W zademonstrowanym przykładzie tworzona jest pusta lista, następnie odczytywana jest liczba elementów, a następnie czytane elementy listy wiersz po wierszu i dołączane do końca. To samo można zrobić, zapisując zmienną n :

5
1809
1854
1860
1891
1925

a = []
for i in range(int(input())):
    a.append(int(input()))
print(a)

Istnieje kilka operacji zdefiniowanych dla list: lista konkatenacja (dodanie list, tj. "Przyklejanie" jednej listy do drugiej) i powtarzanie (mnożenie listy przez liczbę). Na przykład:

None

a = [1, 2, 3]
b = [4, 5]
c = a + b
d = b * 3
print([7, 8] + [9])
print([0, 1] * 3)

Wynikowa lista c będzie równa [1, 2, 3, 4, 5] , a lista d będzie równa [4, 5, 4, 5, 4, 5] . To pozwala ci inaczej organizować proces czytania list: najpierw rozważ rozmiar listy i utwórz listę z żądanej liczby elementów, następnie przeprowadź pętlę przez zmienną i zaczynając od cyfry 0 i wewnątrz pętli przeczytaj i element listy:

5
1809
1854
1860
1891
1925

a = [0] * int(input())
for i in range(len(a)):
    a[i] = int(input())

Możesz wydrukować elementy listy a z print(a) ; wyświetla elementy listy otoczone nawiasami kwadratowymi i oddzielone przecinkami. Ogólnie jest to niewygodne; razem, masz zamiar wydrukować wszystkie elementy w jednym wierszu lub po jednym elemencie w linii. Oto dwa przykłady tego, używając innych form pętli:

None

a = [1, 2, 3, 4, 5]
for i in range(len(a)):
    print(a[i])

Tutaj zmienia się indeks i następnie wyświetlany jest element a[i] .

None

a = [1, 2, 3, 4, 5]
for elem in a:
    print(elem, end=' ')

W tym przykładzie elementy listy są wyświetlane w jednym wierszu oddzielonym spacjami, a nie zmienionym indeksem, ale wartością samej zmiennej (na przykład w pętli for elem in ['red', 'green', 'blue'] variable elem będzie kolejno przyjmować wartości 'red' , 'green' , 'blue' .

Zwróć szczególną uwagę na ostatni przykład! Bardzo ważnym elementem Python ideologii for pętli, która zapewnia wygodny sposób przechodzenia przez wszystkie elementy niektórych sekwencji. W tym miejscu Python różni się od Pascala, gdzie trzeba powtarzać indeksy elementów, ale nie nad samymi elementami.

Sekwencje w Pythonie to ciągi, listy, wartości range() funkcji range() (nie są to listy) i kilka innych obiektów.

Oto przykład pokazujący użycie pętli for , gdy trzeba wyodrębnić wszystkie cyfry z ciągu znaków i utworzyć ich listę numeryczną.

None

# dany: s = 'ab12c59p7dq'
# musisz wyodrębnić cyfry z listy s
# aby tak było:
# cyfry == [1, 2, 5, 9, 7]
s = 'ab12c59p7dq'
digits = []
for symbol in s:
    if '1234567890'.find(symbol) != -1:
        digits.append(int(symbol))
print(digits)

2. Metody dzielenia i łączenia

Elementy listy można podać w jednym wierszu oddzielonym znakiem; w tym przypadku całą listę można odczytać za pomocą metody input() . Następnie można użyć metody split() , która zwraca listę ciągów wynikowych po obcięciu początkowego łańcucha spacjami. Przykład:

1 2 3

# wejście to ciąg znaków
# 1 2 3
s = input() # s == '1 2 3'
a = s.split() # a == ['1', '2', '3']
print(a)

Jeśli uruchomisz ten program z danymi wejściowymi 1 2 3 , lista a będzie równa ['1', '2', '3'] . Pamiętaj, że lista składa się z ciągów, a nie liczb. Jeśli chcesz uzyskać listę numerów, musisz przekonwertować elementy listy jeden po drugim na liczby całkowite:

1 2 3

a = input().split()
for i in range(len(a)):
    a[i] = int(a[i])
print(a)

Używając specjalnej magii Pythona - generatorów - to samo można zrobić w jednej linii:

1 2 3

a = [int(s) for s in input().split()]
print(a)

(Wyjaśnimy, jak działa ten kod w następnej sekcji.) Jeśli chcesz przeczytać listę liczb rzeczywistych, musisz zmienić typ int na float .

Metoda split() ma opcjonalny parametr, który określa, który ciąg znaków będzie używany jako separator między elementami listy. Na przykład wywołanie metody split('.') Zwraca listę uzyskaną przez podzielenie początkowego łańcucha, w którym znajduje się znak '.' napotkano:

None

a = '192.168.0.1'.split('.')
print(a)

W Pythonie możesz wyświetlać listę ciągów przy użyciu komend jednoliniowych. W tym celu stosuje się metodę join ; ta metoda ma jeden parametr: listę łańcuchów. Zwraca ciąg otrzymany przez konkatenację podanych elementów, a separator wstawiany jest między elementy listy; ten separator jest równy ciągowi, na którym jest zastosowana metoda. Wiemy, że nie zrozumiałeś poprzedniego zdania od pierwszego razu. :) Spójrz na przykłady:

None

a = ['red', 'green', 'blue']
print(' '.join(a))
# powrót czerwony zielony niebieski
print(''.join(a))
# return redgreenblue
print('***'.join(a))
# zwraca czerwony *** zielony *** niebieski

Jeśli lista składa się z liczb, musisz użyć mrocznej magii generatorów. Oto jak możesz wydrukować elementy listy oddzielone spacjami:

None

a = [1, 2, 3]
print(' '.join([str(i) for i in a]))
# następna linia powoduje błąd typu,
# as join () może łączyć tylko sekwencje
# print (".join (a))

Jednakże, jeśli nie jesteś fanem czarnej magii, można osiągnąć ten sam efekt przy użyciu pętli for .

3. Generatory

Aby utworzyć listę wypełnioną identycznymi przedmiotami, możesz użyć listy powtórzeń, na przykład:

None

n = 5
a = [0] * n
print(a)

Aby utworzyć bardziej skomplikowane listy, możesz użyć generatorów : wyrażeń pozwalających wypełnić listę zgodnie z formułą. Ogólna forma generatora jest następująca:

[expression for variable in sequence]

gdzie variable jest identyfikatorem pewnej zmiennej, sequence jest ciągiem wartości, który przyjmuje zmienną (może to być lista, ciąg lub obiekt uzyskany za pomocą range funkcji), expression - pewne wyrażenie, zwykle w zależności od zmiennej stosowane w generatorze. Elementy listy zostaną wypełnione zgodnie z tym wyrażeniem.

Oto kilka przykładów osób korzystających z generatorów.

W ten sposób można utworzyć listę n zer przy użyciu generatora:

None

a = [0 for i in range(5)]
print(a)

Oto jak utworzyć listę wypełnioną kwadratami liczb całkowitych:

None

n = 5
a = [i ** 2 for i in range(n)]
print(a)

Jeśli chcesz wypełnić listę kwadratów liczb od 1 do n , możesz zmienić ustawienia range na range(1, n + 1) :

None

n = 5
a = [i ** 2 for i in range(1, n + 1)]
print(a)

Oto jak można uzyskać listę wypełnioną liczbami losowymi od 1 do 9 (używając randrange z modułu random ):

None

from random import randrange
n = 10
a = [randrange(1, 10) for i in range(n)]
print(a)

W tym przykładzie lista będzie składała się z linii odczytanych ze standardowego wejścia: najpierw należy wprowadzić liczbę elementów listy (ta wartość będzie używana jako argument range funkcji), po drugie - liczba łańcuchów:

5
a
b
1
2
3

a = [input() for i in range(int(input()))]
print(a)

4. Plastry

Dzięki listom i ciągom możesz tworzyć plasterki. Mianowicie:

A[i:j] wycinek ji elementy A[i] , A[i+1] , ..., A[j-1] .

A[i:j:-1] slice ij elementy A[i] , A[i-1] , ..., A[j+1] (czyli zmiana kolejności elementów).

A[i:j:k] pocięte z krokiem k : A[i] , A[i+k] , A[i+2*k] , .... Jeśli wartość k <0, elementy występują w odwrotnej kolejności.

Każda z liczb i lub j może być nieobecna, co oznacza "początek linii" lub "koniec linii"

Listy, w przeciwieństwie do łańcuchów, są zmiennymi obiektami : możesz przypisać element listy do nowej wartości. Co więcej, możliwa jest zmiana całych plasterków. Na przykład:

None

A = [1, 2, 3, 4, 5]
A[2:4] = [7, 8, 9]
print(A)

Otrzymaliśmy listę [1, 2, 3, 4, 5] , a następnie spróbuj zastąpić dwa elementy wycinka A[2:4] nową listą trzech elementów. Wynikowa lista jest następująca: [1, 2, 7, 8, 9, 5] .

None

A = [1, 2, 3, 4, 5, 6, 7]
A[::-2] = [10, 20, 30, 40]
print(A)

I tutaj, wynikowa lista będzie [40, 2, 30, 4, 20, 6, 10] . Powodem jest, że A[::-2] jest listą elementów A[-1] , A[-3] , A[-5] , A[-7] , a te elementy są przypisane do 10, 20, 30, 40, odpowiednio.

Jeśli nieciągłemu wycinkowi (tj. Plasterkowi z krokiem k , k > 1 ) przypisywana jest nowa wartość, to liczba elementów w starych i nowych plasterkach musi się pokrywać, w przeciwnym razie wystąpi błąd ValueError .

Zauważ, że A[i] to element listy, a nie plasterek!

5. Operacje na listach

Z listami można łatwo wykonywać wiele różnych operacji.