python list create
V tomto výukovém programu Python List prozkoumáme způsoby vytváření, přístupu, řezání, přidávání / mazání prvků do seznamů Pythonu, které jsou pravděpodobně jedním z nejužitečnějších datových typů:
Python obsahuje 4 datové typy sběru, jak je uvedeno níže:
- Seznam
- Soubor
- Slovník
- Tuple
V tomto kurzu se budeme podrobně zabývat seznamem a jeho různými operacemi. V Pythonu je seznam datová struktura nebo je to jako pole, které se používá k ukládání více dat najednou.
=> Prozkoumejte Python Training Series zde
Pokud máte zkušenosti s jinými programovacími jazyky, jako je Java, C, C ++ atd., Budete obeznámeni s konceptem polí. Seznam je téměř stejný jako pole.
Co se naučíte:
- Jaké jsou seznamy Pythonu
- Více o seznamech v Pythonu
- Závěr
Jaké jsou seznamy Pythonu
V Pythonu je seznam a datový typ , který ukládá kolekci různých objektů (položek) do hranatých závorek (()). Každá položka v seznamu je oddělena čárkou (,) s první položkou v indexu 0.
Poznámka :Pohybem vpřed budou všechny příklady v tomto kurzu běžet přímo z prostředí Pythonu, pokud není uvedeno jinak.
Níže je uveden příklad seznamu s 5 položkami.
>>> l = ('what','who','where','when','how') >>>l ('what','who','where','when','how') Ve výše uvedeném příkladu vidíme, že seznam má Řetězcové objekty jako položky a každá položka je oddělena čárkou.
Charakteristika seznamu Pythonu
Než se podíváme na to, jak můžeme manipulovat s položkami v seznamu, podívejme se na některé vlastnosti, díky nimž jsou seznamy v Pythonu oblíbené.
Seznamy Pythonu jsou sekvence kontejnerů
Na rozdíl od plochých sekvencí ( tětiva , pole. pole , paměťový pohled atd.), které mohou obsahovat pouze položky jednoho typu, seznam je a sekvence kontejneru které pojmou položky jednoho i různých typů.
Příklad s položkami jednoho typu
Pojďme otevřít náš pythonovský shell a definovat seznam čísel.
>>> numbers = ('one','two','three','four','five') >>> numbers ('one','two','three','four','five') Výše uvedený příklad ukazuje seznam položek stejného typu, v tomto případě typu řetězec (str) .
Příklad s položkami různých typů
Pojďme otevřít náš pythonovský shell a definovat další verzi seznamu čísel.
>>> numbers = ('one',2,3,'four',5.0) >>> numbers ('one',2,3,'four',5.0) Výše uvedený příklad ukazuje seznam položek různých typů. Typy jsou tětiva , celé číslo, a plovák .
// a sketch showing the list of items and their types as annotationSeznam Python může také obsahovat všechny objekty, jako je funkce , třídy , moduly , seznamy , n-tice, a mnohem víc.
Otevřete editor a vložte následující kód:
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) Výstup
Seznamy Pythonu jsou seřazené sekvence
Seznam Pythonu je uspořádaná sbírka objektů. Pozice každé položky v seznamu je velmi důležitá. Ve skutečnosti dva seznamy se stejnými položkami nejsou stejné, pokud pořadí, ve kterém jsou položky umístěny, není stejné.
>>> ('a','b','c','d') == ('a','c','b','d') False Tato vlastnost seznamu Pythonu umožňuje přístup k jeho položkám pomocí indexu a rozdělení (více o tom později).
Seznamy Pythonu jsou proměnlivé sekvence
Seznamy Pythonu jsou proměnlivé. Ale co je to proměnlivý objekt? Je to prostě objekt, který lze po vytvoření upravit. Příklady dalších proměnlivých sekvencí je slovník , pole. pole , sbírky .
Proč proměnlivý? Sekvence jako seznamy se používají pro složité operace, takže je logické, že by měli být schopni změna , růst , zmenšit , aktualizace atd . To je možné pouze s měnitelností. Mutability nám také umožňuje upravovat seznamy na místě (více o tomto).
Pojďme ověřit proměnlivost seznamu pomocí níže uvedeného příkladu.
Stačí otevřít editor a vložit kód:
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() Výstup
Z výše uvedeného výstupu si všimneme, že seznam před a po úpravách je jiný. Nicméně Id hodnota je stejná. The Id hodnota zde představuje adresu objektu v paměti - získává se pomocí Pythonu id () .
To nám říká, že ačkoli se obsah seznamu změnil, stále jde o stejný objekt. To tedy uspokojuje naši definici: „ Je to prostě objekt, který lze po vytvoření upravit '
Poznámka :Ve výše uvedeném příkladu jsme k úpravě seznamu použili indexování (více o tomto).
Manipulace se seznamy Pythonu
Se seznamy Pythonů je obloha náš limit. Se seznamy, jako je, můžeme dělat nespočet věcí přidávání , mazání , indexování , krájení , kontrola členství , a mnohem víc. Python má také vestavěné funkce, díky nimž je manipulace se seznamy ještě více vzrušující.
V této části se podíváme na některé běžně používané operace se seznamy.
Vytvoření seznamu
Chcete-li vytvořit seznam, jednoduše vložte několik položek nebo výrazů do hranatých závorek oddělených čárkami.
(expression1, expression2,...,expresionN) >>> l = (4,3,5,9+3,False) >>> l (4, 3, 5, 12, False) Python má také vestavěný objekt s názvem seznam (), které lze použít k vytvoření seznamů.
list( sequence ) >>> l = list() # create an empty list >>> l () Krajta seznam () může přijímat typy sekvencí a převádět je do seznamů. Toto je typický způsob převodu n-tice na seznam.
>>> t = (4,3,5) # tuple >>>l = list(t) # convert into list (4,3,5) Ve výše uvedeném příkladu jsme použili datový typ Tuple . Je podobný seznamu, ale na rozdíl od seznamů je neměnný a jeho položky jsou uzavřeny v závorkách.
Dalším prostředkem, kterým můžeme vytvořit seznam, je použití seznam porozumění který má následující syntaxi.
(expression for item in sequence) >>> (i**2 for i in range(4)) (0, 1, 4, 9) Stojí za zmínku, že seznamy Pythonu jsou předávány odkazem. To znamená, že přiřazení seznamu poskytne jeho identitu umístění v paměti. To, že mnoho nováčků dělá chybu, je vytvářet seznamy tímto způsobem.
>>> l1 = l2 = (4,3) # wrong way to create separate list objects >>> l1 (4,3) >>> l2 (4,3) Tady bychom si mohli myslet, že jsme vytvořili dva různé seznamy, ale skutečně jsme právě vytvořili jeden. Ukažme si to úpravou jedné z proměnných.
>>> l1(0) = 0 >>> l1 (0,3) >>> l2 (0,3) Všimli jsme si, že úpravou jedné proměnné se změní druhá. Důvodem je, že obě proměnné l1 a l2 mají stejnou identitu umístění v paměti, takže obě ukazují na stejný objekt.
Přidávání položek do seznamu
Python má mnoho způsobů, jak přidat prvky do svého seznamu. Nejběžnějším způsobem je použití připojit() metoda. Další způsoby jsou pomocí rozšířit() metoda. Indexování a krájení (více o nich později) se pravděpodobněji používají k nahrazení položek v seznamu.
# 1) Použití metody append ()
Tato metoda přijímá jednu položku a přidává ji na konec seznamu. Nevrací nový seznam, ale pouze upravuje seznam na místě (díky jeho proměnlivosti).
>>>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, ) Několik příkladů z výše uvedeného příkladu:
- Položky zde mohou být výrazy, datové typy, sekvence a mnoho dalších.
- The připojit() metoda má časovou složitost (0) 1. To znamená, že je konstantní.
# 2) Použití metody extend ()
Tato metoda převezme iterovatelný argument a přidá všechny položky z ní na konec seznamu. Tato metoda se většinou používá, když chceme přidat jednotlivé položky sekvence do seznamu
V zásadě rozšířit() metoda iteruje nad svým argumentem a připojuje každou položku do seznamu. Stejně jako metoda append () nevrací nový seznam, ale seznam upravuje na místě.
>>> 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') Několik věcí z výše uvedeného příkladu:
- Řetězec je iterovatelný, takže náš rozšířit() metoda bude iterovat nad svými znaky.
- The rozšířit() metoda má časovou složitost (0) K, kde K je délka argumentu.
Přístup k položkám ze seznamu
Indexování a krájení jsou nejběžnější prostředky, které se používají pro přístup k seznamům. Můžeme také přistupovat k položkám v seznamu se smyčkami, jako je pro smyčku .
# 1) Indexování
Seznam Pythonu používá číslování založené na nule Systém. To znamená, že všechny jeho položky jsou jednoznačně identifikovány indexovým číslem začínajícím od 0 do n-1, kde n je délka seznamu.
Zvažte níže uvedený seznam:
>>> colors = ('red','blue','green','yellow','black') # create list >>> colors ('red','blue','green','yellow','black') >>> len(colors) # get list length 5 Níže uvedená tabulka ukazuje jejich příslušné indexy v číslování seznamu založené na nule.
| Položka | síť | modrý | zelený | žlutá | Černá |
|---|---|---|---|---|---|
| pop () | Odstranění / odebrání prvku z posledního v seznamu. | ||||
| Index | 0 | 1 | dva | 3 | 4 |
Z výše uvedené tabulky vidíme, že první položka („červená“) je na pozici indexu 0 a poslední položka („černá“) je na pozici indexu 4 (n-1), kde n = 5 (délka objektu barvy).
Jak jsme viděli v charakteristické části výše, seznamy Pythonu jsou seřazené sekvence. To nám umožňuje používat indexování pro snadný přístup a manipulaci s jeho položkou.
Pojďme použít indexování pro přístup k položkám na konkrétních indexech objektu barev vytvořeného výše.
>>> 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 Poznámka :Poslední výše uvedený příkaz se pokouší získat přístup k položce na pozici indexu 9 z objektu seznamu o délce 5. V seznamu Pythonu přístup k položce v indexu, který neexistuje, zvýší IndexError výjimka.
Důležitým konceptem indexování je to, že můžeme použít negativní indexování, tj. Můžeme přistupovat k položkám seznamu obráceně, počínaje -1 u poslední položky a konče u -n u poslední položky, kde n je délka objektu seznamu.
Pokud ve výše uvedené tabulce použijeme negativní indexování, bude to vypadat takto:
| Položka | síť | modrý | zelený | žlutá | Černá |
|---|---|---|---|---|---|
| Index | -5 | -4 | -3 | -dva | -1 |
Pojďme použít negativní indexování pro přístup k některým položkám barevného objektu vytvořeného výše.
>>> 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) Krájení
Na rozdíl od indexování, které vrací pouze jednu položku, krájení na druhou stranu může vrátit řadu položek.
Má následující syntaxi:
L(n:m)Když n je číslo indexu, kde řez začíná (výchozí hodnota je 0), a m je exkluzivní číslo indexu, kde řez končí (výchozí hodnota je délka 1). Jsou odděleny dvojtečkou (:)
Zvažte níže uvedený příklad, který používá řezání pro přístup k položkám na konkrétních indexech objektu barev vytvořeného výše.
>>> 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') >>> V syntaxi L (n: m) má n výchozí hodnotu 0 a m výchozí délku seznamu. Takže dovnitř příklady 1 a 3 nahoře bychom mohli vynechat n a m jako barvy (: 2) a barvy (2:). Nebo (:), které v tomto případě vrátí mělkou kopii celého objektu seznamu.
Při sestavování seznamů můžeme také použít záporná čísla indexů. To se obvykle používá, když chceme přistupovat k seznamu obráceným způsobem.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(-3:-2) ('green') >>> colors(-2:) ('yellow', 'black') Existuje také třetí parametr, který podpora řezání nazývá krok (s). Definuje, kolik položek se má posunout vpřed po načtení první položky ze seznamu. Výchozí hodnota je 1.
L(n:m:s)Pomocí našeho stejného seznamu barev definovaného výše použijeme třetí parametr řezu k přesunutí 2 kroků.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(0:3:2) ('red', 'green') # 3) Použití smyček
Smyčky se většinou používají k přístupu k položkám v seznamu za účelem manipulace s nimi. Takže pokud chceme pracovat s položkami seznamu, můžeme použít pro smyčku získat přístup k položkám a předat je k dalšímu použití.
Řekněme, že chceme spočítat počet písmen pro každou položku. Můžeme použít pro smyčku dosáhnout toho.
Otevřete editor a vložte níže uvedený kód:
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)) Výstup
Na konci této sekce se podívejme na dvě skvělé věci, které lze provést krájením.
-
Vytvořte mělkou kopii seznamu
To je základní způsob použití kopírovat() metoda objektu seznamu nebo vestavěné funkce copy.copy . Toho však lze dosáhnout krájením.
>>> 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') >>> -
Obrátit seznam
Základním způsobem je použití zvrátit metoda objektu seznamu nebo vestavěné funkce obráceně () . Toho však lze dosáhnout krájením.
>>> 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') >>> Odebrání položek ze seznamu
Jelikož do seznamu můžeme přidat tolik položek, lze je také ze seznamu odebrat. Tři způsoby, jak lze položky odebrat, jsou:
# 1) Použití příkazu del
Má následující syntaxi:
del target_listCílový seznam ( seznam_cílů ) může být celý seznam (v případě, že jej chcete smazat) nebo položka nebo položky v seznamu (v tomto případě použijete indexování nebo rozdělení).
Zvažte níže uvedený příklad .
Řekněme, že chceme odstranit některé položky ze seznamu barev vytvořeného výše.
>>> 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 >>> Poznámka :Příkaz del odstraní na místě, tj. , místo úpravy nového objektu seznamu upraví původní objekt seznamu.
# 2) Použití seznamu. Odebrat (x)
Odebere první položku ze seznamu, jehož hodnota se rovná X . Vyvolá ValueError, pokud taková položka neexistuje.
Tato metoda se používá většinou k odebrání položek ze seznamu podle názvu, na rozdíl od příkazu del, který používá indexování a rozdělení.
>>> 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 >>> Poznámka :Objekt seznamu odstranit() metoda odstraní na místě, tj. , místo úpravy nového objektu seznamu upraví původní objekt seznamu.
# 3) Používání list.pop ((i))
Odebere a vrátí položku na dané pozici v objektu seznamu. Pokud není k dispozici žádný i (index), odstraní a vrátí poslední položku v seznamu.
Poznámka :Hranatá závorka kolem i výše neznamená seznam i, spíše to znamená, že i je volitelné.
>>> 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') >>> Poznámka: Seznam. pop ((i)) metoda odstraní na místě, tj. , místo úpravy nového objektu seznamu upraví původní objekt seznamu. Vrátí také položku odebranou ze seznamu
Výměna položek ze seznamu
Výměna položek je docela jednoduchá. V jedné z výše uvedených částí jsme viděli indexování a krájení. Ty lze použít k přístupu a odebrání položek ze seznamu.
# 1) Nahradit pomocí indexování
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) Výměna pomocí krájení
L(n:m) = valuePoznámka : Hodnota by měl být iterovatelný nebo jinak TypeError výjimka bude vyvolána.
>>> 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') >>> Často kladené otázky
Otázka č. 1) Co je seznam seznamů v Pythonu?
Odpovědět: Seznam seznamů v Pythonu je seznam, který obsahuje seznamy jako svou položku.
Například
(('a','b'),('c','d'))Lze jej také označit jako a vnořený seznam .
Otázka 2) Jak deklarujete seznam v Pythonu?
Odpovědět: V Pythonu lze seznam deklarovat dvěma způsoby. Buď pomocí vestavěné funkce seznam() nebo pomocí závorky (). seznam() načte iterovatelnou položku a () načte položky libovolného typu oddělené čárkou.
(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)Otázka č. 3) Můžete vložit seznam do seznamu Python?
Odpovědět: Ano, můžeme vložit seznam do seznamu. Ve skutečnosti je seznam sekvence kontejnerů, která přijímá položky jakéhokoli datového typu.
Otázka č. 4) Co dělá list () v Pythonu?
Odpověď: seznam ( ) je integrovaná funkce v Pythonu, která vytváří objekt seznamu. Jako argument bere iterovatelný text.
>>> list((3,2,4)) # The iterable object here is a tuple. (3, 2, 4) >>> Otázka č. 5) Může seznam Pythonu obsahovat různé typy?
Odpovědět: Seznam je sekvence kontejnerů, která přijímá položky libovolných datových typů ( seznam , n-tice , celé číslo , plovák , struny , atd)
Více o seznamech v Pythonu
Co je datová struktura?
Počítače se používají k ukládání velkého množství dat nebo ke zpracování obrovského množství dat s vysokou rychlostí a přesností. Proto je nejlepší ukládat data trvale pro rychlý přístup.
Zatímco zpracování dat probíhá, mělo by k němu dojít v nejkratší možné době bez ztráty přesnosti. Datovou strukturu používáme k organizovanému zpracování dat a ukládání dat do paměti ke zpracování.
Protože Python je programovací jazyk na vysoké úrovni a interpretovaný, je velmi důležité využít datovou strukturu v Pythonu.
Co je to List?
Seznam je datová struktura, která se používá k ukládání více dat najednou.
Data uložená v seznamu jsou homogenní, což z něj činí nejvýkonnější funkci seznamu v Pythonu. V jednom seznamu můžeme ukládat více dat různých datových typů, jako jsou řetězce, celá čísla a objekty.
Seznam je v Pythonu proměnlivý, takže data lze kdykoli změnit i po vytvoření. Seznamy jsou velmi silné pro implementaci zásobníků a front v Pythonu.
Jak již bylo zmíněno dříve, seznam ukládá data v seřazeném pořadí a k datům uloženým v seznamu se přistupuje pomocí jejich indexu a pro seznam bude index vždy začínat od nuly. Každý prvek má v seznamu konkrétní místo a ke všem těmto datům se přistupuje pomocí indexu.
V seznamu můžeme uložit stejnou hodnotu několikrát a každé údaje budou považovány za samostatný a jedinečný prvek. Seznamy je nejlepší ukládat data a iterovat je později.
Vytvoření seznamu
Data v seznamu jsou uložena oddělena čárkami a uzavřena do hranatých závorek (()). Položky v seznamu nemusí být stejného typu.
Syntax: List = (item1, item2, item3)Příklad 1:
List = ( )Příklad 2:
List = (2, 5, 6.7)Příklad 3:
List = (2, 5, 6.7, ‘Hi’)Příklad 4:
List = (‘Hi’, ‘Python’, ‘Hello’)Ve výše uvedených příkladech můžeme pozorovat, že jsme uložili položky různých datových typů s oddělenými čárkami, 2 a 5 jsou typu Integer, 6,7 je typu float a 'Hi' je typu String, všechny tyto položky jsou uzavřeny v seznam a to z něj dělá seznam.
Můžeme také deklarovat prázdný seznam. Můžeme také deklarovat seznam uvnitř jiného seznamu a nazýváme to jako vnořený seznam.
Příklad 5:
List = (‘Hi’, (2, 4, 5), (‘Hello’))Ve výše uvedeném příkladu můžete pozorovat, že seznam byl deklarován uvnitř jiného seznamu.
Přístup k hodnotám v seznamu
Existuje několik způsobů, kterými můžeme přistupovat k položkám přítomným uvnitř seznamu v Pythonu.
Pomocí indexu můžeme přistupovat k prvkům seznamu. Index začíná od 0 a index by měl být vždy celé číslo. Pokud použijeme jiný index než celé číslo jako float, bude to mít za následek TypeError.
Příklad 1:
List = (2, 5, 6.7, ‘Hi’) print(“List is:”, List)Výstup:
Seznam je: (2, 5, 6.7, „Ahoj“)
Výstup:
co je dobrý stahovač hudby pro Android
Ve výše uvedeném příkladu přímo tiskneme seznam pomocí funkce tisku, nepřistupujeme k jednotlivým prvkům ze seznamu.
Pojďme přistupovat k jednotlivým prvkům ze seznamu.
Příklad: 2
List = (2, 5, 6.7, ‘Hi’) print(“Second element of the list is:”, List(1))Výstup:
Druhý prvek seznamu je: 5
Výstup:
Ve výše uvedeném příkladu můžete pozorovat, že tiskneme druhý prvek seznamu, který je 5, ale můžete dostat otázku, proč v tiskovém prohlášení tiskneme List (1)? Je to proto, že index začíná od nuly, proto List (1) odkazuje na druhý prvek seznamu.
Příklad: 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))Výstup:
První prvek v seznamu je: 2
Poslední prvek v seznamu je: Ahoj
Výstup:
Příklad: 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))Výstup:
První prvek seznamu je: i
Prvky přítomné v jiném seznamu jsou: 5
Výstup:
Ve výše uvedeném programu, pokud budete pozorně sledovat, uvidíte, že přistupujeme k prvkům ze vnořeného seznamu.
Data budou interně uložena v maticovém formátu, jak je uvedeno níže:
Ahoj
2 4 5
Když se tedy pokusíme získat přístup k seznamu (0) (1), bude ukazovat na 1Svatýřádek a 2ndsloupec, čímž budou data „i“.
Podobně, když se pokusíme získat přístup k seznamu (1) (2), bude ukazovat na 2ndřádek a 3rdsloupec, tedy data budou 5.
Negativní indexování
K datům můžeme přistupovat také pomocí negativního indexu. Záporný index bude vždy začínat od -1 a -1 odkazuje na poslední prvek a -2 odkazuje na poslední druhou položku atd.
Příklad: 1
List = (2, 5, 7, 3) print(“Last element in the list is: ”, List(-1))Výstup:
Poslední prvek v seznamu je: 3
Výstup:
Příklad: 2
List = (2, 5, 7, 3) print(“Second element in the list is: ”, List(-3))Výstup:
Druhý prvek v seznamu je: 5
Výstup:
Krájení seznamu
Pomocí operátoru řezu (:) můžeme přistupovat k řadě prvků ze seznamu
Příklad: 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(:))Výstup:
Prvky od 2. do 5. jsou: (2, 3, 4, 5)
Prvky začínající na 2. místě jsou: (1, 2, 3, 4)
Prvky od 4. do konce jsou: (4, 5, 6, 7)
Prvky od začátku do konce jsou: (1, 2, 3, 4, 5, 6, 7)
Výstup:
Můžeme také přistupovat k prvkům přítomným uvnitř seznamu pomocí smyčky for.
Příklad: 2
List = (1, 2, 3, 4, 5, 6, 7) forele in List: print(ele)Výstup:
1
dva
3
4
5
6
7
Výstup:
výchozí brána není k dispozici ethernet
Pamatujte si níže uvedený formát indexování:
| H | JE | L | L | NEBO | 5 | 7 | 9 | 4 |
| 0 | 1 | dva | 3 | 4 | 5 | 6 | 7 | 8 |
| -9 | -8 | -7 | -6 | -5 | -4 | -3 | -dva | -1 |
Jak již bylo zmíněno dříve, seznam v pythonu je proměnlivý, což znamená, že prvky lze změnit, i když se jedná o celé číslo nebo řetězec nebo jakýkoli datový typ.
Seznam můžeme aktualizovat pomocí operátoru přiřazení.
Příklad: 3
List = (2, 4, 6, 9) #updating the first element List(0) = 7 print(“Updated list is: ”, List)Výstup:
Aktualizovaný seznam je: (7, 4, 6, 9)
Výstup:
Ve výše uvedeném příkladu aktualizujeme první prvek seznamu „2“ o nový prvek „7“.
Příklad: 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)Výstup:
Aktualizovaný seznam je: (2, 5, 2, 4, 9, 0, 7)
Ve výše uvedeném příkladu aktualizujeme seznam dat do seznamu.
Výstup:
Přidání prvků do seznamu
Existuje několik způsobů, jak můžeme do seznamu přidat prvky, a python má vestavěnou funkci nazvanou append ().
Pomocí append () můžeme do seznamu přidat pouze jeden prvek, pokud chcete do seznamu přidat více prvků, musíme použít pro smyčku . Funkce append () vždy přidá prvek na konec seznamu, funkce append () trvá pouze jeden argument.
Chcete-li přidat prvky na konkrétní pozici, stačí použít metodu insert (). insert () vezme dva argumenty, tj. pozici a hodnotu, pozice odkazuje na index, kde je třeba přidat prvky a hodnota odkazuje na prvek, který se má přidat do seznamu.
Existuje ještě jedna metoda zvaná extend (), pomocí které můžeme do seznamu přidávat prvky. Metoda extend () se používá k přidání seznamu prvků do seznamu. Podobně jako metoda append () a extend () bude také přidávat prvky na konec seznamu.
Příklad: 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)Výstup:
Seznam před připojením hodnot je: („Dobrý den“, „Dobré ráno“)
Seznam po připojení hodnot je: („Hello“, „Good Morning“, „Python“, „Hi“)
Ve výše uvedeném příkladu připojujeme hodnoty „Python“ a „Hi“ na konec seznamu.
Výstup:
Příklad: 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))Výstup:
Seznam před připojením hodnot je: („Dobrý den“, „Dobré ráno“)
Délka seznamu před připojením je: 2
Seznam po připojení hodnot je: („Hello“, „Good Morning“, „Python“, „Hi“)
Délka seznamu po připojení je: 4
Můžeme najít délku seznamu pomocí funkce len (), jak je ukázáno ve výše uvedeném příkladu.
Výstup:
Můžeme také přidat více hodnot do seznamu pomocí smyčky for.
Příklad: 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))Výstup:
Seznam před přidáním prvků je: (7, 9, 8)
Délka seznamu před přidáním prvků je: 3
Seznam po přidání prvků je: (7, 9, 8, 2, 3, 4, 5)
Délka seznamu po přidání prvků je: 7
Výstup:
Co se stane, když k seznamu připojíme seznam? Podívejme se na to v následujícím příkladu.
Příklad: 4
List1 = (“Hi”, “Python”) List2 = (1, 5, 7, 2) List1.append(List2) print(“List1 after appending List2 is: “, List1)Výstup:
List1 after appending List2 is: (“Hi”, “Python”, (1, 5, 7, 2))
Pokud si ve výše uvedeném příkladu všimnete, když přidáme List2 do List1, stane se List1 vnořeným seznamem.
Výstup:
Pokud po vytvoření seznamu nechcete vytvořit vnořený seznam, je lepší použít metodu extend ().
Příklad: 5
List1 = (“Hi”, “Python”) List2 = (1, 5, 7, 2) List1.extend(List2) print(“List1 after appending List2 is: “, List1)Výstup:
List1 after appending List2 is: (“Hi”, “Python”, 1, 5, 7, 2)
Když použijeme metodu extend (), prvky List1 budou rozšířeny o prvky List2. Nezapomeňte, že seznam nepřipojí, když použijeme metodu extend ().
Výstup:
Když rozšíříte seznam o řetězec, připojí každý znak řetězce k seznamu, protože řetězec je iterovatelný.
Příklad: 6
List = (1, 5, 7, 2) List.extend(“Python”) print(“List after extending the String is: “, List)Výstup:
Seznam po prodloužení řetězce je: (1, 5, 7, 2, „P“, „y“, „t“, „h“, „o“, „n“)
Výstup:
List append () vs extend ()
Podívejme se na několik příkladů pro extend () a append ().
Příklad: 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()Výstup:
Prvky seznamu jsou: („Ahoj“, 1, „Ahoj“, 2, 5)
Seznam po připojení řetězce je: („Ahoj“, 1, „Ahoj“, 2, 5, „Python“)
Seznam po připojení seznamu je: („Ahoj“, 1, „Ahoj“, 2, 5, „Python“, („jeden“, „dva“, 3))
List1 po rozšíření List2 je: („Hi“, 1, „Hello“, 2, 5, „Python“, („one“, „two“, 3), „Apple“, „Orange“, 2, 8)
Výstup:
Příklad: 2
List = (“Apple”, “Orange”, “Mango”, “Strawberry”) print(“List before inserting is: “, List) List.insert(2, “Watermelon”) print(“List after inserting is: “, List)Výstup:
Seznam před vložením je: („Apple“, „Orange“, „Mango“, „Strawberry“)
Seznam po vložení je: („Apple“, „Orange“, „Watermelon“, „Mango“, „Strawberry“)
Výstup
Jak jsme již diskutovali dříve, metoda insert () se používá k vložení hodnot do konkrétního indexu seznamu.
Příklad: 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)Výstup:
Seznam po přidání prvků je: (2, 4, 6, 8, 1, 3, 5, 7)
Po opakovaném přidání stejných prvků je: („Ahoj“, „Ahoj“, „Ahoj“, „Ahoj“, „Ahoj“)
Výstup:
Odstranění nebo odebrání prvků ze seznamu
Můžeme také odstranit nebo odebrat prvky ze seznamu pomocí příkazů del and remove ().
Podívejme se na níže uvedený příklad.
Příklad: 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)Výstup:
Seznam před odstraněním 3. prvku je: (1, 2, 3, 4, 5, 6, 7, 8, 9)
Seznam po odstranění 3. prvku je: (1, 2, 3, 5, 6, 7, 8, 9)
Seznam po odstranění více prvků je: (1, 5, 6, 7, 8, 9)
Ve výše uvedeném příkladu můžete pozorovat, že jsme použili příkaz del k odstranění prvku nebo více příkazů ze seznamu.
Výstup:
Nyní uvidíme metodu remove ().
Příklad: 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)Výstup:
Seznam před odstraněním prvku je: (1, 2, 3, 4, 5, 6, 7)
Seznam po odebrání prvku je: (1, 2, 4, 5, 6, 7)
Seznam po vyskakování prvku je: (1, 2, 4, 5, 6)
Ve výše uvedeném příkladu můžete pozorovat, že odstraňujeme prvek ze seznamu pomocí metody remove (). Metoda pop () se používá k odebrání / odstranění posledního prvku ze seznamu.
Výstup:
Seznam metod
| Metody | Popis |
|---|---|
| Průhledná() | Odebrání všech prvků ze seznamu. |
| připojit() | Chcete-li přidat prvek na konec seznamu. |
| vložit() | Chcete-li vložit prvek do konkrétního indexu seznamu. |
| rozšířit() | Chcete-li přidat seznam prvků na konec seznamu. |
| počet() | Chcete-li vrátit počet prvků se specifickou hodnotou. |
| index() | Vrátit index prvního prvku. |
| zvrátit() | Převrácení existujícího seznamu. |
| odstranit() | Odebrání prvků ze seznamu. |
Závěr
V tomto tutoriálu jsme se podívali na některé charakteristiky seznamů Pythonu spolu s různými způsoby manipulace se seznamem, jako je vytvoření seznamu , přístup k položkám ze seznamu , a nahrazení položek ze seznamu.
Tento kurz v seznamu Pythonu lze uzavřít následujícími ukazateli:
- Seznam je jedním z datových typů v Pythonu, který se také označuje jako datová struktura.
- Seznam se používá k ukládání velkého počtu hodnot libovolných datových typů do jedné proměnné, což zase usnadňuje snadný přístup.
- Index seznamu vždy začíná od nuly jako ostatní programovací jazyky.
- Pokud pracujete na seznamu, musíte si pamatovat všechny jeho běžné vestavěné funkce.
=> Navštivte zde a dozvíte se Python od nuly
Doporučené čtení
- Výukový program pro Python pro začátečníky (praktické školení v Pythonu ZDARMA)
- Proměnné Pythonu
- Výukový program pro pokročilé seznamy v Pythonu (řazení seznamu, obrácení, indexování, kopírování, připojení, součet)
- Výukový program pro Python Tuple s praktickými příklady
- Funkce řetězce Python
- Seznamy v STL
- Propojená datová struktura seznamu v C ++ s ilustrací
- Datová struktura kruhového propojeného seznamu v C ++ s ilustrací