Listas y matrices en Python – list
Las listas son uno de los tipos básicos que provee Python y uno de los más útiles. Son objetos mutables capaces de almacenar información en forma de vectores.
Contenido
¿Qué es una lista o un array en Python?
También denominadas array en otros lenguajes como C, las listas en Python son objetos tipo colección, que permiten almacenar cualquier tipo de dato y acceder a cada posición utilizando un índice.
Las listas en Python se implementaron como listas doblemente enlazadas, por lo que desde un elemento se puede acceder tanto al siguiente en la lista como al anterior.
Crear un array o lista en Python
La forma de crear una lista es usando el constructor de listas list o como literal usando [].
>>> people = ['Jon', 'Marcos', 'Maria', 'Ana']
>>> for person in people:
... print(f'Nombre: {person}')
...
Nombre: Jon
Nombre: Marcos
Nombre: Maria
Nombre: Ana
>>> results = list([2.3, 7, 8, 4.5])
>>> for result, person in zip(results, people):
... print(f'Alumno {person} obtuvo puntuación de {result}')
...
Alumno Jon obtuvo puntuación de 2.3
Alumno Marcos obtuvo puntuación de 7
Alumno Maria obtuvo puntuación de 8
Alumno Ana obtuvo puntuación de 4.5Cuando se usa list sobre un objeto iterable el resultado será una lista con cada uno de los elementos del iterable.
>>> str_elems = list('pepe')
>>> print(str_elems)
['p', 'e', 'p', 'e']
>>> dct = dict(pepe=2, juan=7)
>>> print(dct.keys())
dict_keys(['pepe', 'juan'])
>>> lst_keys = list(dct.keys())
>>> print(lst_keys)
['pepe', 'juan']Recorrer listas en Python
El acceso a las listas se hace usando enteros, tanto positivos como negativos.
Para acceder a la primera posición de la lista se utiliza 0 y para acceder a la última se utiliza -1, y en ese intervalo se pueden acceder a todas las posiciones.
>>> acc, dec = 0, -1
>>> letters = ['a', 'b', 'c', 'd', 'e', 'f']
>>> for _ in letters:
... print(f'letters[{acc}] = {letters[acc]} | letters[{dec}] = {letters[dec]}')
... acc += 1
... dec -= 1
...
letters[0] = a | letters[-1] = f
letters[1] = b | letters[-2] = e
letters[2] = c | letters[-3] = d
letters[3] = d | letters[-4] = c
letters[4] = e | letters[-5] = b
letters[5] = f | letters[-6] = aSlicing en listas – sublistas
Python implementa una forma avanzada y simple de crear sublistas de elementos internos de una lista, usando la técnica del slicing. Esta técnica está disponible para cualquier iterador y es muy útil.
La forma básica del slicing es:
[posicion_inicial:posicion_final[:paso]]
Con esta sintaxis tan simple, se pueden obtener sublistas fácilmente. Las posiciones y los pasos pueden ser positivos o negativos como se ve a continuación.
>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
>>> letters[4:]
['e', 'f', 'g', 'h', 'i']
>>> letters[4:6]
['e', 'f']
>>> letters[4:10]
['e', 'f', 'g', 'h', 'i']
>>> letters[4:8]
['e', 'f', 'g', 'h']
>>> letters[2:8]
['c', 'd', 'e', 'f', 'g', 'h']
>>> letters[2:]
['c', 'd', 'e', 'f', 'g', 'h', 'i']
>>> letters[2:8]
['c', 'd', 'e', 'f', 'g', 'h']
>>> letters[2:100]
['c', 'd', 'e', 'f', 'g', 'h', 'i']
>>> letters[2:8:-1]
[]
>>> letters[2:8:2]
['c', 'e', 'g']
>>> letters[8:2:-2]
['i', 'g', 'e']
>>> letters[9:1:-2]
['i', 'g', 'e', 'c']
>>> letters[:-1]
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
>>> letters[:-5]
['a', 'b', 'c', 'd']
>>> letters[:-5:-2]
['i', 'g']Y como no podía ser de otra manera, también se permiten hacer asignaciones sobre slicing de una lista.
>>> letters[3:5] = [4, 5, 6]
>>> letters
['a', 'b', 'c', 4, 5, 6, 'f', 'g', 'h', 'i']
>>> letters[5:4] = 'pepe'
>>> letters
['a', 'b', 'c', 4, 5, 'p', 'e', 'p', 'e', 6, 'f', 'g', 'h', 'i']Métodos de listas disponibles
Los métodos disponibles para listas son:
>>> dir(letters)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__',
'__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__',
'__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__',
'__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__',
'__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__',
'__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index',
'insert', 'pop', 'remove', 'reverse', 'sort']| Método | Descripción | Ejemplo |
|---|---|---|
| append | Añade un elemento al final de la lista | list.append(5) |
| clear | Elimina toda la información de la lista | list.clear() |
| copy | Devuelve una copia de la lista | list.copy() |
| count | Devuelve el número de ocurrencias de un elemento en la lista | list.count('p') |
| extend | Extiende una lista extendida con otro iterador | list.extend(lst2) |
| index | Devuelve el índice que ocupa un elemento | list.index('e') |
| insert | Inserta un elemento en la lista en una posición exacta | list.insert(3, 'y') |
| pop | Elimina un elemento y lo devuelve de la posición marcada o del final | list.pop(4) |
| remove | Elimina la primera ocurrencia de un elemento de la lista | list.remove('p') |
| reverse | Invierte el orden de los elementos de la lista | list.reverse() |
| sort | Permite ordenar la lista con una funcion como key | list.sort(key=lambda x: str(x) > '0') |
Comparar dos listas en python
Para poder comparar listas en python se pueden usar las operaciones de comparación igual (==), diferente (!=), mayor que (>) o menor que (<).
>>> [1, 2, 3] != [1, 2, 3]
False
>>> [1, 2, 3] == [1, 2, 3]
True
>>> [1, 2, 3] > [1, 2]
True
>>> [1, 2, 3] < [1, 2]
False
>>> [1, 2, 3] == ['1', '2', '3']
False
>>> [1, 2, 3] < ['1', '2', '3']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'int' and 'str'Las comparaciones se hacen por defecto elemento a elemento, pero claro, si son de elementos diferentes no se pueden realizar, y por tanto es necesario hacer las comparaciones manualmente.
>>> lst_1 = [1, 2, 3, 4]
>>> lst_2 = ['p', 'j', 'k']
>>> lst_3 = ['1', '2']
>>> def greater(lst1, lst2):
... for elem1, elem2 in zip(lst1, lst2):
... if str(elem1) <= str(elem2):
... return False
... return True
...
>>> greater(lst_1, lst_2)
False
>>> greater(lst_1, lst_3)
False
>>> lst_4 = ['1', '2', '3', '4', '5']
>>> greater(lst_1, lst_4)
FalseOrdenar listas en python
Para sort listas se utiliza la función order y una función de ordenación, normalmente en forma de función anónima lambda.
>>> lst = [4, 5, 6, 3, 2, 5]
>>> lst.sort()
>>> lst
[2, 3, 4, 5, 5, 6]
>>> lst.sort(key=lambda x: -x if x < 5 else x**2)
>>> lst
[4, 3, 2, 5, 5, 6]
>>> lst.sort(key=lambda x: -x if x % 2 else x)
>>> lst
[5, 5, 3, 2, 4, 6]La función de ordenación puede ser tan compleja como sea necesario, incluso utilizando una función usual, con nombre, que devuelva un número o cualquier tipo de dato ordenable.
Usualmente puede ser números o tuplas.
Cómo usar matrices en Python
Una forma común de construir matrices es haciendo uso de listas anidadas (o listas de listas).
Si una lista convencional forma un vector de elementos, al hacer que cada elemento sea un vector, se obtiene una matriz de elementos.
>>> import pprint
>>> lst = list(range(5))
>>> pprint.pprint(lst)
[0, 1, 2, 3, 4]
>>> mtx = [list(range(5)) for _ in range(5)]
>>> pprint.pprint(mtx)
[[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4]]
>>> mtx2 = [list(range(x)) for x in range(5)]
>>> pprint.pprint(mtx2)
[[], [0], [0, 1], [0, 1, 2], [0, 1, 2, 3]]
>>> abc = [chr(65 + x) for x in range(5)]
>>> abc
['A', 'B', 'C', 'D', 'E']
>>> mtx_abc = [[chr(65 + (x * 5) + i) for i in range(5)] for x in range(5)]
>>> pprint.pprint(mtx_abc)
[['A', 'B', 'C', 'D', 'E'],
['F', 'G', 'H', 'I', 'J'],
['K', 'L', 'M', 'N', 'O'],
['P', 'Q', 'R', 'S', 'T'],
['U', 'V', 'W', 'X', 'Y']]Para acceder a cada posición de la matriz hay que seguir el acceso de cada elemento, por ejemplo: si se pretende acceder al elemento 3, 6 (columna 3, fila 6) es tan fácil como usar matriz[2][5].
Cabe destacar que el primer elemento de cada lista es el 0, por tanto, es necesario restar una unidad a las coordenadas deseadas para acceder correctamente a la posición.
>>> mtx_abc = [['A', 'B', 'C', 'D', 'E'],
... ['F', 'G', 'H', 'I', 'J'],
... ['K', 'L', 'M', 'N', 'O'],
... ['P', 'Q', 'R', 'S', 'T'],
... ['U', 'V', 'W', 'X', 'Y']]
>>> mtx_abc[0][2]
'C'
>>> mtx_abc[3][2]
'R'
>>> mtx_abc[3][4]
'T'
>>> mtx_abc[4][0]
'U'
>>> mtx_abc[0][1]
'B'
>>> mtx_abc[0][0]
'A'
>>> mtx_abc[4][4]
'Y'Realmente no hay límite a la hora de construir matrices, por lo que se podrían hacer de tantas dimensiones como se quiera. El único límite es la capacidad de almacenaje que tenga el sistema donde se ejecuta.
>>> mmtx = [[[list(range(2)) for _ in range(2)] for _ in range(2)] for _ in range(2)]
>>> pprint.pprint(mmtx)
[[[[0, 1], [0, 1]], [[0, 1], [0, 1]]],
[[[0, 1], [0, 1]], [[0, 1], [0, 1]]]]Libros recomendados para aprender Python
Estos son los libros que pueden ayudarte a aprender Python, aprender a programar, tipos de datos, algoritmia y mucho más.
Felicidades Maestro, excelente material, voy a adquirir su libro; deseo seguir con mi aprendizaje en Python: Saludos