Juegos de cartas

Una list es una colección mutable de elementos en secuencia. Como la mayoría de las colecciones (consulta los tipos integrados tuple, dict y set), las listas pueden contener referencias a cualquier tipo (o varios tipos) de datos, incluidas otras listas. Como en cualquier secuencia, se puede acceder a los elementos mediante un 0-based index desde la izquierda y un -1-based index desde la derecha. Las listas se pueden copiar total o parcialmente mediante la notación de slices o <list>.copy().

Las listas admiten tanto las operaciones de secuencia comunes como las mutables, por ejemplo min()/max(), <list>.index(), <list>.append() y <list>.reverse(). Se puede iterar sobre los elementos de una lista con la construcción for item in <list>. for index, item in enumerate(<list>) se puede usar cuando se necesitan tanto el índice del elemento como su valor.

Internamente, las lists se implementan como arrays dinámicos, similares al tipo ArrayList de Java, y se usan con mayor frecuencia para almacenar grupos de datos similares (strings, números, sets, etc.) de longitud desconocida. Las listas son una estructura de datos sumamente flexible y útil, y muchos de los métodos y operaciones integrados de Python producen listas como resultado.

Construcción

Una list se puede declarar como un literal con corchetes [] y comas entre los elementos:

>>> no_elements = []

>>> no_elements
[]

>>> one_element = ["Guava"]

>>> one_element
['Guava']

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

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

Para mayor legibilidad, se pueden usar saltos de línea cuando hay muchos elementos o estructuras de datos anidadas dentro de una list:

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

El constructor list() se puede usar vacío o con un iterable como argumento. El constructor recorre los elementos del iterable y los agrega a la list en orden:

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

Los resultados de usar un constructor list con un string o un dict pueden ser sorprendentes:

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

Como el constructor list solo acepta iterables (o nada) como argumentos, los objetos que no son iterables lanzan un error de tipo. Por lo tanto, es mucho más fácil crear una list de un solo elemento con el método literal.

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

Acceder a los elementos

Se puede acceder a los elementos dentro de las listas (así como a los elementos de otros tipos de secuencia, str y tuple) mediante un 0-based index y la notación de corchetes. Los índices pueden ir de left --> right (empezando en cero) o de right --> left (empezando en -1).

índice desde la izquierda ⟹

0 👇🏾 1 👇🏾 2 👇🏾 3 👇🏾 4 👇🏾 5 👇🏾 P y t h o n 👆🏾 -6 👆🏾 -5 👆🏾 -4 👆🏾 -3 👆🏾 -2 👆🏾 -1

⟸ índice desde la derecha

>>> 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'

Se puede acceder a una sección de los elementos dentro de una list mediante la notación de slices (<list>[start:stop]). Un slice se define como una secuencia de elementos en la posición index, tal que start <= index < stop. El slicing devuelve una copia de los elementos «rebanados» y no modifica la list original.

También se puede usar un parámetro step [start:stop:step] para «saltar» o filtrar los elementos de la list (por ejemplo, un step de 2 selecciona elementos alternos en el rango):

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

Trabajar con listas

El uso de la función integrada sum() en una lista devuelve la suma de todos los números de la lista:

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

También puedes obtener la longitud de una lista con la función len():

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

Las listas también se pueden combinar de varias formas:

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

Las listas proporcionan un iterador y se pueden recorrer con un bucle de la misma forma que otros tipos de secuencia.

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

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

Para una explicación más detallada de los loops y los iterators, completa el concepto de loops.