Python: Comprehensions, Funciones y

Manejo de Errores
Sets
Son una estructura de datos usada para almacenar elementos de una manera similar a las listas, pero con ciertas
diferencias.
Un conjunto es una colección desordenada , inmutable * y no indexada. Los elementos establecidos no se pueden
modificar, pero se puede eliminar elementos y agregar elementos nuevos.
Los sets se los trata como conjuntos numéricos

# Manera explícita de hacer un set

set_countries = {'colombia', 'mexico', 'argentina'}
print(type(set_countries)) # set

# Manera implícita
set_string = set("Hoola")
print(set_string) # {'H', 'o', 'l', 'a'}

set_tuple = set(('abc', 'cbv', 'as', 'abc'))

print(set_tuple) = # {'as', 'cbv', 'abc'}

Modificando conjuntos
En esta clase solo se ven métodos.

Operaciones con conjuntos

union(set): Realiza la operacion “union” entre dos conjuntos. La unión entre dos conjuntos es sumar los
elementos de estos sin repetir elementos. Esta operación tambien se puede realizar con el signo “|”: set_a |
set_b.

intersection(set): Realiza la operacion “intersection” entre dos conjuntos. La intersección entre dos conjuntos es
tomar unicamente los elementos en común de los conjutnos. Esta operación tambien se puede realizar con el
signo “&”: set_a & set_b.

difference(set): Realiza la operacion “difference” entre dos conjuntos. La diferencia entre dos conjuntos es restar
los elementos del segundo conjunto al primero. Esta operación tambien se puede realizar con el signo “-”: set_a -
set_b.

symmetric_difference(set): Realiza la operacion “symmetric_difference” entre dos conjuntos. La diferencia

simetrica entre dos conjutnos consta de restar todos los elementos de ambos exceptuando el elemento en

Python: Comprehensions, Funciones y Manejo de Errores 1

 común. Esta operación tambien se puede realizar con el signo “^”: set_a ^ set_b.

NOTA: No se pueden realizar operaciones con otras colecciones de datos, solo se puede únicamente entre
conjuntos.

set_a = {'col', 'mex', 'bol'}

set_b = {'pe', 'bol'}

# unión de los elementos

set_c = set_a.union(set_b)
print(set_c) # {'col', 'mex', 'bol', 'pe'}
print(set_a | set_b) # {'col', 'mex', 'bol', 'pe'}

# obtener los elementos en común

set_c = set_a.intersection(set_b)
print(set_c) # {'bol'}
print(set_a & set_b) # {'bol'}

# dejamos sólo los elementos de A

set_c = set_a.difference(set_b)
print(set_c) # {'col', 'mex'}
print(set_a - set_b) # {'col', 'mex'}

# es hacer una unión, sin los elementos en común

set_c = set_a.symmetric_difference(set_b)
print(set_c) # {'col', 'mex', 'pe'}
print(set_a ^ set_b) # {'col', 'mex', 'pe'}

List Comprehension
Es una lista que tiene por contenido una operación en vez de una lista de conjuntos, y estas operaciones se realizan
con un for para poder iterar y sacar los datos de la lista
Estructura: [element for element in iterable]

# Forma común de crear una lista

numbers = []
for element in range(1, 11):
numbers.append(element)

print(numbers) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

#Forma con List comprehension

numbers2 = [element * 2 for element in range(1, 11)]
print(numbers2) # [2, 4, 6, 8, 10, 12, 14, 17, 18, 20]

# List comprehension con condicionales

numbers3 = [i * 2 for i in range(1, 11) if i % 2 == 0]

Dictionary Comprehension
Estructura: {Key:value for var in iterable}

# Forma común de hacer un diccionario

dict = {}
for i in range(1,11):
dict[i] = i * 2

print(dict) # {1: 2, 2: 4, 3: 6, 4: 8, 5: 10, 6: 12, 7: 14, 8: 17, 9: 18, 10: 20}

# Dictionary Comprehension
dict2 = {i: i * 2 for i in range(1,11)}
print(dict2) # {1: 2, 2: 4, 3: 6, 4: 8, 5: 10, 6: 12, 7: 14, 8: 17, 9: 18, 10: 20}

import random
countries = ['col', 'mex', 'bol', 'pe']

# Forma común usando random

population = {}

Python: Comprehensions, Funciones y Manejo de Errores 2

 for country in countries:
population[country] = random.randint(1, 100)

# Dictionary Comprehension usando random

population2 = { country: random.randint(1, 100) for country in countries }

# Haciendo un diccionario con listas

names = ['nico', 'zule', 'santi']
ages = [12, 56, 98]

print(list(zip(names, ages)))
# zip() toma valor a valor en cada lista, los une en tuplas, y los pone como elementos de un array
# list() debemos ponerlo para transformalo a lista sino sale algo raro
# Resultado: [{'nico', 12}, {'zule', 56}, {'santi', 98}]

# Diccionario con listas con Dictionary Comprehention

new_dict = {name: age for (name, age) in zip(names, ages)}

Dictionary Comprehension: condition

Estructura: {key:value for var in iterable if condition}

import random
countryies = ['col', 'mex', 'bol', 'pe']
population_v2 = { country: random.randint(1,100) for country in countries }

# Diccionario con condicional

result = { country: population for (country, population) in population_v2.items() if population > 20 }

# Diccionario en base a String

text = "Hola, soy Agustin"
unique = { c: c.upper() for c in text if c in 'aeiou'}
print(unique)

Lists vs. Tuples vs. Sets

Funciones
Una función es un bloque de código que solo se ejecuta cuando se le llama.
Puede pasar datos, conocidos como parámetros, a una función.
Una función puede devolver datos como resultado.

# Definir una función

def my_function(parámetro1, parámetro2, etc):
bloque_de_codigo

# Llamar una función

my_function(argumento1, argumento2, etc)

Python: Comprehensions, Funciones y Manejo de Errores 3

 Al final de las funciones podemos colocar la palabra reservada “return” para devolver algo hacia afuera de la función
y poder hacer con el lo que quieras

def suma(a,b):
total = a + b
return total

sumatoria = suma(5,9)
print(sumatoria) # 14

multiplicacion = suma(sumatoria, sumatoria * 2)

Parámetros por defecto y múltiples returns

A las funciones se le pueden asignar valores por defecto a los parámetros al momento de declarar funciones.
Al momento de hacer return podemos retornas varios valores juntos. De esta forma, la función nos devuelve una
tupla con los diferentes valores

def find_volume(length=1, width=1, depth=1):

return length *¨width * depth, width, 'hola'

result = find_volume(width= 10)

print(result) # (10, 10, 'hola')

Pero si inicializamos variables en el mismo orden en el que se retornan los valores. Se guardaran individualmente en
ese orden

def find_volume(length=1, width=1, depth=1):

return length *¨width * depth, width, 'hola'

result, width, text = find_volume(width=10)

print(result) # 10
print(width) # 10
print(text) # 'hola'

El scope
Scope o Alcance, es cuando una variable solo esta disponible desde donde fue construida y para ello existen dos
ambitos, el local y el global.

Scope Local
Cuando una variable es construida dentro de una función pertenece al ámbito local de esa función y solo se puede
usar dentro de esa función.

Scope Global
A diferencia del Scope Local, el Scope Global esta creada en la parte externa de la función y esta puede ser utilizada
tanto de manera global como local.

Python: Comprehensions, Funciones y Manejo de Errores 4

 Funciones anónimas: lamba
Son conocidas como Funciones Anónimas o lambdas, en donde no tienen un identificador o no tienen un nombre, se
puede definir su estructura de la siguiente manera:  lambda argumentos: expresión , las funciones lambda pueden tener
los argumentos que se requieran pero solo una linea de código o una expresión.

def increment(x):
return x + 1

increment_v2 = lambda x : x + 1

result = increment_v2(20)
print(result)

Higher order function: una función dentro de otra función

Una función de Orden Superior o en sus siglas HOF se le lama así solo cuando contiene otras funciones como
parámetro de entrada o devuelve una función como salida, es decir que en este caso las funciones que operan a
otras funciones se les denomina Higher order function.

Propiedades de HOF
Una función es una instancia de tipo objeto.

Puede almacenar una función en una variable.

Puede pasar una función como un parámetro a otra función.

Puede devolver la función desde una función.

Se puede almacenar en una estructura de datos como tablas, listas, etc.

def increment(x):
return x + 1

def high_ord_func(x, func):

return x + func(x)

result = high_ord_func(2, increment) # Para pasar la función como argumento no se ponen parentesis

# High order function con lamba

# Forma 1
high_ord_func_v2 = lambda x, func: x + func(x)
result = high_ord_func_v2(2, increment_v2)

# Forma 2
result = high_ord_func_v3(2, lambda x: x + 2)

Python: Comprehensions, Funciones y Manejo de Errores 5

 Map
La función  map ()  ejecuta una función especifica para cada elemento en un iterable y el elemento se envía a la
función como un parámetro.

Sintaxis: map(function, iterables)

numbers = [1, 2, 3, 4]
numbers_v2 = []

for i in numbers:
numbers_v2.append(i * 2)

# Versión con map

numbers_v3 = map(lambda i: i * 2, numbers)
print()

Se le pueden pasar más de un iterable para que aplique su función

numbers1 = [1, 2, 3, 4]
numbers2 = [5, 6, 7, 8]

result = list(map(lambda x, y: x + y, numbers1, numbers2))

Map con diccionarios

items = [
{
'product': 'camisa',
'price': 100
}
{
'product': 'pantalones',
'price': 300
}
{
'product': 'pantalones2',
'price': 200
}
]

prices = list(map(lambda item: item['price'], items))

print(prices)

def add_taxes(item):
item['taxes'] = item['price'] * 0.19
return item

new_items = list(map(add_taxes, items))

print(new_items)

Reto: map con inmutabilidad

El problema de la modificacion de la lista original tras aplicar una transformacion con un map se debe a la referencia
en memoria, es decir, cuando trabajamos con un diccionarios hay un espacio en memoria reservada para ese
diccionario; al aplicar una transformacion sobre el diccionario, los nuevos valores se asignan al diccionario como una
referencia en memoria; entonces al hacer una modificacion se aplica tanto para el array original como para el nuevo
ya que ambos comparten la misma referencia en memoria.

Solucion con el metodo copy()

Python: Comprehensions, Funciones y Manejo de Errores 6

 #-------------Quitar la referencia en memoria del diccionario------------------

items = [
{
'product':'camisa',
'price':100
},
{
'product':'pantalon',
'price':300
},
{
'product':'vestido',
'price':150
},
{
'product':'chaqueta',
'price':400
}
]

# al agregar el metodo copy desreferenciamos el array original con el nuevo

def add_taxes(items):
new_item = items.copy()
new_item['taxes'] = new_item['price'] * .19
return new_item

new_items = list(map(add_taxes, items))

print('New list')
print(new_items)
--> New list
[{'product': 'camisa', 'price': 100, 'taxes': 19.0},
{'product': 'pantalon', 'price': 300, 'taxes': 57.0},
{'product': 'vestido', 'price': 150, 'taxes': 28.5},
{'product': 'chaqueta', 'price': 400, 'taxes': 76.0}]

print('Old list')
print(items)
--> Old list
[{'product': 'camisa', 'price': 100},
{'product': 'pantalon', 'price': 300},
{'product': 'vestido', 'price': 150},
{'product': 'chaqueta', 'price': 400}]

Filter
La función filter() devuelve un iterable donde los elementos se filtran a través de una función para probar si el
elemento se acepta o no.

Sintaxis: filter(function, iterable)

matches = [
{
'home_team': 'Bolivia',
'away_team': 'Uruguay',
'home_team_score': 3,
'away_team_score': 1,
'home_team_result': 'Win'
},
{
'home_team': 'Brazil',
'away_team': 'Mexico',
'home_team_score': 1,
'away_team_score': 1,
'home_team_result': 'Draw'
},
{
'home_team': 'Ecuador',
'away_team': 'Venezuela',
'home_team_score': 5,
'away_team_score': 0,
'home_team_result': 'Win'
},
]

Python: Comprehensions, Funciones y Manejo de Errores 7

 new_list = list(filter(lambda item: item['home_team_result'] == 'Win', matches))
print(new_list)

Reduce
reduce() es una función que toma como argumento un conjunto de valores y lo “reduce” a un único valor. Esta
función debe ser importada desde “functools”. A la función que se le pasa a reduce se le debe poner un contador
para que vaya reduciendo el iterable.
Sintaxis: functools.reduce(función, iterable)

Como funciona:

Primero toma los dos primeros elementos de la secuencia y aplica la función particular.

Toma el resultado anterior y a este valor mas el siguiente elemento de la secuencia le aplica la función particular.

El proceso continua hasta que no tiene mas elementos.

Retorna el resultado.

import functools

numbers = [1, 2 , 3 , 4]

result = functools.reduce(lambda counter, item: counter + item, numbers)

Módulos
Un modulo se puede definir que es lo mismo a una biblioteca de código. Es decir es un archivo que contiene un
conjunto de funciones que se pueden aplicar.

Como crear un Módulo?

1. Para crear un módulo debemos escribir el nombre del archivo + la extensión de python que
es  .py  ejemplo  name.py

2. Escribimos el código que vamos a utilizar en el archivo que acabamos de nombrar.

3. Abrimos el archivo con el cual vamos a trabajar y declaramos el modulo que le dimos el nombre por ejemplo con
la extensión import, sería de la siguiente manera:  import name

Archivo de funciones (utils.py)

def get_population():
keys = ['col', 'bol']
values = [300, 400]
return keys, values

Archivo main

import utils

keys, values = utils.get_population()

print(keys, values)

Módulos como scripts: __name__ y __main__

Cuando un intérprete de Python lee un archivo de Python, primero establece algunas variables especiales. Luego
ejecuta el código del archivo. Una de esas variables se llama __name__.

Python: Comprehensions, Funciones y Manejo de Errores 8

 Entonces, cuando el intérprete ejecuta un módulo, la variable __name__ se establecerá como __main__ si el módulo
que se ejecuta es el programa principal.

But if the code is importing the module from another module, then the  __name__   variable will be set to that module’s
name.

if __name__ == '__main__':
run()

Este if le dice a python que si este archivo es ejecutado desde la terminal, ejecute el metodo run. Pero si es
ejecutado desde otro archivo, eso no se ejecutará

Paquetes
Los paquetes son las carpetas que contienen varios módulos y cada uno con una función distinta.
Para versiones de Python anteriores a la 3.3 se debe tener siempre un archivo de nombre  __init__.py  (por lo general
esta vacio, ya que así es compatible con programas python versiones anteriores a la 3), con esto le estamos indicado
a python que esto se trata de un paquete y no de una carpeta.

Para acceder a los módulos de los paquetes podemos utilizar estas opciones:

import nombrecarpeta.nombremodulo
from nombrecarpeta import nombremodulo
from nombrecarpeta.nombremodulo import def

Iterables
Un iterable se define como el objeto que contiene un número contable con valores y este al tener un valor puede
recorrer uno a uno los elementos que la contienen como una estructura de datos y operar con ellos, pero a la vez se
rigen bajo la instrucción que se le es dada, con lo cual son dependientes de la instrucción a recibir.

Los metodos de su uso son dos  __iter__()  y  __next__()  .

fruit = ("manzana", 'pera', 'banano')

myit = iter(fruit) # Con iter retornamos un objeto iterable

print(next(myit)) # Con next vamos avanzando al siguiente valor del iterable de manera manual
print(next(myit))
print(next(myit))

Cuando hay otro next pero no hay más valores para iterar, se genera un error.

Errores en Python
Exception Description

ArithmeticError Raised when an error occurs in numeric calculations

AssertionError Raised when an assert statement fails

AttributeError Raised when attribute reference or assignment fails

Exception Base class for all exceptions

EOFError Raised when the input() method hits an "end of file" condition (EOF)

FloatingPointError Raised when a floating point calculation fails

GeneratorExit Raised when a generator is closed (with the close() method)

ImportError Raised when an imported module does not exist

Python: Comprehensions, Funciones y Manejo de Errores 9

 Exception Description

IndentationError Raised when indentation is not correct

IndexError Raised when an index of a sequence does not exist

KeyError Raised when a key does not exist in a dictionary

KeyboardInterrupt Raised when the user presses Ctrl+c, Ctrl+z or Delete

LookupError Raised when errors raised cant be found

MemoryError Raised when a program runs out of memory

NameError Raised when a variable does not exist

NotImplementedError Raised when an abstract method requires an inherited class to override the method

OSError Raised when a system related operation causes an error

OverflowError Raised when the result of a numeric calculation is too large

ReferenceError Raised when a weak reference object does not exist

RuntimeError Raised when an error occurs that do not belong to any specific exceptions

StopIteration Raised when the next() method of an iterator has no further values

SyntaxError Raised when a syntax error occurs

TabError Raised when indentation consists of tabs or spaces

SystemError Raised when a system error occurs

SystemExit Raised when the sys.exit() function is called

TypeError Raised when two different types are combined

UnboundLocalError Raised when a local variable is referenced before assignment

UnicodeError Raised when a unicode problem occurs

UnicodeEncodeError Raised when a unicode encoding problem occurs

UnicodeDecodeError Raised when a unicode decoding problem occurs

UnicodeTranslateError Raised when a unicode translation problem occurs

ValueError Raised when there is a wrong value in a specified data type

ZeroDivisionError Raised when the second operator in a division is zero

Manejo de Excepciones
Cuando se nos presenta un error o una excepción como se le llama en python, el programa se detiene y presenta el
error que se presento, pero si utilizamos la excepción  try()  podemos omitir ese error y continuar con el programa.
Esto es de uso fundamental para que el programa no continue con su ejecución por el error y así evitar retrasos en la
producción, también de su uso para determinar en los bloques de código si se nos presenta un error poder ser
identificado de manera mas facil.
Para qué  try  sea efectivo podemos utilizar estas declaraciones:

Exception Description
try Permite probar un bloque de código en búsqueda de un error.
except Permite manejar el tipo de error en el bloque.
else Permite ejecutar el código cuando no hay ningún tipo de error en el bloque.
finally Permite ejecutar el código en el bloque, independiente en el resultado de los bloques de prueba y excepción

try:
print(0 / 0) # Error ZeroDibisionError
except: ZeroDivisionError as error: # Acá atrapamos el error y lo nombramos como "error"
print(error)

print('Hola') # Esto si se ejecutaría ya que no se cortó el programa

Python: Comprehensions, Funciones y Manejo de Errores 10

 Leer un archivo de texto
Para realizar la lectura de un archivo tipo texto en Python debemos utilizar la función  open( ) , esta función nos
permite abrir un archivo tipo texto en python.

f = open('./text.txt')
print(f.read())
"""
linea 1
lina 2
linea 3
linea 4
"""

La función  open()  devuelve un resultado con  print(f.read())  de tipo texto el cual es el método rápido de lectura.

Si queremos solamente realizar la lectura de una linea de texto, debemos utilizar  readline()  de la siguiente manera:

f = open('./text.txt')
print(f.readline()) # linea 1

También con  for  podemos recorrer el tipo texto de la siguiente manera:

f = open('./text.txt')
print(f.readline())

for l in f:
print(l)

f.close()

"""
linea 1

lina 2

linea 3

linea 4
"""

Al finalizar la lectura de un archivo debe ser cerrar su lectura con  f.close() , pero hay una sintaxis para que Python lo
haga automáticamente:

with open(archivo) as file:

for line in file:
print(line)

Escribir en un archivo
Para poder escribir texto en python solo debemos agregar al parámetro  open( )  algunas de las siguientes reglas:

Exception Description

“a” Agregar: se agregar texto al final del texto.

“w” Escribir: Elimina todo el texto del archivo y sobre escribe cualquier contenido existente

Sintaxis: f = open('./text.txt')  o  file = open('./text.txt')

Su sintaxis es un simple y fácil de usar, solo es necesario especificar el tipo de parámetro que queremos agregar a
nuestro texto.

Python: Comprehensions, Funciones y Manejo de Errores 11

 f = open('./text.txt', "a")
f.write("nueva linea de texto1\n") #nueva linea de texto1
f.write("nueva linea de texto2\n") #nueva linea de texto2
f.write("nueva linea de texto3\n") #nueva linea de texto3

Gracias a Python existen mas comandos que podemos utilizar con la función  open( )

Exception Description

“r” Lectura: Abre por defecto un archivo para su lectura, genera error si este no existe.

“a” Agregar: se agregar texto al final del texto.

“w” Escribir: Sobre escribir cualquier contenido existente en el archivo texto.

“x” Crear: Crea un archivo en especifico, devuelve un error si este no es valido.

“t” texto: Valor por defecto, devuelve el resultado como tipo texto.

“b” Binario: Devuelve el valor de tipo binario (por ejemplo imágenes)

“r+” Lectura y escritura

Leer un CSV
Las siglas CSV vienen del inglés "Comma Separated Values" y significan valores separados por comas. Dicho
esto, un archivo CSV es cualquier archivo de texto en el cual los caracteres están separados por comas, haciendo
una especie de tabla en filas y columnas. Las columnas quedan definidas por cada punto y coma (;), mientras que
cada fila se define mediante una línea adicional en el texto.

#----- modulo para leer el acrhivo csv --------

import csv

# funcion abrir archivo

def read_csv(path):
with open(path, 'r') as csvfile:
reader = csv.reader(csvfile, delimiter=',') # El delimiter indíca con que caracter están separados los datos ("," o ";")

#nombre de las columnas se encuentra en la primera fila

header = next(reader)

data = []
for row in reader:
iterable = zip(header, row) # une los valores de la listas en tuplas
country_dict = {key:value for key, value in iterable}
data.append(country_dict)
print(country_dict)

return data

# correr archivo como script desde la terminal

if __name__ == '__main__':
data = read_csv('./app/data.csv')
print(data)

Creando una gráfica

Para visualizar datos con Python se usa la librería “Matplotlib”. Esta herramienta se debe instalar porque no viene con
Python y ser importada en el archivo.

import matplotlib.pyplot as plt

def generate_bar_chart(labels, values):

fig, ax = plt.subplots()
ax.bar(labels, values)
plt.show()

def generate_pie_chart(labels, values):

Python: Comprehensions, Funciones y Manejo de Errores 12

 fig, ax = plt.subplots()
ax.pie(values, labels=labels)
ax.axis('equals')
plt.show()

if __name__ == '__main__':
labels = ['a', 'b', 'c']
values = [100, 200, 80]
# generate_bar_chart()
# generate_pie_chart()

Python: Comprehensions, Funciones y Manejo de Errores 13