CURSO DE PYTHON DESDE CERO PARA PRINCIPIANTES

Autor = MoureDev by Brais Moure

Fecha de publicación = 30/09/2022

Duración = 10:07:35

https://youtu.be/Kp4Mvapo5kc

RECURSOS

Wikipedia de Python = https://wiki.python.org/moin/SpanishLanguage

Tutorial official de Python = https://docs.python.org/es/3/tutorial/index.html

Pagina para aprender interactivamente = https://www.codedex.io/

Pagina interactivamente para aprender Python = https://www.codedex.io/python

Repositorio en GitHub = https://github.com/Asabeneh/30-Days-Of-Python

Retos de programación = https://retosdeprogramacion.com/

 CONTENIDO
CREAR FICHEROS...................................................................................................................................3
COMENTARIOS......................................................................................................................................4
MENSAJES.............................................................................................................................................5
TIPO DE DATOS.....................................................................................................................................5
OPERADORES EN PYTHON....................................................................................................................5
¿QUÉ TIPO DE DATO ES?.......................................................................................................................6
VARIABLES.............................................................................................................................................6
IMPRIMIR CON VARIOS ARGUEMENTOS..............................................................................................7
VARIABLES EN UNA SOLA LINEA...........................................................................................................7
FUNCIONES PREDETERMINADAS EN PYTHON......................................................................................8
PEDIR DATOS AL USUARIO...................................................................................................................8
OPERADORES........................................................................................................................................9
STRINGS...............................................................................................................................................13
DIFERENCIA ENTRE MUTABLE E INMUTABLE.....................................................................................15
LISTAS..................................................................................................................................................16
TUPLAS................................................................................................................................................17
SETS.....................................................................................................................................................18
DICCIONARIO......................................................................................................................................25
CONDICIONALES.................................................................................................................................27
BUCLES/LOOPS/CICLOS.......................................................................................................................28
FUNCIONES.........................................................................................................................................31
CLASES.................................................................................................................................................33
EXEPCIONES........................................................................................................................................35
MÓDULOS...........................................................................................................................................38
 CREAR FICHEROS
Pautas para nombrar ficheros de manera adecuada:

 Utilizar nombres descriptivos: Elegir nombres que sean claros y describan la función o
contenido del fichero. Evitar nombres genéricos como "archivo.py" o "codigo_final.py". En
su lugar, utilizar nombres que indiquen el propósito o el tema principal del fichero.
 Utilizar minúsculas y guiones bajos: En Python, es común utilizar minúsculas y guiones bajos
para separar las palabras en los nombres de los ficheros. Por ejemplo, en lugar de
"MiArchivo.py", es preferible usar "mi_archivo.py" o "miarchivo.py". Esta convención se
conoce como snake_case.

 Evitar caracteres especiales: En general, evitar el uso de caracteres especiales como

espacios, acentos o caracteres no alfanuméricos en los nombres de ficheros. Esto puede
causar problemas al importar o acceder a los ficheros en diferentes sistemas operativos.

1. Espacios: Evita utilizar espacios en los nombres de fichero. En su lugar, puedes utilizar
guiones bajos (_) o guiones (-) para separar las palabras.

Ejemplo incorrecto: "mi archivo.py"

Ejemplo correcto: "mi_archivo.py" o "mi-archivo.py"

2. Acentos y diacríticos: Evita utilizar acentos, diacríticos u otros caracteres especiales que no
sean alfanuméricos.
 Ejemplo incorrecto: "fichéro.py"

Ejemplo correcto: "fichero.py"

3. Caracteres no alfanuméricos: Evita utilizar caracteres especiales como @, !, #, $, %, etc., en

los nombres de fichero.

Ejemplo incorrecto: "mi@archivo.py"

Ejemplo correcto: "mi_archivo.py" o "miarchivo.py"

 Sé consistente: Intenta mantener una convención de nomenclatura coherente en todos tus

ficheros. Si decides utilizar snake_case para tus nombres de fichero, asegúrate de seguir esa
convención en todo tu código.

 Utiliza extensiones de archivo apropiadas: Asegúrate de utilizar las extensiones de archivo

adecuadas según el tipo de contenido del fichero. Por ejemplo, utiliza ".py" para los ficheros
de código fuente de Python, ".txt" para ficheros de texto plano, ".csv" para ficheros CSV, etc.

 Evita nombres demasiado largos: Aunque es importante que los nombres sean descriptivos,
trata de no hacerlos excesivamente largos. Nombres demasiado largos pueden dificultar la
lectura del código y aumentar la probabilidad de cometer errores al escribir o referenciar los
nombres.

COMENTARIOS

Comentario de 1 línea

# Hola mundo

Comentario de varias líneas

1 forma

"""
Este es un
comentario
de varias
líneas
"""

2 forma

'''
Este es un
comentario
de varias
líneas
'''

MENSAJES

print("Hola Python")
print('Hola Python')

TIPO DE DATOS

 Números enteros (int): Representa números enteros sin parte decimal. Por ejemplo: 1, 100,
-10.

 Números de punto flotante (float): Representa números con parte decimal. Por ejemplo:
3.14, -0.5, 2.0.

 Números complejos (complex): Representa números complejos con una parte real y una
parte imaginaria. Por ejemplo: 1 + 2j, -3j.

 Cadenas de texto (str): Representa una secuencia de caracteres. Las cadenas se pueden
crear utilizando comillas simples ('') o comillas dobles (""). Por ejemplo: "Hola", 'Python',
"123".

 Booleanos (bool): Representa un valor de verdad, que puede ser Verdadero (True) o Falso
(False). Se utilizan en operaciones de lógica y control de flujo. Por ejemplo: True, False.

 Listas (list): Representa una colección ordenada y mutable de elementos. Puedes almacenar
diferentes tipos de datos en una lista. Se crean utilizando corchetes ([]). Por ejemplo: [1, 2,
3], ['a', 'b', 'c'].

 Tuplas (tuple): Similar a las listas, pero son inmutables, lo que significa que no se pueden
modificar una vez creadas. Se crean utilizando paréntesis (()). Por ejemplo: (1, 2, 3), ('a', 'b',
'c').

 Conjuntos (set): Representa una colección desordenada y mutable de elementos únicos. No

permite elementos duplicados. Se crean utilizando llaves ({}). Por ejemplo: {1, 2, 3}, {'a', 'b',
'c'}.

 Diccionarios (dict): Representa una colección de pares clave-valor. Cada valor está asociado
con una clave única, lo que permite acceder a los valores mediante sus claves. Se crean
utilizando llaves ({}) y dos puntos (:) para separar las claves y los valores. Por ejemplo:
{'nombre': 'Juan', 'edad': 30}.

OPERADORES EN PYTHON
print(2 + 3) # suma(+)
print(3 - 1) # resta(-)
print(2 * 3) # multiplicación(*)
print(3 / 2) # division(/)
print(3 ** 2) # exponencial**)
print(3 % 2) # modulo(%)
print(3 // 2) # Operador de división de pisos(//)

Modulo = devuelve el resto de la división entre dos números.

numero = 15

if numero % 2 == 0: En este caso, utilizamos el operador % para determinar si

un número es par o impar. Si el resto de la división entre
print("El número es par") el número y 2 es igual a 0, entonces el número es par. Si
else: el resto es diferente de 0, entonces el número es impar.

print("El número es impar")

Operador de división de pisos = devuelve el cociente de la operación de división, como un número

entero o un número de coma flotante, según los tipos de datos de los operandos.

¿QUÉ TIPO DE DATO ES?

# Checking data types

print(type(10)) # Int
print(type(3.14)) # Float
Type = operación del sistema
print(type(1 + 3j)) # Complex number
que permite inferir que tipo de
print(type('Asabeneh')) # String
dato es.
print(type([1, 2, 3])) # List
print(type({'name': 'Asabeneh'})) # Dictionary
print(type({9.8, 3.14, 2.7})) # Set
print(type((9.8, 3.14, 2.7))) # Tuple

VARIABLES

 Utiliza nombres descriptivos: Elegir nombres que sean claros y describan el propósito o
contenido de la variable. Evitar nombres genéricos como "x" o "var1". En su lugar, utiliza
nombres que reflejen el significado de la variable en el contexto de tu código.

 Utiliza letras minúsculas y guiones bajos: En Python, es común utilizar minúsculas y guiones
bajos para separar las palabras en los nombres de variables. Por ejemplo, en lugar de
"miVariable", es preferible usar "mi_variable" o simplemente "variable". Esta convención se
conoce como snake_case.
  Evita caracteres especiales y espacios: En general, evita el uso de caracteres especiales,
espacios o acentos en los nombres de variables. Esto puede causar problemas y confusiones
en el código. Solo se permite el uso de letras, números y guiones bajos en los nombres de
variables.

 Sé consistente: Mantén una convención de nomenclatura coherente en todo tu código. Si

decides utilizar snake_case para tus nombres de variables, asegúrate de seguir esa
convención en todas las variables.

 Utiliza nombres significativos, pero no demasiado largos: Los nombres de variables deben
ser descriptivos, pero también es importante no hacerlos excesivamente largos. Nombres
demasiado largos pueden dificultar la lectura y escritura del código. Intenta encontrar un
equilibrio entre claridad y concisión.

Ejemplos:

edad = 25

nombre_completo = "Juan Pérez"

Se imprimen en pantalla:

print(nombre_completo)

print(edad)

IMPRIMIR CON VARIOS ARGUEMENTOS

Se usa la coma (,) para separar los argumentos:

Ejemplo:

edad = 25
nombre_completo = "Juan Pérez"

print("Nombre:", nombre_completo, " Edad:", edad)

VARIABLES EN UNA SOLA LINEA

Nota = No es recomendable combinar variables

tipo_vehiculo, marca, modelo = "Camioneta", "Mercedez AMG", 2024

print("El tipo del vehiculo es ", tipo_vehiculo,

" y es de la marca ", marca, " del año ", modelo)
 FUNCIONES PREDETERMINADAS EN PYTHON

animal = "Paco emilio"

vecino = "caMIlo cruz"

print(animal.isnumeric()) # ¿Es numerico?

print(animal.count("o")) # contar cuando x caracteres tiene
print(animal.upper()) # Pone en mayuscula todo
print(animal.lower()) # Pone en miniscula todo
print(vecino.capitalize()) # Pone solo el primer caracter en mayuscula
print(animal.title()) # Pone los primeros caracteres de cada palabra en
mayuscula
print(animal.strip()) # Remover todos los espacios a la derecha e izquierda
print(animal.strip().capitalize()) # Se puede encadenar metodos
print(animal.rstrip()) # Remover espacios derecha
print(animal.lstrip()) # Remover espacios izquierda
print(vecino.find("c")) # Devuelve el indice del caracter
print(vecino.replace("cruz", "baby")) # reemplaza caracteres
print(vecino.title().replace("Camilo", "Jonathan")) # Se puede encadenar
metodos
print("MIlo" in vecino) # Devuelve un boolean si se encuentra el caracter
print("MIlo" not in vecino) # Devuelve un boolean si no se encuentra el
caracter

PEDIR DATOS AL USUARIO

Nota = Se debe usar la función input para pedir datos

nombre_mascota = input("Inserte el nombre de su mascota: ")

print("Nombre de la mascota: ", nombre_mascota)

OPERADORES

NOTA = SE PUEDEN OPERAR ALGUNOS STR CON + Y *

Print(“Hola ” + “Mundo”) #Hola Mundo
Print (“Hola” * 2) #Hola Hola

Operadores aritméticos:

Addition (+): a + b
Subtraction (-): a - b
Multiplication (*): a * b
Division (/): a / b
Modulus (%): a % b
Floor division (//): a // b
Exponentiation (**): a ** b
Ejemplo de enteros

print('Addition: ', 1 + 2) #3
print('Subtraction: ', 2 - 1) #1
print('Multiplication: ', 2 * 3) # 6
print ('Division: ', 4 / 2) # 2.0 Division in Python gives floating number
print('Division: ', 6 / 2) # 3.0
print('Division: ', 7 / 2) # 3.5
print('Division without the remainder: ', 7 // 2) # 3, gives without the floating number or without the
remaining
print ('Division without the remainder: ',7 // 3) # 2
print('Modulus: ', 3 % 2) # 1, Gives the remainder
print('Exponentiation: ', 2 ** 3) # 9 it means 2 * 2 * 2

Ejemplo de flotantes

print('Floating Point Number, PI', 3.14)

print('Floating Point Number, gravity', 9.81)

Ejemplo de numeros complejos

print('Complex number: ', 1 + 1j)

print('Multiplying complex numbers: ',(1 + 1j) * (1 - 1j))

Ejemplo de un uso extenso de operadores

# Declaring the variable at the top first

a = 3 # a is a variable name and 3 is an integer data type

b = 2 # b is a variable name and 3 is an integer data type

# Arithmetic operations and assigning the result to a variable

total = a + b

diff = a - b

product = a * b

division = a / b

remainder = a % b

floor_division = a // b

exponential = a ** b

# I should have used sum instead of total but sum is a built-in function - try to avoid overriding built-
in functions

print(total) # if you do not label your print with some string, you never know where the result is
coming from

print('a + b = ', total)

print('a - b = ', diff)

print('a * b = ', product)

print('a / b = ', division)

print('a % b = ', remainder)

print('a // b = ', floor_division)

print('a ** b = ', exponentiation)

Operadores de comparación

Nota = También se puede hacer comparaciones con str y principalmente si se pone solo los str
hará una comparación alfabética

Ejemplo de comparación

print(3 > 2) # True, because 3 is greater than 2

print(3 >= 2) # True, because 3 is greater than 2
print(3 < 2) # False, because 3 is greater than 2
print(2 < 3) # True, because 2 is less than 3
print(2 <= 3) # True, because 2 is less than 3
print(3 == 2) # False, because 3 is not equal to 2
print(3 != 2) # True, because 3 is not equal to 2
print(len('mango') == len('avocado')) # False
print(len('mango') != len('avocado')) # True
print(len('mango') < len('avocado')) # True
print(len('milk') != len('meat')) # False
print(len('milk') == len('meat')) # True
print(len('tomato') == len('potato')) # True
print(len('python') > len('dragon')) # False

# Comparing something gives either a True or False

print('True == True: ', True == True)
print('True == False: ', True == False)
print('False == False:', False == False)

# In addition to the above comparison operator Python uses:

is: Returns true if both variables are the same object (x is y)
is not: Returns true if both variables are not the same object (x is not y)
in: Returns True if the queried list contains a certain item (x in y)
not in: Returns True if the queried list doesn't have a certain item (x in y)

print('1 is 1', 1 is 1) # True - because the data values are the same
print('1 is not 2', 1 is not 2) # True - because 1 is not 2
print('A in Asabeneh', 'A' in 'Asabeneh') # True - A found in the string
print('B in Asabeneh', 'B' in 'Asabeneh') # False - there is no uppercase B
print('coding' in 'coding for all') # True - because coding for all has the word coding
print('a in an:', 'a' in 'an') # True
print('4 is 2 ** 2:', 4 is 2 ** 2) # True
Operadores logicos

print(3 > 2 and 4 > 3) # True - because both statements are true
print(3 > 2 and 4 < 3) # False - because the second statement is false
print(3 < 2 and 4 < 3) # False - because both statements are false
print('True and True: ', True and True)
print(3 > 2 or 4 > 3) # True - because both statements are true
print(3 > 2 or 4 < 3) # True - because one of the statements is true
print(3 < 2 or 4 < 3) # False - because both statements are false
print('True or False:', True or False)
print(not 3 > 2) # False - because 3 > 2 is true, then not True gives False
print(not True) # False - Negation, the not operator turns true to false
print(not False) # True
print(not not True) # True
print(not not False) # False

STRINGS

nombre_cliente = "Jonathan"

apellido_cliente = "Acevedo"

# Función para saber cuántos caracteres tiene el dato de x variable len()

print(len(nombre_cliente))

print(len(apellido_cliente))

# Concatenar strings +

print(nombre_cliente + " " + apellido_cliente)

# Salto de línea (\n)

frase = "Mi nombre es Jonathan\nAcevedo y tengo 2 mascotas"

print(frase)

# tabulación (\t)

comentario = "\tMi nombre es Jonathan Acevedo y tengo 2 mascotas"

print(comentario)

FORMATEO DE STRINGS

El formateo de strings en Python se refiere a la técnica que permite combinar valores variables con
una cadena de texto para crear una nueva cadena formateada. Esto facilita la construcción de strings
dinámicos y personalizados en función de los valores que deseas incluir.

%s - String (or any object with a string representation, like numbers)

%d - Integers

%f - Floating point numbers (en este se pone %2f) el 2 significa puntos de precisión

"%.number of digitsf" - Floating point numbers with fixed precision

# Formateo

nombre_mascota = "Paco"

edad_mascota = 7

print("Nombre de la mascota es {} y la edad es {}".format(nombre_mascota, edad_mascota))

print("Nombre de la mascota es %s y la edad es %d" %(nombre_mascota, edad_mascota))

# Inferencia de datos

La inferencia de datos en Python se refiere a la capacidad de la máquina para deducir

automáticamente el tipo de datos de una variable o expresión en tiempo de ejecución. En Python,
como lenguaje de programación de tipado dinámico, no es necesario declarar explícitamente el tipo
de datos de una variable antes de asignarle un valor. En su lugar, el intérprete de Python puede
inferir el tipo de datos basándose en el valor asignado a la variable.

print(f"Nombre de la mascota es {nombre_mascota} y la edad es {edad_mascota}")

# Desempaquetado de caracteres

raza_mascota = "Pincher"

a, b, c, d, e, f, g = raza_mascota

print(a)

print(b)

print(c)

print(d)
print(e)

print(f)

print(g)

#python 2023

# 0 1 2 3 4 5 6 7 8 9 10 (índices)

nombre_curso = "python 2023"

# Para acceder a un carácter específico los índices comienzan de 0 a x...

print(nombre_curso[0])

# para recortar una palabra

print(nombre_curso[0:6])

# Si no se pone nada, Python se encarga de poner hasta el último índice

print(nombre_curso[7:])

# Si no se pone nada, Python se encarga de poner hasta el primer índice

print(nombre_curso[:6])

# Reversa

print(nombre_curso[::-1])

# Saltos (El 2 significa para que vaya de dos en dos y esos caracteres no los cuente)

print(nombre_curso[0:11:2])

DIFERENCIA ENTRE MUTABLE E INMUTABLE

Objetos Mutables:

Los objetos mutables son aquellos que pueden cambiar después de ser creados. Esto significa que se
pueden modificar sus valores, agregar nuevos elementos o eliminar elementos existentes sin crear
un nuevo objeto.

Algunos ejemplos de objetos mutables en Python son las listas (list), los conjuntos (set) y los
diccionarios (dict).

Si se asigna una variable a un objeto mutable y se modifica ese objeto, cualquier otra variable que se
haya asignado al mismo objeto también reflejará los cambios.

Objetos Inmutables:

Los objetos inmutables son aquellos que no pueden cambiar después de ser creados. Esto significa
que no se pueden modificar sus valores una vez que han sido asignados. Si se intenta modificar un
objeto inmutable, se creará un nuevo objeto con los nuevos valores.
Algunos ejemplos de objetos inmutables en Python son las tuplas (tuple), los números (int, float), las
cadenas de texto (str) y las tuplas congeladas (frozen sets).

Al asignar una variable a un objeto inmutable y realizar operaciones que implican cambios, se crea
un nuevo objeto en lugar de modificar el existente.

LISTAS

En Python, una lista es una estructura de datos que se utiliza para almacenar una colección
ordenada de elementos. Puedes pensar en ella como una secuencia mutable de elementos, donde
cada elemento tiene una posición única en la lista.

Se pueden agregar diferentes tipos de datos, ejemplo: mi_lista = [1, "Hola", True, 3.14]

SINTAXIS

nombre_lista = [] -> Esta es una sintaxis más concisa y fácil de leer, y es ampliamente utilizada por
los programadores de Python.

mi_lista = list() -> Se utiliza principalmente cuando necesitas crear una lista vacía y luego agregar
elementos de forma dinámica a medida que avanzas en tu código.

USO

 Se puede usar funciones del sistema en las listas, por ejemplo: print(len(mi_lista)) esto
contara los elementos en la lista.
 Imprimir datos, por ejemplo: print(mi_lista[índice]) el índice es la posición del dato y siempre
empieza con un orden de 0,1,2,3,4,5… Si se empieza con negativo ahora la posición seria -1,-
2-3,-4… pero de derecha a izquierda.

 # Las variables deben ir en la posición de los datos correspondientes

name, surname, age, tall = Cliente
print(name) #Imprime Jonathan

 # Se puede concatenar dos listas

print(tipo_mascotas + Cliente)

 # Agregar un elemento después de x tiempo con la operación. append = adjuntar (Se adjunta
al final de la lista)

tipo_mascotas.append("Roedor")

print(tipo_mascotas)

 # Agregar en un índice especifico con la operación

# tipo_mascotas.insert(índice, dato)

tipo_mascotas.insert(0, "Insecto")

print(tipo_mascotas)
  # Eliminar un valor especifico
tipo_mascotas.remove("pez")
print(tipo_mascotas)

 # Eliminar un elemento sin retornar con índice

del tipo_mascotas[3]

print(tipo_mascotas)

NOTA = HAY MUCHAS OPERACIONES QUE SE PUEDEN HACER EN LA LISTA DE PYTHON

Insertar, adjuntar, eliminar por índice, eliminar por dato, eliminar lista, actualizar datos, ordenar,
etc...

TUPLAS

las tuplas son una estructura de datos inmutable que permite almacenar múltiples elementos. Se
definen mediante paréntesis () y los elementos se separan por comas. A diferencia de las listas, las
tuplas no se pueden modificar una vez creadas, lo que significa que no se pueden agregar, eliminar o
modificar elementos individualmente.

Las tuplas son útiles en situaciones donde se necesite almacenar un conjunto de valores que no
deben cambiar, como coordenadas, información de fechas o datos relacionados. Algunas de las
razones por las que puedes utilizar tuplas en Python son:

 Secuencias inmutables: Las tuplas son útiles cuando necesitas garantizar que los datos no
sean modificados accidental o intencionalmente. Esto puede ser importante en situaciones
donde se necesita preservar la integridad de los datos.

 Intercambio de valores: Puedes intercambiar los valores de dos variables utilizando tuplas
sin necesidad de una variable temporal adicional. Esto se conoce como asignación múltiple y
es una característica útil de Python.

 Claves de diccionario: Las tuplas se pueden utilizar como claves de diccionario, a diferencia
de las listas que no son hasheables y, por lo tanto, no pueden ser utilizadas como claves.

 Retorno múltiple de funciones: Las funciones en Python pueden devolver múltiples valores
utilizando tuplas. Puedes empaquetar varios valores en una tupla y luego desempaquetarlos
cuando la función sea llamada.

# Estructura de tupla

# Estructura para definir una tupla vacía

My_tuple = tuple()
# Estructura para poner valores

My_tuple = ("Jonathan", "Acevedo", 1.68, 20, 20)

My_other_tuple = ("Jonathan", "Acevedo", 1.68, 20, "Azul")

# Imprimir con el índice

print(My_tuple[0])

print(My_other_tuple[1])

# Función count

print(My_tuple.count(20))

print(My_other_tuple.count("Jonathan"))

# Función index

print(My_tuple.index(20))

print(My_other_tuple.index("Acevedo"))

# Se puede concatenar las tuplas (sería una nueva tupla)

Suma = My_tuple + My_other_tuple

print(Suma)

# Se puede delimitar algunos valores

print(Suma[2:5])

# Se puede volver una tupla a lista

My_tuple = list(My_tuple)

print(My_tuple)

print(type(My_tuple))

My_tuple.append("Verde")

print(My_tuple)

# Se puede eliminar una tupla

del My_tuple

SETS

Un set (conjunto) es una colección desordenada y mutable de elementos únicos. Se utiliza para
almacenar varios elementos en un solo objeto, sin tener en cuenta el orden en que se agregan los
elementos, y garantiza que no haya duplicados.

Los sets en Python son útiles en varias situaciones:

  Eliminación de duplicados: Si tienes una lista o cualquier otra estructura de datos que
contiene elementos duplicados y deseas eliminarlos, puedes convertirlos en un set. Al
convertir la estructura de datos en un set, se eliminarán automáticamente los duplicados, ya
que los sets solo pueden contener elementos únicos.

 Verificación de pertenencia: Los sets son eficientes para verificar rápidamente si un

elemento se encuentra en un conjunto. Al utilizar el operador de pertenencia in, puedes
comprobar si un elemento está presente en un set sin tener que recorrer todos los
elementos de la colección.

 Operaciones de conjunto: Los sets en Python también admiten operaciones de conjunto

como la unión, la intersección, la diferencia y la diferencia simétrica. Estas operaciones son
útiles para realizar comparaciones y combinaciones de conjuntos en el ámbito de la teoría
de conjuntos.

 Filtrado de elementos: Puedes utilizar sets para filtrar elementos comunes entre dos
conjuntos. Al realizar operaciones de conjunto, puedes encontrar los elementos que son
comunes entre dos sets o aquellos que son exclusivos de uno u otro set.

 Iteración eficiente: Los sets son iterables, lo que significa que puedes recorrer sus elementos
de manera eficiente utilizando bucles for. A diferencia de las listas, los sets no mantienen un
orden específico, por lo que no se puede acceder a sus elementos mediante índices.

# Operaciones

### SETS ###

my_set = set()
my_other_set = {} # Si no se ponen valores Python lo toma como diccionario
print(type(my_other_set))

my_other_set = {"Jonathan", "Acevedo", 20} # Ya con valores es un set

print(type(my_other_set))

# Operaciones con sets

print(len(my_other_set))

# Insertar datos en el set

my_other_set.add("Paco")
print(my_other_set)

# Ver si el valor esta en el set

print("Acevedo" in my_other_set)
print("acevedo" in my_other_set)
print(69 in my_other_set)

# Eliminar datos
my_other_set.remove("Jonathan")
print(my_other_set)
# Borrar todos los elementos
my_other_set.clear()
print(my_other_set)

# Eliminar el set
del my_other_set

"""
Unión:La unión de dos sets devuelve
un nuevo set que contiene todos los
elementos presentes en ambos sets,
sin duplicados.
"""

set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1.union(set2) # 1 forma
union_set = set1 | set2 # 2 forma

print(union_set) # Output: {1, 2, 3, 4, 5}

"""
Intersección: La intersección de dos sets
devuelve un nuevo set que contiene solo
los elementos que están presentes en
ambos sets.
"""

set1 = {1, 2, 3}
set2 = {3, 4, 5}
intersection_set = set1.intersection(set2) # 1 forma
intersection_set = set1 & set2 # 2 forma

print(intersection_set) # Output: {3}

"""
Diferencia: La diferencia de dos sets
devuelve un nuevo set que contiene los
elementos presentes en el primer set
pero no en el segundo set.
"""
set1 = {1, 2, 3}
set2 = {3, 4, 5}
difference_set = set1.difference(set2) # 1 forma
difference_set = set1 - set2 # 2 forma
print(difference_set) # Output: {1, 2}

"""
Diferencia simétrica: La diferencia
simétrica de dos sets devuelve un
nuevo set que contiene los elementos
que están en uno de los sets pero no
en ambos.
"""

set1 = {1, 2, 3}
set2 = {3, 4, 5}
symmetric_difference_set = set1.symmetric_difference(set2) # 1 forma
symmetric_difference_set = set1 ^ set2 # 2 forma

print(symmetric_difference_set) # Output: {1, 2, 4, 5}

"""
Comprobación de subconjunto: Puedes verificar
si un set es un subconjunto de otro set utilizando
el método issubset() o el operador <=. Devuelve True
si todos los elementos del primer set están presentes
en el segundo set.
"""

set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5}

print(set1.issubset(set2)) # 1 forma
print(set1 <= set2) # 2 forma

"""
Comprobación de superconjunto: Puedes verificar si un set
es un superconjunto de otro set utilizando el método
issuperset() o el operador >=. Devuelve True si todos los
elementos del segundo set están presentes en el primer set.
"""

set1 = {1, 2, 3, 4, 5}
set2 = {1, 2, 3}

print(set1.issuperset(set2)) # 1 forma
print(set1 >= set2) # 2 forma
"""
Eliminar elementos (remove() o discard()): Puedes eliminar un
elemento de un set utilizando el método remove() o discard().
La diferencia entre ambos es que remove() generará un error si
el elemento no está presente en el set, mientras que discard()
no generará ningún error.
"""

my_set = {1, 2, 3}
my_set.remove(2) # 1 forma

print(my_set) # Output: {1, 3}

my_set.discard(3) # 2 forma

print(my_set) # Output: {1}

"""
Copiar un set (copy()): Puedes copiar un set para crear un nuevo
set independiente utilizando el método copy().
"""

set1 = {1, 2, 3}
set2 = set1.copy()

print(set2) # Output: {1, 2, 3}

"""
Eliminación de elementos comunes (intersection_update() o &=): Puedes
eliminar los elementos del set que no están presentes en otro set
utilizando el método intersection_update() o el operador &=.
"""

set1 = {1, 2, 3}
set2 = {2, 3, 4}

set1.intersection_update(set2) # 1 forma
set1 &= set2 # 2 forma

print(set1) # Output: {2, 3}

"""
Unión de sets (update() o |=): Puedes agregar elementos de otro set a un
set existente utilizando el método update() o el operador |=.
"""
set1 = {1, 2, 3}
set2 = {3, 4, 5}

set1.update(set2) # 1 forma
set1 |= set2 # 2 forma

print(set1) # Output: {1, 2, 3, 4, 5}

"""
Diferencia entre sets (difference_update() o -=): Puedes eliminar los
elementos de un set que también están presentes en otro set utilizando
el método difference_update() o el operador -=.
"""

set1 = {1, 2, 3, 4, 5}
set2 = {3, 4}

set1.difference_update(set2) # 1 forma
set1 -= set2 # 2 forma

print(set1) # Output: {1, 2, 5}

"""
Eliminación de elementos comunes y no comunes (symmetric_difference_update() o
^=):
Puedes modificar un set para contener solo los elementos que están en uno de
los sets
pero no en ambos utilizando el método symmetric_difference_update() o el
operador ^=.
"""

set1 = {1, 2, 3}
set2 = {3, 4}

set1.symmetric_difference_update(set2) # 1 forma
set1 ^= set2 # 2 forma

print(set1) # Output: {1, 2, 4}

"""
Comprobación de disyunción (isdisjoint()): Puedes verificar si dos sets son
disyuntos,
es decir, si no tienen elementos en común, utilizando el método isdisjoint().
Devuelve
True si los sets no tienen elementos en común y False en caso contrario.
"""

set1 = {1, 2, 3}
set2 = {4, 5, 6}

print(set1.isdisjoint(set2)) # Output: True

"""
Eliminación de elementos aleatorios (pop()): Puedes eliminar y devolver un
elemento aleatorio
de un set utilizando el método pop(). Debido a que los sets no están
ordenados, el elemento
eliminado será impredecible.
"""

my_set = {1, 2, 3, 4, 5}
removed_element = my_set.pop()

print(removed_element) # Output: un elemento aleatorio del set

print(my_set) # Output: el set sin el elemento eliminado

"""
Comprobación de igualdad (==): Puedes verificar si dos sets son iguales, es
decir, si tienen
los mismos elementos, utilizando el operador de igualdad ==.
"""

set1 = {1, 2, 3}
set2 = {3, 2, 1}

print(set1 == set2) # Output: True

"""
Comprobación de desigualdad (!=): Puedes verificar si dos sets son diferentes,
es decir, si no
tienen los mismos elementos, utilizando el operador de desigualdad !=.
"""

set1 = {1, 2, 3}
set2 = {4, 5, 6}

print(set1 != set2) # Output: True

DICCIONARIO
Un diccionario es una estructura de datos que se utiliza para almacenar y organizar elementos de
manera eficiente. Se trata de una colección mutable de pares clave-valor, donde cada clave es única
y se utiliza para acceder a su respectivo valor.

A diferencia de las listas o las tuplas, que se acceden mediante un índice numérico, los diccionarios
permiten acceder a los valores asociados a una clave específica. Esto los hace especialmente útiles
cuando se necesita buscar, actualizar o eliminar elementos según una clave personalizada, en lugar
de un índice fijo.

Los diccionarios en Python son extremadamente versátiles y se utilizan en una amplia variedad de
situaciones. Algunas de las aplicaciones comunes de los diccionarios son:

 Búsqueda eficiente: Los diccionarios permiten buscar rápidamente un valor asociado a una
clave, lo que puede ser útil cuando se necesita recuperar información de manera eficiente
en función de una identificación única.

 Mapeo de datos: Los diccionarios se utilizan para establecer relaciones entre diferentes
conjuntos de datos. Por ejemplo, se pueden utilizar para almacenar traducciones de
palabras, nombres de variables y sus valores correspondientes, y otras relaciones de datos
complejas.

 Configuración y opciones: Los diccionarios se utilizan a menudo para almacenar

configuraciones y opciones en un programa. Las claves pueden representar los nombres de
las opciones, y los valores pueden ser los ajustes correspondientes.
 Contadores y frecuencia de elementos: Los diccionarios son ideales para contar y realizar un
seguimiento de la frecuencia de elementos en una colección. La clave puede ser el elemento
y el valor puede ser el recuento o la frecuencia de aparición.

 Almacenamiento de datos estructurados: Si tienes datos estructurados en forma de

registros con campos específicos, puedes utilizar un diccionario para almacenar cada
registro, donde las claves serían los nombres de los campos y los valores serían los valores
correspondientes.

## DICCIOANARIO##

my_dict = dict()
my_other_dict = {1: "Primer registro",
"Nombre": "Jonathan",
"Apellido": "Acevedo",
"Edad": 20}

print(type(my_dict))
print(type(my_other_dict))

my_dict = {
 1: "Primer registro",
"Nombre": "Jonathan",
"Apellido": "Acevedo",
"Edad": 20,
"Lenguajes": ["Python", "C++", "Java", "C#", "C"]
}

print(my_other_dict)
print(my_dict)

# Imprimir claves especificas y que retorne su valor

print(my_dict[1])
print(my_dict["Nombre"])
print(my_dict["Apellido"])
print(my_dict["Edad"])
print(my_dict["Lenguajes"])

# Actualizar una clave con diferente valor

my_dict["Edad"] = 21
print(my_dict)

# Agregar un nuevo clave:valor al diccionario

my_dict["Direccion"] = "Km 4.5 Via La Calera"
print(my_dict)

# Eliminar un elemento en especifico de x diccionario

del my_dict[1]
print(my_dict)

# Validar si una clave esta en el diccionario

print("Nombre" in my_dict)
print("nombre" in my_dict)

# Algunas Operaciones que sirven con dict

print(my_dict.items())
print(my_dict.keys())
print(my_dict.values())

CONDICIONALES

Son estructuras de control que permiten tomar decisiones en función de una condición o conjunto
de condiciones. Los condicionales se utilizan para controlar el flujo del programa, ejecutando
diferentes bloques de código según se cumplan o no ciertas condiciones.

## CONDICIONALES ##
# NOTA: se pueden usar varios operadores con los if

my_conditionals = True
my_name = "Jonathan"
my_last_name = "Acevedo"
color_1 = "Rojo"
color_2 = "Azul"
Age_1 = 0
# Intento 1

if my_conditionals:
print("Hola")
else:
print("Adios")

# Intento 2

if my_name == "Jonathan":
print("Hola Jonathan")
else:
print("No eres Jonathan")

# Intento 3

if my_name == "Jonathan" and my_last_name == "Acevedo":

print("Hola Jonathan Acevedo")
else:
print("No eres Jonathan Acevedo")
# Intento 4
# Nota = la tabulación influye si la condición sigue o no

if color_1 == "Rojo" and color_2 == "Azul":

print(
f"El color {color_1} y el el color {color_2} da como resultado el
color morado")
else:
print("El color no da morado") # Se ejecuta
print("El color morado me gusta!") # Se ejecuta

print("Se termina el intento 4") # Se ejecuta pero ya afuera de la condición

# Intento 5

if Age_1 >= 1 and Age_1 <= 6:

print("Infancia")
elif Age_1 > 6 and Age_1 <= 12:
print("Niñez")
elif Age_1 > 12 and Age_1 <= 20:
print("Adolescencia")
elif Age_1 > 20 and Age_1 <= 25:
print("Juventud")
elif Age_1 > 25 and Age_1 <= 60:
print("Adultez")
elif Age_1 > 60:
print("vejez")
else:
print("No es valido")

# Intento 6 "Concatenar"

numero = 10

if numero > 0:
print("El número es positivo.")

if numero % 2 == 0:
print("El número es par.")

# O

numero = 10

if numero > 0 and numero % 2 == 0:

print("El número es positivo y par.")

BUCLES/LOOPS/CICLOS

Son estructuras de control que te permiten repetir un bloque de código varias veces. Los bucles son
útiles cuando quieres ejecutar una acción o un conjunto de acciones repetidamente, ya sea un
número fijo de veces o mientras se cumpla una condición específica.

## BUCLES/LOOPS/CICLOS ##

# WHILE

El bucle "while" se utiliza cuando deseas repetir un bloque de código mientras se cumpla una
condición específica.

El bloque de código se ejecutará repetidamente mientras la condición sea evaluada como verdadera.
Es importante asegurarse de que la condición se vuelva falsa en algún momento para evitar un bucle
infinito.

Dentro de los bucles, puedes utilizar instrucciones de control como "break" y "continue" para alterar
el flujo de ejecución. "Break" se utiliza para salir del bucle por completo, mientras que "continue" se
utiliza para saltar a la siguiente iteración sin ejecutar el resto del bloque de código.
# intento 1

my_condition = 0

while my_condition < 10:

print(my_condition)
my_condition += 3

# Intento 2

my_condition_2 = 0

while my_condition_2 < 15:

my_condition_2 += 1
print(my_condition_2)
if my_condition_2 == 12:
print("Ya llego al número 12")

# Intento 3

my_condition_3 = 0

while my_condition_3 < 15:

my_condition_3 += 1
if my_condition_3 == 12:
print("Ya llego al número 12")
break
print(my_condition_3)

# FOR

Se utiliza para iterar sobre una secuencia (como una lista, una cadena de texto, una tupla o un
rango) y ejecutar un bloque de código para cada elemento de la secuencia.

## BUCLES/LOOPS/CICLOS ##

# FOR

# Intento 1

my_list = [9, 45, 77, 23, 1, 0, 66]

print("Imprime una lista")

for element in my_list:
print(element)

my_tupla = ("Jonathan", "Acevedo", 20, 1.68)

print("Imprime una tupla")
for element in my_tupla:
print(element)

my_set = {"Jonathan", "Acevedo", 20, 1.68}

print("Imprime un set")
for element in my_set:
print(element)
my_dict = {"Nombre": "Jonathan",
"Apellido": "Acevedo",
"Edad": 20,
"Altura": 1.68}

print("Imprime un diccionario (claves)")

for element in my_dict:
print(element)

print("Imprime un diccionario (Valores)")

for element in my_dict.values():
print(element)

# Intento 2

print("Imprime un diccionario (Valores)")

for element in my_dict.values():
print(element)
if element == "Edad":
break
else:
print("Se acabo el bucle For")

print("Imprime un diccionario (claves)")

for element in my_dict:
print(element)
if element == "Edad":
break

# Intento 3

numero = 5

for i in range(0, 11):

resultado = numero * i
print(f"{numero} * {i} = {resultado}")

FUNCIONES
una función es un bloque de código reutilizable que se define con un nombre y puede tomar uno o
más argumentos como entrada, realizar un conjunto de operaciones y devolver un resultado
opcional. Las funciones son una forma eficiente de organizar y reutilizar el código, ya que permiten
agrupar un conjunto de instrucciones en una sola entidad lógica.

Las funciones en Python se definen utilizando la palabra clave def, seguida del nombre de la función
y paréntesis que pueden contener los argumentos de la función. Aquí tienes la sintaxis básica de una
función en Python:

def nombre_de_la_funcion(argumentos):
# bloque de código
# operaciones
return resultado # opcional

Donde:

 Nombre_de_la_funcion: es el nombre que le das a tu función. Debes elegir un nombre

descriptivo y que siga las convenciones de nombrado de Python (por ejemplo, en minúsculas
y separado por guiones bajos si es necesario).

 Argumentos: son los valores de entrada que la función puede recibir. Pueden ser cero o más
argumentos separados por comas. Estos argumentos son opcionales, es decir, una función
puede no tener argumentos si no los necesita.

 El bloque de código es el conjunto de instrucciones que se ejecutan cuando la función es

llamada.

 Return: es una palabra clave opcional que se utiliza para devolver un resultado o valor
calculado por la función. Una función puede tener múltiples declaraciones de retorno, pero
solo se ejecutará la primera vez que se encuentre.

Una vez que has definido una función, puedes llamarla o invocarla en cualquier parte de tu
programa para ejecutar el código dentro de ella. Para llamar a una función, simplemente utilizas el
nombre de la función seguido de paréntesis, pasando los valores de los argumentos si es necesario.

## FUNCIONES ##

# Intento 1

def my_function():
print("Hola Mundo")

my_function()

# Intento 2

def suma(number_1, numerber_2):

print(number_1 + numerber_2)

suma(5, 4)
# Intento 3

def div(number_1, number_2):

return number_1 / number_2

Total = div(10, 2)
print(Total)

def divi(number_1, number_2):

resultado = number_1 / number_2
return resultado

Total = divi(20, 2)
print(Total)

# Intento 4 valores por defecto

def my_introduction(name, lastname, nickname="Sin apodo"):

print(f"{name} {lastname} tiene como apodo {nickname}")

my_introduction("Jonathan", "Acevedo")
my_introduction("Jonathan", "Acevedo", "Jona")

# Intento 5 Función que imprime un texto

def my_text(text):
print(text)

my_text("Hola mundo")

# Intento 5 Función que imprime varios textos usando *

def my_texto(*text):
print(text)

my_texto("Hola mundo", "soy Jonathan", "y tengo", 20, "Años")

CLASES
las clases son estructuras fundamentales de la programación orientada a objetos (POO). Una clase es
un tipo de dato personalizado que te permite definir atributos y métodos relacionados en un solo
objeto. Puedes pensar en una clase como un plano o una plantilla para crear objetos específicos.

Las clases en Python se definen utilizando la palabra clave class, seguida del nombre de la clase (que
generalmente se escribe en CamelCase).

Dentro de una clase, puedes definir atributos, que son variables asociadas a la clase, y métodos, que
son funciones definidas en la clase. Los atributos y métodos encapsulan datos y comportamientos
específicos de la clase.

Por ejemplo, podrías tener una clase llamada Perro que tenga atributos como nombre, edad y raza, y
métodos como ladrar() y correr(). Puedes crear objetos o instancias de una clase utilizando su
constructor, que es una función especial llamada __init__() en Python.

## CLASS ##
# El pass sirve para dejar una clase vacía

class MyEmptyperson:
pass

# def __init__(self) Es la forma de hacer un constructor que tendrá valores

asociados que se van a recibir

# Intento 1 con atributos

class Person:
def __init__(self, name, lastname, age):
self.name = name
self.lastname = lastname
self.age = age

my_person = Person("Jonathan", "Acevedo", 20)

print(my_person.name)
print(my_person.lastname)
print(my_person.age)
print(
f"El nombre del cliente es: {my_person.name} {my_person.lastname} de
{my_person.age} años")

# Intento 2 con atributos

class Pets:
def __init__(self, name, lastname, age, race, owner):
self.full_name = f"Nombre de la mascota: {name} {lastname}, edad:
{age}, raza: {race} y el propietario es {owner}"
my_pet = Pets("Paco", "Acevedo", 7, "Pincher", "Jonathan Acevedo")
print(my_pet.full_name)
# Intento 3 con atributos y funciones o metodos

class Employee:
def __init__(self, name="", second_name="", lastname_one="",
lastname_two="", employment="", salary=0):
self.full_name = f"{name} {second_name} {lastname_one} {lastname_two}"
self.name = name
self.second_name = second_name
self.lastname_one = lastname_one
self.lastname_two = lastname_two
self.employment = employment
self.salary = salary

def salario_semestral(self):
total = self.salary * 6
return total

def salario_anual(self):
return self.salary * 12

employee_1 = Employee("Jonathan", "Estiben", "Acevedo",

"López", "Gerente de proyecto", 30500000)

print(employee_1.full_name)
print(employee_1.salario_semestral())
print(employee_1.salario_anual())

employee_2 = Employee("Johan", "stiven", "Cifuentes",

"", "Gerente de proyecto", 29900000)

print(employee_2.full_name)
print(employee_2.salario_semestral())
print(employee_2.salario_anual())

EXEPCIONES

Una excepción es un evento que ocurre durante la ejecución de un programa y que interrumpe el
flujo normal de ejecución. Las excepciones se utilizan para manejar situaciones de error o eventos
inesperados que pueden ocurrir durante la ejecución de un programa.

Cuando ocurre una excepción, se lanza un objeto de excepción que contiene información sobre el
tipo de excepción y el lugar donde ocurrió. Si no se maneja adecuadamente, la excepción puede
hacer que el programa se detenga y se muestre un mensaje de error.
En Python, las excepciones se manejan utilizando bloques de código try-except. Dentro del bloque
try se coloca el código que puede generar una excepción, y dentro del bloque except se coloca el
código que se ejecutará si se produce una excepción. El bloque except puede especificar el tipo de
excepción que se va a manejar o puede manejar múltiples tipos de excepciones.

try:
# Código que puede generar una excepción
resultado = 10 / 0 # División por cero, generará una excepción
ZeroDivisionError
except ZeroDivisionError:
# Código que se ejecuta si se produce una excepción ZeroDivisionError
print("Error: División por cero.")

En este ejemplo, si se produce una excepción ZeroDivisionError durante la ejecución de la división,

se ejecutará el bloque except y se imprimirá un mensaje de error.

## EXEPCIONES ##

number_one = 19
# number_two = 1
number_two = "1"

# try - except

try:
print(number_one + number_two)
print("Sin error")
except:
# Se ejecuta si se produce una exepción
print("ERROR DE COHERENCIA")

# try - except - else

try:
print(number_one + number_two)
 print("Sin error")
except:
print("ERROR DE COHERENCIA")
else:
# Se ejecuta si no produce una exepción
print("SIGUE CORRECTAMENTE")
# try - except - else - finaly

try:
print(number_one + number_two)
print("Sin error")
except:
print("ERROR DE COHERENCIA")
else: # Opcional
# Se ejecuta si no produce una exepción
print("SIGUE CORRECTAMENTE")
finally: # Opcional
# Se ejecuta siempre
print("SIGUE CORRECTAMENTE SIN PROBLEMAS")

# EXEPCIONES POR TIPO (type) (Para errores muy especificos)

try:
print(number_one + number_two)
print("Sin error")
except TypeError:
# Se ejecuta si se produce una exepción
print("ERROR DE COHERENCIA POR TYPE")

# EXEPCIONES POR VALOR (values) (Para errores muy especificos)

try:
print(number_one + number_two)
print("Sin error")
except TypeError:
# Se ejecuta si se produce una exepción
print("ERROR DE COHERENCIA POR TYPE")
except ValueError:
# Se ejecuta si se produce una exepción
print("ERROR DE COHERENCIA POR VALUES")

# CAPTURA DE LA INFORMACIÓN DE LA EXEPCIÓN

try:
print(number_one + number_two)
print("Sin error")
except ValueError as error:
# Se ejecuta si se produce una exepción
 print(error)
except Exception as exepcition_error: #CON Exception TOMARA CUALQUIER ERROR
NO ESPECIFICADO (exepción generica)
# Se ejecuta si se produce una exepción
print(exepcition_error)

print("HOLA MUNDOO")

MÓDULOS

Un módulo es un archivo que contiene definiciones y declaraciones de Python, como funciones,

clases y variables, que se pueden reutilizar en otros programas. Los módulos se utilizan para
organizar y estructurar el código de manera modular, lo que facilita la reutilización y el
mantenimiento del código.

Un módulo en Python puede ser creado por el propio programador o puede ser un módulo
predefinido proporcionado por la biblioteca estándar de Python o por terceros. Los módulos
predefinidos incluyen una amplia gama de funcionalidades, como operaciones matemáticas, manejo
de archivos, acceso a bases de datos, procesamiento de cadenas, entre otros.

Para utilizar un módulo en Python, primero debe importarse en el programa. Esto se puede hacer
mediante la declaración import. Por ejemplo, para importar el módulo math, que proporciona
funciones matemáticas, se puede hacer de la siguiente manera:

import math

# Uso de una función del módulo math

resultado = math.sqrt(25)
print(resultado) # Imprime 5.0

También es posible importar solo funciones específicas o darles un alias utilizando la declaración
from import. Por ejemplo:

from math import sqrt

# Uso directo de la función importada

resultado = sqrt(25)
print(resultado) # Imprime 5.0

Además de los módulos predefinidos, también es posible crear y utilizar módulos propios. Para
hacerlo, simplemente se crea un archivo Python con las definiciones y declaraciones deseadas, y
luego se puede importar y utilizar en otros programas.
 SE CREA UN FICHERO.PY CON
FUNCIONES DE OPERACIONES DE:
+, -, * Y /.

SE IMPORTA EL FICHERO
ModuloHerramienta y uso las
funciones ya creadas.

## MODULES ##

import ModuloHerramienta # Importar todas las funciones

from Funciones import my_introduction # Importar funciones especificas

ModuloHerramienta.suma(20, 27)
ModuloHerramienta.resta(10, 5)
ModuloHerramienta.multiplication(5, 5)
ModuloHerramienta.div(10, 2)

my_introduction("Kira", "Acevedo")
# MODULOS CREADOR POR EL SISTEMA

import math

print(math.pi)
print(math.pow(3, 2))

# DARLE UN ALIAS A UNA FUNCION QUE SE IMPORTE

from math import pi as valor_de_pi

print(valor_de_pi)