import this. La lista completa:
La documentación es la información que nos explica como funciona un lenguaje o tecnología 😄 es como un manual de instrucciones. Nos explica detalladamente como operarlo y las características.
La documentación de Python 🔥:
Podemos encontrar tutoriales, referencias de la biblioteca, etc. 🤓.
Los Índices PEP (Python Enhancement Proposals) son los documentos que conforman a toda la guía de estilos del lenguaje (como deberíamos escribirlo). El más importante es el PEP8, que nos explica las buenas prácticas que debemos seguir. 🤯 PEP8 es:
python3 -m venv <nombre de ambiente> , donde la bandera -m nos deja llamar a un módulo, en este caso venv de virtual environment. 🔥source <nombre de ambiente>/bin/activate. Para que sea más fácil usar esto, podemos crear un alias 👀.deactivate.alias <nombre>="<comando>". Pero para que quede de manera permanente, debes agregarlo al documento .bashrc (el mismo comando).pip dentro de Python es el Package Installer for Python 😃. Esto es ya que hay módulos de Python que no están instalados de fábrica como Pandas o Numpy. Hay varios manejadores de módulos, como pio, conda o pyenv.pip dentro del entorno virtual donde queremos instalar dependencias.pip freeze nos dice que módulos tenemos instalados en ese momento.pip install <nombre de módulo> para instalar un módulo. Es muy similar a npm de JavaScript.pip freeze > requirements.txt. Si tiene formato raro, también puedes usar pip list --format=freeze > requirements.txt.pip install -r requirements.txt.pip. Es muy famosa para data science 🔥.conda config --set auto_activate_base false para que no se active el base envirment de conda de manera automática y puedas usar tus envs creados como lo vimos en las clases pasadas 😄.Para ignorar el environment env lo agregamos en el archivo .gitignore 😃.
Las listas y los diccionarios son estructuras de datos, ambas son maneras de organizar objetos. Las listas pueden almacenar diccionarios y los diccionarios listas 🤯.
if __name__=='__main__' es el entry point del script 🐍.
defmain():# Lists with dictionaries inside 😋
super_list = [
{'firstname':'Missael', 'lastname':'Barco'},
{'firstname':'Gabriel', 'lastname':'Torres'},
{'firstname':'David', 'lastname':'Mendoza'},
{'firstname':'María', 'lastname':'García'}
]
# Dictionaries with lists inside 👀
super_dict = {
'natural_nums':[1, 2, 3, 4, 5],
'integer_nums':[-1, -2, 0, 1, 2],
'floating_nums':[1.1, 4.5, 6.43]
}
# Check the content of the super_dict 🤔for key, value in super_dict.items():
print(key, '=', value)
# Check the content of the super_list 🔍for dictionarie in super_list:
print(dictionarie)
if __name__=='__main__':
main()
Algunas veces, queremos crear listas con ciertas características que se repiten. Podemos hacer esto con un ciclo loop, pero también con list comprehension 😃.
La estructura general es: 🔥
list_comprehension = [function(element) for element in iterable if condition]
Mi solución al reto 👀:
deffilter_num(x):# Function to check if the number follow the rulesreturn (x % 4 == 0and x % 6 == 0and x % 9 == 0and x < 10**5)
defmain():# First, with a for loop 😀
number_list1 = []
for x in range(1, 10**5):
if filter_num(x):
number_list1.append(x)
# Look at the first 10 terms
print('With a for loop: ', number_list1[0:10])
# Now, with list comprehension 🔥
number_list2 = [x for x in range(1, 10**5) if filter_num(x)]
print('With list comprehensions', number_list2[0:10])
# Check if the lists are aqualif number_list1 == number_list2:
print('They are equal 🎉')
else:
print('They are different 😟')
if __name__ == '__main__':
main()
Lo mismo que hicimos con listas podemos hacerlo con diccionarios 👀.
La estructura es la misma que con las listas:
my_dict = {key:value for value in iterable if condition}
Mi solución al reto 😃:
defmain():# First, with a for loop 😋
dict_1 = {}
for i in range(1, 1001):
dict_1[i] = i**0.5# Print 5 elements of the dict
five_keys1 = list(dict_1.keys())[0:5]
print('With a for loop: ', [(i, dict_1[i]) for i in five_keys1])
# Now, with dictionary comprehension 🔥
dict_2 = {i: i**0.5for i in range(1, 1001)}
five_keys2 = list(dict_1.keys())[0:5]
print('With dict comprehension: ', [(i, dict_2[i]) for i in five_keys2])
# Check if the dicts are aqualif dict_1 == dict_2:
print('They are equal 🎉')
else:
print('They are different 😟')
if __name__ == '__main__':
main()
Las funciones normales nos sirven para reutilizar código que se aplica en varias secciones. Sin embargo, hay otro tipo de funciones: lambda 😎.
Son funciones si nombre o anónimas; estás no tienen un nombre. La estructura en general es:
lambda argumentos: expresión
Las funciones lambda pueden tener los argumentos que queramos, pero una sola línea de código. 🤯
Ejemplo con palíndromos:
palindrome = lambda string: string == string[::-1]
print(palindrome('ana'))
En este caso, palindrome es una variable que guarda un objeto de tipo función, no es la función en si misma.
Código de la sesión:
defmain():# With normal functiondefpalindrome(string):return string == string[::-1]
print('With normal function', palindrome('ana'))
# With lambda function
palindrome_lambda = lambda string: string == string[::-1]
print('With lambda variable:', palindrome_lambda('ana'))
# Check type of variable
print('Type of variable:', type(palindrome_lambda))
if __name__ == '__main__':
main()
saludo es de orden superior ya que recibe una función como argumento.defsaludo(func):
func()
defhola():
print("Holaaa!!!")
defadios():
print("Adioooos!!")
saludo(hola)
saludo(adios)
filter regresa un iterator, que es un tipo especial de objeto, por lo que debemos pasarlo a tipo lista. 🔍my_list = [1, 4, 5, 6, 9, 13, 19, 21]
odd = list(filter(lambda x: x%2 !=0, my_list))
print(odd)
my_list = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x**2, my_list))
functools. La función debe recibir dos elementos, y la función reduce regresa un único valor resultado de aplicar a pares el último resultado con el siguiente elemento del iterable. 🧠from functools import reduce
my_list = [2, 2, 2, 2, 2]
all_multiplied = reduce(lambda a, b: a*b, my list)
Tenemos una lista con diccionarios sobre distintas personas. 👀
Cuando en Python colocamos una variable en mayúsculas, significa que no esperamos modificarla, esto es, es una constante ⛵.
El operador pipe | te permite unir un diccionario viejo con uno nuevo, y es un feature nuevo de python 3.9 🤯 (sumar diccionarios).
Solución al reto:
defmain():
all_python_devs = list(
filter(lambda worker: worker['language'] == 'python', DATA))
all_python_devs = list(map(lambda worker: worker['name'], all_python_devs))
all_platzi_devs = list(
filter(lambda worker: worker['organization'] == 'Platzi', DATA))
all_platzi_devs = list(map(lambda worker: worker['name'], all_platzi_devs))
adults = [worker['name'] for worker in DATA if worker['age'] > 18]
old_people = [{**worker, **{'old': worker['age'] > 70}} for worker in DATA]
print(all_python_devs, all_platzi_devs, adults, old_people)
if __name__ == '__main__':
main()
Try, except → Nos sirve para configurar acciones predeterminadas dado que sucede alguna Exception. 👀 El formato general es:
try:
<código>
except <tipo de excepción> as <alias>:
<otro código>
raise → Esto nos sirve para manejar errores que python no reconoce como errores directamente. Con esto, nosotros creamos o definimos algo que si es un error.
if <condición>:
raise <tipo de excepción>(<Mensaje>)
Eso en principio interrumpe el programa (dado que es una excepción). Podemos poner esto dentro de un try-except.
finally → Es muy rara de encontrar: cerrar archivos, conexiones y liberar recursos externos 🤔. Suceda un error o no esto sucede.
Es importante definir bien el orden en el que ponemos cada excepción dentro del try, ya que cada excepción es leída de arriba a abajo, y la primera coincidencia que encuentra es la que ejecuta omitiendo las demás. Se pueden poner varios except para los distintos tipos de errores.
try:
numero = 1 / 0
print(numero)
except ZeroDivisionError:
print('No se puede divir entre 0')
except ArithmeticError:
print('Se encontro un error aritmetico')
except:
print('Se encontro un error')
Solución al reto 😄
defdivisors(num):
divisors = []
for x in range(1, num+1):
if num%x == 0:
divisors.append(x)
return divisors
defmain():try:
num = int(input('Ingresa un número entero positivo: '))
if num < 0or num%1 != 0:
raise Exception('Debes ingresar un número entero positivo 🙄')
print(divisors(num))
except ValueError:
print('Debes ingresar un número 👀')
except Exception as ve:
print(ve)
exit()
else:
print('Ningun error en el camino 😁')
finally:
print('Terminó mi programa 💓')
if __name__=='__main__':
main()
Es una manera mas extravagante de manejar los errores. Esto puede marcar un diferencial al programar 😛. Esto es con los assert o afirmaciones. Estas son expresiones. La estructura general:
assert condicion, mensaje de error
Por ejemplo, podríamos agregar en el código de palíndromos:
assert len(string) > 0, "No se puede ingresar una cadena vacía"Esto es una alternativa al try, except, raise y finally. No importa cual usar, pero es mucho más común encontrar try, except.
Hay muchísimos tipos de archivos 📁. Dentro de la programación, es muy común trabajar con archivos. Los podemos clasificar en dos:
Normalmente, al trabajar con Python 🐍 solo trabajaremos con archivos de texto, no con binarios. 👀.
Hay tres modos de apertura de una archivo de texto:
Para abrir un archivo, es con la siguiente línea y la palabra clave with que es un manejador contextual que maneja el archivo y, en caso de que se finalice el programa, no se rompa el archivo:
with open('archivo.txt', 'r') as f:
defread():
numbers = []
with open('./archivos/numbers.txt', 'r', encoding='utf-8') as f:
for line in f:
numbers.append(int(line))
print(numbers)
defwrite():
names = ['Rodolfo', 'Ricardo', 'Bubu', 'Fanny']
with open('./archivos/names.txt', 'w', encoding='utf-8') as f:
for name in names:
f.write(name+'\n')
defmain():
read()
write()
if __name__ == '__main__':
main()
