Estructuras

Aprende las estructuras básicas de Python.

Clases

🧩 La estructura [ class ] nos permite crear objectos con diferentes carácteristicas, con sus propios métodos o tipos de datos. Además funciona como una coroutine, ya que se ejecuta una vez que es invocada.

Partes de la Estructura

class -> Definimos la clase.
x -> Identificador de la clase.
x() -> Invocamos a la clase.

class x:

  #Resto del código.
  ...

x()    

Funciones

⚡ Las [ funciones ] son una estructura en la programación que permiten crear un bloque de código independiente que no será ejecutado hasta que sea llamado y al cual le puedes pasar parámetros. A estas estructuras se les llama Coroutines y en Python las puedes identificar como invocables o Callables.
🥤 La funciones en la programación nos permiten crear un bloque de código independiente pero con la capacidad de interactar con otros datos. Este mismo se ejecutará hasta que sea invocado con sus respectivos parámetros si es necesario.

Partes de la estructura

def -> Definición de la función.
x() -> identificador para la función
a -> Parámetro númerico
b -> Parámetro númerico
'-> int' -> Se supone que debe devolver un Integer.

funciones.py
def función(a : int, b : int) -> int:

  ...

función(10, 10) #La función es invocada para ser ejecutada.

Anotaciones

🧭 Una anotación en Python es usada para indicar el valor de retorno de una función en cualquier objecto o tipo de dato.
✨ Las anotaciones nos permite indicar que una función podria devolver un objecto, o cualquier valor posible.

anotaciones.py
#La función deberia retornar un integer porque '(-> int)'.
def función(a : int, b : int) -> int:

  ...

función(10, 10)

Return

🚮 La palabra clave return le indica al intérprete que una determinada función finaliza y retorna un objecto, valor o cualquier otra cosa.

return.py
def función(a : int, b : int) -> int:

  #Retorna un tipo de dato integer respectivo al parámetro 'a'.
  return a

función(10, 10)

Operadores de Comparación

✔️ Los operadores de comparación nos permite como su nombre lo indica comparar un elemento del otro. Devolviéndonos en el proceso si es verdadero o falso, en este caso True or False.
🚨 Esto forma parte esecial de las condicionales.

Z, X = Objectos, variables, tipos de datos...

' != ' = Z no es igual que X
' >= ' = Z es mayor igual que X
' < = ' = Z es menor igual que X
' == ' = Z es igual a X
' > ' = Z es mayor que X
' < ' = Z es menor que X

oc.py
print(9 >= 10) # False
print(1 > 10) # False
print(10 != 5) # True

Operadores Lógicos

❌ Los operadores lógicos nos permiten evaluar dos datos o evaluar por separado cada dato y nos permite mejorar la composición de una estructura if - elif con sus condiciones además nos permite simplificar el código.

ol.py
True or False # Verdadero o Falso

1 and 1 # 1 y 1

not True # False, ya que el contrario de True es False.
not False # True, ya que el contrario de False es True.

# Es muy parecido al operador de comparación ' == ' pero funciona mejor con Objectos.
1 is 1 

Condicionales

📚 Las estructuras (if - elif) nos permiten crear condicionales con objectos o variables para que un determinado bloque de código se ejecute o no.

🤝 Van de la mano con los operadores lógicos y operadores de comparación

True -> El bloque de código siempre se ejecutará.
False -> El bloque de código nunca se ejecutará.
None -> El bloque de código nunca se ejecutará.

condicionales.py
hi = 'hi'

if hi == 'Hi': # False, por lo tanto nunca se ejecutará

  #Como la variable 'hi' no tiene el valor 'Hi', esto nunca se ejecutará.
  print('Son iguales')

elif hi != 'HI': # True, ya que los valores son diferentes.

  # Este código se ejecutará ya que se cumple la condición.
  print('Son diferentes')

else: # Esto se ejecutará en el caso que ninguna condicional anterior haya sido cumplida.
  ...   

Bucle For

♻️ El bucle [ for ] es una estructura que nos permite recorrer cualquier tipo de iterable, recorrer una secuencia númerica, acceder a cada valor del iterable, entre otras muchas funciones que veremos más adelante.

Partes de la estructura

for -> Definición de la estructura 'for'.
element -> Variable temporal para acceder al elemento del iterable.
in -> Apunta al iterable que será recorrido.
iterable -> El iterable que será recorrido por la estructura.

for.py
#Creamos una variable con un tipo de dato list.
iterable = ['Hi', 'hola', 10]

#Usamos la estructura 'for' para recorrer la lista.
#El bloque de código se ejecutará 3 veces, ya que hay 3 objectos en la lista.
for element in iterable:

  #Imprimimos por consola cada elemento de la lista.
  #Usamos la salida estándar -> 'print()'.
  print(element)

Bucle While

📥 El bucle while nos permite crear un bucle como la estructura for pero infinito, siempre que se cumpla una determinada condición.

Partes de las estructura

while -> Definimos la estructura del bucle.
x != y: -> Condicional que si se cumple, será ejecutado el código bajo su herarquía infinitamente.

Aspectos Importantes

break -> Nos permite romper cualquier bucle for o while.
continue -> Nos permite saltar al siguiente elemento de la iteracción en un bucle for o while.

while.py
#El bucle será ejecutado infinitamente con el código que haya en su jerarquía. 
while 10 > 5: ...

#El bucle finalizará inmediatamente debido a la palabra clave ' break '.
while 10 > 7: break 

while 10 != 9:

  #El bucle se ejecutaría infinitamente.
  continue

  #Este código nunca será ejecutado ya que la palabra clave ' continue ' romple el flujo natural de ejecución.
  print('Hi')

Range

➡️ La clase range nos permite crear una secuencia númerica entre dos números y emplearlo para ejecutar determinadas veces una estructura for.
🔃 Definimos le bucle for, pero en vez de recorrer el iterable, recorremos la secuencia númerica creada por la clase 'range' que además se considera un iterable.

range.py
#El bloque de código se ejecutará 10 veces por la secuencia de 0 - 10.
for i in range(0, 10):
  ...

Enumerate

🔑 La clase enumerate nos permite recorrer un objeto de algún iterable y indicar su indice en el mismo.
💎 Es practicamente lo mismo que hace el método '.items()' en los diccionarios.

enumerate.py
x = ['a', 'b', 'c']

for i, v in enumerate(x):

  #Imprimimos cada llave con su respectivo valor.
  print(i, v)

Excepciones

⚠️ Las excepciones se les conoce cómo errores en la programación. Estos pueden pasar durante el tiempo de ejecución o durante la conversión a binario para los lenguajes compilados.
📲 La identación, estructuras, variables, objectos mal programados puede resultar en una posible excepción.

excepciones.py
# Generamos una excepción.
0 / 0

Manejo de Excepciones

❌ Para manejar estos errores se usa el bloque Try - Except que controla este flujo de errores ejecutando otra parte del código para evitar un cierre abrupto del programa en ejecución.

manejo de excepciones.py
try:

  #Creamos un error de división.
  0 / 0 # ZeroDivisionError

#Podemos crear un filtro de excepciones y solo la excepción de un tipo podrá controlada.
except ZeroDivisionError:

  #El bloque except es ejecutado, por lo tanto esto será imprimido por consola.
  print('0 entre 0 es indefinido.')    

except NameError: ...
except IndentationError: ...

#Controlamos cualquier excepción.
except Exception: ...

#Otra manera de controlar cualquier excepción.
except: ...

Extras de las Excepciones

➕ Finally nos permite ejecutar un determinado código siempre que haya terminado un bloque try - except independientemente si ocurre algo durante la ejecución.

Importante

🔝 El código que este en la jerarquía de finally, SIEMPRE se va ejecutar aunque ocurra un error durante la ejecución.

finally.py
try:

  0 / 0 #ZeroDivisionError

except ZeroDivisionError:

  #Código ejecutado.
  print('No puedo dividir 0 entre 0.')

finally:

  #Código que SIEMPRE será ejecutado.
  print('El tiene razón.')        

Lambdas

🔴 Lambda nos permite crear funciones anónimas osea sin un identificador a las cuales les podemos pasar parámetros y podemos invocarla de la misma manera que una función tradicional.

Partes de las estructura

lambda -> Definimos la función anónima.
a, b : -> Parámetros para la función anónima.
a + b -> Proceso que hace la función anónima.

lambdas.py
#Creamos una variable con un tipo de dato coroutine.
x = lambda a, b : a + b 

#Imprimimos por consola el resultado de la función anónima.
print(x(10, 10))

Módulos

📂 Los módulos se refieren a librerías estándar (Ya viene con Python al instalarlo) o de terceros que vienen de algún gestor de paquetes como pip. Para importar un módulo debemos usar la siguiente sintaxis:

Importamos desde un módulo una determinada función:

from module import xfunción

Importamos absolutamente todo del módulo utilizando el símbolo usado en multiplicación:

from module import *

Hay que aclarar que podemos importar datos de módulos propios hechos por nosotros.

main.py && module.py

#Módulo main.py

#Importamos la función 'fib' del módulo 'module'.
from module import fib

fib(20)

#-----------------------------------------------

# Módulo module.py

def fib(n : int) -> None:

  a, b = 0, 1
  while a < n:

    print(a, end=' ')
    a, b = b, a+b

  print()

Enum

🌟 Los [ enum ] son una estructura conformada por una clase heredando la clase Enum de la librería estándar de Python que nos permite crear elementos con cualquier tipo de dato.
♨️ Estas estructuras podemos usarlas para crear constantes o datos absolutos.

enum.py
from enum import Enum

class x(Enum):

  a : int = 1
  b : int = 2
  c : int = 3

#Para acceder al valor de un elemento en el enum usamos '.value'.
print(x.a.value)    

Async

🚀 La palabra clave async nos permite crear coroutines en Python que tengan un cierto retraso, mejor dicho no están sincronizadas en cambio son asincronas.
🧪 La palabra clave await nos permite ejecutar un código con un cierto retraso en la Coroutine asincrona en Python además que es necesario para ejecutar una.
🔔 La palabra clave await solo se puede usar dentro de una función asincrona por lo que si necesitamos ejecutar una función asincrona desde una sincronizada para eso necesitamos de la función run del módulo asyncio.

async.py

import asyncio

async def coroutine(x : int) -> int:

  await asyncio.sleep(x) #Debe esperar 10 segundos antes de retornar el parámetro 'x'.

  return x

#La función 'coroutine' es invocada para ser ejecutada pero como una función asincrona.
asyncio.run(coroutine(10))

Estructuras

Clases​

Funciones​

Anotaciones​

Return​

Operadores de Comparación​

Operadores Lógicos​

Condicionales​

Bucle For​

Bucle While​

Range​

Enumerate​

Excepciones​

Manejo de Excepciones​

Extras de las Excepciones​

Lambdas​

Módulos​

Enum​

Async​