Programación

Tecnicatura Universitaria en Telecomunicaciones

Año 2024

AP Santiago Nicolau
1
 PROGRAMACIÓN
Python - Listas - Tuplas - Set - Diccionarios

2
Listas
Son utilizadas para almacenar colecciones de datos.
Son mutables (se pueden modificar). Son ordenadas.
Son un tipo de datos de secuencia, por lo que permite indexar y segmentar.
Puede contener diferentes tipos de datos, incluidos otras listas.
En otros lenguajes se los denomina como arrays dinámicos , ya que se pueden
añadir o eliminar elementos.

a = [1, 2, 3, "Hola Mundo",['a','b','c']]

print(a)
print(type(a))

3
Listas - Accediendo a valores con índices
a = [1, 2, 3, "Hola Mundo",['a','b','c']]
print(a[3])
print(a[-1])
print(a[-1][2])

# Hola Mundo
# ['a', 'b', 'c']
# c

4
Listas - Sublistas a partir de "segmentos"
Las listas permiten utilizar la notación de segmentos.
lista[inicio:fin:paso] .
Resultado: una nueva lista con los elementos desde el índice inicial hasta el
índice final-1.

a = [1, 2, 3, "Hola Mundo",['a','b','c']]

print(a[:3])
print(a[3:])
print(a[::-1])
# [1, 2, 3]
# ['Hola Mundo', ['a', 'b', 'c']]
# [['a', 'b', 'c'], 'Hola Mundo', 3, 2, 1]

5
Listas - Recorriendo
a = [1, 2, 3, "Hola Mundo",['a','b','c']]
for item in a:
print(item)

# 1
# 2
# 3
# Hola Mundo
# ['a', 'b', 'c']

6
Listas - Obteniendo índice e item
a = [1, 2, 3, "Hola Mundo",['a','b','c']]

for idx,item in enumerate(a):

print(idx,item,sep=' -> ')

# 0 -> 1
# 1 -> 2
# 2 -> 3
# 3 -> Hola Mundo
# 4 -> ['a', 'b', 'c']

7
Listas - Concatenación
disneyClasico=['Mickey Mouse','Pato Donald','Goofy']
starWars=['Anakin','Vader','Obi One','Yoda']
toyStory=['Woody','Buzz','Betty','SR. Cara de Papa','Andy']

disney=disneyClasico + starWars + toyStory

print(disney)

# ['Mickey Mouse', 'Pato Donald', 'Goofy', 'Anakin', 'Vader', 'Obi One', 'Yoda', 'Woody', 'Buzz', 'Betty', 'SR. Cara de Papa', 'Andy']

8
Listas - Operadores in y not .
sw=['Anakin','Vader','Obi One','Yoda','Luke']

print('Vader' in sw)
print('Rey' in sw)
print('Kirk' in sw)
print('Kirk' not in sw)

True
False
False
True

9
Listas - Asignación múltiple
Permite asignar a múltiples variables , los valores de una lista.

jugadores=['Messi','Dibu','Lautaro','Otamendi','McAllister']

messi,arquero,delantero,defensa,mediocampo=jugadores

10
Métodos de las listas y operadores.
len() : muestra la longitud (cantidad de elementos) de la lista.
clear() : elimina todos los elementos de la lista.
append() : añade un nuevo elemento al final de la lista.
extend(enumerable) : extiende la lista añadiendo elementos de otro
enumerable.
index(value, [startIndex]) : obtiene el índice de la primera aparición del
valor de entrada.
insert(index, value) : inserta value justo antes del índice especificado. Por lo
tanto, después de la inserción, el nuevo elemento ocupa la posición index.

11
Métodos de las listas y operadores.
pop([index]) : elimina y devuelve el elemento en index. Sin argumentos,
elimina y devuelve el último elemento de la lista.
reverse() : invierte la lista en el lugar y devuelve None.
count(value) : cuenta la cantidad de apariciones de algún valor en la lista.
sort() : ordena la lista en orden numérico y lexicográfico y devuelve None.

12
Métodos de las listas y operadores.
Eliminación de elementos
: elimina la primera aparición del valor especificado. Si no se
remove(value)
puede encontrar el valor proporcionado, se genera un ValueError .
del y la notación de segmentos.

lst=['perro','gato','conejo','canario','rata','vibora','sapo']
print(lst)

lst.remove('rata')
print(lst)

del lst[4:]
print(lst)

['perro', 'gato', 'conejo', 'canario', 'rata', 'vibora', 'sapo']

['perro', 'gato', 'conejo', 'canario', 'vibora', 'sapo']
['perro', 'gato', 'conejo', 'canario'] 13
Listas - Copiar
El símbolo "=" asigna una referencia de la lista original al nuevo nombre. Es
decir, tanto el nombre original como el nuevo nombre apuntan al mismo
objeto de lista.
nuevaLista = listaOriginal (NO es una copia, es una asignación. )
nuevaLista = listaOriginal[:] (Opción 1, correcta, uso del segmentado)
nuevaLista = list (listaOriginal) (Opción2, correcta, uso de la función
list() )

14
Comprensiones de listas (List comprehensions)
Son construcciones sintácticas concisas.
Se pueden utilizar para generar listas a partir de otras listas aplicando
funciones a cada elemento de la lista.
Forma básica
[ <expresión> for <elemento> in <iterable> ]
Forma alternativa con if
[ <expresión> for <elemento> in <iterable> if <condición> ]

15
Comprensiones de listas (List comprehensions)

cuadrados=[x*x for x in [1,2,3,4,5,6,7,8]]

print(cuadrados)
# [1, 4, 9, 16, 25, 36, 49, 64]

lstPares=[x for x in range(10) if ((x % 2) == 0)]

print(lstPares)
# [0, 2, 4, 6, 8]

16
Listas - Función zip()
Dada una lista(s) o diccionario(s) devuelve una tupla.

a=[1,2,3,4,5]
b=['a','b','c']
c=['x','y','z','xx','yy','zz','xxx','yyy','zzz']
for item in zip(a,b,c):
print(item)

# (1, 'a', 'x')

# (2, 'b', 'y')
# (3, 'c', 'z')

17
Listas - Funciones Map, Filter
map aplica una determinada función a todos los elementos de una entrada o
lista. Devuelve una nueva lista donde todos y cada uno de los elementos de la
lista original han sido pasados por la función
map(funcion_a_aplicar, lista_de_entradas)

lista = [1, 2, 3, 4, 5]

def fn_porTres(x):
return x * 3

resultado = map(fn_porTres, lista)

print(list(resultado))
# [3, 6, 9, 12, 15] 18
Listas - Funciones Map, Filter
filter recibe una función y una lista pero el resultado es la lista inicial
filtrada. Es decir, se pasa cada elemento de la lista por la función, y sólo si su
resultado es True, se incluye en la nueva lista.
filter(funcion_filtrar, entrada_iterable)

lista = [1,9, 18,12,99,11,22]

def fn_esPar(x):
return ((x % 2)==0)

resultado = filter(fn_esPar, lista)

print(list(resultado))

# [18, 12, 22]

19
Set - Conjunto
Estructura para contener elementos de una manera similar a las listas, pero
con diferencias.
Los elementos de un set son únicos, lo que significa que no puede haber
elementos duplicados.
El set es desordenado, lo que significa que no mantiene el orden de los
elementos.
Los elementos deben ser inmutables, no puede ser ni un diccionario ni una
lista.
Se delimitan por llaves {......}
Se pueden iterar de la misma forma que las listas.

20
Set - Conjunto
laLista=[1,1,2,3,4,4,5,6,6,6,7,8,8]

elConjunto=set(laLista)

print(laLista)
print(elConjunto)
[1, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 8]
{1, 2, 3, 4, 5, 6, 7, 8}

21
Set - Operaciones
# Intersección
{1, 2, 3, 4, 5}.intersection({3, 4, 5, 6}) # {3, 4, 5}
{1, 2, 3, 4, 5} & {3, 4, 5, 6} # {3, 4, 5}
# Unión
{1, 2, 3, 4, 5}.union({3, 4, 5, 6}) # {1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5} | {3, 4, 5, 6} # {1, 2, 3, 4, 5, 6}
# Diferencia
{1, 2, 3, 4}.difference({2, 3, 5}) # {1, 4}
{1, 2, 3, 4} - {2, 3, 5} # {1, 4}
# Diferencia simétrica
{1, 2, 3, 4}.symmetric_difference({2, 3, 5}) # {1, 4, 5}
{1, 2, 3, 4} ^ {2, 3, 5} # {1, 4, 5}
# Chequeo por SuperConjunto
{1, 2}.issuperset({1, 2, 3}) # False
{1, 2} >= {1, 2, 3} # False
# Chequeo de Subconjunto
{1, 2}.issubset({1, 2, 3}) # True
{1, 2} <= {1, 2, 3} # True
# Chequeo disyunción
{1, 2}.isdisjoint({3, 4}) # True
{1, 2}.isdisjoint({1, 4}) # False
22
Set - Métodos
add() : permite añadir un elemento al set
remove(): elimina el elemento que se pasa como parámetro. Si no se
encuentra, se lanza la excepción KeyError.
discard() : parecido al remove(), borra el elemento pasado como parámetro,
y si no lo encuentra no hace nada.
pop() : elimina un elemento aleatorio del set.
clear() : elimina todos los elementos de set.

23
Tuplas
Una tupla es una lista inmutable de valores. Admite valores repetidos.
Las tuplas son uno de los tipos de colección más simples y comunes de Python
y se pueden crear con el operador de coma (valor = 1, 2, 3).
Sintácticamente, una tupla es una lista inmutable de valores separados por
comas.
Aunque no es necesario, es común encerrar las tuplas entre paréntesis.
Las tuplas son más eficientes en el uso de la memoria que las listas.

24
Tuplas
Ejemplos

t = 'a', 'b', 'c', 'd', 'e'

print(type(t))

# <class 'tuple'>

t = ('a', 'b', 'c', 'd', 'e')

print(type(t))

# <class 'tuple'>

Crear una tupla vacía con paréntesis:

t0 = ()
print(type(t0))

# <class 'tuple'>
25
Tuplas
Para crear una tupla de un solo elemento, es obligatorio incluir una coma
final.

t1 = 'a', # Forma sin paréntesis

print(type(t1))

t1=('a',) # Forma con paréntesis

print(type(t1))

t1=('a')
print(type(t1)) # No es una tupla

# <class 'tuple'>
# <class 'tuple'>
# <class 'str'>

26
Tuplas - Inmutabilidad
t1=("Tango","Cumbia","Folklore","Rock","Trap","Jazz")
print(t1[0])

t1[0]="R&B"

Tango

Traceback (most recent call last):

t1[0]="R&B"
TypeError: 'tuple' object does not support item assignment

27
Conversión entre list() y tuple()
t=tuple(['MainFrame','Minicomputadora','PC','Server'])
l=list(("Tango","Cumbia","Folklore","Rock","Trap","Jazz"))

print(type(t))
print(t)

print(type(l))
print(l)
# <class 'tuple'>
# ('MainFrame', 'Minicomputadora', 'PC', 'Server')
# <class 'list'>
# ['Tango', 'Cumbia', 'Folklore', 'Rock', 'Trap', 'Jazz']

28
Asignaciones múltiples
Ejemplo

x,y,z = (25,5,1810) #Inmutable

print(x,y,z,sep='/')

El símbolo _ (guión bajo) se puede utilizar como nombre de variable

descartable si solo se necesitan algunos elementos de la tupla.

x,_ ,y,_ = ('vi','nano','emacs','notepad')

print(x,y )

29
Tuplas - Funciones integradas
len devuelve la longitud total de la tupla
max devuelve el elemento de la tupla con el valor máximo
min devuelve el elemento de la tupla con el valor mínimo
tuple convierte una lista en una tupla.
Para concatenar dos tuplas utilizar el +

t1 = ('a', 'b', 'c', 'd', 'e')

t2 = ('1','2','3')
t3 = ('a', 'b', 'c', 'd', 'e')

30
Diccionario
Es de la forma clave:valor, también conocido como Mapping.
Permite almacenar y recuperar elementos haciendo referencia a una clave.
Los diccionarios se referencian por clave, tienen búsquedas muy rápidas.
Como se utilizan principalmente para hacer referencia a elementos por clave,
no están ordenados.
En otros lenguajes de programación se los llama HashTable .

31
Diccionario - Creación
d={} # vacio
fm_dict={"99.9":"La Cien", "104.3":"Urbana Play"}
print(fm_dict)
# {'99.9': 'La Cien', '104.3': 'Urbana Play'}

# con dict() -> Se pasa una lista con tuplas (k,v)

d2=dict([('99.9','La Cien'),('104.3','Urbana Play')])
print(d2)
{'99.9': 'La Cien', '104.3': 'Urbana Play'}

32
Diccionario - Copia
fm_dict={"99.9":"La Cien", "104.3":"Urbana Play"}
d3={**fm_dict}
print(d3)

d4={'101.5':'POP Radio','102.3':'FM Aspen'}

d5={**d3,**d4}
print(d5)
# {'99.9': 'La Cien', '104.3': 'Urbana Play'}
# {'99.9': 'La Cien', '104.3': 'Urbana Play', '101.5': 'POP Radio', '102.3': 'FM Aspen'}

33
Diccionario - Modificación
Agregando

fm_dict={"99.9":"La Cien", "104.3":"Urbana Play"}

fm_dict['101.5']="POP Radio"
fm_dict['00']=["Una","Lista","En","Un","Diccionario"]
fm_dict['01']={'2302':'General Pico','2954':'Santa Rosa'}

Eliminando

del fm_dict['00']

Modificación

fm_dict['101.5']="Radio POPCorn"
34
Diccionario - Accediendo a elementos
fm_dict={"99.9":"La Cien", "104.3":"Urbana Play"}
fm_dict['101.5']="POP Radio"
fm_dict['00']=["Una","Lista","En","Un","Diccionario"]
fm_dict['01']={'2302':'General Pico','2954':'Santa Rosa'}

sub_dict=fm_dict['01']
print(sub_dict['2302'])

print(fm_dict['01']['2302']) # Versión Resumida

# General Pico
# General Pico

35
Diccionario - Iterando
Forma bucle

fm_dict={"99.9":"La Cien", "104.3":"Urbana Play"}

for k in fm_dict:
print(k, fm_dict[k],sep=" -> ")
# 99.9 -> La Cien
# 104.3 -> Urbana Play

36
Diccionario - Errores
El error clásico al utilizar diccionarios es intentar usar una clave inexistente.
Se puede usar el método get(clave, valorPorDefault) , que permite
especificar un valor predeterminado para devolver en caso de que no exista
una clave.

fm_dict={"99.9":"La Cien", "104.3":"Urbana Play"}

print(fm_dict.get('99.9','No Disponible'))
print(fm_dict.get('88.7','No Disponible'))
print(fm_dict)
# La Cien
# No Disponible
# {'99.9': 'La Cien', '104.3': 'Urbana Play'}

37
Diccionario - Errores
Si se desea conservar ese par clave:valor, usar
setdefault(clave, valorPorDefault) ,
que almacena el par clave-valor.

fm_dict={"99.9":"La Cien", "104.3":"Urbana Play"}

print(fm_dict.setdefault('99.9','No Disponible'))
print(fm_dict.setdefault('88.7','No Disponible'))
print(fm_dict)
# La Cien
# No Disponible
# {'99.9': 'La Cien', '104.3': 'Urbana Play', '88.7': 'No Disponible'}

38
Diccionario - Errores
Alternativa comprobar si la clave existe en el diccionario.

if clave in fm_dict:
valor = fm_dict[clave]
else:
valor = 'No Disponible'

39
Diccionario - Otros métodos
clear() Borra todo el diccionario
values() : devuelve una Lista con los valores (no las claves).
items() : devuelve una lista de tuplas, donde cada tupla es (clave,valor)

40
Diccionario - Búsqueda (lookup)
Dado un diccionario d y una clave k, es fácil encontrar el valor
correspondiente v = d[k]. Esta operación se llama búsqueda ( lookup ).
Pero al revés, encontrar la clave a partir del valor.¿? No hay una sintaxis
sencilla para realizar una búsqueda inversa; hay que buscar.

def busquedaInversa(d, v):

for k in d:
if (d[k] == v):
return k
return 'Error'

fm_dict={"99.9":"La Cien", "104.3":"Urbana Play"}

print(busquedaInversa(fm_dict,"La Cien"))
print(busquedaInversa(fm_dict,"La 99"))
41