Kártyajátékok

A list elemek sorozatából álló, módosítható gyűjtemény. A legtöbb gyűjteményhez hasonlóan (lásd a beépített tuple, dict és set típusokat), a listák bármilyen (vagy akár többféle) adattípusra tárolhatnak hivatkozást, beleértve más listákat is. Ahogy bármelyik sorozatnél, az elemek balról a 0-based index számmal, jobbról a -1-based index számmal érhetők el. A listák egészben vagy részben is másolhatók szeleteléssel vagy a <list>.copy() metódussal.

A listák a közös és a módosító sorozatműveleteket is támogatják, például a min()/max(), <list>.index(), <list>.append() és <list>.reverse() metódusokat. A listák elemein a for item in <list> szerkezettel lehet végigiterálni. A for index, item in enumerate(<list>) szerkezet akkor hasznos, ha az elem indexére és értékére is szükséged van.

A háttérben a lists dinamikus tömbökként vannak megvalósítva, hasonlóan a Java ArrayList típusához, és leggyakrabban hasonló adatok (stringek, számok, halmazok stb.) ismeretlen hosszúságú csoportjainak tárolására használják őket. A listák rendkívül rugalmas és hasznos adatszerkezetek, és a Python számos beépített metódusa és művelete listát ad eredményül.

Létrehozás

A list literálként hozható létre szögletes [] zárójelekkel és az elemek közötti vesszőkkel:

>>> no_elements = []

>>> no_elements
[]

>>> one_element = ["Guava"]

>>> one_element
['Guava']

>>> elements_separated_with_commas = ["Parrot", "Bird", 334782]

>>> elements_separated_with_commas
['Parrot', 'Bird', 334782]

Az olvashatóság érdekében sortöréseket is használhatsz, ha sok elem vagy egy list-en belül egymásba ágyazott adatszerkezet van:

>>> lots_of_entries = [
      "Rose",
      "Sunflower",
      "Poppy",
      "Pansy",
      "Tulip",
      "Fuchsia",
      "Cyclamen",
      "Lavender"
   ]
   
>>> lots_of_entries
['Rose', 'Sunflower', 'Poppy', 'Pansy', 'Tulip', 'Fuchsia', 'Cyclamen', 'Lavender']

# Each data structure is on its own line to help clarify what they are.
>>> nested_data_structures = [
      {"fish": "gold", "monkey": "brown", "parrot": "grey"},
      ("fish", "mammal", "bird"),
      ['water', 'jungle', 'sky']
   ]
   
>>> nested_data_structures
[{'fish': 'gold', 'monkey': 'brown', 'parrot': 'grey'}, ('fish', 'mammal', 'bird'), ['water', 'jungle', 'sky']]

A list() konstruktor használható üresen, vagy argumentumként egy iterálható objektummal. A konstruktor végigmegy az iterálható elemeken, és sorban hozzáadja őket a list-hez:

>>> no_elements = list()

>>> no_elements
[]

# The tuple is unpacked and each element is added.
>>> multiple_elements_from_tuple = list(("Parrot", "Bird", 334782))

>>> multiple_elements_from_tuple
['Parrot', 'Bird', 334782]

# The set is unpacked and each element is added.
>>> multiple_elements_from_set = list({2, 3, 5, 7, 11})

>>> multiple_elements_from_set
[2, 3, 5, 7, 11]

A list konstruktor string-gel vagy dict-tel való használata meglepő eredményt adhat:

# String elements (Unicode code points) are iterated through and added *individually*.
>>> multiple_elements_string = list("Timbuktu")

>>> multiple_elements_string
['T', 'i', 'm', 'b', 'u', 'k', 't', 'u']

# Unicode separators and positioning code points are also added *individually*.
>>> multiple_code_points_string = list('अभ्यास')

>>> multiple_code_points_string
['अ', 'भ', '्', 'य', 'ा', 'स']

# The iteration default for dictionaries is over the keys, so only key data is inserted into the list.
>>> source_data = {"fish": "gold", "monkey": "brown"}

>>> multiple_elements_dict_1 = list(source_data)
['fish', 'monkey']

Mivel a list konstruktor csak iterálhatókat (vagy semmit) fogad el argumentumként, a nem iterálható objektumok típushibát dobnak. Ezért sokkal egyszerűbb egy egyelemű list-et a literál szintaxissal létrehozni.

# Numbers are not iterable, and so attempting to create a list with a number passed to the constructor fails.
>>> one_element = list(16)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable

# Tuples *are* iterable, so passing a one-element tuple to the constructor does work, but it's awkward
>>> one_element_from_iterable = list((16,))

>>> one_element_from_iterable
[16]

Elemek elérése

A listán belüli elemek (valamint más sorozattípusok, például a str és a tuple elemei) 0-based index és zárójeles jelölés segítségével érhetők el. Az indexelés történhet left --> right irányban (nullától indulva) vagy right --> left irányban (-1-től indulva).

>>> breakfast_foods = ["Oatmeal", "Fruit Salad", "Eggs", "Toast"]

# Oatmeal is at index 0 or index -4.
>>> breakfast_foods[0]
'Oatmeal'

>>> breakfast_foods[-4]
'Oatmeal'

# Eggs are at index -2 or 2
>>> breakfast_foods[-2]
'Eggs'

>>> breakfast_foods[2]
'Eggs'

# Toast is at -1
>>> breakfast_foods[-1]
'Toast'

A list-en belüli elemek egy szakasza szeleteléssel (<list>[start:stop]) érhető el. Egy szelet az index pozícióban lévő elemsorozat, ahol start <= index < stop. A szeletelés a „kivágott” elemek másolatát adja vissza, és nem módosítja az eredeti list-et.

A [start:stop:step] szintaxisban egy step paraméter is használható, hogy „átugorj” vagy szűrj bizonyos list elemeket (például a step értéke 2 esetén minden második elemet választja ki a tartományban):

>>> colors = ["Red", "Purple", "Green", "Yellow", "Orange", "Pink", "Blue", "Grey"]

# If there is no step parameter, the step is assumed to be 1.
>>> middle_colors = colors[2:6]

>>> middle_colors
['Green', 'Yellow', 'Orange', 'Pink']

# If the start or stop parameters are omitted, the slice will
# start at index zero, and will stop at the end of the list.
>>> primary_colors = colors[::3]

>>> primary_colors
['Red', 'Yellow', 'Blue']

Munka listákkal

A beépített sum() függvény egy listán a lista összes számának összegét adja vissza:

>>> number_list = [1, 2, 3, 4]
>>> sum(number_list)
10

A lista hosszát a len() függvénnyel is megkaphatod:

>>> long_list = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]
>>> len(long_list)
10

A listák többféleképpen is összefűzhetők:

# Using the plus + operator unpacks each list and creates a new list, but it is not efficient.
>>> new_via_concatenate = ["George", 5] + ["cat", "Tabby"]

>>> new_via_concatenate
['George', 5, 'cat', 'Tabby']

# Likewise, using the multiplication operator * is the equivalent of using + n times.
>>> first_group = ["cat", "dog", "elephant"]
>>> multiplied_group = first_group * 3

>>> multiplied_group
['cat', 'dog', 'elephant', 'cat', 'dog', 'elephant', 'cat', 'dog', 'elephant']

A listák iterátort biztosítanak, és ugyanúgy végig lehet rajtuk iterálni, mint más sorozattípusokon.

#  Looping through the list and printing out each element.
>>> colors = ["Orange", "Green", "Grey", "Blue"]

>>> for item in colors:
...     print(item)
...
Orange
Green
Grey
Blue

A loops és iterators részletesebb magyarázatáért dolgozd fel a loops fogalmat.