#00 - Python

Roadmap/00 - SINTAXIS, VARIABLES, TIPOS DE DATOS Y HOLA MUNDO/python/ainaragmt.py

@@ -0,0 +1,24 @@
+# https://www.python.org/
+
+# Comentario en una línea
+
+"""
+Comentario en
+varias líneas
+"""
+
+'''
+Esto también es un
+comentario en
+varias líneas
+'''
+
+my_str = "variable"
+my_int = 0
+my_float = 3.14
+my_bool = True
+
+MY_CONSTANT = "constant" # Variable en mayúsculas = constante
+
+language = "Python"
+print("¡Hola, " + language + "!")

Roadmap/01 - OPERADORES Y ESTRUCTURAS DE CONTROL/python/ainaragmt.py

@@ -0,0 +1,110 @@
+# Operadores aritméticos
+print("\nOperadores aritméticos")
+print(f"Suma: 2 + 3 = {2 + 3}")
+print(f"Resta: 2 - 3 = {2 - 3}")
+print(f"Multiplicación: 2 * 3 = {2 * 3}")
+print(f"División: 2 / 3 = {2 / 3}")
+print(f"Módulo: 2 % 3 = {2 % 3}") # Resto de la división
+print(f"Exponente: 2 ** 3 = {2 ** 3}")
+print(f"División entera: 2 // 3 = {2 // 3}") # División truncada
+
+# Operadores lógicos
+print("\nOperadores lógicos")
+print(f"AND: 2 + 3 == 4 & 2 + 3 == 5 es {2 + 3 == 4 & 2 + 3 == 5}") # & o and
+print(f"OR: 2 + 3 == 4 | 2 + 3 == 5 es {2 + 3 == 4 | 2 + 3 == 5}") # | o or
+print(f"NOT: 2 + 3 == 4 es {not 2 + 3 == 4}")
+
+# Operadores de comparación
+print("\nOperadores de comparación")
+print(f"Igualdad: 2 == 3 es {2 == 3}")
+print(f"Desigualdad: 2 != 3 es {2 != 3}")
+print(f"Mayor que: 2 > 3 es {2 > 3}")
+print(f"Menor que: 2 < 3 es {2 < 3}")
+print(f"Mayor igual que: 2 >= 3 es {2 >= 3}")
+print(f"Menor igual que: 2 <= 3 es {2 <= 3}")
+
+# Operadores de asignación
+print("\nOperadores de asignación")
+my_int = 17 # asignación
+print(my_int)
+my_int += 1 # suma y asignación
+print(my_int)
+my_int -= 1 # resta y asignación
+print(my_int)
+my_int *= 2 # multiplicación y asignación
+print(my_int)
+my_int /= 2 # división y asignación
+print(my_int)
+my_int %= 2 # módulo y asignación
+print(my_int)
+my_int **= 1 # exponente y asignación
+print(my_int)
+my_int //= 1 # división entera y asignación
+print(my_int)
+
+# Operadores de identidad (comparan la posición de memoria)
+print("\nOperadores de identidad")
+my_new_int = 1.0
+print(f"my_int es my_new_int? {my_int is my_new_int}")
+my_int = my_new_int
+print(f"my_int es my_new_int? {my_int is my_new_int}")
+
+# Operadores de pertenecia
+print("\nOperadores de pertenencia")
+print(f"'a' está en 'ainara'? {'a' in 'ainara'}")
+print(f"'a' está en 'ainara'? {'a' not in 'ainara'}")
+
+# Operadores de bits
+print("\nOperadores de bits")
+a = 10 # 1010
+b = 3 # 0011
+print(f"AND: 10 & 3 = {a & b}")
+print(f"OR: 10 | 3 = {a | b}")
+print(f"XOR: 10 ^ 3 = {a ^ b}")
+print(f"NOT: ~ 10 = {~ a}")
+print(f"Shift right: 10 >> 1 = {10 >> 1}")
+print(f"Shift left: 10 << 1 = {10 << 1}")
+
+# Estructuras condicionales
+print("\nEstructuras condicionales")
+a = 10
+b = 3
+if (a == b):
+    print("a == b")
+elif (a == 10):
+    print("a == 10")
+else:
+    print("a != b")
+
+# Estructuras iterativas
+print("\nEstructuras iterativas")
+for i in range (5):
+    print("i: ", i) # hace el i++ por defecto
+
+j = 5
+while j > 2:
+    j -= 1
+    print("j: ", j)
+
+# Excepciones
+print("\nExcepciones")
+try:
+    print(3 / 1)
+    print(5 / 0)
+    print(2 / 1) # no se llega a ejecutar porque salta la excepción
+except:
+    print("No se puede dividir entre 0")
+finally:
+    print("Ha finalizado el manejo de excepciones") # se ejecuta tanto si se produce algún error como si no
+
+'''
+Crea un programa que imprima por consola todos los números comprendidos
+entre 10 y 55 (incluidos), pares, y que no son ni el 16 ni múltiplos de 3.
+'''
+print("\nEjercicio de dificultad extra")
+a = 10
+while a <= 55:
+    if (a != 16 and (a % 3) != 0):
+        if (a % 2) == 0:
+            print(a)
+    a+=1

Roadmap/02 - FUNCIONES Y ALCANCE/python/ainaragmt.py

@@ -0,0 +1,124 @@
+# Función simple
+print("\nFunción simple")
+def greet():
+    print("Hello!")
+
+greet()
+
+# Función con retorno
+print("\nFunción con retorno")
+def greet_return():
+    return "Hello with return!"
+
+args = greet_return()
+print(args) # or print(greet_return())
+
+# Función con argumento
+print("\nFunción con argumento")
+def greet_args(args):
+    print(args)
+
+greet_args("Hello with args!")
+
+# Función con argumento definido
+print("\nFunción con argumento definido")
+def greet_args_default(args = "Hello with default args!"):
+    print(args)
+
+greet_args_default()
+greet_args_default("Hello again.")
+
+# Función con argumento y retorno
+print("\nFunción con argumento y retorno")
+def greet_args_return(args):
+    return "Hello with args and return, "+ args + "!"
+
+print(greet_args_return("Python"))
+
+# Función con retorno de varios valores
+print("\nFunción con retorno de varios valores")
+def greet_multiple_return():
+    return "Hello ", "with ", "multiple ", "return!"
+
+a, b, c, d = greet_multiple_return()
+print(a + b + c + d)
+
+# Función con número variable de argumentos
+print("\nFunción con número variable de argumentos")
+def greet_variable_args(*args):
+    for name in args:
+        print(f"Hello {name}")
+
+greet_variable_args("Python ", "C ", "Java ")
+
+# Función con número variable de argumentos con palabra clave
+print("\nFunción con número variable de argumentos con palabra clave")
+def greet_variable_args_key(**args):
+    for key, name in args.items():
+        print(f"Hello {name} ({key})")
+
+greet_variable_args_key(language1 = "Python", language2 = "C", language3 = "Java")
+
+# Funciones dentro de funciones
+print("\nFunciones dentro de funciones")
+def outer_function():
+    print("I'm in the outer function.")
+    def inner_function():
+        print("I'm in the inner function.")
+    inner_function() # Sin está llamada inner_function no se ejecuta
+
+outer_function()
+
+# Funciones built-in
+print("\nFunciones built-in")
+print(len("Hello")) # length
+print(type("Hello")) # class
+print("Hello".upper()) # uppercase
+print(int("10")) # convert to int
+print(max([1, 5, 3]))
+print(round(3.14159, 2)) # round with 2 decimals
+print(list(range(5))) # list from 0 to 4
+print(ord('A')) # char to unicode
+print(chr(65)) # unicode to char
+print(list("Hello")) # ['H', 'e', 'l', 'l', 'o']
+print(set([1, 2, 2, 3])) # {1, 2, 3}: deletes repeated numbers
+
+# Variables locales y globales
+print("\nVariables locales y globales")
+
+global_variable = "Global variable" # outside of the function
+
+def local():
+    local_variable = "Local variable"
+
+def hello_python():
+    print("Hello " + global_variable.lower())
+    # print("Hello " + local_variable.lower()) # error: cannot be accessed from outside the function
+
+hello_python()
+
+'''
+Crea una función que reciba dos parámetros de tipo cadena de texto y retorne un número.
+ * - La función imprime todos los números del 1 al 100. Teniendo en cuenta que:
+ *   - Si el número es múltiplo de 3, muestra la cadena de texto del primer parámetro.
+ *   - Si el número es múltiplo de 5, muestra la cadena de texto del segundo parámetro.
+ *   - Si el número es múltiplo de 3 y de 5, muestra las dos cadenas de texto concatenadas.
+ *   - La función retorna el número de veces que se ha impreso el número en lugar de los textos.
+'''
+print("\nEjercicio de dificultad extra")
+
+def funct(param1,param2):
+    number = 0
+    for i in range(1, 101):
+        if i % 3 == 0 and i % 5 == 0:
+            print(param1+param2)
+        elif i % 3 == 0:
+            print(param1)
+        elif i % 5 == 0:
+            print(param2)
+        else:
+            print(i)
+            number += 1
+    return number
+
+print(funct("tres","cinco"))