En Python: Tipos básicos vimos los números, las cadenas de texto y los booleanos. En esta lección veremos algunos tipos de colecciones de datos: listas, tuplas y diccionarios. Se les llama colecciones debido a que sirven para agrupar elementos.
La lista es un tipo de colección ordenada. Sería equivalente a lo que en otros lenguajes se conoce por arrays, o vectores.
Crear una lista es tan sencillo como indicar entre corchetes, y separados por comas, los valores que queremos incluir en la lista:
lista = [1 , 3 , "Hola" , 2.12 , 3j]
print(lista)
[1, 3, 'Hola', 2.12, 3j]
Podemos acceder a cada uno de los elementos de la lista escribiendo el nombre de la lista e indicando el índice del elemento entre corchetes. Ten en cuenta sin embargo que el índice del primer elemento de la lista es 0, y no 1 como vimos anteriormente.
lista[2]
'Hola'
lista[5]
--------------------------------------------------------------------------- IndexError Traceback (most recent call last) <ipython-input-4-cf0236d70f2a> in <module>() ----> 1 lista[5] IndexError: list index out of range
Recordar que los índices se toman de la siguiente manera:
Si queremos modificar algun elemento de la lista usamos la asignación:
lista[3] = "Kappa"
print(lista)
[1, 3, 'Hola', 'Kappa', 3j]
Al igual que las cadenas podemos usar el slicing
lista[2:4]
['Hola', 'Kappa']
Las listas también pueden contener otras listas:
test = [2 , 5 , [2, 3, 5]]
test[2]
[2, 3, 5]
test[2][2]
5
Podemos usar la función len()
para obtener el tamaño de una lista:
lista2 = [1, 6, 7, 8, 20 ,99]
len(lista2)
6
Podemos concatenar listas como si fueran cadenas:
xas = [1, 4, 7] + ["A", "B", "C"]
print(xas)
[1, 4, 7, 'A', 'B', 'C']
La instrucción del
eliminará los valores en un índice de una lista. Todos los valores de la lista después del valor eliminado se moverán hacia arriba un índice:
animales = ["gato","perro","conejo","cuy","llama"]
print(animales)
['gato', 'perro', 'conejo', 'cuy', 'llama']
del animales[2]
print(animales)
['gato', 'perro', 'cuy', 'llama']
Ahora hagamos el ejemplo de un programa en donde ingresaremos el nombre de perros a una lista:
dogNames = []
while True:
print('Ingrese el nombre del perro ' + str(len(dogNames) + 1) + ' (O deje en blanco para terminar):')
name = input()
if name == '':
break
dogNames = dogNames + [name] # concatenamos
print('El nombre de los perros son:')
for name in dogNames:
print(' ' + name)
Ingrese el nombre del perro 1 (O deje en blanco para terminar): Diomedes Ingrese el nombre del perro 2 (O deje en blanco para terminar): Galu Ingrese el nombre del perro 3 (O deje en blanco para terminar): Thera Ingrese el nombre del perro 4 (O deje en blanco para terminar): El nombre de los perros son: Diomedes Galu Thera
Puede determinar si un valor está o no en una lista con los operadores in
y not
. Estas expresiones se evaluarán con un valor booleano.
girls = ["Zasha","Sofia","Milagros","Melissa","Nadia"]
"Zasha" in girls
True
"Katherine" in girls
False
"Diana" not in girls
True
"Melissa" not in girls
False
También podemos recorrer una lista con el bucle for
for name in girls:
print(name)
Zasha Sofia Milagros Melissa Nadia
for num in [1,3,5,7,21,1,68,32]:
if(num%2==0):
print(num)
68 32
Aquí veremos como generar lista y dicccionarios de manera inline en python. Se trata de una notación práctica para definir listas, sets, diccionarios.
Su forma es muy parecida la del for in
lista = [k for k in range(8)]
lista
[0, 1, 2, 3, 4, 5, 6, 7]
[str(n*n) for n in range(6)]
['0', '1', '4', '9', '16', '25']
También se puede aplicar filtros a la secuencia, mediante la utilización del if
.
[str(n*n) for n in range(13) if n % 2]
['1', '9', '25', '49', '81', '121']
list( i for i in range(0,10,3))
[0, 3, 6, 9]
list(i*0.1 for i in range(0,10))
[0.0, 0.1, 0.2, 0.30000000000000004, 0.4, 0.5, 0.6000000000000001, 0.7000000000000001, 0.8, 0.9]
Un método es lo mismo que una función, excepto que es "llamado" a un valor. Por ejemplo, si un valor de lista se almacenaba en spam, se llamaría el método de lista index() (que explicaré a continuación) en esa lista de la siguiente manera: spam.index ('hola'). La parte del método viene después del valor, separados por un punto. Cada tipo de datos tiene su propio conjunto de métodos. El tipo de datos de lista, por ejemplo, tiene varios métodos útiles para encontrar, agregar, quitar y de otra manera manipular valores en una lista.
index()
¶departamentos = ['Piura', 'Lambayeque', 'Lima', 'Puno']
departamentos.index('Piura')
0
departamentos.index('Lambayeque')
1
departamentos.index('Ucayali')
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-31-adfed6891950> in <module>() ----> 1 departamentos.index('Ucayali') ValueError: 'Ucayali' is not in list
append()
e insert()
¶ciudades = ["Tokio","Roma","Berlín","Moscú"]
ciudades.append("París")
print(ciudades) # El método append agregará Paris al final de la lista
['Tokio', 'Roma', 'Berlín', 'Moscú', 'París']
ciudades.insert(2,"Berna")
print(ciudades) # El método insert agregará Berna en la posicion 2 y desplazara las demás
['Tokio', 'Roma', 'Berna', 'Berlín', 'Moscú', 'París']
remove()
¶ciudades.remove("Berna")
print(ciudades)
['Tokio', 'Roma', 'Berlín', 'Moscú', 'París']
ciudades.remove("Lima") # Lima no está en la lista por eso no puede removerla
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-36-e2727cf98e22> in <module>() ----> 1 ciudades.remove("Lima") # Lima no está en la lista por eso no puede removerla ValueError: list.remove(x): x not in list
sort()
¶numbers = [2 ,7,1,2,6,8]
numbers.sort()
print(numbers)
[1, 2, 2, 6, 7, 8]
names = ["maria","juana","ana","camila"]
names.sort()
print(names)
['ana', 'camila', 'juana', 'maria']
names.reverse()
print(names)
['maria', 'juana', 'camila', 'ana']
split()
¶oracion = "Este ejemplo tiene cinco palabras"
palabras = oracion.split()
print(palabras)
['Este', 'ejemplo', 'tiene', 'cinco', 'palabras']
Veamos algo interesante...
test = [1,3,7,2,3,6,8]
copy_test = test
print(copy_test)
[1, 3, 7, 2, 3, 6, 8]
¿Qué pasará si...?
copy_test[5] = "Hello"
print(copy_test)
[1, 3, 7, 2, 3, 'Hello', 8]
print(test)
[1, 3, 7, 2, 3, 'Hello', 8]
¿Qué acaba de pasar? ... NO he modificado test... D:
Si hiciera lo mismo en variables su valor cambia, pero en las listas no funciona así, cuando asigna una lista a una variable, en realidad está asignando una referencia de lista a la variable. Una referencia es un valor que apunta a algún bit de datos, y una referencia de lista es un valor que apunta a una lista.
Entonces como copio una lista sin alterar sus valores? La respuesta es usando el método copy() del módulo copy
import copy
lista = [1,2,4,5,6,7,8]
lista2 = copy.copy(lista)
lista2[3] = "Hola"
print(lista)
print(lista2)
[1, 2, 4, 5, 6, 7, 8] [1, 2, 4, 'Hola', 6, 7, 8]
Las tuplas son casi idénticas a las listas, excepto en dos formas. Pero tienen ciertas características:
Entonces, ¿para qué sirven las tuplas?
Las tuplas son más rápidas que las listas. Si está usted definiendo un conjunto constante de valores y todo lo que va a hacer con él es recorrerla, utilice una tupla en lugar de una lista. ¿Recuerda que dije que las claves de un diccionario pueden ser enteros, cadenas y “algunos otros tipos”? Las tuplas son uno de estos tipos. Las tuplas pueden utilizarse como claves en un diccionario, pero las listas no. Las tuplas se utilizan para formatear cadenas.
from numpy.random import rand
values = rand(10000,4)
lst = [list(row) for row in values]
tup = tuple(tuple(row) for row in values)
%timeit for row in lst: list(row)
1.39 ms ± 133 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
%timeit for row in tup: tuple(row)
861 µs ± 39.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
Nota
Las tuplas pueden convertirse en listas, y viceversa. La función incorporada tuple toma una lista y devuelve una tupla con los mismos elementos, y la función list toma una tupla y devuelve una lista. En la práctica, tuple congela una lista, y list descongela una tupla.
tupla_test = (2,4,5,8,10)
print(tupla_test)
print(tupla_test[3])
(2, 4, 5, 8, 10) 8
Las tuplas también pueden anidarse como las listas :
u = (tupla_test, (1, 2, 3, 4, 5))
print(u)
((2, 4, 5, 8, 10), (1, 2, 3, 4, 5))
Pero la principal forma en que las tuplas son diferentes de las listas es que las tuplas, como las cadenas, son inmutables. Las tuplas no pueden modificar sus valores, agregar o eliminar.
tupla_test[3] = 8
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-50-c9802ce7e10d> in <module>() ----> 1 tupla_test[3] = 8 TypeError: 'tuple' object does not support item assignment
type(tupla_test)
tuple
Los diccionarios, también llamados matrices asociativas, deben su nombre a que son colecciones que relacionan una clave y un valor. La principal diferencia entre los diccionarios con las tuplas y listas, es que sus valores no son accedidos a través de un índice, porque no poseen orden (ya que los diccionarios se implementan como tablas hash), sino que mediante su clave utilizando el operador[clave]. Por esta misma razón es que tampoco puede aplicarse slicing sobre estas.
diccionario = {'nombre' : 'Carlos', 'edad' : 22, 'cursos': ['C','Java','Python'] }
print(diccionario)
{'nombre': 'Carlos', 'edad': 22, 'cursos': ['C', 'Java', 'Python']}
Podemos acceder al elemento de un Diccionario mediante la clave de este elemento, como veremos a continuación:
print(diccionario['nombre']) #Carlos
print(diccionario['edad'])#22
print(diccionario['cursos']) #['C','Java','Python']
Carlos 22 ['C', 'Java', 'Python']
print(diccionario['cursos'][0])
C
print(diccionario['cursos'][1])
Java
for key in diccionario:
print(key, ":", diccionario[key])
nombre : Carlos edad : 22 cursos : ['C', 'Java', 'Python']
Vamos a programar un diccionario que tenga los cumpleaños de algunas personas:
birthdays = {'Alondra': '5 de Abril', 'Carla': '12 de Diciembre ', 'Martin': '3 de Enero'}
while True:
print('Ingrese un nombre: (deje en blanco para salir)')
name = input()
if name == '':
break
if name in birthdays:
print(birthdays[name] + ' es el cumpleaños de ' + name)
else:
print('No tengo información de: ' + name)
print('Cuando es su cumpleaños?')
bday = input()
birthdays[name] = bday
print('Base de datos de cumpleaños actualizada!')
Ingrese un nombre: (deje en blanco para salir) Katherine No tengo información de: Katherine Cuando es su cumpleaños? 24 de Febrero Base de datos de cumpleaños actualizada! Ingrese un nombre: (deje en blanco para salir) Gerson No tengo información de: Gerson Cuando es su cumpleaños? 23 de diciembre Base de datos de cumpleaños actualizada! Ingrese un nombre: (deje en blanco para salir)
print(birthdays)
{'Alondra': '5 de Abril', 'Carla': '12 de Diciembre ', 'Martin': '3 de Enero', 'Katherine': '24 de Febrero', 'Gerson': '23 de diciembre'}
Ahora vamos a usar algunos métodos interesantes en los diccionarios:
values()
¶capitales = {"Rusia":"Moscu","Francia":"Paris","Alemania":"Berlín"}
for i in capitales.values(): # El metodo values nos lista los valores de diccionario
print(i)
Moscu Paris Berlín
keys()
¶for j in capitales.keys(): # el metodo keys nos lista las llaves del diccionario
print(j)
Rusia Francia Alemania
items()
¶for k in capitales.items(): #el metodo items nos lista todos los items del diccionario
print(k)
('Rusia', 'Moscu') ('Francia', 'Paris') ('Alemania', 'Berlín')
"Alemania" in capitales.keys()
True
"Berlin" in capitales.values()
False
Ahora veamos unos ultimos métodos
get()
¶# Metodo get()
# Recibe como parámetro una clave, devuelve el valor de la clave. Si no lo encuentra, devuelve un objeto none.
capitales = {"Rusia":"Moscu","Francia":"Paris","Alemania":"Berlín"}
capitales.get("Rusia")
'Moscu'
pop()
¶# Metodo pop()
# Recibe como parámetro una clave, elimina esta y devuelve su valor. Si no lo encuentra, devuelve error.
capitales.pop("Francia")
'Paris'
print(capitales)
{'Rusia': 'Moscu', 'Alemania': 'Berlín'}
setdefault()
¶# Metodo setdefault()
# Funciona como get y tambien sirve para agregar un nuevo elemento al diccionario
print(capitales.setdefault("Alemania"))
Berlín
capitales.setdefault("Italia","Roma")
'Roma'
print(capitales)
{'Rusia': 'Moscu', 'Alemania': 'Berlín', 'Italia': 'Roma'}
# Este es un juego de advinar el numero mágico
import random
lista_numeros = [] # creamos una lista vacia
for i in range(10):
k = random.randint(1,20)
lista_numeros.append(k)
intentos = 3 # numero de intentos
for l in range(3):
entrada = int(input("Ingrese un numero entre 1 y 20: "))
if entrada in lista_numeros:
print("Usted ha adivinado")
else:
print("Siga intentando")
print("Lista de numeros")
print(lista_numeros)
Ingrese un numero entre 1 y 20: 5 Usted ha adivinado Ingrese un numero entre 1 y 20: 10 Siga intentando Ingrese un numero entre 1 y 20: 3 Siga intentando Lista de numeros [16, 15, 7, 20, 7, 5, 11, 8, 2, 20]
hexToBinary = {'0':'0000', '1':'0001', '2':'0010',
'3':'0011', '4':'0100', '5':'0101',
'6':'0110', '7':'0111', '8':'1000',
'9':'1001', 'A':'1010', 'B':'1011',
'C':'1100', 'D':'1101', 'E':'1110',
'F':'1111'}
binary = ""
number = input("Ingrese el numerohexadecimal: ")
for digit in number:
binary = binary + hexToBinary[digit]
print(binary)
Ingrese el numerohexadecimal: 8F3D35 100011110011110100110101
Por último tambien tenemos a los conjuntos:
a = set([1, 2, 3, 1])
a
{1, 2, 3}
type(a)
set
b = {2,3,4,5,6}
b
{2, 3, 4, 5, 6}
Podemos realizar operaciones entre conjuntos como:
a.union(b)
{1, 2, 3, 4, 5, 6}
b.union(a)
{1, 2, 3, 4, 5, 6}
a | b # Podemos usar tambien esta notación
{1, 2, 3, 4, 5, 6}
a.intersection(b)
{2, 3}
b.intersection(a)
{2, 3}
a & b # Notacion para interseccion
{2, 3}
Podemos agregar elementos con el método add :
a.add(322)
a
{1, 2, 3, 322}
b.difference(a)
{4, 5, 6}
a.difference(b)
{1, 322}
a - b
{1, 322}
a.symmetric_difference(b) == b.symmetric_difference(a)
True
a ^ b
{1, 4, 5, 6, 322}
Si queremos saber si un conjunto es subconjunto de otro hacemos:
a = {1,2,3,4}
b = {0,1,2,3,4,5,6,7}
a.issubset(b)
True
a <= b
True
b.issuperset(a)
True
b >= a
True
# Esta celda da el estilo al notebook
from IPython.core.display import HTML
css_file = '../styles/StyleCursoPython.css'
HTML(open(css_file, "r").read())