Estructura de datos¶
Son una utilidad de Python dispuesta para almacenar y guardar cualquier tipo de Dato, tanto así que pueden contenerse entre sí. Cada una posee un tipo de paréntesis, o comillas en el caso de los strings, siendo fácil diferenciarlos unos de otro.
Strings
‘ ’: Representan texto , siendo una cadena ordenada de caracteres y un tipo de dato, como los números y booleanos, pero con una complejidad mayor al ser también una estructura. Pueden estar entre comillas ‘simples’ o “dobles”.Listas
[ ]: Son una cadena ordenada de datos, los cuales, al igual que en los strings y tuplas, tienen la relación dato-posición.Tuplas
( ): Son una cadena ordenada de datos, pero a diferencia de las listas, y al igual que los strings, es inmutable, es decir, no se puede modificar.Diccionarios
{ : }: Son un conjunto de pares de datos que se caracteriza por utilizar una relación llave-dato. Debido a esto no necesitan orden, ya que al tener una llave se puede sacar su dato relacionado.
Las estructuras de datos de string ya fueron estudiados en secciones pasada. En esta sección nos centraremos en las estructuras de Listas, Tuplas y Diccionarios.
# lista vacia (Usando corchetes)
lista = []
print(lista)
[]
# lista vacia (Usando el constructor)
lista = list()
print(lista)
[]
# lista de enteros
lista = [1, 2, 3]
print(lista)
[1, 2, 3]
# lista mixta
lista = [1, "hola", 3.4]
print(lista)
[1, 'hola', 3.4]
Operaciones sobre listas¶
Operador len
len(lista) entrega el largo de la lista; es decir, cuántos elementos tiene:
colores = ['azul', 'rojo', 'verde', 'amarillo']
print(len(colores))
4
Acceder al índice
l[i] entrega el i-ésimo valor de la lista. El valor $i$ se llama índice del valor. Al igual que para los strings, los índices parten de cero:
colores = ['azul', 'rojo', 'verde', 'amarillo']
print(f'primer elemento de la lista: {colores[0]}')
print(f'tercer elemento de la lista: {colores[2]}')
primer elemento de la lista: azul tercer elemento de la lista: verde
# elemento fuera de la lista
print( colores[4])
--------------------------------------------------------------------------- IndexError Traceback (most recent call last) <ipython-input-12-f7eb673eabf2> in <module> 1 # elemento fuera de la lista ----> 2 print( colores[4]) IndexError: list index out of range
Índice negativo
Si el índice es negativo, los elementos se cuentan desde el final hacia atrás:
colores = ['azul', 'rojo', 'verde', 'amarillo']
print(colores[-1])
amarillo
Agregar un elemento
l.append(x) agrega el elemento x al final de la lista:
primos = [2, 3, 5, 7, 11]
primos.append(13)
print(primos)
[2, 3, 5, 7, 11, 13]
Concatenar dos listas
l1 + l2 concatena las listas l1 y l2:
l1 = [1,2,3]
l2 = [4,5,6]
print(l1+l2)
[1, 2, 3, 4, 5, 6]
Repetir lista
l * n repite $n$ veces la lista l:
lista = [1,2,3]
print(2*lista)
[1, 2, 3, 1, 2, 3]
Elemento en una lista
Para saber si un elemento x está en la lista l, se usa x in l. La versión negativa de in es not in:
lista = [1,2,3,4,5,6,7,8,9]
print(12 in lista)
False
print(12 not in lista)
True
Operador rebanado
l[i:j] es el operador de rebanado, que entrega una nueva lista que tiene desde el i-ésimo hasta justo antes del j-ésimo elemento de la lista l:
l = [1.5, 3.3, 8.4, 3.1, 2.9]
print(l[2:4])
[8.4, 3.1]
Operador índice
l.index(x) entrega cuál es el índice del valor x:
colores = ['azul', 'rojo', 'verde', 'amarillo']
print(colores.index('verde'))
2
Operador remover
l.remove(x) elimina el elemento x de la lista:
l = [7, 0, 3, 9, 8, 2, 4]
l.remove(2)
print(l)
[7, 0, 3, 9, 8, 4]
Operador borrar
del l[i] elimina el i-ésimo elemento de la lista:
l = [7, 0, 3, 9, 8, 2, 4]
del l[2]
print(l)
[7, 0, 9, 8, 2, 4]
Operador reversa
l.reverse() invierte la lista:
l = [7, 0, 3, 9, 8, 2, 4]
l.reverse()
print(l)
[4, 2, 8, 9, 3, 0, 7]
Operador ordenar
l.sort() ordena la lista:
l = [7, 0, 3, 9, 8, 2, 4]
l.sort()
print(l)
[0, 2, 3, 4, 7, 8, 9]
Iterar sobre una lista¶
En Python, una lista es un tipo de objeto iterable, lo que significa que puedes recorrer sus elementos utilizando un ciclo for.
A continuación, te mostraremos un ejemplo de cómo hacerlo paso a paso:
# Definimos una lista llamada 'valores' con algunos números
valores = [1, 2, 3, 4, 5]
# Usamos un ciclo 'for' para recorrer cada elemento de la lista
for i in valores:
# En cada iteración, 'i' toma el valor de un elemento de la lista
# y calculamos su cuadrado utilizando el operador '**'
cuadrado = i ** 2
# Luego, imprimimos el valor y su cuadrado en la consola
print(f"El cuadrado de {i} es {cuadrado}")
El cuadrado de 1 es 1 El cuadrado de 2 es 4 El cuadrado de 3 es 9 El cuadrado de 4 es 16 El cuadrado de 5 es 25
Creamos una lista llamada
valoresque contiene los números[1, 2, 3, 4, 5]. Esta será la lista que recorreremos.Utilizamos un ciclo
forpara iterar a través de cada elemento de la lista. En cada iteración, la variableitoma el valor del siguiente elemento de la lista.Dentro del ciclo
for, calculamos el cuadrado deiusando el operador**y almacenamos el resultado en la variablecuadrado.Finalmente, imprimimos en la consola un mensaje que muestra el número original (
i) y su cuadrado (cuadrado) utilizando una f-string.
Tuplas¶
Una tupla es una secuencia de valores agrupados. Una tupla sirve para agrupar, como si fueran un único valor, varios valores que, por su naturaleza, deben ir juntos.
El tipo de datos que representa a las tuplas se llama tuple. El tipo tuple es inmutable: una tupla no puede ser modificada una vez que ha sido creada.
# tupla vacia (Usando corchetes)
tupla = ()
print(tupla)
()
# tupla vacia (Usando el constructor)
tupla = tuple()
print(tupla)
()
# tupla con elementos
numeros = ("uno", "dos", "tres", "cuatro")
print(numeros)
('uno', 'dos', 'tres', 'cuatro')
Desempaquetado de tuplas¶
Los valores individuales de una tupla pueden ser recuperados asignando la tupla a las variables respectivas. Esto se llama desempaquetar la tupla (en inglés: unpack):
persona = ('Javier', 'Perez')
nombre, apellido = persona
print(nombre, apellido)
Javier Perez
Si se intenta desempaquetar una cantidad incorrecta de valores, ocurre un error de valor:
a, b, c = persona
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-4-998bf8320296> in <module> ----> 1 a, b, c = persona ValueError: not enough values to unpack (expected 3, got 2)
Comparación de tuplas¶
Dos tuplas son iguales cuando tienen el mismo tamaño y cada uno de sus elementos correspondientes tienen el mismo valor:
(1, 2) == (2 / 2, 1 + 1)
True
(6, 1) == (6, 2)
False
Para determinar si una tupla es menor que otra, se utiliza lo que se denomina orden lexicográfico. Si los elementos en la primera posición de ambas tuplas son distintos, ellos determinan el ordenamiento de las tuplas:
(1, 4, 7) < (2, 0, 0, 1)
True
(1, 9, 10) < (0, 5)
False
Acceder a valores de una tupla¶
Al igual que las listas, se pueden acceder a distintos elemntos de las tuplas de la siguiente forma:
numeros = ("uno", "dos", "tres", "cuatro")
print(numeros[1]) #Output: dos
print(numeros[3]) #Output: cuatro
print(numeros[-1]) # Output: cuatro
Iteración sobre tuplas¶
Las tuplas en Python también son objetos iterables, lo que significa que puedes recorrer sus elementos usando un ciclo for.
A continuación, te mostraremos un ejemplo de cómo hacerlo paso a paso:
# Definimos una tupla con algunos números
tupla_valores = (1, 2, 3, 4, 5)
# Usamos un ciclo 'for' para recorrer cada elemento de la tupla
for valor in tupla_valores:
# En cada iteración, 'valor' toma el valor de un elemento de la tupla
# y calculamos su cuadrado utilizando el operador '**'
cuadrado = valor ** 2
# Luego, imprimimos el valor y su cuadrado en la consola
print(f"El cuadrado de {valor} es {cuadrado}")
El cuadrado de 1 es 1 El cuadrado de 2 es 4 El cuadrado de 3 es 9 El cuadrado de 4 es 16 El cuadrado de 5 es 25
Convertir Entre Listas y Tuplas
En Python, puedes convertir una tupla en una lista utilizando la función list() y una lista en una tupla utilizando la función tuple(). Esto es útil cuando necesitas cambiar el tipo de contenedor de datos. A continuación, te proporciono ejemplos para ilustrar ambos casos:
Convertir una Tupla en una Lista:
# Definimos una tupla
mi_tupla = (1, 2, 3, 4, 5)
# Usamos la función 'list()' para convertir la tupla en una lista
mi_lista = list(mi_tupla)
# Imprimimos la lista resultante
print("Tupla original:", mi_tupla)
print("Lista resultante:", mi_lista)
Tupla original: (1, 2, 3, 4, 5) Lista resultante: [1, 2, 3, 4, 5]
Convertir una Lista en una Tupla:
# Definimos una lista
mi_lista = [1, 2, 3, 4, 5]
# Usamos la función 'tuple()' para convertir la lista en una tupla
mi_tupla = tuple(mi_lista)
# Imprimimos la tupla resultante
print("Lista original:", mi_lista)
print("Tupla resultante:", mi_tupla)
Lista original: [1, 2, 3, 4, 5] Tupla resultante: (1, 2, 3, 4, 5)
Conjuntos¶
Un conjunto es una colección desordenada de valores no repetidos.
Los conjuntos de Python son análogos a los conjuntos matemáticos. El tipo de datos que representa a los conjuntos se llama set.
Cómo crear conjuntos¶
Las dos maneras principales de crear un conjunto son:
# conjunto vacio (Usando corchetes)
conjunto = {}
print(conjunto)
{}
# conjunto vacio (Usando el constructor)
conjunto = set()
print(conjunto)
set()
# usar un conjunto literal, entre llave
conjunto = {1, 2, 3}
print(conjunto)
{1, 2, 3}
# set aplicada sobre un iterable
conjunto = set([1, 2, 3])
print(conjunto)
{1, 2, 3}
Los elementos de un conjunto deben ser inmutables. Por ejemplo, no es posible crear un conjunto de listas, pero sí un conjunto de tuplas:
conjunto = {[2, 4], [6, 1]}
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-34-c1f516a9affc> in <module> ----> 1 s = {[2, 4], [6, 1]} TypeError: unhashable type: 'list'
Como un conjunto no es ordenado, no tiene sentido intentar obtener un elemento usando un índice:
conjunto = {'a', 'b', 'c'}
conjunto[0]
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-35-501605a4a770> in <module> 1 conjunto = {'a', 'b', 'c'} ----> 2 conjunto[0] TypeError: 'set' object is not subscriptable
Sin embargo, sí es posible iterar sobre un conjunto usando un ciclo for:
conjunto = {'a', 'b', 'c'}
for i in conjunto:
print(i)
a c b
Operaciones sobre conjuntos¶
Largo del conjunto
len(s) entrega el número de elementos del conjunto s:
len({'azul', 'verde', 'rojo'})
3
Elementos en el conjunto
x in s permite saber si el elemento x está en el conjunto s:
3 in {2, 3, 4}
True
x not in s permite saber si x no está en s:
3 not in {2, 3, 4}
False
Agregar elementos al conjunto
s.add(x) agrega el elemento x al conjunto s:
s = {6, 1, 5, 4, 3}
s.add(-37)
s
{-37, 1, 3, 4, 5, 6}
Remover elementos al conjunto
s.remove(x) elimina el elemento x del conjunto s:
s = {6, 1, 5, 4, 3}
s.remove(1)
s
{3, 4, 5, 6}
Si el elemento x no está en el conjunto, ocurre un error de llave:
s.remove(10)
--------------------------------------------------------------------------- KeyError Traceback (most recent call last) <ipython-input-42-23b5f1bb77c8> in <module> ----> 1 s.remove(10) KeyError: 10
Operaciones sobre conjuntos
& y | son los operadores de intersección y unión repectivamente:
# crear dos conjuntos
a = {1, 2, 3, 4}
b = {2, 4, 6, 8}
# interseccion
a & b
{2, 4}
# union
a | b
{1, 2, 3, 4, 6, 8}
s - t entrega la diferencia entre s y t; es decir, los elementos de s que no están en t:
# diferencia
a - b
{1, 3}
s ^ t entrega la diferencia simétrica entre s y t; es decir, los elementos que están en s o en t, pero no en ambos:
# diferencia simetrica
a ^ b
{1, 3, 6, 8}
El operador < aplicado sobre conjuntos significa «es subconjunto de»:
{1, 2} < {1, 2, 3}
True
{1, 4} < {1, 2, 3}
False
s <= t también indica si s es subconjunto de t. La distinción ocurre cuando los conjuntos son iguales:
{1, 2, 3} < {1, 2, 3}
False
{1, 2, 3} <= {1, 2, 3}
True
Diccionarios¶
Un diccionario es un tipo de datos que sirve para asociar pares de objetos.
Un diccionario puede ser visto como una colección de llaves, cada una de las cuales tiene asociada un valor. Las llaves no están ordenadas y no hay llaves repetidas. La única manera de acceder a un valor es a través de su llave.
Cómo crear diccionarios¶
Los diccionarios literales se crean usando llaves ({ y }). La llave y el valor van separados por dos puntos:
# diccionario vacio (Usando corchetes)
dct = {}
print(dct)
{}
# lista vacia (Usando el constructor)
dct = dict()
print(dct)
{}
# diccionario de enteros
dct = {1: 'apple', 2: 'ball'}
# diccionario dde llaves mixtas
dct = {'name': 'John', 1: [2, 4, 3]}
Cómo usar un diccionario¶
El valor asociado a la llave $k$ en el diccionario $dct$ se puede obtener mediante $dct[k]$:
dct = {'nombre':'Jack', 'edad': 26, 'salario': 4534.2}
print(dct['edad']) # Output: 26
26
Si se asigna un valor a una llave que ya estaba en el diccionario, el valor anterior se sobreescribe. Recuerde que un diccionario no puede tener llaves repetidas:
dct = {'nombre':'Jack', 'edad': 26}
# cambiar edad
dct['edad'] = 36
print(dct) # Output: {'name': 'Jack', 'age': 36}
También se pueden adherir llaves al diccionario
# adherir llave salario
dct['salario'] = 4342.4
print(dct) # Output: {'name': 'Jack', 'age': 36, 'salary': 4342.4}
Por otro lado, si se quiere borrar una llave o el mismo diccionario, se ocupa el comando del
# borrar llave edad
del dct['edad']
print(dct) # Output: {'name': 'Jack', 'salary': 4342.4}
# borrar diccionario
del dct
Iterar un diccionario¶
Los diccionarios son iterables. Al iterar sobre un diccionario en un ciclo for, se obtiene las llaves:
dct = {1: 'apple', 2: 'ball'}
for k in dct:
print(k)
1 2
Para iterar sobre las llaves, se usa values():
for v in dct.values():
print(v)
apple ball
Para iterar sobre las llaves y los valores simultáneamente, se usa el método items():
for k,v in dct.items():
print(f"llave: {k}, valor: {v}")
llave: 1, valor: apple llave: 2, valor: ball
Restricciones sobre las llaves¶
No se puede usar cualquier objeto como llave de un diccionario. Las llaves deben ser de un tipo de datos inmutable. Por ejemplo, no se puede usar listas:
dct = {[1, 2, 3]: 'hola'}
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-30-873bc4fce75e> in <module> ----> 1 dct = {[1, 2, 3]: 'hola'} TypeError: unhashable type: 'list'
Típicamente, se usa números, tuplas y strings como llaves de los diccionarios.
Ejercicios¶
Listas¶
Ejercicio 01
Considere las siguientes listas:
a = [5, 1, 4, 9, 0]
b = range(3, 10) + range(20, 23)
c = [[1, 2], [3, 4, 5], [6, 7]]
d = ['perro', 'gato', 'jirafa', 'elefante']
e = ['a', a, 2 * a]
Sin usar el computador, indique cuál es el resultado y el tipo de las siguientes expresiones. A continuación, verifique sus respuestas en el computador.
a[2]
b[9]
c[1][2]
e[0] == e[1]
len(c)
len(c[0])
len(e)
c[-1]
c[-1][+1]
c[2:] + d[2:]
a[3:10]
a[3:10:2]
d.index('jirafa')
e[c[0][1]].count(5)
sorted(a)[2]
complex(b[0], b[1])
# respuesta
Tuplas¶
Ejercicio 01
Considere las siguientes asignaciones:
a = (2, 10, 1991)
b = (25, 12, 1990)
c = ('Donald', True, b)
x, y = ((27, 3), 9)
z, w = x
v = (x, a)
Sin usar el computador, indique cuál es el resultado y el tipo de las siguientes expresiones. A continuación, verifique sus respuestas en el computador.
a < b
y + w
x + a
len(v)
v[1][1]
c[0][0]
z, y
a + b[1:5]
(a + b)[1:5]
str(a[2]) + str(b[2])
str(a[2] + b[2])
str((a + b)[2])
str(a + b)[2]
# respuesta
Conjuntos¶
Ejercicio 01
Considere las siguientes asignaciones:
a = {5, 2, 3, 9, 4}
b = {3, 1}
c = {7, 5, 5, 1, 8, 6}
d = [6, 2, 4, 5, 5, 3, 1, 3, 7, 8]
e = {(2, 3), (3, 4), (4, 5)}
f = [{2, 3}, {3, 4}, {4, 5}]
Sin usar el computador, indique cuál es el resultado y el tipo de las siguientes expresiones. A continuación, verifique sus respuestas en el computador.
len(c)
len(set(d))
a & (b | c)
(a & b) | c
c - a
max(e)
f[0] < a
set(range(4)) & a
(set(range(4)) & a) in f
len(set('perro'))
len({'perro'})
# respuesta
Diccionarios¶
Ejercicio 01
Considere las siguientes asignaciones:
a = {'a': 14, 'b': 23, 'c': 88}
b = {12: True, 55: False, -2: False}
c = dict()
d = {1: [2, 3, 4], 5: [6, 7, 8, 9], 10: [11]}
e = {2 + 3: 4, 5: 6 + 7, 8: 9, 10: 11 + 12}
Sin usar el computador, indique cuál es el resultado y el tipo de las siguientes expresiones. A continuación, verifique sus respuestas en el computador.
a['c']
a[23]
b[-2] or b[55]
23 in a
'a' in a
5 in d[5]
sum(b)
len(c)
len(d)
len(d[1])
len(b.values())
len(e)
sum(a.values())
max(list(e))
d[1] + d[5] + d[10]
# respuesta