python list create
W tym samouczku dotyczącym list języka Python zbadamy sposoby tworzenia, uzyskiwania dostępu, wycinania, dodawania / usuwania elementów do list języka Python, które są prawdopodobnie jednym z najbardziej przydatnych typów danych:
Python zawiera 4 typy danych kolekcji, jak wspomniano poniżej:
- Lista
- Zestaw
- Słownik
- Tuple
W tym samouczku omówimy szczegółowo listę i jej różne operacje. W Pythonie lista jest strukturą danych lub przypomina tablicę, która służy do przechowywania wielu danych jednocześnie.
=> Poznaj serię szkoleń Python tutaj
Jeśli masz doświadczenie w innych językach programowania, takich jak Java, C, C ++ itp., Będziesz zaznajomiony z pojęciem tablic. Lista jest prawie taka sama jak tablice.
Czego się nauczysz:
- Co to są listy w Pythonie
- Więcej informacji o listach w Pythonie
- Wniosek
Co to są listy w Pythonie
W Pythonie lista to typ danych , który przechowuje zbiór różnych obiektów (elementów) w nawiasach kwadratowych (()). Każda pozycja na liście jest oddzielona przecinkiem (,) z pierwszą pozycją o indeksie 0.
Uwaga :Idąc dalej, wszystkie przykłady w tym samouczku będą uruchamiane bezpośrednio z powłoki Pythona, chyba że określono inaczej.
Poniżej znajduje się przykład listy z 5 pozycjami.
>>> l = ('what','who','where','when','how') >>>l ('what','who','where','when','how') W powyższym przykładzie widzimy, że lista ma Obiekty ciągów jako elementy, a każdy element jest oddzielony przecinkiem.
Charakterystyka listy Pythona
Zanim przyjrzymy się, jak możemy manipulować elementami na liście, przyjrzyjmy się niektórym cechom, które sprawiają, że listy w Pythonie są preferowane.
Listy w Pythonie są sekwencjami kontenerów
W przeciwieństwie do płaskich sekwencji ( strunowy , array.array , Widok pamięciowy itp.), które mogą zawierać tylko elementy jednego typu, lista to sekwencja kontenerów które mogą pomieścić przedmioty jednego lub różnych typów.
Przykład z elementami jednego rodzaju
Otwórzmy naszą powłokę Pythona i zdefiniujmy listę liczb.
>>> numbers = ('one','two','three','four','five') >>> numbers ('one','two','three','four','five') Powyższy przykład przedstawia listę pozycji tego samego typu, w tym przypadku typu string (str) .
Przykład z elementami różnych typów
Otwórzmy naszą powłokę Pythona i zdefiniujmy inną wersję listy liczb.
>>> numbers = ('one',2,3,'four',5.0) >>> numbers ('one',2,3,'four',5.0) Powyższy przykład przedstawia listę elementów różnych typów. Typy są strunowy , liczba całkowita, i pływak .
// a sketch showing the list of items and their types as annotationLista Pythona może również zawierać wszystkie obiekty, takie jak Funkcje , zajęcia , moduły , listy , krotki, i wiele więcej.
Otwórz edytor i wklej poniższy kod:
def test(): '''This is a function''' print('This is a test') if __name__ == '__main__': print(test) # return instance object of function 'test' instance = type(test) print(instance) # create a list of colors colors = ('red','blue','green') print(colors) # create a list holding all the various data types defined above, including boolean. my_list = (test, instance, colors, False) print(my_list) Wynik
Listy Pythona to uporządkowane sekwencje
Lista w Pythonie to uporządkowany zbiór obiektów. Pozycja każdego elementu na liście jest bardzo ważna. W rzeczywistości dwie listy z tymi samymi elementami nie są takie same, jeśli kolejność, w jakiej pozycje są umieszczone, nie jest taka sama.
>>> ('a','b','c','d') == ('a','c','b','d') False Ta cecha listy Pythona umożliwia dostęp do jej elementów poprzez indeksowanie i wycinanie (więcej o tym później).
Listy Pythona są sekwencjami modyfikowalnymi
Listy Pythona są zmienne. Ale co to jest zmienny obiekt? To po prostu obiekt, który po utworzeniu można modyfikować. Przykłady innych mutowalnych sekwencji słownik , array.array , collections.deque .
Dlaczego zmienny? Sekwencje takie jak listy są używane do złożonych operacji, więc ma sens, aby były w stanie to zrobić zmiana , rosnąć , kurczyć się , aktualizacja itp . Jest to możliwe tylko przy zmienności. Zmienność umożliwia nam również modyfikowanie list w miejscu (więcej na ten temat).
Sprawdźmy zmienność listy na poniższym przykładzie.
Po prostu otwórz edytor i wklej kod:
def veryfiy_mutability(): # create a list l = (9,0,4,3,5) print('Display before modifying') print('List: {}
Id: {}'.format(l,id(l))) # modify the list by replacing the item at # index 3 to the item -2. l(3) = -2 print('Display after modifying') print('List: {}
Id: {}'.format(l,id(l))) if __name__ == '__main__': veryfiy_mutability() Wynik
Z powyższego wynika, że lista przed i po modyfikacji jest inna. Jednakże ID wartość jest taka sama. Plik ID Wartość tutaj reprezentuje adres obiektu w pamięci - który jest uzyskiwany za pomocą Pythona ID() .
To mówi nam, że chociaż zawartość listy uległa zmianie, nadal jest to ten sam obiekt. Dlatego spełnia to naszą definicję: „ To po prostu obiekt, który po utworzeniu można modyfikować '
Uwaga :W powyższym przykładzie użyliśmy indeksowania (więcej na ten temat), aby zmodyfikować listę.
Manipulowanie listami Pythona
Dzięki listom Pythona nie ma ograniczeń. Jest wiele rzeczy, które możemy zrobić z takimi listami, jak dodanie , usuwanie , indeksowanie , krajanie na plastry , sprawdzanie członkostwa , i wiele więcej. Ponadto Python ma wbudowane funkcje, które sprawiają, że manipulowanie listami jest bardziej ekscytujące.
W tej sekcji przyjrzymy się niektórym często używanym operacjom na listach.
Tworzenie listy
Aby utworzyć listę, po prostu umieść kilka elementów lub wyrażeń w nawiasach kwadratowych oddzielonych przecinkami.
(expression1, expression2,...,expresionN) >>> l = (4,3,5,9+3,False) >>> l (4, 3, 5, 12, False) Ponadto Python ma wbudowany obiekt o nazwie lista (), których można użyć do tworzenia list.
list( sequence ) >>> l = list() # create an empty list >>> l () Pyton lista () może przyjmować typy sekwencji i konwertować je na listy. Jest to typowy sposób konwertowania krotki na listę.
>>> t = (4,3,5) # tuple >>>l = list(t) # convert into list (4,3,5) W powyższym przykładzie użyliśmy typu danych Tuple . Jest podobna do listy, ale w przeciwieństwie do list jest niezmienna, a jej elementy są umieszczone w nawiasach.
Innym sposobem tworzenia listy jest użycie lista zrozumienia który ma następującą składnię.
(expression for item in sequence) >>> (i**2 for i in range(4)) (0, 1, 4, 9) Warto zauważyć, że listy w Pythonie są przekazywane przez odniesienie. Oznacza to, że przypisanie listy zapewni jej tożsamość w pamięci. Błędem, który popełnia wielu początkujących, jest tworzenie list w ten sposób.
>>> l1 = l2 = (4,3) # wrong way to create separate list objects >>> l1 (4,3) >>> l2 (4,3) Tutaj moglibyśmy pomyśleć, że stworzyliśmy dwie różne listy, ale tak naprawdę właśnie utworzyliśmy jedną. Zademonstrujmy to, modyfikując jedną ze zmiennych.
>>> l1(0) = 0 >>> l1 (0,3) >>> l2 (0,3) Zauważamy, że modyfikowanie jednej zmiennej zmienia drugą. Dzieje się tak, ponieważ obie zmienne l1 i l2 mają tę samą tożsamość lokalizacji pamięci, więc obie wskazują ten sam obiekt.
Dodawanie pozycji do listy
Python ma wiele sposobów dodawania elementów do swojej listy. Najczęstszym sposobem jest użycie dodać() metoda. Inne sposoby to użycie poszerzać() metoda. Indeksowanie i krajanie na plastry (więcej na ten temat później) są częściej używane do zastępowania elementów na liście.
# 1) Za pomocą metody append ()
Ta metoda pobiera pojedynczy element i dodaje go na koniec listy. Nie zwraca nowej listy, ale po prostu modyfikuje listę w miejscu (dzięki swojej zmienności).
>>>l = list() # create empty list >>> l () >>> l.append(4) # add an integer >>> l (4) >>> l.append((0,1)) # add a list >>> l (4, (0, 1)) >>> l.append(4 >> l (4, (0, 1), True) >>> l.append(x for x in range(3)) # add result of a tuple comprehension >>> l (4, (0, 1), True, ) Kilka rzeczy do zapamiętania z powyższego przykładu:
- Elementami tutaj mogą być wyrażenia, typy danych, sekwencje i wiele innych.
- Plik dodać() metoda ma złożoność czasową (0) 1. Oznacza to, że jest stały.
# 2) Użycie metody ext ()
Ta metoda przyjmuje iterowalny argument jako argument i dodaje wszystkie elementy z niego na koniec listy. Ta metoda jest najczęściej używana, gdy chcemy dodać pojedyncze elementy sekwencji do listy
Zasadniczo poszerzać() metoda iteruje po swoim argumencie i dołącza każdy element do listy. Podobnie jak metoda append (), nie zwraca nowej listy, ale modyfikuje listę w miejscu.
>>> l1 = (3,2,5) # create a list of items >>> l1 (3, 2, 5) >>> l2 = (0,0,-1) # create a second list of items >>> l2 (0, 0, -1) >>> str = 'hello' # create a string(iterable) >>> str 'hello' >>> l1.extend(l2) # append all items from l2 to l1 >>> l1 (3, 2, 5, 0, 0, -1) >>> l1.extend(str) # append all items from str to l1 >>> l1 (3, 2, 5, 0, 0, -1, 'h', 'e', 'l', 'l', 'o') Kilka rzeczy do zapamiętania z powyższego przykładu:
- Ciąg jest iterowalny, więc nasz poszerzać() metoda będzie iterować po swoich znakach.
- Plik poszerzać() metoda ma złożoność czasową wynoszącą (0) K, gdzie K jest długością argumentu.
Dostęp do pozycji z listy
Indeksowanie i krajanie na plastry są najczęściej używanymi środkami dostępu do list. Możemy również uzyskać dostęp do elementów na liście za pomocą pętli, takich jak dla pętli .
# 1) Indeksowanie
Lista w Pythonie używa rozszerzenia numeracja od zera system. Oznacza to, że wszystkie jego pozycje są jednoznacznie identyfikowane przez numer indeksu zaczynający się od 0 do n-1, gdzie n jest długością listy.
Rozważ poniższą listę:
>>> colors = ('red','blue','green','yellow','black') # create list >>> colors ('red','blue','green','yellow','black') >>> len(colors) # get list length 5 Poniższa tabela przedstawia ich odpowiednie indeksy w formacie numeracja listy od zera.
| Pozycja | netto | niebieski | Zielony | żółty | czarny |
|---|---|---|---|---|---|
| Muzyka pop () | Aby usunąć / usunąć element z ostatniego na liście. | ||||
| Indeks | 0 | 1 | dwa | 3 | 4 |
Z powyższej tabeli widzimy, że pierwszy element („czerwony”) znajduje się w pozycji indeksu 0, a ostatni element („czarny”) jest na pozycji indeksu 4 (n-1), gdzie n = 5 (długość obiektu zabarwienie).
Jak widzieliśmy w sekcji charakterystycznej powyżej, listy w Pythonie są uporządkowanymi sekwencjami. To pozwala nam używać indeksowania do łatwego dostępu i manipulowania jego elementem.
Użyjmy indeksowania, aby uzyskać dostęp do elementów o określonych indeksach obiektu kolorów utworzonego powyżej.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(0) # access item at index 0 'red' >>> colors(4) # access item at index 4 'black' >>> colors(9) # access item at index 9 Traceback (most recent call last): File '', line 1, in IndexError: list index out of range Uwaga :Ostatnia powyższa instrukcja próbuje uzyskać dostęp do elementu na pozycji indeksu 9 z obiektu listy o długości 5. Na liście Pythona, dostęp do elementu w indeksie, który nie istnieje, podniesie wartość IndexError wyjątek.
Ważną koncepcją indeksowania jest to, że możemy użyć indeksowania ujemnego, tj. Możemy uzyskać dostęp do elementów listy w odwrotny sposób, zaczynając od -1 dla ostatniego elementu i kończąc na -n dla ostatniego elementu, gdzie n jest długością obiektu listy.
W powyższej tabeli, jeśli użyjemy indeksowania ujemnego, będzie wyglądać tak, jak pokazano poniżej:
| Pozycja | netto | niebieski | Zielony | żółty | czarny |
|---|---|---|---|---|---|
| Indeks | -5 | -4 | -3 | -dwa | -1 |
Użyjmy indeksowania ujemnego, aby uzyskać dostęp do niektórych elementów obiektu koloru utworzonego powyżej.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(-1) # access item and index -1(first item counting backward) 'black' >>> colors(-3) # access item at index -3(third item counting backward) 'green' >>> colors(-5) # access item at index -5 (last item counting backward) 'red' # 2) Krojenie
W przeciwieństwie do indeksowania, które zwraca tylko jeden element, krajanie na plastry z drugiej strony może zwrócić szereg elementów.
Ma następującą składnię:
L(n:m)Kiedy n to numer indeksu, od którego zaczyna się wycinek (domyślnie 0), a m to wyłączny numer indeksu, na którym kończy się wycinek (domyślnie długość to 1). Są oddzielone dwukropkiem (:)
Rozważ poniższy przykład, w którym zastosowano wycinanie w celu uzyskania dostępu do elementów o określonych indeksach obiektu kolorów utworzonego powyżej.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(0:2) # get first two items ('red', 'blue') >>> colors(1:4) # get items at index 1,2 and 3 ('blue', 'green', 'yellow') >>> colors(2:len(colors) # get items from index 2 to the last item ('green', 'yellow', 'black') >>> colors(3:4) # get one item at index 3. Same as colors(3) ('yellow') >>> W składni L (n: m), n przyjmuje wartość domyślną 0, a m domyślnie odpowiada długości listy. Więc w przykłady 1 i 3 powyżej, możemy pominąć n i m odpowiednio jako kolory (: 2) i kolory (2:). Lub (:), co w tym przypadku zwraca płytką kopię całego obiektu listy.
Możemy również używać ujemnych liczb indeksowych podczas krojenia list. Jest to zwykle używane, gdy chcemy uzyskać dostęp do listy w odwrotny sposób.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(-3:-2) ('green') >>> colors(-2:) ('yellow', 'black') Istnieje również trzeci parametr, który obsługuje krojenie o nazwie krok (s). Określa, o ile elementów należy przesunąć do przodu po pobraniu pierwszego elementu z listy. Domyślnie 1.
L(n:m:s)Korzystając z tej samej listy kolorów zdefiniowanej powyżej, użyjmy trzeciego parametru wycinka, aby przejść o 2 kroki.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(0:3:2) ('red', 'green') # 3) Korzystanie z pętli
Pętle są najczęściej używane do uzyskiwania dostępu do elementów na liście w celu manipulowania nimi. Jeśli więc chcemy operować na elementach listy, możemy użyć dla pętli aby uzyskać dostęp do przedmiotów i przekazać je do obsługi.
Powiedzmy, że chcemy policzyć liczbę liter w każdej pozycji. Możemy użyć dla pętli aby to osiągnąć.
Otwórz edytor i wklej poniższy kod:
def count_letters(l): count = {} # define a dict to hold our count for i in l: # loop through the list count(i) = len(i) # for each item, compute its length and store it in the dict return count # return the count if __name__ == '__main__': colors = ('red', 'blue', 'green', 'yellow', 'black') print(count_letters(colors)) Wynik
Aby zakończyć tę sekcję, przyjrzyjmy się dwóm fajnym rzeczom, które można zrobić za pomocą krojenia.
-
Zrób płytką kopię listy
Jest to podstawowy sposób korzystania z Kopiuj() metoda obiektu listy lub funkcji wbudowanej copy.copy . Można to jednak osiągnąć przez krojenie.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors_copy = colors(:) # make a shallow copy >>> colors_copy ('red', 'blue', 'green', 'yellow', 'black') >>> colors_copy(0) = 0 # modify item at index 0 by changing its value to 0 >>> colors_copy # the copied version now has 0 at index 0 (0, 'blue', 'green', 'yellow', 'black') >>> colors # the original version is unchanged ('red', 'blue', 'green', 'yellow', 'black') >>> -
Odwróć listę
Podstawowym sposobem jest użycie odwrócić metoda obiektu listy lub funkcji wbudowanej wywrócony() . Można to jednak osiągnąć przez krojenie.
>>> colors # original list object ('red', 'blue', 'green', 'yellow', 'black') >>> colors(::-1) # returns a reversed shallow copy of the the original list ('black', 'yellow', 'green', 'blue', 'red') >>> Usuwanie pozycji z listy
Ponieważ możemy dodać dowolną liczbę pozycji do listy, można je również usunąć z listy. Trzy sposoby usuwania elementów to:
# 1) Korzystanie z instrukcji del
Ma następującą składnię:
del target_listLista docelowa ( target_list ) może być całą listą (w przypadku, gdy chcesz usunąć listę) lub pozycją lub pozycjami na liście (w tym przypadku używasz indeksowania lub wycinania).
Rozważ poniższy przykład .
Powiedzmy, że chcemy usunąć niektóre elementy z listy kolorów utworzonej powyżej.
>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> del c_copy(0) # delete item at index 0 >>> c_copy ('blue', 'green', 'yellow', 'black') >>> del c_copy(0:2) # delete items at index 0 and 1(slicing) >>> c_copy ('yellow', 'black') >>> del c_copy(:) # delete all items in a list. Same as ‘c_copy.clear()’ () >>> del c_copy # delete the list object >>> c_copy # access object that doesn't exist Traceback (most recent call last): File '', line 1, in NameError: name 'c_copy' is not defined >>> Uwaga :Instrukcja del usuwa na miejscu tj. , zmodyfikuje oryginalny obiekt listy zamiast zwracać nowy obiekt listy.
# 2) Korzystanie z list.remove (x)
Usuwa pierwszy element z listy, którego wartość jest równa x . Podnosi błąd ValueError, jeśli nie ma takiego elementu.
Ta metoda jest używana głównie do usuwania elementów z listy według nazwy, w przeciwieństwie do instrukcji del, która wykorzystuje indeksowanie i wycinanie.
>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # create shallow copy to work on >>> c_copy ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy.remove('blue') # remove first item with name 'blue' >>> c_copy ('red', 'green', 'yellow', 'black') >>> c_copy.remove('blue') # try to remove item that doesn't exist Traceback (most recent call last): File '', line 1, in ValueError: list.remove(x): x not in list >>> Uwaga :Obiekt listy usunąć() metoda usuwa na miejscu tj. , zmodyfikuje oryginalny obiekt listy zamiast zwracać nowy obiekt listy.
# 3) Korzystanie z list.pop ((i))
Usuwa i zwraca element na podanej pozycji w obiekcie listy. Jeśli nie podano i (indeks), usuwa i zwraca ostatnią pozycję na liście.
Uwaga :Nawias kwadratowy wokół i powyżej nie oznacza listy i, a raczej oznacza, że i jest opcjonalne.
>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> c_copy ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy.pop(3) # pop out the item at index 3 'yellow' >>> c_copy ('red', 'blue', 'green', 'black') >>> c_copy.pop() # pop out the last item in the list 'black' >>> c_copy ('red', 'blue', 'green') >>> Uwaga: Lista. pop ((i)) metoda usuwa na miejscu tj. , zmodyfikuje oryginalny obiekt listy zamiast zwracać nowy obiekt listy. Zwraca również element usunięty z listy
Zastępowanie pozycji z listy
Wymiana przedmiotów jest dość prosta. W jednej z powyższych sekcji widzieliśmy indeksowanie i wycinanie. Można ich używać do uzyskiwania dostępu i usuwania elementów z listy.
# 1) Zastąp za pomocą indeksowania
L(index) = value >>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> c_copy ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy(0) = 'brown' # replace item at index 0 with 'brown' >>> c_copy ('brown', 'blue', 'green', 'yellow', 'black') >>> # 2) Wymiana za pomocą krojenia
L(n:m) = valueUwaga : Wartość powinien być iterowalne lub TypeError wyjątek zostanie podniesiony.
>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> c_copy(0:2) = ('brown') # replace items at index 0 and 1 with 'brown' >>> c_copy ('brown', 'green', 'yellow', 'black') >>> c_copy(1:3) = ('white','purple') # replace items at index 1 and 2 with 'white' and 'purple' >>> c_copy ('brown', 'white', 'purple', 'black') >>> c_copy(1:4) = ('white','purple') # replace items at index 1,2 and 3 with 'white' and 'purple'. Here we replace 3 items with 2 items >>> c_copy ('brown', 'white', 'purple') >>> Często Zadawane Pytania
Pytanie 1) Co to jest lista list w Pythonie?
Odpowiedź: Lista list w Pythonie to lista zawierająca listy jako swój element.
Na przykład
(('a','b'),('c','d'))Może być również określany jako plik lista zagnieżdżona .
Pytanie 2) Jak deklaruje się listę w Pythonie?
Odpowiedź: W Pythonie listę można zadeklarować na dwa sposoby. Albo za pomocą wbudowanej funkcji lista() lub używając notacji w nawiasach (). lista() przyjmuje iterowalne, a () pobiera elementy dowolnego typu oddzielone przecinkiem.
(pytyon)>>> list('hello') # a string is iterable ('h', 'e', 'l', 'l', 'o') >>> (3,4,5,23) # numbers are separated by comma (3, 4, 5, 23) >>> (/python)P # 3) Czy możesz umieścić listę w liście Python?
Odpowiedź: Tak, możemy umieścić listę wewnątrz listy. W rzeczywistości lista jest sekwencją kontenerów, która przyjmuje elementy dowolnego typu danych.
P # 4) Co robi list () w Pythonie?
Odpowiedź: list ( ) to funkcja wbudowana w Pythonie, która tworzy obiekt listy. Przyjmuje jako argument iterowalny.
>>> list((3,2,4)) # The iterable object here is a tuple. (3, 2, 4) >>> Pytanie 5) Czy lista Pythona może zawierać różne typy?
Odpowiedź: Lista to sekwencja kontenerów, która przyjmuje elementy dowolnego typu danych ( lista , krotka , liczba całkowita , pływak , smyczki itp.)
Więcej informacji o listach w Pythonie
Co to jest struktura danych?
Komputery są używane do przechowywania ogromnej liczby danych lub przetwarzania ogromnej liczby danych z dużą szybkością i dokładnością. Dlatego najlepiej przechowywać dane na stałe, aby mieć do nich szybki dostęp.
Przetwarzanie danych powinno nastąpić w jak najkrótszym czasie bez utraty dokładności. Korzystamy ze struktury danych, aby obchodzić się z danymi w zorganizowany sposób i przechowywać dane w pamięci do przetwarzania.
Ponieważ Python jest językiem programowania wysokiego poziomu i jest interpretowany, bardzo ważne jest, aby korzystać ze struktury danych w Pythonie.
Co to jest lista?
Lista to struktura danych używana do przechowywania wielu danych jednocześnie.
Dane przechowywane na liście są jednorodne, co z kolei sprawia, że jest to najpotężniejsza funkcja listy w Pythonie. Na jednej liście możemy przechowywać wiele danych różnych typów danych, takich jak ciągi, liczby całkowite i obiekty.
Lista jest zmienna w Pythonie, dzięki czemu dane można zmienić w dowolnym momencie, nawet po utworzeniu. Listy są bardzo przydatne do implementowania stosów i kolejek w Pythonie.
Jak wspomniano wcześniej, lista przechowuje dane w uporządkowanej kolejności, a dostęp do danych przechowywanych na liście uzyskuje się za pomocą ich indeksu, aw przypadku listy indeks zawsze zaczyna się od zera. Każdy element ma określone miejsce na liście, a dostęp do wszystkich tych danych odbywa się za pomocą indeksu.
Na liście możemy wielokrotnie przechowywać tę samą wartość, a każde dane będą traktowane jako osobny i niepowtarzalny element. Listy najlepiej przechowywać dane i przeglądać je później.
Tworzenie listy
Dane na liście są przechowywane w postaci oddzielonych przecinkami i ujęte w nawias kwadratowy (()). Pozycje na liście nie muszą być tego samego typu.
Syntax: List = (item1, item2, item3)Przykład 1:
List = ( )Przykład 2:
List = (2, 5, 6.7)Przykład 3:
List = (2, 5, 6.7, ‘Hi’)Przykład 4:
List = (‘Hi’, ‘Python’, ‘Hello’)W powyższych przykładach możemy zauważyć, że przechowywaliśmy elementy różnych typów danych oddzielone przecinkami, 2 i 5 są typu Integer, 6.7 to float, a 'Hi' jest typu String, wszystkie te elementy są zawarte w list i to sprawia, że jest Listą.
Możemy również zadeklarować pustą listę. Możemy również zadeklarować listę wewnątrz innej listy i nazywamy to listą zagnieżdżoną.
Przykład 5:
List = (‘Hi’, (2, 4, 5), (‘Hello’))W powyższym przykładzie można zauważyć, że lista została zadeklarowana wewnątrz innej listy.
Dostęp do wartości na liście
Dostęp do elementów znajdujących się na liście w Pythonie można uzyskać na różne sposoby.
Za pomocą indeksu mamy dostęp do elementów listy. Indeks zaczyna się od 0, a indeks powinien zawsze być liczbą całkowitą. Jeśli użyjemy indeksu innego niż liczba całkowita, takiego jak float, to spowoduje to TypeError.
Przykład 1:
List = (2, 5, 6.7, ‘Hi’) print(“List is:”, List)Wynik:
Lista to: (2, 5, 6.7, „Cześć”)
Wynik:
narzędzia do testowania REST API open source
W powyższym przykładzie bezpośrednio drukujemy listę za pomocą funkcji print, nie uzyskujemy dostępu do pojedynczego elementu z listy.
Przejdźmy do pojedynczego elementu z listy.
Przykład: 2
List = (2, 5, 6.7, ‘Hi’) print(“Second element of the list is:”, List(1))Wynik:
Drugi element listy to: 5
Wynik:
W powyższym przykładzie możesz zauważyć, że drukujemy drugi element listy czyli 5, ale może pojawić się pytanie, dlaczego w instrukcji print drukujemy List (1)? Dzieje się tak, ponieważ indeks zaczyna się od zera, stąd List (1) odnosi się do drugiego elementu listy.
Przykład: 3
List = (2, 5, 6.7, ‘Hi’) print(“First element in the List is: ”, List(0)) print(“Last element in the List is: ”, List(3))Wynik:
Pierwszy element na liście to: 2
Ostatni element na liście to: Cześć
Wynik:
Przykład: 4
List = (‘Hi’, (2, 4, 5)) print(“First element of the list is: ”, List(0)(1)) print(“Elements present inside another list is: ”, List(1)(2))Wynik:
Pierwszy element listy to: i
Elementy obecne na innej liście to: 5
Wynik:
W powyższym programie, jeśli przyjrzysz się uważnie, zobaczysz, że uzyskujemy dostęp do elementów z zagnieżdżonej listy.
Dane wewnętrzne będą przechowywane w formacie macierzy, jak pokazano poniżej:
cześć
2 4 5
W związku z tym, gdy spróbujemy uzyskać dostęp do listy (0) (1), wskaże 1śwwiersz i 2ndkolumna, tym samym dane będą „i”.
Podobnie, gdy spróbujemy uzyskać dostęp do listy (1) (2), wskaże ona 2ndwiersz i 3r & Dkolumna, tym samym dane będą wynosić 5.
Indeksowanie negatywne
Możemy również uzyskać dostęp do danych za pomocą ujemnego indeksu. Indeks ujemny zawsze zaczyna się od -1, a -1 odnosi się do ostatniego elementu, a -2 do ostatniej drugiej pozycji i tak dalej.
Przykład 1
List = (2, 5, 7, 3) print(“Last element in the list is: ”, List(-1))Wynik:
Ostatni element na liście to: 3
Wynik:
Przykład: 2
List = (2, 5, 7, 3) print(“Second element in the list is: ”, List(-3))Wynik:
Drugi element na liście to: 5
Wynik:
Cięcie listy
Używając operatora wycinka (:) możemy uzyskać dostęp do szeregu elementów z listy
Przykład 1
List = (1, 2, 3, 4, 5, 6, 7) print(“Elements from 2nd to 5th is: ”, List(1:5)) print(“Elements beginning to 2rd is: ”, List(:-3)) print(“Elements 4th to end is: ”, List(3:)) print(“Elements from start to end is: “, List(:))Wynik:
Elementy od 2 do 5 to: (2, 3, 4, 5)
Elementy zaczynające się od 2-ego to: (1, 2, 3, 4)
Elementy od czwartego do końca to: (4, 5, 6, 7)
Elementy od początku do końca to: (1, 2, 3, 4, 5, 6, 7)
Wynik:
Możemy również uzyskać dostęp do elementów znajdujących się na liście za pomocą pętli for.
Przykład: 2
List = (1, 2, 3, 4, 5, 6, 7) forele in List: print(ele)Wynik:
1
dwa
3
4
5
6
7
Wynik:
Zapamiętaj format indeksowania poniżej:
| H. | JEST | L | L | LUB | 5 | 7 | 9 | 4 |
| 0 | 1 | dwa | 3 | 4 | 5 | 6 | 7 | 8 |
| -9 | -8 | -7 | -6 | -5 | -4 | -3 | -dwa | -1 |
Jak wspomniano wcześniej, List w pythonie jest zmienny, co oznacza, że elementy można zmieniać, nawet jeśli jest to liczba całkowita, łańcuch lub dowolny typ danych.
Listę możemy zaktualizować za pomocą operatora przypisania.
Przykład: 3
List = (2, 4, 6, 9) #updating the first element List(0) = 7 print(“Updated list is: ”, List)Wynik:
Zaktualizowana lista to: (7, 4, 6, 9)
Wynik:
W powyższym przykładzie aktualizujemy pierwszy element listy „2” o nowy element „7”.
Przykład: 4
List = (2, 5, 1, 3, 6, 9, 7) #updating one or more elements of the list at once List(2:6) = (2, 4, 9, 0) print(“Updated List is: ”, List)Wynik:
Zaktualizowana lista to: (2, 5, 2, 4, 9, 0, 7)
W powyższym przykładzie aktualizujemy listę danych do listy.
Wynik:
Dodawanie elementów do listy
Istnieje kilka sposobów dodawania elementów do listy, a python ma wbudowaną funkcję o nazwie append ().
Za pomocą append () możemy dodać tylko jeden element do listy, jeśli chcesz dodać wiele elementów do listy to musimy skorzystać z dla pętli . Funkcja append () zawsze dodaje element na końcu listy, funkcja append () przyjmuje tylko jeden argument.
Jeśli chcesz dodać elementy w określonej pozycji, wystarczy użyć metody insert (). Funkcja insert () przyjmuje dwa argumenty, tj. pozycję i wartość, pozycja odnosi się do indeksu, w którym elementy muszą zostać dodane, a wartość odnosi się do elementu, który ma zostać dodany do listy.
Jest jeszcze jedna metoda o nazwie extension (), za pomocą której możemy dodawać elementy do listy. Extend () służy do dodawania listy elementów do listy. Podobnie jak metoda append () i metoda extension (), dodaje również elementy na końcu listy.
Przykład 1
List = (“Hello”, “Good Morning”) print(“List before appending values is: “, List) List.append(“Python”) List.append(“Hi”) print(“List after appending values is: ”, List)Wynik:
Lista przed dołączeniem wartości to: („Hello”, „Good Morning”)
Lista po dołączeniu wartości to: („Hello”, „Good Morning”, „Python”, „Hi”)
W powyższym przykładzie dodajemy wartości „Python” i „Hi” na końcu listy.
Wynik:
Przykład: 2
List = (“Hello”, “Good Morning”) print(“List before appending values is: “, List) print(“Length of the list before appending is: “, len(List)) List.append(“Python”) List.append(“Hi”) print(“List after appending values is: ”, List) print(“Length of the list after appending is: “, len(List))Wynik:
Lista przed dołączeniem wartości to: („Hello”, „Good Morning”)
Długość listy przed dołączeniem to: 2
Lista po dołączeniu wartości to: („Hello”, „Good Morning”, „Python”, „Hi”)
Długość listy po dołączeniu to: 4
Możemy znaleźć długość listy za pomocą funkcji len (), jak pokazano w powyższym przykładzie.
Wynik:
Możemy również dodać wiele wartości do listy za pomocą pętli for.
Przykład: 3
List = (7, 9, 8) print(“List before adding elements is: “, List) print(“Length of List before adding elements is: “, len(List)) for i in range(2, 6): List.append(i) print(“List after adding elements is: “, List) print(“Length of List after adding elements is: “, len(List))Wynik:
Lista przed dodaniem elementów to: (7, 9, 8)
Długość listy przed dodaniem elementów to: 3
Lista po dodaniu elementów to: (7, 9, 8, 2, 3, 4, 5)
Długość listy po dodaniu elementów to: 7
Wynik:
Co się stanie, jeśli dołączymy listę do listy? Zobaczmy to w poniższym przykładzie.
Przykład: 4
List1 = (“Hi”, “Python”) List2 = (1, 5, 7, 2) List1.append(List2) print(“List1 after appending List2 is: “, List1)Wynik:
List1 po dołączeniu List2 to: („Cześć”, „Python”, (1, 5, 7, 2))
jaki jest najlepszy system operacyjny Windows
Jeśli zauważysz w powyższym przykładzie, kiedy dodamy List2 do List1, to List1 stanie się listą zagnieżdżoną.
Wynik:
Jeśli nie chcesz, aby lista była zagnieżdżona po jej dołączeniu, lepiej jest użyć metody rozszerzania ().
Przykład: 5
List1 = (“Hi”, “Python”) List2 = (1, 5, 7, 2) List1.extend(List2) print(“List1 after appending List2 is: “, List1)Wynik:
List1 po dołączeniu List2 to: („Cześć”, „Python”, 1, 5, 7, 2)
Kiedy używamy metody extend (), elementy List1 zostaną rozszerzone o elementy List2. Pamiętaj, że lista nie zostanie dołączona, gdy użyjemy metody ext ().
Wynik:
Kiedy rozszerzysz listę za pomocą łańcucha, doda on każdy znak ciągu do listy, ponieważ ciąg jest iterowalny.
Przykład: 6
List = (1, 5, 7, 2) List.extend(“Python”) print(“List after extending the String is: “, List)Wynik:
Lista po rozszerzeniu ciągu to: (1, 5, 7, 2, „P”, „y”, „t”, „h”, „o”, „n”)
Wynik:
Lista append () a rozszerzenie ()
Spójrzmy na kilka przykładów rozszerzeń () i append ().
Przykład 1
def my_fun(): List1 = (“Hi”, 1, “Hello”, 2, 5) print(“The elements of List is: “, List) List.append(“Python”) print(“List after appending the String is: “, List) List.append((“one”, “two”, 3)) print(“List after appending the list is: “, List) List2 = (“Apple”, “Orange”, 2, 8) List1.extend(List2) print(“List1 after extending the List2 is: “, List1) if __name__ == “__main__”: my_fun()Wynik:
Elementy listy to: („Cześć”, 1, „Cześć”, 2, 5)
Lista po dołączeniu ciągu to: („Cześć”, 1, „Cześć”, 2, 5, „Python”)
Lista po dołączeniu listy to: („Cześć”, 1, „Cześć”, 2, 5, „Python”, („jeden”, „dwa”, 3))
List1 po rozszerzeniu List2 to: („Hi”, 1, „Hello”, 2, 5, „Python”, („one”, „two”, 3), „Apple”, „Orange”, 2, 8)
Wynik:
Przykład: 2
List = (“Apple”, “Orange”, “Mango”, “Strawberry”) print(“List before inserting is: “, List) List.insert(2, “Watermelon”) print(“List after inserting is: “, List)Wynik:
Lista przed wstawieniem to: („Jabłko”, „Pomarańcza”, „Mango”, „Truskawka”)
Lista po wstawieniu to: („Jabłko”, „Pomarańcza”, „Arbuz”, „Mango”, „Truskawka”)
Wynik
Jak omówiliśmy wcześniej, metoda insert () służy do wstawiania wartości w określonym indeksie listy.
Przykład: 3
List1 = (2, 4, 6, 8) print(“List after adding the elements is: “, List1 + (1, 3, 5, 7)) print(“After adding same elements repeatedly is: “, (“Hi”) *5)Wynik:
Lista po dodaniu elementów to: (2, 4, 6, 8, 1, 3, 5, 7)
Po wielokrotnym dodaniu tych samych elementów to: („Cześć”, „Cześć”, „Cześć”, „Cześć”, „Cześć”)
Wynik:
Usuwanie lub usuwanie elementów z listy
Możemy również usuwać lub usuwać elementy z listy za pomocą instrukcji del i remove ().
Zobaczmy w poniższym przykładzie.
Przykład 1
List = (1, 2, 3, 4, 5, 6, 7, 8, 9) print(“List before deleting 3rd element is: ”, List) del List(3) print(“List after deleting 3rd element is: ”, List) del List(1:3) print(“List after deleting multiple elements is: “, List)Wynik:
Lista przed usunięciem trzeciego elementu to: (1, 2, 3, 4, 5, 6, 7, 8, 9)
Lista po usunięciu trzeciego elementu to: (1, 2, 3, 5, 6, 7, 8, 9)
Lista po usunięciu wielu elementów to: (1, 5, 6, 7, 8, 9)
W powyższym przykładzie można zauważyć, że użyliśmy instrukcji del do usunięcia elementu lub wielu instrukcji z listy.
Wynik:
Teraz zajmiemy się metodą remove ().
Przykład: 2
List = (1, 2, 3, 4, 5, 6, 7) print(“List before removing a element is: “, List) List.remove(3) print(“List after removing a element is: “, List) List.pop() print(“List after poping the element is: “, List)Wynik:
Lista przed usunięciem elementu to: (1, 2, 3, 4, 5, 6, 7)
Lista po usunięciu elementu to: (1, 2, 4, 5, 6, 7)
Lista po wyskoczeniu elementu to: (1, 2, 4, 5, 6)
W powyższym przykładzie można zauważyć, że usuwamy element z listy za pomocą metody remove (). Metoda pop () służy do usuwania / usuwania ostatniego elementu z listy.
Wynik:
Lista metod
| Metody | Opis |
|---|---|
| jasny() | Aby usunąć wszystkie elementy z listy. |
| dodać() | Aby dodać element na końcu listy. |
| wstawić() | Aby wstawić element pod określonym indeksem listy. |
| poszerzać() | Aby dodać listę elementów na końcu listy. |
| liczyć() | Aby zwrócić liczbę elementów o określonej wartości. |
| indeks() | Aby zwrócić indeks pierwszego elementu. |
| odwrócić() | Aby cofnąć istniejącą listę. |
| usunąć() | Aby usunąć elementy z listy. |
Wniosek
W tym samouczku przyjrzeliśmy się niektórym charakterystyka list Pythona wraz z różnymi sposobami manipulowania listą, taką jak tworzenie listy , dostęp do elementów z listy , i zastępowanie pozycji z listy.
Ten samouczek dotyczący listy Pythona można zakończyć za pomocą następujących wskaźników:
- Lista jest jednym z typów danych w Pythonie, który jest również nazywany strukturą danych.
- Lista służy do przechowywania dużej liczby wartości dowolnego typu danych w jednej zmiennej, co z kolei ułatwia dostęp.
- Indeks listy zawsze zaczyna się od zera, podobnie jak inne języki programowania.
- Jeśli pracujesz na liście, musisz pamiętać o wszystkich typowych wbudowanych w niej funkcjach.
=> Odwiedź tutaj, aby nauczyć się Pythona od podstaw
rekomendowane lektury
- Samouczek Pythona dla początkujących (praktyczne BEZPŁATNE szkolenie Python)
- Zmienne Pythona
- Python Advanced List tutorial (sortowanie listy, odwracanie, indeks, kopiowanie, łączenie, sumowanie)
- Python Tuple Tutorial z praktycznymi przykładami
- Funkcje łańcuchowe w Pythonie
- Listy w STL
- Struktura danych listy połączonej w C ++ z ilustracją
- Struktura danych listy połączonej cyklicznie w C ++ z ilustracją