Listas y matrices en Python – list

Listas o array en Python

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.

¿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.5

Cuando 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] = a

Slicing 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étodoDescripciónEjemplo
appendAñade un elemento al final de la listalist.append(5)
clearElimina toda la información de la listalist.clear()
copyDevuelve una copia de la listalist.copy()
countDevuelve el número de ocurrencias de un elemento en la listalist.count('p')
extendExtiende una lista extendida con otro iteradorlist.extend(lst2)
indexDevuelve el índice que ocupa un elementolist.index('e')
insertInserta un elemento en la lista en una posición exactalist.insert(3, 'y')
popElimina un elemento y lo devuelve de la posición marcada o del finallist.pop(4)
removeElimina la primera ocurrencia de un elemento de la listalist.remove('p')
reverseInvierte el orden de los elementos de la listalist.reverse()
sortPermite ordenar la lista con una funcion como keylist.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)
False

Ordenar 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.

Disponible en:

Compartir

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Información básica sobre protección de datos Ver más

  • Responsable Oscar Ramirez.
  • Finalidad Moderar los comentarios. Responder las consultas.
  • Legitimación Su consentimiento.
  • Destinatarios  ionos.
  • Derechos Acceder, rectificar y suprimir los datos.

Publicar un comentario