Curso de Python Comprehensions Funciones y Manejo de Errores

Curso de Python:
Comprehensions, Funciones y
Manejo de Errores
Start Lesson @January 25, 2023 4:51 PM
End Lesson
Status In Progress
Type curso
1. El Zen de Python
2. Sets
3. Modificando conjuntos
4. Operaciones con conjuntos
Comprehensions
5. List Comprehension
6. Dictionary Comprehension
7. Dictionary Comprehension: condition
8. Lists vs. Tuples vs. Sets
FUNCIONES
9. Funciones
10. Funciones: return
11. Parámetros por defecto y múltiples returns
12. El scope
13. Refactor game
14.Funciones anónimas: lambda
15. Higher order function: una función dentro de otra función
Propiedades de HOF
16. Map
Sintaxis.
17. Map con diccionarios
18. Reto: map con inmutabilidad
19. Filter
Curso de Python: Comprehensions, Funciones y Manejo de Errores 1

SINTAXIS
Valores.
20.Reduce
21. Módulos
Como crear un Módulo?
Importar desde un Módulo.
22. Mis propios módulos
Como Construir Módulos.
23. Módulos como scripts: __name__ y __main__
24. Paquetes
25. Iterables
26. Errores en Python
27. Manejo de excepciones
28. Leer un archivo de texto
28. Escribir en un archivo
29. Leer un CSV
1. El Zen de Python
The Zen of Python, by Tim Peters
Beautiful is better than ugly.

Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than right now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Zen de Python:
1. Bello es mejor que feo.
2. Explícito es mejor que implícito.
3. Simple es mejor que complejo.
4. Complejo es mejor que complicado.
5. Plano es mejor que anidado.
6. Espaciado es mejor que denso.
7. La legibilidad es importante.
8. Los casos especiales no son lo suficientemente especiales como para romper las
reglas.
9. Sin embargo, la practicidad le gana a la pureza.
10. Los errores nunca deben pasar silenciosamente.
11. A menos que se silencien explícitamente.12.
12. Frente a la ambigüedad, evita adivinar.13.
13. Debería existir una sola manera obvia de hacerlo.14.
14. A pesar de que esa manera no sea obvia al principio, al menos que seas holandés.15
15. . Ahora es mejor que nunca.16.
16. A pesar de que nunca es mejor que ahora mismo.17
17. . Si la implementación es difícil de explicar, es una mala idea.18
18. . Si la implementación es fácil de explicar, puede ser una buena idea.
2. Sets
Se pueden modificar
No tienen un orden
No pueden tener elementos duplicados
# no tiene un par key-value, así me doy cuenta que es un set, un conjunto.

set_countries = {'col', 'mex', 'bol'}
print (set_countries)

# si yo pongo algo repetido, él me lo quita al imprimir
set_countries2 = {'col', 'mex', 'bol', 'col'}
print (set_countries2) # {'col', 'mex', 'bol'}
# puede ser mixto. El set se ordena solo, lo importante es lo que tengo dentro.
set_types = {1, 'hola',False, 12.12}
print(set_types) # {False, 1, 12.12, 'hola'}
# la podemos crear a partir de un string

set_from_string = set('hoola')
print (set_from_string) # {'a', 'l', 'o', 'h'}
# la podemos crear a partir de una tupla

set_from_tuples = set (('abc','cbv','as','abc'))
print (set_from_tuples) # {'as', 'abc', 'cbv'}
# la podemos crear a partir de una lista

numbers = [1,2,3,1,2,3,4]
set_numbers= set(numbers)
print (set_numbers) # {1, 2, 3, 4}
# si quiero convertir este set único a una lista, lo puedo hacer:
unique_numbers = list(set_numbers)
print (unique_numbers)
3. Modificando conjuntos
Funciones de set:
add(): Añade un elemento.
update(): Añade cualquier tipo de objeto iterable como: listas, tuplas.
discard(): Elimina un elemento y si ya existe no lanza ningún error.
remove(): Elimina un elemento y si este no existe lanza el error “keyError”.
pop(): Nos devuelve un elemento aleatorio y lo elimina y si el conjunto está vacío lanza el
error “key error”.
clear(): Elimina todo el contenido del conjunto.
4. Operaciones con conjuntos

Operaciones set
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 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.
Comprehensions
5. List Comprehension
Comprensión de lista:
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, y
esta lista tiene la siguiente forma:

También podemos buscar si hay ciertos elementos dentro la lista con el comando “in” de la
siguiente manera, “Elemento a buscar - in - nombre de la lista”.
#HABITUAL
numbers = []
for i in range(1, 11):
if i % 2 == 0:
numbers.append(i * 2)
print(numbers)
#lists comprehension
numbers_v2 = [i * 2 for i in range(1, 11) if i % 2 == 0]
print(numbers)
### EJEMPLO
days = ["lunes", "martes", "miercoles", "jueves", "viernes", "sabado", "domingo"]
newlist = []
for i in days:
if "a" in i:
newlist.append(i)
print(newlist) #["martes", "sabado"]
## LISTS COMPRENHESION
days = ["lunes", "martes", "miercoles", "jueves", "viernes", "sabado", "domingo"]
newlist = [i for i in days if "a" in i]
print(newlist) # ["martes", "sabado"]
6. Dictionary Comprehension
Dict comprehensions
Los Dictionary comprehensions -o Dict comprehensions para abreviar- son estructuras

semejantes a las vistas pero, tal y como indica su nombre, generan diccionarios. Un
ejemplo es el siguiente:

cities = ["Madrid", "Barcelona", "Milán", "Santander"]
{c: len(c) for c in cities}
{'Madrid': 6, 'Barcelona': 9, 'Milán': 5, 'Santander': 9}
En este ejemplo hemos hecho referencia a una única lista, pero no tiene por qué ser así:
cities = ["Madrid", "Barcelona", "Milán", "Santander"]

years = [2017, 2018, 2019, 2020]
{c: y for c in cities for y in years}
Obsérvese que, en este caso, también se está simulando el mismo bucle for anidado que
ya hemos visto:
d = {}
forc in cities:
fory in years:
d.update({c:y})
d
Solo subsisten cuatro parejas clave-valor (en lugar de 16) pues ya sabemos que en un
diccionario no puede haber claves repetidas, por lo que para cada valor c se recorren
todos los años en la variable “y” y se va sobrescribiendo el valor que pueda existir para la
clave c.
Si quisiéramos obtener un diccionario que relacionase cada par de valores de cities y

years, podríamos hacerlo con la función zip:
{c: y for c, y in zip(cities, years)}

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

print(population_v2)
result = { country: population for (country, population) in

population_v2.items() if population > 50}
print(result)
text = 'Hola, soy Nicolas y tengo 22 años'

unique = { c: text.count(c) for c in text if c in 'aeiou'}
print(unique)
8. Lists vs. Tuples vs. Sets

FUNCIONES
9. Funciones
Una función es un grupo de declaraciones relacionadas que realizan una tarea específica.
Las funciones ayudan a dividir nuestro programa en partes más pequeñas y modulares. A
medida que nuestro programa crece más y más, las funciones lo hacen más organizado y
manejable.
Además, evita la repetición y hace que el código sea reutilizable.
deffunction_name(parameters):
"""docstring"""
statement(s)

print('Hola')
def my_print(text):
print(text * 2)
my_print('Este es mi texto')
my_print('Hola')
a = 10
b = 90
c = a + b
def suma(a, b):

my_print(a + b)
suma(1 ,5)
suma(10 ,4)
10. Funciones: return

La función recibe unos parámetros y debe retornar la respuesta a esos parámetros.
Las funciones pueden retornar valores.
def sum_with_range(min, max):

print(min, max)
sum = 0
for x in range(min, max):
sum += x
return sum
result = sum_with_range(1, 10)

print(result)
result_2 = sum_with_range(result, result + result + 10)
print(result_2)
11. Parámetros por defecto y múltiples returns

def find_volume(length=1, width=1, depth=1):
return length * width * depth, width, 'hola'
result, width, text = find_volume(width=10)

print(result)
print(width)
print(text)
12. El scope
Dentro de una función puede haber variables, las cuales se llaman
variables locales
. Estas variables locales, se identifican porque están escritas dentro de la definición de la
función; y únicamente funcionan mientras que la función sea llamada o utilizada. Si vas a
llamar a una variable local por fuera de la función, no servirá.
Y existen
variables globales
que son las que están escritas fuera de una función. Estas variables si funcionan al ser
llamadas sin la función, porque no están determinadas dentro de la función.
price = 100 # global

result = 200
def increment():
price = 200
result = price + 10
print(result)
return result
print(price)
price_2 = increment()
print(price_2)
price(result)
13. Refactor game

import random
def choose_options():
options = ('piedra', 'papel', 'tijera')
user_option = input('piedra, papel o tijera => ')
user_option = user_option.lower()
if not user_option in options:

print('esa opcion no es valida')
# continue
return None, None
computer_option = random.choice(options)
print('User option =>', user_option)

print('Computer option =>', computer_option)
return user_option, computer_option
def check_rules(user_option, computer_option, user_wins, computer_wins):

if user_option == computer_option:
print('Empate!')
elif user_option == 'piedra':
if computer_option == 'tijera':
print('piedra gana a tijera')
print('user gano!')
user_wins += 1
else:
print('Papel gana a piedra')
print('computer gano!')
computer_wins += 1
elif user_option == 'papel':
if computer_option == 'piedra':
print('papel gana a piedra')
print('user gano')
user_wins += 1
else:
print('tijera gana a papel')
computer_wins += 1
elif user_option == 'tijera':
if computer_option == 'papel':
print('tijera gana a papel')
print('user gano!')
user_wins += 1
else:
print('piedra gana a tijera')
computer_wins += 1
return user_wins, computer_wins
def run_game():
computer_wins = 0
user_wins = 0
rounds = 1
while True:
print('*' * 10)
print('ROUND', rounds)
print('*' * 10)
print('computer_wins', computer_wins)
print('user_wins', user_wins)
rounds += 1
user_option, computer_option = choose_options()

user_wins, computer_wins = check_rules(user_option, computer_option, user_wins, computer_wins)

if computer_wins == 2:
print('El ganador es la computadora')
break
if user_wins == 2:
print('El ganador es el usuario')
break
run_game()
14.Funciones anónimas: lambda
15. Higher order function: una función dentro

de otra función
Nota:
Normalmente solemos usar parámetros y argumentos como sinónimos,
y en la práctica podemos inferir lo que esto significa según el contexto.
Pero en un entorno profesional, deberíamos tener muy claro que los
parámetro son las reglas o instrucciones que definimos dentro de la

función, mientras los argumentos son los datos que le pasamos a la
función para que los “reemplace” y ejecute la función.
Algo así como en matemáticas básicas, cuando definimos y = x^2 + x +
3, la derecha de la ecuación serían los parámetros, mientras que los
argumentos, serían los valores que le asignamos a la x, bien sea para
encontrar las coordenadas de un punto (una iteración), o para trazar la
gráfica completa (multiples iteraciones)…
*Parámetros: **Reglas Internas de la Función.
*Argumentos: **Datos Externos que le Pasamos a la Función para

que Pueda Hacer sus Cálculos.
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.
También hay que entender que a estas Funciones de Orden Superior HOF se aplican para
funciones y métodos que toman como funciones a los parámetros o devuelven una función
como un resultado.
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 + 10
increment_v2 = lambda x: x + 10

def hof(x,func):
return x +func(x)
hof_v2 = lambda x,func: x +func(x) +func(x)
result = hof(20, increment)

# 20 + (20 + 10)
print(result)
En este caso Observamos como utilizando la función lambda podemos

continuar seguir la función.
_Produccion_
50
Ahora HOF podemos incluir en este caso un signo de operación matemático de suma y

multiplicación.
def increment(x):
return x + 10
increment_v2 = lambda x: x + 10
def hof(x, func):

return x + func(x)
hof_v2 = lambda x, func: x + func(x) + func(x)
result = hof(20, increment)

# 20 + (20 + 10)
print(result)
result = hof_v2(20, increment_v2)

print(result)
result = hof_v2(20, lambda x: x + 2)

result = hof_v2(20, lambda x: x * 2)
_Producción:_
50
80
Material de apoyo

16. 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)
Con esto vamos hacer unos deliciosos tacos, para ello utilizáremos maps()
def ingredientes(a,b):
return a + " es a " + b
menu = list(map(ingredientes, ('carne', 'maiz', 'aguacate'), ('molida', 'tacos', 'guacamole')))
print(list(menu))
_Producción_
['carne es a molida', 'maiz es a tacos', 'aguacate es a guacamole']
17. Map con diccionarios

Un Map con diccionarios es una estructura de datos que permite almacenar pares clave-
valor.
Se puede acceder a los valores utilizando las claves asociadas a ellos en lugar de los
índices numéricos típicos de otras estructuras de datos.
Map también se conoce como “diccionario” en Python y se denota con llaves {}.
18. 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()

#-------------Quitarla referenciaen memoria del diccionario------------------
items = [
{
'product':'camisa',
'price':100
},
{
'product':'pantalon',
'price':300
},
{
'product':'vestido',
'price':150
},
{
'product':'chaqueta',
'price':400
}
]
#al agregarel metodocopy desreferenciamosel array originalconel 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)
--> Newlist
[{'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)
--> Oldlist
[{'product': 'camisa', 'price': 100},
{'product': 'pantalon', 'price': 300},
{'product': 'vestido', 'price': 150},
{'product': 'chaqueta', 'price': 400}]
19. Filter
La función filter(), devuelve un valor que esta siendo iterado de la cual su resultado será el
valor que se esta buscando en el filter
SINTAXIS

_filter (function, iterable_
Valores.
filter: Una función que se ejecutara para cada elemento iterableiterable:

Lo que se va a filtrar.
Ejercicio:
Tenemos una lista de estudiantes de la cual debemos saber quienes son de Colombia y
quienes son considerados mayores de edad al tener igual o mas de 18 años y cuantos son.
people = [
{
'name' : 'Pedro',
'country': 'Colombia',
'age' : 18,
'course' : 'developer'
},
{
'name' : 'Juan',
'country': 'Perú',
'age' : 17,
'course' : 'UX'
},
{
'name' : 'Carlos',
'country': 'Chile',
'age' : 31,
'course' : 'Diseño'
},
{
'name' : 'Ana Maria',
'age' : 25,
'course' : 'Tester'
}
]
Ahora planteamos el primer problema a resolver, cuales son los estudiantes de Colombia
y cuantos son:
countrie = list(filter(lambda country: country['country'] == 'Colombia', people))

print(countrie)print(len(countrie))

_Produccion:_
[{'name': 'Pedro', 'country': 'Colombia', 'age': 18, 'course': 'developer'}, {'name': 'Ana Mari
a', 'country': 'Colombia', 'age': 25, 'course': 'Tester'}]
2
Ya sabemos que hay 2 personas en nuestros cursos que son de

Colombia quienes son: Pedro y Ana Maria.
Ahora necesitamos saber quienes son considerados mayores de edad al tener 18 años o
más.
adult = list(filter(lambda age: age['age'] >= 18, people))

print(adult)print(len(adult))
_Producción:_[{'name': 'Pedro', 'country': 'Colombia', 'age': 18, 'course': 'developer'}, {'nam

e': 'Carlos', 'country': 'Chile', 'age': 31, 'course': 'Diseño'}, {'name': 'Ana Maria', 'countr
y': 'Colombia', 'age': 25, 'course': 'Tester'}]
3
Con esto podemos saber que hay 3 estudiantes que son considerados
mayores de edad al tener 18 años o más quienes serían: Pedro con 18
años, carlos, con 31 años y Ana Maria con 25 años.
20.Reduce
La función reduce()
reduce() es una función incorporada de Python 2, que toma como argumento un conjunto de
valores (una lista, una tupla, o cualquier objeto iterable) y lo “reduce” a un único valor. Cómo
se obtiene ese único valor a partir de la colección pasada como argumento dependerá de la
función aplicada.
Por ejemplo, el siguiente código reduce la lista [1, 2, 3, 4] al número 10 aplicando la función
accum(counter, item), que retorna la suma de sus argumentos.
<
defaccum(counter, item):
return counter + item

print(reduce(accum, [1, 2, 3, 4]))
>
La función pasada como primer argumento debe tener dos parámetros. reduce() se
encargará de llamarla de forma acumulativa (es decir, preservando el resultado de llamadas
anteriores) de izquierda a derecha. De modo que el código anterior es similar a:
<
print(accum(accum(accum(1, 2), 3), 4))
>
Es decir, la operación realizada es ((1 + 2) + 3) + 4, de la que resulta 10.
A partir de Python 3 la función fue movida al módulo estándar functools.
21. 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
Codigo en module .py
defgreeting(name):
print("Hello, " + name)
Código en el archivo que vamos a trabajar exercise_module.py_
importmodulemodule.greeting("Camilo")
Producción:Hello, Camilo

Si en nuestro modulo principal tenemos una lista con varios valores, podemos extraer un
solo resultado.
_ module .py_
people = {
"name": "Camilo",
"age": 35,
"country": "Colombia"
}
exercise_module .py
import module
a = module.people["age"]
print(a)
Producción: 35
Importar desde un Módulo.

AL utilizar la palabra from podemos importar partes especificas del módulo principal a
nuestra documento de extracción de información.
module .py
defgreeting(name):
print("Hello, " + name)
people1 = {
"name": "Camilo",
"age": 35,
"country": "Colombia"
}
exercise_module.py
from moduleimport people1
print (people1["age"])
Producción: 35

22. Mis propios módulos
Los módulos en python son cualquier archivo que termine en .py
# utils.py
defget_population():
keys = ['col','bol']
values = [300,400]
return keys,values
defpopulation_by_country(data, country):
result = list(filter(lambda item: item['Country'] == country,data))
return result
# main.py
import utils
keys,values = utils.get_population()
print(keys,values) # ['col','bol'] [300,400]
data = [{
'Country': 'Colombia',
'Population': 500
},
{
'Country': 'Bolivia',
'Population': 300
}
]
country = input('Type Country => ')
result = utils.population_by_country(data, country)

print(result) # [{'Country': 'Colombia','Population': 500}]
print(utils.A)
Como Construir Módulos.

Para construir módulos debemos tener en cuenta que se deben crear en la misma carpeta a
lo cual utilizaremos import para ser llamada en el archivo a trabajar:
Tenemos un módulo que tiene los datos de la población de 3 paises de Sur America, los
cualse vamos a crear en la carpeta app y daremos por nombre utils.py
def get_population():
keys = ['Colombia', 'Peru', 'Argentina']
values = [500, 250, 350]
return keys, values

def population_by_countrie(data, country):
result = list(filter(lambdaitem:item['country'] == country, data))
return result
Ahora creamos el archivo con nombre main.py , este archivo vamos a digitar los datos a
buscar.
import utils
keys,values = utils.get_population()
print(keys,values)
data = [
{
'Population': 500
},
{
'country': 'Peru',
'Population': 250
},
{
'country': 'Argentina',
'Population': 350
}
]
Ahora invocamos el módulo a utilizar y sus valores según lo que contienecountry =

input('Digite el país: ')result = utils.population_by_countrie(data, country)print(result)
Producción:
Digiteel país: Peru

[{'country': 'Peru', 'Population': 250}]
Digiteel país: Colombia

[{'country': 'Colombia', 'Population': 500}]
Digiteel país: Argentina

[{'country': 'Argentina', 'Population': 350}]

23. Módulos como scripts: __name__ y
__main__
Cuando utilizamos name == ‘main’ estamos dando dualidad a cierta función para que sea
ejecutada en dos archivos distintos.
Para ello debemos tener en cuenta que su uso esta catalogado de dos maneras:
1. Se puede ejecutar el archivo como un script.
2. Importando el codding de un archivo a otro archivo python.
Para Python, es independiente cual de las dos formas estemos utilizando el código, ya que
python define una variable especial llamada __name__ la cual contiene un string y cuyo
resultado dependerá de la forma en como sea usada.
Como en el ejemplo, se observa que el primer archivo que denominamos main.py .

main.py
import utils
keys, values = utils.get_population()

print(keys, values)
data = [
{
'Population': 500
},
{
'country': 'Peru',
'Population': 250
},
{
'country': 'Argentina',
'Population': 350
}
]
def run():
keys, values = utils.get_population()
print(keys, values)
country = input('Digite el país: ')

result = utils.population_by_countrie(data, country)
print(result)
if __name__ == '__main__':
run()

Cuando ejecutamos el archivo directamente como un script nuestra variable if
__name__ tomara el valor de __main__
Al ser ejecutado nuestro output será el siguiente:
Producción:
Digiteel país: Peru

[{'country': 'Peru', 'Population': 250}]
Con esto podemos concluir que la función __name__ == '__main__' ayuda a que python
identifique de que manera se debe ejecutar e o los módulos ó script.Material de apoyo
24. Paquetes
Los paquetes son las carpetas que contienen varios módulos y cada uno con una función
distinta.
Para ello 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.nombremodulofrom nombrecarpeta
import nombremodulofrom nombrecarpeta.nombremodulo import def
Estos son algunos ejemplos:

Antes de realizar el ejemplo debemos tener nuestra carpeta definida con la siguiente
estructura:
En nuestra carpeta pkg, creamos dos archivos: __init__.py y aritmetica.py
Se utiliza cuando debemos utilizar paquetes en versiones anteriores a python 3 o

__init__.py
puede contener información la cual se ejecutara siempre, para este caso le colocamos el
titulo Bienvenido a la clase de Aritmetica.
aritmetica.py va a contener nuestras operaciones aritmeticas que son, suma, resta,
multiplicacion y division:
defsumar(a, b):
returna +bdefrestar(a, b):

returna-bdefmult(a, b):
returna *bdefdiv(a, b):
returna /b
Ahora en nuestro archivo principal main.py ejecutaremos los paquetes de la siguiente

manera:
import nombrecarpeta.nombremodulo
import pkg.aritmetica
print(pkg.aritmetica.sumar(5,7))
print(pkg.aritmetica.restar(5,7))
Produccion:
Bienvenido ala clasede Aritmética

12
-2
from nombrecarpeta import nombremodulo
from pkg import aritmetica

print(aritmetica.sumar(5,7))
print(aritmetica.restar(5,7))
Produccion:

12
-2
from nombrecarpeta.nombremodulo import def
from pkg.aritmetica import sumar

print(sumar(5,7))
from pkg.aritmetica import restar
print(restar(5,7))
Produccion:

12
-2
25. 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__() .
Veamos un ejemplo:
Tenemos una serie de frutas las cuales debemos recorrer una a una
para saber cuales son las que están dentro de la lista.
fruit = ("manzana", 'pera', 'banano')

myit = iter(fruit)
print(next(myit))
print(next(myit))
print(next(myit))
Ahora vamos a imprimir el resultado una a una con print(next(myit)) , con esto controlamos
un iterador por print
print(next(myit))
_Producción:_
manzana
print(next(myit))
print(next(myit))
_Producción:_
manzana
pera

print(next(myit))
print(next(myit))
print(next(myit))
_Producción:_
manzana
pera
banano
También podemos utilizar los iterables como una cadena de texto que recorre un texto o una
serie de números.
fruit = ("manzana")
myit =iter(fruit)
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
_Producción:_manzana
Otra forma de realizar un iterador es atraves de for() o un bucle, para ello realizaremos el
siguiente ejemplo:
cars = ('chevrolet', 'volvo', 'audi', 'mazda')

for x in cars:
print(x)
_Produccion:_
chevrolet
volvo
audi
mazda
Con el iterador también podemos crear una secuencia de números hasta cierto valor que le
determinemos.

classMyNumbers:
def__iter__(self):
self.a = 1
return self
def__next__(self):
x = self.a
self.a += 1
return x
myclass = MyNumbers()
myiter = iter(myclass)
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
_Producción:_
1
2
3
4
5
Ahora si queremos que la iteración se detenga en un valor determinador podemos utilizar la

declaración StopIteration
classMyNumbers:
def__iter__(self):
self.a = 1
return self
def__next__(self):
if self.a <= 10:
x = self.a
self.a += 1
return x
else:
raise StopIteration
myclass = MyNumbers()
myiter = iter(myclass)
for xin myiter:

print(x)

_Producción:_
1
2
3
4
5
6
7
8
9
10
26. Errores en Python

#---------- Errores ---------
# error de sintaxis
print(0/0))
--> SyntaxError: unmatched ')'
# error division por cero

print(0/0)
--> ZeroDivisionError: division
by
zero
#variable no declarada
print(result)
--> NameError: name 'result'
is
not
defined
#verificacion con assert

suma = lambda x, y: x + y
assert suma(2,2) == 5
--> AssertionError

# lanzar errores propios con raise
age = 10
if
age < 18:

raise Exception('No se permiten menores de edad')
--> Exception: No se permiten menores de edad
ERRORES O EXCEPCIONES INTEGRADAS EN PYTHONEn la siguiente tabla podemos

encontrar los errores o excepciones que se presentan en Python.
Exception Description
ArithmeticError Se genera cuando se produce un error en los cálculos numéricos
AssertionError Se genera cuando falla una declaración de afirmación
AttributeError Se genera cuando falla la asignación o la referencia de atributo
Exception Clase base para todas las excepciones
Se genera cuando el método input() alcanza una condición de “fin de archivo”

EOFError
(EOF)
FloatingPointError Se genera cuando falla un cálculo de punto flotante
GeneratorExit Se genera cuando se cierra un generador (con el método close())
ImportError Se genera cuando no existe un módulo importado
IndentationError Se genera cuando la sangría no es correcta
IndexError Se genera cuando no existe un índice de una secuencia
KeyError Se genera cuando una clave no existe en un diccionario
KeyboardInterrupt Se genera cuando el usuario presiona Ctrl+c, Ctrl+z o Eliminar
LookupError Se genera cuando no se pueden encontrar los errores generados
MemoryError Se genera cuando un programa se queda sin memoria
NameError Se genera cuando una variable no existe
Se genera cuando un método abstracto requiere una clase heredada para

NotImplementedError
anular el método
OSError Se genera cuando una operación relacionada con el sistema provoca un error
OverflowError Se genera cuando el resultado de un cálculo numérico es demasiado grande
ReferenceError Se genera cuando no existe un objeto de referencia débil
Se genera cuando ocurre un error que no pertenece a ninguna expectativa

RuntimeError
específica

StopIteration Se genera cuando el método next() de un iterador no tiene más valores
SyntaxError Se genera cuando se produce un error de sintaxis
TabError Se genera cuando la sangría consta de tabulaciones o espacios
SystemError Se genera cuando se produce un error del sistema
SystemExit Se genera cuando se llama a la función sys.exit()
TypeError Se genera cuando se combinan dos tipos diferentes
Se genera cuando se hace referencia a una variable local antes de la

UnboundLocalError
asignación
UnicodeError Se genera cuando se produce un problema Unicode
UnicodeEncodeError Se genera cuando se produce un problema de codificación Unicode
UnicodeDecodeError Se genera cuando se produce un problema de decodificación Unicode
UnicodeTranslateError Se genera cuando se produce un problema de traducción Unicode
ValueError Se genera cuando hay un valor incorrecto en un tipo de datos especificado
ZeroDivisionError Se genera cuando el segundo operador en una división es cero
27. Manejo de excepciones

Las excepciones son errores que se disparan durante la ejecución de
un programa. En Python podemos dejar que dichas excepciones
detengan el programa o en caso contrario escribir un algoritmo para
reaccionar a dicha situación.
Los ejemplos más comunes que podemos nombrar de excepciones:
Tratar de convertir a entero un string que no contiene valores numéricos.
Tratar de dividir por cero.
Abrir un archivo de texto inexistente o que se encuentra bloqueado por otra aplicación.
Conectar con un servidor de bases de datos que no se encuentra activo.
Acceder a subíndices de listas o tuplas inexistentes.
Llamada a un método o función inexistente.
Importar módulos que no existen.

La captura de excepciones nos permite crear programas mucho más robustos y
tolerante a fallas que ocurren en escasas situaciones, pero en caso que se presenten
disponemos de un algoritmo alternativo para reaccionar a dicha situación evitando
que el programa finalice su ejecución.
28. 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())
_Producción:_
linea 1
lina 2
linea3
linea 4
asj
hjdc
judfnvkdjnv
zujcb
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:
print(f.readline())
_Producción:_
linea 1
Tambien con for podemos recorrer el tipo texto de la siguiente manera:

print(f.readline())
for lin f:
print(l)
f.close()
_Producción:_
linea 1
lina 2
linea3
linea 4
asj
hjdc
judfnvkdjnv
zujcb
Es de buena practica siempre cerrar el documento texto al finalizar su

lectura, algunas veces python lo puede hacer d emanera automática
pero si lo dejas abierto, esto te evitara que te reste memoria o que
realices la lectura del archivo hasta cierto punto.
Al finalizar la lectura de un archivo debe ser cerrar su lectura con f.close()
28. Escribir en un archivo

#------- Escribir sobre un archivo ------------
# r para permiso de lectura

# w para permiso de escritura
# r+ para permisos tanto de lectura como de escritura. Enfocado en agregar
# nuevo contenido al contenido existente en el archivo
# w+ para permisos tanto de lectura como de escritura. Enfocado en reescribir
# el contenido existente

# leer archivo
with
open('./text.txt', 'r+')
as
file:
# leer archivo
for
line
in
file:
print(line)
# agregar nuevo contenido al existente

file.write('\n') # salto de linea
file.write('una nueva linea\n')
# leer archivo
with
open('./text.txt', 'w+')
as
file:
# leer archivo
for
line
in
file:
print(line)
# sobreescribir sobre el contenido existente

file.write('\n') # salto de linea
file.write('una nueva linea\n')

29. Leer un CSV
#----- 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=',')
#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)
¿Qué es un archivo CSV?
Un archivo CSV es un tipo de archivo que se utiliza para almacenar datos en una forma
tabular estructurada (fila / columna). Es un archivo de texto plano y, como su nombre lo
indica, almacena los valores separados por una coma.
En este artículo, tendremos una discusión detallada sobre cómo leer, escribir y analizar
un archivo CSV en Python.
Fuente del archivo CSV
El concepto de tener un archivo CSV nació de la necesidad de exportar grandes

cantidades de datos de un lugar a otro (programas). Por ejemplo, importando datos de
una hoja de cálculo de gran tamaño y exportándolos a una base de datos. Asimismo,
podemos exportar grandes cantidades de datos a programas.
Los diferentes lenguajes usan diferentes formatos para almacenar datos, por lo que
cuando los programadores necesitan exportar datos de un programa a otro, sienten la
necesidad de tener algún tipo de archivo universal con el cual transferir grandes
cantidades de datos; Un tipo de archivo que cualquier programa puede leer y analizar en
su propio formato.

Curso de Python Comprehensions Funciones y Manejo de Errores

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Curso de Python Comprehensions Funciones y Manejo de Errores

Cargado por

Copyright:

Formatos disponibles

Curso de Python:

Curso de Python: Comprehensions, Funciones y Manejo de Errores 1

Beautiful is better than ugly.

Curso de Python: Comprehensions, Funciones y Manejo de Errores 2

1. Bello es mejor que feo.

2. Explícito es mejor que implícito.

3. Simple es mejor que complejo.

4. Complejo es mejor que complicado.

5. Plano es mejor que anidado.

6. Espaciado es mejor que denso.

9. Sin embargo, la practicidad le gana a la pureza.

10. Los errores nunca deben pasar silenciosamente.

11. A menos que se silencien explícitamente.12.

12. Frente a la ambigüedad, evita adivinar.13.

13. Debería existir una sola manera obvia de hacerlo.14.

15. . Ahora es mejor que nunca.16.

16. A pesar de que nunca es mejor que ahora mismo.17

17. . Si la implementación es difícil de explicar, es una mala idea.18

18. . Si la implementación es fácil de explicar, puede ser una buena idea.

No pueden tener elementos duplicados

# no tiene un par key-value, así me doy cuenta que es un set, un conjunto.

Curso de Python: Comprehensions, Funciones y Manejo de Errores 3

# la podemos crear a partir de un string

# la podemos crear a partir de una tupla

# la podemos crear a partir de una lista

add(): Añade un elemento.

update(): Añade cualquier tipo de objeto iterable como: listas, tuplas.

discard(): Elimina un elemento y si ya existe no lanza ningún error.

remove(): Elimina un elemento y si este no existe lanza el error “keyError”.

clear(): Elimina todo el contenido del conjunto.

4. Operaciones con conjuntos

union(set): Realiza la operacion “union” entre dos conjuntos. La unión entre dos

Curso de Python: Comprehensions, Funciones y Manejo de Errores 4

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

symmetric_difference(set): Realiza la operacion “symmetric_difference” entre dos

Curso de Python: Comprehensions, Funciones y Manejo de Errores 5

print(newlist) #["martes", "sabado"]

newlist = [i for i in days if "a" in i]

print(newlist) # ["martes", "sabado"]

Los Dictionary comprehensions -o Dict comprehensions para abreviar- son estructuras

Curso de Python: Comprehensions, Funciones y Manejo de Errores 6

{c: len(c) for c in cities}

{'Madrid': 6, 'Barcelona': 9, 'Milán': 5, 'Santander': 9}

cities = ["Madrid", "Barcelona", "Milán", "Santander"]

{c: y for c in cities for y in years}

{'Madrid': 2020, 'Barcelona': 2020, 'Milán': 2020, 'Santander': 2020}

{'Madrid': 2020, 'Barcelona': 2020, 'Milán': 2020, 'Santander': 2020}

Si quisiéramos obtener un diccionario que relacionase cada par de valores de cities y

{c: y for c, y in zip(cities, years)}

{'Madrid': 2017, 'Barcelona': 2018, 'Milán': 2019, 'Santander': 2020}

Curso de Python: Comprehensions, Funciones y Manejo de Errores 7

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

result = { country: population for (country, population) in

text = 'Hola, soy Nicolas y tengo 22 años'

8. Lists vs. Tuples vs. Sets

Curso de Python: Comprehensions, Funciones y Manejo de Errores 8

Además, evita la repetición y hace que el código sea reutilizable.

Curso de Python: Comprehensions, Funciones y Manejo de Errores 9

def suma(a, b):

10. Funciones: return

def sum_with_range(min, max):

result = sum_with_range(1, 10)

11. Parámetros por defecto y múltiples returns