Main

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

@@ -0,0 +1,34 @@
+# https://python.org
+
+# Comentario en una línea
+
+"""
+Esto también es
+un comentario
+en varias líneas
+"""
+
+'''
+Esto también es
+un comentario
+en varias líneas
+'''
+
+my_variable = "Mi variable"
+my_variable = "Nuevo valor de mi variable"
+
+MY_CONSTANT = "Mi constante"  # por convención
+
+my_int = 1
+my_float = 1.5
+my_bool = True
+my_bool = False
+my_string = "Mi cadena de texto"
+my_other_string = 'Mi otra cadena de texto'
+
+print("¡Hola, Python!")
+
+print(type(my_int))
+print(type(my_float))
+print(type(my_bool))
+print(type(my_string))

Roadmap/03 - ESTRUCTURAS DE DATOS/python/gringoam.py

@@ -0,0 +1,108 @@
+# Listas
+my_list: list = ["Brais", "Bl4ck", "Wolfy", "Visionos"]
+print(my_list)
+my_list.append("Castor")  # Inserción
+my_list.append("Castor")
+print(my_list)
+my_list.remove("Brais")  # Eliminación
+print(my_list)
+print(my_list[1])  # Acceso
+my_list[1] = "Cuervillo"  # Actualización
+print(my_list)
+my_list.sort()  # Ordenación
+print(my_list)
+print(type(my_list))
+
+# Tuplas
+my_tuple: tuple = ("Brais", "Moure", "@mouredev", "36")
+print(my_tuple[0])  # Acceso
+print(my_tuple[3])
+my_tuple = tuple(sorted(my_tuple))  # Ordenación
+print(my_tuple)
+print(type(my_tuple))
+
+# Sets
+my_set: set = {"Brais", "Moure", "@mouredev", "36"}
+print(my_set)
+my_set.add("mouredev@gmail.com")  # Inserción
+my_set.add("mouredev@gmail.com")
+print(my_set)
+my_set.remove("Moure")  # Eliminación
+print(my_set)
+my_set = set(sorted(my_set))  # No se puede ordenar
+print(my_set)
+print(type(my_set))
+
+# Diccionario
+my_dict: dict = {
+    "name": "Brais",
+    "surname": "Moure",
+    "alias": "@mouredev",
+    "age": "36"
+}
+my_dict["email"] = "mouredev@gmail.com"  # Inserción
+print(my_dict)
+del my_dict["surname"]  # Eliminación
+print(my_dict)
+print(my_dict["name"])  # Acceso
+my_dict["age"] = "37"  # Actualización
+print(my_dict)
+my_dict = dict(sorted(my_dict.items()))  # Ordenación
+print(my_dict)
+print(type(my_dict))
+
+"""
+Extra
+"""
+#Agenda
+
+agenda={}
+
+def insert_contact():
+    phone = input("Introduce el teléfono del contacto: ")
+    if phone.isdigit() and len(phone) > 0 and len(phone) <= 11:
+        agenda[nombre] = phone
+    else:
+        print(
+                "Debes introducir un número de teléfono un máximo de 11 dígitos.")
+
+
+
+while True:
+     print("Agenda:")
+     print("Ingrese operaci+on a realizar")
+     print("1) Aregar contacto.")
+     print("2) Borrar contacto.")
+     print("3) Buscar contacto.")
+     print("4) Actualizar contacto.")
+     print("5) Salir.")
+
+     op=input()
+     match op:
+        case "1":
+          nombre=input("Ingrese nombre del contacto: ")
+          insert_contact()
+        case "2":
+         nombre=input("Ingrese nombre del contacto: ")
+         if nombre in agenda:
+            del agenda[nombre]
+            print(f"El contacto {nombre} fue eliminado")
+         else:
+              print("El contacto no existe")
+        case "3":
+         nombre=input("Ingrese nombre del contacto: ")
+         if nombre in agenda:
+           print(f"Contacto  encontrado nombre: {nombre} teléfono: {agenda[nombre]} ")
+         else:
+              print("El contacto no existe")
+        case "4":
+         nombre=input("Ingrese nombre del contacto: ")  
+         if nombre in agenda:
+           insert_contact()
+         else:
+           print("El contacto no existe")  
+        case "5":
+          break
+
+print(agenda)
+

Roadmap/04 - CADENAS DE CARACTERES/python/gringoam.py

@@ -0,0 +1,107 @@
+"""
+Operaciones
+"""
+
+s1 = "Hola"
+s2 = "Python"
+
+# Concatenación
+print(s1 + ", " + s2 + "!")
+
+# Repetición
+print(s1 * 3)
+
+# Indexación
+print(s1[0] + s1[1] + s1[2] + s1[3])
+
+# Longitud
+print(len(s2))
+
+# Slicing (porción)
+print(s2[2:6])
+print(s2[2:])
+print(s2[0:2])
+print(s2[:2])
+
+# Busqueda
+print("a" in s1)
+print("i" in s1)
+
+# Reemplazo
+print(s1.replace("o", "a"))
+
+# División
+print(s2.split("t"))
+
+# Mayúsculas, minúsculas y letras en mayúsculas
+print(s1.upper())
+print(s1.lower())
+print("brais moure".title())
+print("brais moure".capitalize())
+
+# Eliminación de espacios al principio y al final
+print(" brais moure ".strip())
+
+# Búsqueda al principio y al final
+print(s1.startswith("Ho"))
+print(s1.startswith("Py"))
+print(s1.endswith("la"))
+print(s1.endswith("thon"))
+
+s3 = "Brais Moure @mouredev"
+
+# Búsqueda de posición
+print(s3.find("moure"))
+print(s3.find("Moure"))
+print(s3.find("M"))
+print(s3.lower().find("m"))
+
+# Búsqueda de ocurrencias
+print(s3.lower().count("m"))
+
+# Formateo
+print("Saludo: {}, lenguje: {}!".format(s1, s2))
+
+# Interpolación
+print(f"Saludo: {s1}, lenguje: {s2}!")
+
+# Tranformación en lista de caracteres
+print(list(s3))
+
+# Transformación de lista en cadena
+l1 = [s1, ", ", s2, "!"]
+print("".join(l1))
+
+# Transformaciones numéricas
+s4 = "123456"
+s4 = int(s4)
+print(s4)
+
+s5 = "123456.123"
+s5 = float(s5)
+print(s5)
+
+# Comprobaciones varias
+s4 = "123456"
+print(s1.isalnum())
+print(s1.isalpha())
+print(s4.isalpha())
+print(s4.isnumeric())
+
+"""Extra"""
+
+
+
+def check(palabra1:str, palabra2:str):
+    #Polindroma
+    print(f"{palabra1} es una palabra polindroma: {palabra1== palabra1[::-1]}")
+    print(f"{palabra2} es una palabra polindroma: {palabra2== palabra2[::-1]}")
+
+    #Anagramas
+    print(f"{palabra1} y {palabra2} son anagrama?: {palabra1== palabra1[::-1]}")
+
+    #
+
+
+check("radar", "ardar")
+

Roadmap/05 - VALOR Y REFERENCIA/python/gringoam.py

@@ -0,0 +1,94 @@
+"""
+Valor y referencia
+"""
+
+# Tipos de dato por valor
+
+my_int_a = 10
+my_int_b = my_int_a
+my_int_b = 20
+# my_int_a = 30
+print(my_int_a)
+print(my_int_b)
+
+# Tipos de dato por referencia
+
+my_list_a = [10, 20]
+my_list_b = my_list_a
+my_list_b.append(30)
+print(my_list_a)
+print(my_list_b)
+
+# Funciones con datos por valor
+
+
+def my_int_func(my_int: int):
+    my_int = 20
+    print(my_int)
+
+
+my_int_c = 10
+my_int_func(my_int_c)
+print(my_int_c)
+
+# Funciones con datos por referencia
+
+
+def my_list_func(my_list: list):
+    my_list.append(30)
+
+    my_list_d = my_list
+    my_list_d.append(40)
+
+    print(my_list)
+    print(my_list_d)
+
+
+my_list_c = [10, 20]
+my_list_func(my_list_c)
+print(my_list_c)
+
+"""
+Extra
+"""
+#Funcion de intercambio de valor con parametros por valor
+my_int_d=10
+my_int_e=20
+
+def intercambioValor(my_int_d:int, my_int_e:int):
+    aux=my_int_d
+    my_int_d= my_int_e
+    my_int_e= aux
+
+    return my_int_d, my_int_e
+
+print(f"Valores antes de intercambio\n{my_int_d}")
+print(my_int_e)
+
+
+
+my_int_f, my_int_g= intercambioValor(my_int_d, my_int_e)
+
+print(f"Valores después de intercambio\n{my_int_f}")
+print(my_int_g)
+
+#Funcion de intercambio de valor con parametros por valor
+
+
+my_list_d=[10, 20]
+my_list_e=[30, 40]
+
+def intercambioRef(my_int_d:list, my_int_e:list):
+    aux=my_int_d
+    my_int_d= my_int_e
+    my_int_e= aux
+
+    return my_int_d, my_int_e
+
+print(f"Valores antes de intercambio\n{my_list_d}")
+print(my_list_e)
+
+my_list_f, my_list_g= intercambioRef(my_list_d, my_list_e)
+
+print(f"Valores después de intercambio\n{my_list_f}")
+print(my_list_g)

Roadmap/06 - RECURSIVIDAD/python/gringoam.py

@@ -0,0 +1,44 @@
+"""
+Recurcividad
+"""
+
+def imp_del_1_al_100(num:int=0):
+    if num<100:
+        imp_del_1_al_100(num+1)
+    print(num)
+
+imp_del_1_al_100()
+
+
+"""
+Extra
+"""
+
+#Calcula el factorial de un numero
+
+def factorial(num:int) -> int:
+    aux=num
+    if num>1:
+        aux=aux*factorial(num-1)
+
+    else: 
+        aux=1
+    return aux
+
+
+numero= 4
+
+print(f"El de {numero} es:{factorial(numero)}")
+
+#El valor de una posición en la suseción de fibonachi
+
+def pos_en_fibonachi (pos: int)-> int:
+    if pos==1:
+        return 0
+    elif pos==2:
+        return 1
+    else:
+        return pos_en_fibonachi(pos-1)+ pos_en_fibonachi(pos-2)
+
+
+print(pos_en_fibonachi(8))