diff --git a/Roadmap/12 - JSON Y XML/python/any7dev.py b/Roadmap/12 - JSON Y XML/python/any7dev.py
new file mode 100644
index 0000000000..5ae3d2fb50
--- /dev/null
+++ b/Roadmap/12 - JSON Y XML/python/any7dev.py	
@@ -0,0 +1,66 @@
+""" /*
+ * IMPORTANTE: Sólo debes subir el fichero de código como parte del ejercicio.
+ * 
+ * EJERCICIO:
+ * Desarrolla un programa capaz de crear un archivo XML y JSON que guarde los
+ * siguientes datos (haciendo uso de la sintaxis correcta en cada caso):
+ * - Nombre
+ * - Edad
+ * - Fecha de nacimiento
+ * - Listado de lenguajes de programación
+ * Muestra el contenido de los archivos.
+ * Borra los archivos.
+ *
+ * DIFICULTAD EXTRA (opcional):
+ * Utilizando la lógica de creación de los archivos anteriores, crea un
+ * programa capaz de leer y transformar en una misma clase custom de tu 
+ * lenguaje los datos almacenados en el XML y el JSON.
+ * Borra los archivos.
+ */ """
+
+#EJERCICIO
+import json
+import xml.etree.ElementTree as ET
+import os
+
+#JSON
+contenido = {
+    "Nombre": "Ana",
+    "Edad": 36,
+    "Fecha Nacimiento": "11/03/1988",
+    "Lenguajes": ["Cobol", "Python"]
+}
+
+with open ("archivo.json", 'w') as archivo:
+    json.dump(contenido, archivo, indent=3)
+
+with open ("archivo.json", 'r') as archivo:
+    print(json.load(archivo))
+
+os.remove("archivo.json")
+
+#XML
+archivo = "archivo.xml"
+
+#Creamos el árbol con los datos
+contenido = ET.Element("contenido")
+datos = ET.SubElement(contenido, "datos")
+ET.SubElement(datos, "Nombre").text = "Ana"
+ET.SubElement(datos, "Edad").text = "36"
+ET.SubElement(datos, "Fecha_Nacimiento").text = "11/03/1988"
+ET.SubElement(datos, "Lenguajes").text = "Cobol, Python"
+
+#Creamos el fichero
+ET.indent(contenido)
+et = ET.ElementTree(contenido)
+et.write(archivo, xml_declaration=True, encoding="UTF-8")
+
+with open (archivo, 'r') as a:
+    print(a.read())
+
+os.remove("archivo.xml")
+
+
+
+
+
diff --git a/Roadmap/13 - PRUEBAS UNITARIAS/python/any7dev.py b/Roadmap/13 - PRUEBAS UNITARIAS/python/any7dev.py
new file mode 100644
index 0000000000..650dbf9678
--- /dev/null
+++ b/Roadmap/13 - PRUEBAS UNITARIAS/python/any7dev.py	
@@ -0,0 +1,29 @@
+""" /*
+* EJERCICIO:
+* Crea una función que se encargue de sumar dos números y retornar
+* su resultado.
+* Crea un test, utilizando las herramientas de tu lenguaje, que sea
+* capaz de determinar si esa función se ejecuta correctamente.
+*
+* DIFICULTAD EXTRA (opcional):
+* Crea un diccionario con las siguientes claves y valores:
+* "name": "Tu nombre"
+* "age": "Tu edad"
+* "birth_date": "Tu fecha de nacimiento"
+* "programming_languages": ["Listado de lenguajes de programación"]
+* Crea dos test:
+* - Un primero que determine que existen todos los campos.
+* - Un segundo que determine que los datos introducidos son correctos.
+*/ """
+
+#EJERCICIO
+import unittest
+from assertpy import assert_that
+
+def suma (num1, num2):
+    return num1+num2
+
+class TestSuma(unittest.TestCase):
+    def test(self):
+        resultado = suma (2, 3)
+        assert_that(resultado).is_instance_of(int)
\ No newline at end of file
diff --git a/Roadmap/14 - FECHAS/python/any7dev.py b/Roadmap/14 - FECHAS/python/any7dev.py
new file mode 100644
index 0000000000..556b62be38
--- /dev/null
+++ b/Roadmap/14 - FECHAS/python/any7dev.py	
@@ -0,0 +1,37 @@
+""" /*
+ * EJERCICIO:
+ * Crea dos variables utilizando los objetos fecha (date, o semejante) de tu lenguaje:
+ * - Una primera que represente la fecha (día, mes, año, hora, minuto, segundo) actual.
+ * - Una segunda que represente tu fecha de nacimiento (te puedes inventar la hora).
+ * Calcula cuántos años han transcurrido entre ambas fechas.
+ *
+ * DIFICULTAD EXTRA (opcional):
+ * Utilizando la fecha de tu cumpleaños, formatéala y muestra su resultado de
+ * 10 maneras diferentes. Por ejemplo:
+ * - Día, mes y año.
+ * - Hora, minuto y segundo.
+ * - Día de año.
+ * - Día de la semana.
+ * - Nombre del mes.
+ * (lo que se te ocurra...)
+ */ """
+
+#EJERCICIO
+import datetime 
+
+fecha_actual = datetime.datetime.now()
+fecha_nacimiento = datetime.datetime(1988, 3, 11, 15, 0, 0)
+print(fecha_actual.year - fecha_nacimiento.year)
+
+#DIFICULTAD EXTRA
+print(fecha_nacimiento.strftime("%d-%m-%y")) #1
+print(fecha_nacimiento.strftime("%H:%M:%S")) #2
+print(fecha_nacimiento.timetuple()[7])#3
+print(fecha_nacimiento.isoweekday())#4
+print(fecha_nacimiento.strftime("%B"))#5
+print(fecha_nacimiento.ctime())#6
+print(fecha_nacimiento.strftime("%A, %d. %B %Y %I:%M%p"))#7
+print(fecha_nacimiento.isocalendar()[1]) #8 Número de la semana
+print(fecha_nacimiento.strftime("%d %m %Y")) #9
+print(fecha_nacimiento.toordinal())#10 Ordinal gregoriano proléptico de la fecha
+
diff --git "a/Roadmap/15 - ASINCRON\303\215A/python/any7dev.py" "b/Roadmap/15 - ASINCRON\303\215A/python/any7dev.py"
new file mode 100644
index 0000000000..d2dc238fb4
--- /dev/null
+++ "b/Roadmap/15 - ASINCRON\303\215A/python/any7dev.py"	
@@ -0,0 +1,57 @@
+""" /*
+ * 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.
+ *
+ * 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.
+ */ """
+
+#EJERCICIO
+import asyncio
+import time
+
+async def funcion_asincrona(segundos):
+    nombre = "Hola Mundo asíncrono"
+    print(nombre)
+    print(time.strftime("%H:%M:%S"))
+    print(segundos)
+    await asyncio.sleep(segundos)    
+    print(time.strftime("%H:%M:%S"))
+
+asyncio.run(funcion_asincrona(3))
+
+#DIFICULTAD EXTRA
+async def funcion_a():
+    print("Soy la función A")
+    await asyncio.sleep(1)
+
+async def funcion_b():
+    print("Soy la función B")
+    await asyncio.sleep(2)
+
+async def funcion_c():
+    print("Soy la función C")
+    await asyncio.sleep(3)
+
+async def funcion_d():
+    print("Soy la función D")
+    await asyncio.sleep(1)
+
+async def extra():
+    await asyncio.gather(funcion_a(), funcion_b(), funcion_c())
+    await funcion_d()
+    
+
+asyncio.run(extra())
diff --git a/Roadmap/16 - EXPRESIONES REGULARES/python/any7dev.py b/Roadmap/16 - EXPRESIONES REGULARES/python/any7dev.py
new file mode 100644
index 0000000000..5aaf75a8a7
--- /dev/null
+++ b/Roadmap/16 - EXPRESIONES REGULARES/python/any7dev.py	
@@ -0,0 +1,108 @@
+""" /*
+ * 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.
+ *
+ * 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.
+ */ """
+
+#EJERCICIO
+import re
+
+texto = ("La sociedad francesa estaba dividida en estamentos dependiendo de sus clases sociales",
+        "el poder mas alto lo tenía el rey, detrás estaban la nobleza y el clero y el nivel mas bajo de poder", 
+        "lo tenia el tercer estado que estaba constituido por la burguesía, los artesanos y los campesinos.", 
+        "Los Estados Generales eran una asamblea, compuesta por tres ordenes separados: el clero, la nobleza y el grupo formado", 
+        "por burguesía y campesinado. Este último orden se conoce como el tercer estadeo, término que usaremos para referirnos", 
+        "a él en lo sucesivo. Dicha asamblea se había citado por ultima vez en 1614 y el dramatismo de la situación obligó al", 
+        "gobierno a convocarla nuevamente.",
+        "Luis XVI cedió a las presiones de la reina María Antonieta y del conde de Artois y dio instrucciones para que varios", 
+        "regimientos extranjeros leales se concentraran en París y Versailles. Al mismo tiempo, Necker fue nuevamente destituido.", 
+        "El pueblo de París respondió con la insurrección ante estos actos de provocación; los disturbios comenzaron el 12 de julio", 
+        "y las multitudes asaltaron y tomaron La Bastilla -una prisión real que simbolizaba el despotismo de los Borbones- el 14", 
+        "de julio.",
+        "El 5 de octubre de 1789, las mujeres parisinas partieron desde los barrios obreros hacia la residencia real de Versailles,", 
+        "este suceso dió comienzo a la revolución.", 
+        "A fines de 1792 comenzó el proceso de Convención contra Luis XVI, quien fue juzgado y condenado a la guillotina por mayoría",
+        "de votos. El 21 de enero de 1793, Luis subió al cadalso, inconmovible hasta el último momento en el sentimiento", 
+        "de su inocencia. La noticia de la muerte del rey produjo indignación en Inglaterra, la que despidió al embajador o",  
+        "representante francés. Francia contestó declarando la guerra a Inglaterra y a Holanda, su aliada.")
+
+patron1 = re.findall(r"\b(\d{1,})\b", str(texto))
+print(patron1)
+for match in re.finditer(r"\b(\d{1,})\b", str(texto)):
+    print(match.group())
+
+patron2 = re.findall("[0-9]", str(texto))
+print(patron2)
+
+#DIFICULTAD EXTRA
+email1 = "ana@ana.es"
+email2 = "-1.3@_dev.com"
+email3 = "12345"
+
+patron_email = r"\b[a-z0-9\"#$% &`*+-_.\/|\^\{\} ~]+[a-z0-9]@[a-z0-9-]+.[a-z]{2,}\b"  
+
+if re.match(patron_email, email1):
+    print(f"{email1} válido")
+else:
+    print(f"{email1} no válido")
+
+if re.match(patron_email, email2):
+    print(f"{email2} válido")
+else:
+    print(f"{email2} no válido")
+
+if re.match(patron_email, email3):
+    print(f"{email3} válido")
+else:
+    print(f"{email3} no válido")        
+
+tlf1 = "911203650"
+tlf2 = "541201459"
+tlf3 = "770777007"
+
+patron_tlf = r"\b[6-9]+[0-9]{8}\b"
+
+if re.match(patron_tlf,tlf1):
+    print(f"{tlf1} válido")
+else:
+    print(f"{tlf1} no válido")
+
+if re.match(patron_tlf,tlf2):
+    print(f"{tlf2} válido")
+else:
+    print(f"{tlf2} no válido")
+
+if re.match(patron_tlf,tlf3):
+    print(f"{tlf3} válido")
+else:
+    print(f"{tlf3} no válido")
+
+
+url1 = "http://www.hack.com"	
+url2 = "123.com"
+url3 = "hola_!3.es"
+
+patron_url = "(http|https|ftp):\/\/[w]{3}\.[a-z0-9]+\.[a-z0-9]{2,}"
+
+if re.match(patron_url,url1):
+    print(f"{url1} válida")
+else:
+    print(f"{url1} no válida")
+
+if re.match(patron_url,url2):
+    print(f"{url2} válido")
+else:
+    print(f"{url2} no válida")
+
+if re.match(patron_url,url3):
+    print(f"{url3} válida")
+else:
+    print(f"{url3} no válida")
+
diff --git a/Roadmap/17 - ITERACIONES/python/any7dev.py b/Roadmap/17 - ITERACIONES/python/any7dev.py
new file mode 100644
index 0000000000..9309ccd150
--- /dev/null
+++ b/Roadmap/17 - ITERACIONES/python/any7dev.py	
@@ -0,0 +1,76 @@
+""" /*
+ * EJERCICIO:
+ * Utilizando tu lenguaje, emplea 3 mecanismos diferentes para imprimir
+ * números del 1 al 10 mediante iteración.
+ *
+ * DIFICULTAD EXTRA (opcional):
+ * Escribe el mayor número de mecanismos que posea tu lenguaje
+ * para iterar valores. ¿Eres capaz de utilizar 5? ¿Y 10?
+ */ """
+
+#EJERCICIO
+for i in range(1, 11): #1
+    print(i)
+
+i = 1 
+while i<=10: #2
+    print(i)
+    i += 1
+
+lista_numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] #3
+for i in lista_numeros:
+    print(i)
+
+#DIFICULTAD EXTRA
+def iterar(numero):
+    if numero <= 10:
+        print(numero)
+        iterar(numero+1) #4
+
+iterar(1)
+
+for num in enumerate(lista_numeros): #5
+    print(num)
+
+zip_numeros = zip(lista_numeros) #6
+for num in zip_numeros:
+    print(num)
+
+dict_numeros = {"n1":1, "n2":2, "n3":3, "n4":4, "n5":5, "n6":6, "n7":7, "n8":8, "n9":9, "n10":10}
+for n, numero in dict_numeros.items(): #7
+    print(n, numero)
+
+def generador(n):
+    contador = 1
+    while contador <= n:
+        yield contador #8
+        contador += 1
+
+for numero in generador(10):
+    print(numero)
+
+mi_iterador = iter(lista_numeros) #9
+print(next(mi_iterador))
+print(next(mi_iterador))
+print(next(mi_iterador))
+print(next(mi_iterador))
+print(next(mi_iterador))
+print(next(mi_iterador))
+print(next(mi_iterador))
+print(next(mi_iterador))
+print(next(mi_iterador))
+print(next(mi_iterador))
+
+print([num for num in lista_numeros]) #10
+
+lista_numeros15= [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
+
+def menores(n):
+    return n <= 10
+
+lista_numeros15_filtrada = filter(menores, lista_numeros15) #11
+print(list(lista_numeros15_filtrada))
+
+suma_lista = map(lambda n: n + 0, lista_numeros) #12
+print(list(suma_lista))
+
diff --git a/Roadmap/18 - CONJUNTOS/python/any7dev.py b/Roadmap/18 - CONJUNTOS/python/any7dev.py
new file mode 100644
index 0000000000..09f954bf8d
--- /dev/null
+++ b/Roadmap/18 - CONJUNTOS/python/any7dev.py	
@@ -0,0 +1,56 @@
+""" /*
+ * EJERCICIO:
+ * Utilizando tu lenguaje crea un conjunto de datos y realiza las siguientes
+ * operaciones (debes utilizar una estructura que las soporte):
+ * - Añade un elemento al final.
+ * - Añade un elemento al principio.
+ * - Añade varios elementos en bloque al final.
+ * - Añade varios elementos en bloque en una posición concreta.
+ * - Elimina un elemento en una posición concreta.
+ * - Actualiza el valor de un elemento en una posición concreta.
+ * - Comprueba si un elemento está en un conjunto.
+ * - Elimina todo el contenido del conjunto.
+ *
+ * DIFICULTAD EXTRA (opcional):
+ * Muestra ejemplos de las siguientes operaciones con conjuntos:
+ * - Unión.
+ * - Intersección.
+ * - Diferencia.
+ * - Diferencia simétrica.
+ */ """
+
+#EJERCICIO
+lista = [2, 4, 7, 20, 23, 6] #Crear
+print(lista)
+
+lista.append(24) #Añadir al final
+print(lista)
+
+lista.insert(0, 1) #Añadir al principio
+print(lista)
+
+lista.extend([0, 3, 10]) #Añadir en bloque al final
+print(lista)
+
+lista[5:3] = [11, 50, 30] #Añade varios elementos en una posición concreta
+print(lista)
+
+lista.pop(7) #Elimina el elemento de la posición 6
+print(lista)
+
+lista[5] = 5 #Actualiza el valor del elemento en la posición 5
+print(lista)
+
+print(20 in lista) #Comprueba si 20 está en la lista
+
+lista.clear() #Elimina todo el contenido
+print(lista)
+
+#DIFICULTAD EXTRA
+conjunto1 = {2, 4, 7, 20, 23, 6, 0, 11}
+conjunto2 = {0, 3, 10, 11, 50, 30, 7, 4}
+
+print(conjunto1.union(conjunto2)) 
+print(conjunto1.intersection(conjunto2))
+print(conjunto1.difference(conjunto2))
+print(conjunto1.symmetric_difference(conjunto2))
\ No newline at end of file