diff --git "a/Roadmap/15 - ASINCRON\303\215A/python/Gallitofast.py" "b/Roadmap/15 - ASINCRON\303\215A/python/Gallitofast.py"
new file mode 100644
index 0000000000..d6217be895
--- /dev/null
+++ "b/Roadmap/15 - ASINCRON\303\215A/python/Gallitofast.py"	
@@ -0,0 +1,58 @@
+#  * EJERCICIO:
+#  * Utilizando tu lenguaje, crea un programa capaz de ejecutar de manera
+#  * asíncrona una función que tardará en finalizar un número concreto de
+#  * segundos parametrizables. También debes poder asignarle un nombre.
+#  * La función imprime su nombre, cuándo empieza, el tiempo que durará
+#  * su ejecución y cuando finaliza.
+
+import asyncio
+from datetime import datetime
+async def funcion_asincronia():
+    print(f"Comenzando a la hora {datetime.now().strftime('%H:%M:%S')}")
+    await asyncio.sleep(2) #simulamos 2 segundos de espera
+    print(f"Finalizando a las {datetime.now().strftime('%H:%M:%S')}")
+
+asyncio.run(funcion_asincronia())
+
+print("-"*60)
+
+#  * DIFICULTAD EXTRA (opcional):
+#  * Utilizando el concepto de asincronía y la función anterior, crea
+#  * el siguiente programa que ejecuta en este orden:
+#  * - Una función C que dura 3 segundos.
+#  * - Una función B que dura 2 segundos.
+#  * - Una función A que dura 1 segundo.
+#  * - Una función D que dura 1 segundo.
+#  * - Las funciones C, B y A se ejecutan en paralelo.
+#  * - La función D comienza su ejecución cuando las 3 anteriores han
+#  *   finalizado.
+
+print("Dificultad extra\n")
+print(f"Las funciones se empezaran a ejecutar a las: {datetime.now().strftime('%H:%M:%S')}")
+async def funcion_c():
+    await asyncio.sleep(3)
+    return print(f"Funcion C termino a las: {datetime.now().strftime('%H:%M:%S')}")
+async def funcion_b():
+    await asyncio.sleep(2)
+    return print(f"Funcion B termino a las: {datetime.now().strftime('%H:%M:%S')}")
+
+async def funcion_a():
+    await asyncio.sleep(1)
+    return print(f"Funcion A termino a las: {datetime.now().strftime('%H:%M:%S')}")
+
+async def conjuncion():
+    task_a= asyncio.create_task(funcion_a())
+    task_b= asyncio.create_task(funcion_b())
+    task_c= asyncio.create_task(funcion_c())
+    await asyncio.gather(task_a,task_b,task_c)
+
+async def funcion_d():
+    await asyncio.sleep(1)
+    return print(f"Funcion D termino a las {datetime.now().strftime('%H:%M:%S')}")
+
+asyncio.run(conjuncion())
+asyncio.run(funcion_d())
+print("-"*60)
+
+
+
diff --git a/Roadmap/16 - EXPRESIONES REGULARES/python/Gallitofast.py b/Roadmap/16 - EXPRESIONES REGULARES/python/Gallitofast.py
new file mode 100644
index 0000000000..08e7a83046
--- /dev/null
+++ b/Roadmap/16 - EXPRESIONES REGULARES/python/Gallitofast.py	
@@ -0,0 +1,37 @@
+# * EJERCICIO:
+#  * Utilizando tu lenguaje, explora el concepto de expresiones regulares,
+#  * creando una que sea capaz de encontrar y extraer todos los números
+#  * de un texto.
+
+import re
+text=" Y esa fue la noche mas linda del mundo aunque nos durara tan solo 1 segundo"
+x_num=re.findall("[0,9]",text)
+print(text)
+print(f"Los numeros encontrados en el texto son: {x_num}")
+print("-"*60)
+
+# * DIFICULTAD EXTRA (opcional):
+#  * Crea 3 expresiones regulares (a tu criterio) capaces de:
+#  * - Validar un email.
+#  * - Validar un número de teléfono.
+#  * - Validar una url.
+recorreo=r"^[a-zA-Z0-9]*@[a-zA-Z0-9]*\.[a-z]{3}$"
+retelefono= r"^\+\d{2} \d{4} \d{6}$"
+reurl=r"^(https?://)?([a-z0-9]*\.)?[a-z0-9]*\.[a-z]{3}$"
+
+def validacion(correo,telefono,url):
+    if re.search(recorreo,correo):
+        print(f"Correo validado: {correo}")
+    else:
+        print(f"correo invalidado: {correo}")
+    if re.search(retelefono,telefono):
+        print(f"Numero de telefono validado: {telefono}")
+    else:
+        print(f"Numero de telefono invalidado: {telefono}")
+    if re.search(reurl,url):
+        print(f"Url validada: {url}")
+    else:
+        print(f"Url invalidada: {url}")
+
+validacion("Messigallito@gmail.com","+54 6324 695874","www.freecodecamp.com")
+    
diff --git a/Roadmap/17 - ITERACIONES/python/Gallitofast.py b/Roadmap/17 - ITERACIONES/python/Gallitofast.py
new file mode 100644
index 0000000000..ecef06ca70
--- /dev/null
+++ b/Roadmap/17 - ITERACIONES/python/Gallitofast.py	
@@ -0,0 +1,57 @@
+# * EJERCICIO:
+#  * Utilizando tu lenguaje, emplea 3 mecanismos diferentes para imprimir
+#  * números del 1 al 10 mediante iteración.
+#----------------------------------------------------------------------------
+print("-"*60)
+print("Ciclo for")
+for i in range (10):
+    print(i+1)
+print("-"*60)
+print("While")
+a=0
+while a<10:
+    print(a+1)
+    a+=1
+print("-"*60)
+print("For con lista")
+lista=[1,2,3,4,5,6,7,8,9,10]
+for item in lista:
+    print(item)
+
+# * DIFICULTAD EXTRA (opcional):
+#  * Escribe el mayor número de mecanismos que posea tu lenguaje
+#  * para iterar valores. ¿Eres capaz de utilizar 5? ¿Y 10?
+print("-"*60)
+print("1.-For")
+for i in range(5):
+    print("i+1")
+print("-"*60)
+print("2.-While")
+a=0
+while a<5:
+    print("a+1")
+    a+=1
+print("-"*60)
+print("3.-Iteracion de lista con for")
+for item in lista:
+    print(item)
+print("-"*60)
+print("4.-Recursividad")
+def recursifuncion(numero):
+    print(numero)
+    if numero>0:
+        numero-=1
+        recursifuncion(numero)
+    else:
+        print("Iteracion recursiva finalizada")
+
+recursifuncion(10)
+print("-"*60)
+
+for e in sorted(["G","a","l","l","o"]):
+    print(e)
+
+for i, e in enumerate(sorted(["G","a","l","l","o"])):
+    print(f"Índice: {i}, valor: {e}")
+
+