diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 00000000..923ad0b9
Binary files /dev/null and b/.DS_Store differ
diff --git a/.vscode/launch.json b/.vscode/launch.json
new file mode 100644
index 00000000..3d8a0ca8
--- /dev/null
+++ b/.vscode/launch.json
@@ -0,0 +1,7 @@
+{
+  // Use IntelliSense para saber los atributos posibles.
+  // Mantenga el puntero para ver las descripciones de los existentes atributos.
+  // Para más información, visite: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": []
+}
diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 00000000..35318b82
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,17 @@
+{
+  "npm.exclude": "",
+  "cSpell.words": [
+    "chrt",
+    "cockorocock",
+    "Fanta",
+    "Joseito",
+    "Josemi",
+    "mayusculas",
+    "Nestea",
+    "numeros",
+    "oinc",
+    "semaforo",
+    "sumalo",
+    "unico"
+  ]
+}
diff --git a/Basic/03_strings.py b/Basic/03_strings.py
index aca89f8a..9b1bb402 100644
--- a/Basic/03_strings.py
+++ b/Basic/03_strings.py
@@ -26,7 +26,7 @@
 print("Mi nombre es " + name + " " + surname + " y mi edad es " + str(age))
 print(f"Mi nombre es {name} {surname} y mi edad es {age}")
 
-# Desempaqueado de caracteres
+# Desempaquetado de caracteres
 
 language = "python"
 a, b, c, d, e, f = language
diff --git a/Basic/ARB_00_helloworld.py b/Basic/ARB_00_helloworld.py
new file mode 100644
index 00000000..5b33b1f0
--- /dev/null
+++ b/Basic/ARB_00_helloworld.py
@@ -0,0 +1,16 @@
+#Esto es un comentario.
+
+#Escribir por consola.
+print("¿Hola que haces?")
+
+"""
+Comentario en
+varias lineas.
+"""
+
+#Operación del sistema TYPE
+print(type("¿Hola que haces?")) # Nos dice de que tipo es lo escrito.
+print(type(5)) # Enteros.
+print(type(5.4)) # decimales tiene que ser con punto.
+
+print("concatenar sin espacios"", es seguro que se puede con el signo +")
\ No newline at end of file
diff --git a/Basic/ARB_00_helloworld_exercises.py b/Basic/ARB_00_helloworld_exercises.py
new file mode 100644
index 00000000..36204d59
--- /dev/null
+++ b/Basic/ARB_00_helloworld_exercises.py
@@ -0,0 +1,35 @@
+# 1.- Imprimir "¡Hola Mundo!" por consola.
+# 2.- Escribir un comentario de una sola linea explicando que hace el código del Ejercicio 1.
+print("\"¡Hola Mundo!\"") #Imprime "¡Hola Mundo" literalmente.
+
+# 3.- Imprime tu nombre y edad en la misma linea utilizando la función print.
+print("Antonio de 43 años.")
+
+# 4.- Usa la función type() para imprimir el tipo de dato de una cadena de texto, un numero entero y un numero decimal.
+print(type("Esto es un texto.")) # tipo texto (str)
+print(type(5)) # tipo entero (int)
+print(type(5.8)) #tipo decimal (float)
+
+# 5 .- Escribe un comentario en varias lineas explicando que son los tipos e datos en Python.
+"""
+Un tipo de dato hace referencia a la sintaxis que puede utilizar el código
+que se pueden clasificar en varios tipos según su funcionamiento, como por ejemplo si es texto, números, booleanos, fechas, entre otros.
+"""
+
+# 6 .- Imprime el resultado de concatenar dos cadenas de texto, por ejemplo: "Hola" y "Mundo".
+print("Hola""Mundo")
+print("Hola"+"Mundo2")
+
+# 7 .- Crea una variable para almacenar tu nombre, otra para tu edad, e imprime ambas en la misma línea.
+mi_nombre = "Antonio"
+mi_edad = 43
+print(mi_nombre, mi_edad)
+
+# 8 .- Escribe un programa que solicite al usuario su nombre y lo imprima junto con un saludo.
+print("Escribe tu nombre y pulsa \"Enter\"")
+tu_nombre = input()
+print("Hola", tu_nombre)
+
+#9 .- Usa print() para mostrar el resultado de la suma de dos números enteros y el tipo de dato resultante.
+#10 .- Comenta el código del ejercicio 9, y explica que hace cada linea usando comentarios de una sola linea.
+print(type(5+6)) #Imprime el tipo de dato del resultado de una suma.
\ No newline at end of file
diff --git a/Basic/ARB_01_variables_exercises.py b/Basic/ARB_01_variables_exercises.py
new file mode 100644
index 00000000..77c6c250
--- /dev/null
+++ b/Basic/ARB_01_variables_exercises.py
@@ -0,0 +1,58 @@
+# 1.- Declara y asigna valores a las siguientes variables:
+# 	name: una cadena que contenga tu nombre.
+# 	age: un número entero que represente tu edad.
+# 	height: un número flotante que represente tu altura.
+# 	Imprime cada variable en una li­nea separada.
+
+nombre = "Antonio"
+edad = 43
+altura = 1.70
+print(nombre)
+print(edad)
+print(altura)
+
+# 2 .- Convierte la variable edad de entero a cadena y concatena con un texto que diga cuantos años tienes.
+edad = str(edad)
+print(type(edad))
+print(nombre, "tu edad es:", edad+".")
+
+# 3 .- Declara una variable booleana is_student que indique si eres estudiante o no. Usa True o False según corresponda e imprimela.
+is_student = True
+print(is_student)
+
+# 4 .- Usa la función len() para calcular cuantos caracteres tiene tu nombre completo, almacenado en una variable.
+longitud = len(nombre)
+print(longitud)
+
+# 5 .- Declara tres variables en una sola lí­nea que representen tu nombre, apellido y ciudad de origen. Luego, imprime estos valores.
+primer_apellido = "Romero"
+segundo_apellido = "Bravo"
+ciudad = "Granada"
+print("Te llamas:", nombre, primer_apellido, segundo_apellido, "y vives en:", ciudad+".")
+
+# 6 .- Usa la función input() para solicitar al usuario su color favorito y almacenalo en una variable color. Luego, imprime el valor ingresado.
+print("¿Cual es tu color favorito?")
+su_color = input()
+print("Tu color favorito es el", su_color)
+
+# 7 .- Declara una variable fruit e inicializala con un valor. Luego, cambia el valor de la fruta a otro diferente y vuelve a imprimirla.
+fruit = "Manzana"
+print(fruit)
+fruit = "Se puede cambiar la fruta."
+print(fruit)
+
+# 8 .- Convierte un número decimal, almacenado en la variable price, a un número entero y luego imprimela.
+decimal = 8.6
+decimal = round(decimal, None)
+print(decimal)
+
+# 9 .- Declara una variable llamada address_len y almacena en ella la cantidad de caracteres de una dirección usando la función len(). Imprime el resultado.
+address_len = "Calle Lanzarote"
+address_len = len(address_len)
+print(address_len)
+
+# 10 .- Usa un tipo de dato forzado para declarar una variable phone, asegurándote de que siempre será un número. Luego, cambia su valor a un número diferente y verifica el tipo de la variable con type().
+phone: int = 958901858
+phone = "Python no es un lenguaje fuertemente tipado."
+print(phone)
+print(type(phone))
diff --git a/Basic/ARB_02_operators.py b/Basic/ARB_02_operators.py
new file mode 100644
index 00000000..75328e00
--- /dev/null
+++ b/Basic/ARB_02_operators.py
@@ -0,0 +1,9 @@
+
+
+#floor division, nos dará automáticamente el resultado más aproximado.
+print(10 // 3)
+
+#Operadores comparativos
+print(5 >= 6)
+
+#Operadores lógicos
\ No newline at end of file
diff --git a/Basic/ARB_02_operators_exercises.py b/Basic/ARB_02_operators_exercises.py
new file mode 100644
index 00000000..f7e5a35e
--- /dev/null
+++ b/Basic/ARB_02_operators_exercises.py
@@ -0,0 +1,45 @@
+# 1. Realiza las siguientes operaciones aritméticas:
+# •	Suma: 15 + 25
+print(15 + 25)
+# •	Resta: 50 - 22
+print(50 - 22)
+# •	Multiplicación: 8 * 7
+print(8 * 7)
+# •	División: 100 / 20      
+print("La division da:", 100 / 20)
+
+# 2. Calcula el resto de la división de 37 entre 5 y almacénalo en una variable remainder. Luego imprímelo.
+remainder = (37 & 5)
+print("El resto es:", remainder)
+
+# 3. Convierte el número 7 en una cadena de texto y concaténalo con la frase “ es mi número favorito”. Imprime el resultado.
+print(str(7) + " es mi numero favorito.")
+
+# 4. Repite la palabra “Python” 10 veces usando el operador de multiplicación para cadenas y luego imprímela.
+print("Python, " * 10)
+
+# 5. Crea dos variables: a y b con los valores 12 y 8 respectivamente. Compara si a es mayor que b y almacena el resultado en una variable booleana resultado. Imprime el valor de resultado.
+a = 12
+b = 8
+resultado = a > b
+print(resultado)
+
+# 6. Compara dos cadenas de texto (“apple” y “banana”) usando los operadores > y < y explica cuál tiene mayor orden alfabético.
+comp_mayor = "apple" > "banana"
+print(comp_mayor)
+comp_menor = "apple" < "banana"
+print(comp_menor)
+
+# 7. Realiza una comparación lógica usando and para verificar si el número 10 es mayor que 5 y menor que 20. Imprime el resultado.
+es_verdad = ((10 > 5) and (10 < 20))
+print(es_verdad, ", tiene que dar True si los dos son verdaderos.")
+
+# 8. Usa el operador or para verificar si el número 7 es menor que 3 o mayor que 5. Imprime el resultado.
+sera_verdad = ((7 < 3) or (7 > 5))
+print(sera_verdad, ", tiene que dar True si uno es verdadero.")
+
+# 9. Aplica el operador not para invertir el resultado de la comparación 15 > 20. ¿Cuál es el resultado?
+print(not(15 > 20), ", Da True porque invierte el resultado que es: False.")
+
+# 10. Combina operadores aritméticos y lógicos: Verifica si el número resultante de la expresión (5 * 3) + 2 es mayor que 10 y menor que 20. Imprime el resultado.
+print((((5 * 3) + 2) > 10) and (((5 * 3) + 2) < 20), ", Da True con el operador and")
\ No newline at end of file
diff --git a/Basic/ARB_03_strings_exercises.py b/Basic/ARB_03_strings_exercises.py
new file mode 100644
index 00000000..881801b8
--- /dev/null
+++ b/Basic/ARB_03_strings_exercises.py
@@ -0,0 +1,51 @@
+# 1. Declara una variable text con la frase “Aprendiendo Python” y luego imprime la longitud de la cadena usando len().
+text = "Aprendiendo Python"
+print(len(text))
+
+# 2. Concatena dos cadenas: “Hola” y “Python”, y muestra el resultado en una sola línea.
+print("Hola" + "Python")
+
+# 3. Crea una cadena que incluya un salto de línea, y luego imprímela para ver el resultado.
+print("Esta es mi \ncadena con salto \nde lineas.")
+
+# 4. Usa el formateo de cadenas con f-strings para imprimir tu nombre, apellido y edad en una cadena de texto.
+nombre, apellido, edad = "Antonio", "Romero", 43
+print(f"Hola, soy {nombre} {apellido} y tengo {edad} años.")
+
+# 5. Desempaqueta los caracteres de la palabra “Python” en variables separadas y luego imprímelos uno por uno.
+palabra = "Python"
+primera = palabra[0]
+print(primera)
+segunda = palabra[1]
+print(segunda)
+segunda = palabra[2]
+print(segunda)
+tercera = palabra[3]
+print(tercera)
+cuarta = palabra[4]
+print(cuarta)
+quinta = palabra[5]
+print(quinta)
+
+# 6. Extrae un “slice” de la palabra “Programación” para obtener los caracteres desde la posición 3 hasta la 7.
+extraer = "Programación"
+parte = extraer[3:7]
+print(parte)
+
+# 7. Invierte la cadena “Python” usando slicing y muestra el resultado.
+# Utilizo la variable (palabra) del ejercicio 5
+print(palabra[::-1])
+
+# 8. Convierte la cadena “aprendiendo python” en mayúsculas usando el método adecuado e imprímela.
+cadena = "aprendiendo python"
+print(cadena.upper())
+
+# 9. Cuenta cuántas veces aparece la letra “n” en la cadena “Programación en Python”.
+print(cadena.count("n"))
+print(cadena) #Compruebo que no se ha cambiado a mayúsculas.
+
+# 10. Verifica si la cadena “12345” es numérica usando el método adecuado e imprime el resultado.
+cadena_num = "12345"
+print(cadena_num.isdecimal())
+
+print("python".isnumeric())
\ No newline at end of file
diff --git a/Basic/ARB_04_lists_exercises.py b/Basic/ARB_04_lists_exercises.py
new file mode 100644
index 00000000..b2334717
--- /dev/null
+++ b/Basic/ARB_04_lists_exercises.py
@@ -0,0 +1,49 @@
+# 1. Crea una lista con los números del 1 al 5 e imprímela.
+lista_num = [1, 2, 3, 4, 5]
+print(lista_num)
+
+# 2. Accede e imprime el tercer elemento de la lista [10, 20, 30, 40, 50].
+lista_dos = [10, 20, 30, 40, 50]
+print("El tercer elemento es:", lista_dos[2])
+
+# 3. Agrega el número 6 al final de la lista [1, 2, 3, 4, 5] e imprímela.
+lista_num.append(6)
+print(lista_num)
+
+# 4. Inserta el número 15 en la posición 2 de la lista [10, 20, 30, 40, 50].
+lista_dos.insert(1, 15)
+print(lista_dos)
+
+# 5. Elimina el primer valor 30 de la lista [10, 20, 30, 30, 40, 50].
+lista_tres = [10, 20, 30, 30, 40, 50]
+lista_tres.remove(30)
+print(lista_tres)
+
+# 6. Usa la función pop() para eliminar el último elemento de la lista [1, 2, 3, 4, 5] y almacénalo en una variable. Imprime la variable y la lista.
+lista_cuatro = [1, 2, 3, 4, 5]
+eliminado = lista_cuatro.pop(-1)
+print(lista_cuatro)
+print(eliminado)
+
+# 7. Invierte la lista [100, 200, 300, 400, 500] e imprímela.
+lista_cinco = [100, 200, 300, 400, 500]
+lista_cinco.reverse()
+print(lista_cinco)
+
+# 8. Ordena la lista [3, 1, 4, 2, 5] en orden ascendente e imprímela.
+lista_seis = [3, 1, 4, 2, 5]
+lista_seis.sort()
+print(lista_seis)
+lista_seis.sort(reverse = True)
+print(lista_seis)
+
+# 9. Concatena las listas [1, 2, 3] y [4, 5, 6] y almacena el resultado en una nueva lista. Imprime la lista resultante.
+lista_mitad_uno = [1, 2, 3]
+lista_mitad_dos = [4, 5, 6]
+lista_unida = lista_mitad_uno + lista_mitad_dos
+print(lista_unida, "Lista unida.")
+
+# 10. Crea una sub lista con los elementos de la lista [10, 20, 30, 40, 50] que van desde la posición 1 hasta la 3 (sin incluir la posición 3).
+sub_lista = lista_dos.copy()
+sub_lista.remove(15)
+print(sub_lista[1:3])
\ No newline at end of file
diff --git a/Basic/ARB_05_tuples_exercises.py b/Basic/ARB_05_tuples_exercises.py
new file mode 100644
index 00000000..baba3e24
--- /dev/null
+++ b/Basic/ARB_05_tuples_exercises.py
@@ -0,0 +1,52 @@
+# 1. Crea una tupla con los valores (10, 20, 30, 40, 50) e imprímela.
+tupla = (10, 20, 30, 40, 50)
+print(tupla)
+print(type(tupla))
+
+# 2. Accede al segundo elemento de la tupla (100, 200, 300, 400, 500) y muéstralo.
+otra_tupla = (100, 200, 300, 400, 500)
+print(otra_tupla[1])
+
+# 3. Intenta modificar el primer elemento de la tupla (1, 2, 3) a 10 y observa el resultado.
+segunda_tupla = (1, 2, 3)
+# segunda_tupla[0] = 100 Error
+print(segunda_tupla)
+
+# 4. Cuenta cuántas veces aparece el número 3 en la tupla (1, 2, 3, 3, 4, 5, 3).
+contar_tupla = (1, 2, 3, 3, 4, 5, 3)
+print(contar_tupla.count(3))
+
+# 5. Encuentra el índice de la primera aparición de la cadena "Python" en la tupla ("Java", "Python", "JavaScript", "Python").
+coincidencia = ("Java", "Python", "JavaScript", "python")
+print(coincidencia.index("python")) # Reconoce mayúsculas
+
+# 6. Concatena dos tuplas: (1, 2, 3) y (4, 5, 6) e imprime la tupla resultante.
+tupla_uno = (1, 2, 3)
+tupla_dos = (4, 5, 6)
+suma_tuplas = tupla_uno + tupla_dos
+print(suma_tuplas)
+
+# 7. Crea una subtupla con los elementos desde la posición 2 hasta la 4 (sin incluir la 4) de la tupla (10, 20, 30, 40, 50).
+original = (10, 20, 30, 40, 50)
+sub_lista = original[1:4]
+print(sub_lista)
+
+# 8. Convierte la tupla ("rojo", "verde", "azul") en una lista, cambia el segundo elemento a "amarillo" y vuelve a convertirla en una tupla. Imprime la tupla resultante.
+colores = ("rojo", "verde", "azul")
+colores = list(colores)
+print(colores)
+colores[1] = "amarillo"
+print(colores)
+colores = tuple(colores)
+print(type(colores))
+
+# 9. Elimina una tupla llamada my_tuple usando del y luego intenta imprimirla para ver el resultado.
+my_tuple = (100, 200)
+print(my_tuple)
+del my_tuple
+# print(my_tuple) Da error porque se ha eliminado
+
+# 10. Crea una tupla con un solo elemento (el número 100) e imprímela. Asegúrate de usar la sintaxis correcta para crear una tupla con un solo elemento.
+unico = (1000,)
+print(type(unico))
+print(1000 in unico)
\ No newline at end of file
diff --git a/Basic/ARB_06_sets_exercises.py b/Basic/ARB_06_sets_exercises.py
new file mode 100644
index 00000000..18eb2f8b
--- /dev/null
+++ b/Basic/ARB_06_sets_exercises.py
@@ -0,0 +1,49 @@
+# 1. Crea un set con los números del 1 al 5 e imprímelo.
+es_set = {1, 2, 3, 4, 5}
+print(es_set)
+print(type(es_set))
+
+# 2. Añade el número 6 al set {1, 2, 3, 4, 5} e imprímelo.
+es_set.add(6)
+print(es_set)
+
+# 3. Intenta añadir el número 5 al set {1, 2, 3, 4, 5} nuevamente. ¿Qué sucede?
+es_set.add(5) #no añade el número ya que no permite elementos repetidos.
+print(es_set)
+
+# 4. Verifica si el número 3 está en el set {1, 2, 3, 4, 5} e imprime el resultado.
+print(3 in es_set)
+
+# 5. Elimina el número 4 del set {1, 2, 3, 4, 5} e imprime el set resultante.
+es_set.remove(4)
+print(es_set)
+
+# 6. Usa el método clear() para vaciar un set y luego imprime su longitud.
+es_set.clear()
+print(es_set)
+
+# 7. Convierte el set {"manzana", "naranja", "plátano"} en una lista e imprime el primer elemento de la lista.
+fruta = {"manzana", "naranja", "plátano"}
+fruta = list(fruta)
+print(fruta[0])
+print(type(fruta))
+
+# 8. Realiza la unión de dos sets: {1, 2, 3} y {4, 5, 6}, e imprime el set resultante.
+set_uno = {1, 2, 3}
+set_dos = {4, 5, 6}
+set_unido = set_uno.union(set_dos)
+print(set_unido)
+
+# 9. Calcula la diferencia entre los sets {1, 2, 3, 4} y {3, 4, 5, 6} e imprime el resultado.
+di_uno = {1, 2, 3, 4}
+di_dos = {3, 4, 5, 6}
+di_resultado = di_uno.difference(di_dos)
+print(di_resultado)
+
+# 10. Elimina un set llamado my_set usando del y luego intenta imprimirlo para ver el resultado.
+my_set = {50, 60}
+del my_set
+# print(my_set) dará error por que la variable se ha borrado por completo.
+
+otro_set = {1, 1, 2, 2, 3, 3}
+print(len(otro_set))
\ No newline at end of file
diff --git a/Basic/ARB_07_dicts_exercises.py b/Basic/ARB_07_dicts_exercises.py
new file mode 100644
index 00000000..35558d09
--- /dev/null
+++ b/Basic/ARB_07_dicts_exercises.py
@@ -0,0 +1,43 @@
+# 1. Crea un diccionario con las claves name, age, y country, asignando valores a cada una. Imprime el diccionario.
+el_dic = {
+    "name":"Antonio",
+    "age":43,
+    "country":"Granada"
+    }
+print(el_dic)
+
+# 2. Accede al valor de la clave name en el diccionario.
+print(el_dic["name"])
+
+# 3. Añade una nueva clave job con el valor "Programador" al diccionario del punto anterior. Imprime el diccionario actualizado.
+el_dic["job"] = "programador"
+print(el_dic)
+
+# 4. Modifica el valor de la clave age en el diccionario para que sea 38. Imprime el diccionario actualizado.
+el_dic["age"] = 38
+print(el_dic)
+
+# 5. Elimina la clave country del diccionario e imprime el diccionario resultante.
+del el_dic["age"]
+print(el_dic)
+
+# 6. Crea un diccionario donde las claves sean números del 1 al 5 y los valores sean sus cuadrados (ejemplo: 1: 1, 2: 4, ...).
+cuadrados = {1:1, 2:4, 3:9, 4:16, 5:25}
+print(cuadrados)
+print(cuadrados.items())
+
+# 7. Verifica si la clave age está presente en el diccionario {"name": "Brais", "age": 37, "country": "Galicia"}.
+print("age" in el_dic)
+
+# 8. Imprime solo las claves del diccionario.
+print(el_dic.keys())
+
+# 9. Convierte las claves del diccionario en una lista e imprime la lista resultante.
+print(list(el_dic))
+
+# 10. Crea un nuevo diccionario a partir de una lista de claves ["name", "age", "job"] usando fromkeys(), asignando a todas las claves el valor "Desconocido".
+nuevo_dic = {}
+nuevo_dic = nuevo_dic.fromkeys(("name", "age", "job"))
+print(nuevo_dic)
+nuevo_dic = nuevo_dic.fromkeys(nuevo_dic, "Desconocido")
+print(nuevo_dic)
diff --git a/Basic/ARB_08_conditionals_exercises.py b/Basic/ARB_08_conditionals_exercises.py
new file mode 100644
index 00000000..3c00ea8f
--- /dev/null
+++ b/Basic/ARB_08_conditionals_exercises.py
@@ -0,0 +1,80 @@
+# 1. Escribe un programa que verifique si un número es positivo, negativo o cero.
+el_num = int(input("Pon tu edad.: "))
+if el_num > 0:
+    print("El número es positivo")
+elif el_num == 0:
+    print("El número es cero")
+else:
+    print("El número es negativo")
+
+# 2. Solicita al usuario que ingrese su edad y muestra un mensaje indicando si es mayor de edad(18 años o más) o menor de edad.
+if el_num < 18 and el_num >= 0:
+    print("Eres menor de edad.")
+elif el_num >= 18:
+    print("Eres mayor de edad")
+else:
+    print("No has nacido o has muerto.")
+
+# 3. Escribe un programa que verifique si una cadena de texto está vacía y muestre un mensaje en consecuencia.
+el_texto = str(input("Escribe algo o no.: "))
+if el_texto == "":
+    print("No has escrito nada.")
+else:
+    print("Tu texto es: " + el_texto)
+
+# 4. Crea un programa que solicite dos números al usuario y compare cuál es mayor. Si son iguales, muestra un mensaje indicando la igualdad.
+un_num = int(input("Escríbeme un numero.: "))
+otro_num = int(input("Escríbeme otro numero.: "))
+if un_num == otro_num:
+    print("Son números iguales.")
+elif un_num > otro_num:
+    print("El primer numero es mayor.")
+elif un_num < otro_num:
+    print("El segundo numero es mayor.")
+else:
+    print("No es un numero.")
+
+# 5. Escribe un programa que verifique si un número es divisible por 3 y por 5 al mismo tiempo.
+print("El resto de " + str(el_num) + " entre 3 es: " + str((el_num % 3)))
+print("El resto de " + str(el_num) + " entre 3 es: " + str((el_num % 5)))
+
+if el_num % 3 == 0 and el_num % 5 == 0:
+    print(str(el_num) + " Es divisible entre 3 y 5 al mismo tiempo.")
+else:
+    print(str(el_num) + " No es divisible entre 3 y 5 al mismo tiempo.")
+
+# 6. Solicita al usuario que ingrese un número y verifica si es par o impar.
+if el_num % 2 == 0:
+    print(str(el_num) + " El número es par")
+else:
+    print(str(el_num) + " Es impar.")
+
+# 7. Escribe un programa que determine si una persona puede votar en función de su edad(mayor o igual a 18). Si tiene 16 o 17 años, indica que puede votar con permiso especial.
+if el_num >= 18:
+    print("Puedes votar")
+elif el_num >= 16 and el_num <= 17:
+    print("Puedes votar si tienes una autorización de un representante legal.")
+else:
+    print("No puedes votar.")
+
+# 8. Crea un programa que solicite una contraseña al usuario y verifique si coincide con una contraseña predefinida. Si no coincide, muestra un mensaje de error.
+tu_contraseña = input("Escribe (noRte) u otra cosa o no.: ")
+if tu_contraseña == "noRte":
+    print("¡Bienvenido!")
+else:
+    print("Contraseña incorrecta.")
+# 9. Escribe un programa que determine si un número está entre 10 y 20 (ambos incluidos).
+if el_num >= 10 and el_num <= 20:
+    print("El número está entre 10 y 20.")
+# 10. Escribe un programa que simule un semáforo: solicita al usuario que ingrese un color(rojo, amarillo, verde) y muestra un mensaje indicando si debe detenerse, estar alerta o avanzar.
+semaforo = input("Escribe Rojo, Amarillo, Verde.: ")
+semaforo = semaforo.capitalize()
+print(semaforo)
+if semaforo == "Rojo":
+    print("Detente.")
+elif semaforo == "Amarillo":
+    print("Precaución has de detenerte.")
+elif semaforo == "Verde":
+    print("Puedes pasar.")
+else:
+    print("No es un color de semaforo.")
\ No newline at end of file
diff --git a/Basic/ARB_09_loops_exercises.py b/Basic/ARB_09_loops_exercises.py
new file mode 100644
index 00000000..a9c9bb21
--- /dev/null
+++ b/Basic/ARB_09_loops_exercises.py
@@ -0,0 +1,81 @@
+# 1. Usa un bucle while para imprimir los números del 1 al 10.
+cuenta = 0
+while cuenta < 10:
+    cuenta += 1
+    print(cuenta)
+print("Fin de while. \n")
+
+# 2. Usa un bucle for para recorrer la lista[10, 20, 30, 40, 50] e imprime cada número.
+bucle = [10, 20, 30, 40, 50]
+for mirar in bucle:
+    print(mirar)
+print("Fin de for. \n")
+
+# 3. Escribe un programa que use un bucle while para sumar los números del 1 al 20 e imprime el resultado.
+cuenta = 0
+sumatoria = 0
+while cuenta <= 20:
+    print(f"Voy a sumar {cuenta} + {sumatoria}.")
+    sumatoria = cuenta + sumatoria
+    print(sumatoria)
+    cuenta += 1
+else:
+    print(f"El valor de la sumatoria de 20 números es: {sumatoria}")
+print("Fin de sumatoria. \n")
+
+# 4. Escribe un bucle for que imprima cada carácter de la cadena "Python".
+palabra = "Python"
+for deletrea in palabra:
+    print(deletrea)
+print("Fin deletrea. \n")
+
+# 5. Usa un bucle while para encontrar el primer número divisible por 7 entre 1 y 50.
+buscar = 1
+while (buscar & 7) != 0:
+    buscar += 1
+else:
+    print(f"{buscar - 1} es divisible entre 7. \n")
+
+# 6. Usa un bucle for para recorrer el diccionario {"name": "Brais", "age": 37, "country": "Galicia"} e imprime las claves.
+disc = {"name": "Brais", "age": 37, "country": "Galicia"}
+# Imprime la clave
+for claves in disc:
+    print(claves)
+else:
+    print("Fin de las claves. \n")
+
+# Imprimir valores
+for claves, valor in disc.items():
+    print(valor)
+else:
+    print("Fin de valores. \n")
+
+# 7. Escribe un programa que use un bucle while para imprimir los números pares entre 1 y 20.
+pares = 1
+while pares <= 20:
+    if pares % 2 == 0:
+        print(f"{pares} es par.")
+    pares += 1
+else:
+    print("Fin de pares. \n")
+
+# 8. Usa un bucle for con la función range() para imprimir los números del 1 al 10 en orden inverso.
+for inverso in range(10, 0, -1):
+    print(inverso)
+
+# 9. Escribe un programa que use un bucle for para contar cuántas veces aparece el número 30 en la lista[30, 10, 30, 20, 30, 40].
+treinta = [30, 10, 30, 20, 30, 40]
+contador = 0
+for repetido in treinta:
+    if repetido == 30:
+        contador += 1
+else:
+    print(f"El número 30 se repite {contador} veces. \n")
+
+# 10. Usa un bucle for para recorrer una lista de nombres y detener el bucle cuando se encuentre el nombre "Brais".
+nombres = ["Jose", "Mauricio", "Pepe", "brais", "Pepito", "menganico"]
+for te_vi in nombres:
+    print(te_vi.capitalize())
+    if te_vi.capitalize() == "Brais":
+        print(f"Te encontré {te_vi.capitalize()} detengo el bucle. \n")
+        break
diff --git a/Basic/ARB_10_functions_exercises.py b/Basic/ARB_10_functions_exercises.py
new file mode 100644
index 00000000..665ec905
--- /dev/null
+++ b/Basic/ARB_10_functions_exercises.py
@@ -0,0 +1,78 @@
+# 1. Crea una función llamada "personalized_greeting" que reciba un nombre como argumento e imprima "Hola, <nombre>". Si no se proporciona ningún nombre, debe saludar diciendo "Hola, desconocido".
+def personalizado(nombre):
+    print(f"Hola {nombre}. \n")
+personalizado(input("Escribe tu nombre.: "))
+
+# 2. Escribe una función llamada "multiply" que reciba dos números como argumentos y retorne el resultado de multiplicarlos.
+def multiplicar(n_uno, n_dos):
+    return n_uno * n_dos
+print(multiplicar(5, 8))
+print("\n")
+
+# 3. Crea una función llamada "is_even" que reciba un número entero como argumento y retorne True si es par y False si es impar.
+def is_even(n_n):
+    n_n = int(n_n)
+    if n_n % 2 == 0:
+        return True
+    else:
+        return False
+devuelto = is_even(input("Escribe un numero.: "))
+print(f"Tu numero es {devuelto}. \n")
+
+# 4. Escribe una función llamada "convert_to_uppercase" que reciba una cadena de texto y la retorne en mayúsculas.
+def convert_up(texto):
+    mayusculas = ""
+    for up in texto:
+        mayusculas += up.upper()
+    return mayusculas
+ver = convert_up(input("Escribe una palabra.: "))
+print(f"Tu palabra en mayúsculas: {ver}. \n")
+
+# 5. Crea una función llamada "arbitrary_sum" que reciba un número arbitrario de números como argumentos y retorne la suma de todos ellos.
+def arbitrary (*suma):
+    numeros = 0
+    for sumalo in suma:
+        numeros += sumalo
+    return (f"La sumatoria es: {numeros}")
+print(arbitrary(5, 6, 10))
+
+# 6. Escribe una función llamada "generate_full_greeting" que reciba dos argumentos: nombre y apellido, y retorne el saludo completo "Hola, <nombre> <apellido>". Los argumentos deben ser pasados por clave.
+tu_nombre = {
+    "nombre" : "Josemi",
+    "apellido" : "Delgado"
+    }
+def full_greeting (diccionario):
+    nom = diccionario["nombre"]
+    ap = diccionario["apellido"]
+    print(f"Hola {nom} {ap}. \n")
+full_greeting(tu_nombre)
+
+# 7. Crea una función llamada "power" que reciba dos números: base y exponente, y retorne el resultado de elevar la base al exponente.
+cuadrado = (5, 2)
+def power (base, exponente):
+    return base**exponente
+print(power(cuadrado[0], cuadrado[1]))
+print("\n")
+
+# 8. Escribe una función llamada "calculate_average" que reciba tres números y retorne su promedio.
+def calculate_average (*calcular):
+    sumado = 0
+    for calculo in calcular:
+        sumado += calculo
+        print(sumado)
+    return (f"La media de los numeros es: {sumado/len(calcular)}")
+print(calculate_average(2, 4, 6))
+print("\n")
+
+
+# 9. Crea una función llamada "count_characters" que reciba una cadena de texto y retorne el número de caracteres que contiene.
+def count_chrt (texto):
+    return (f"Tu texto tiene {len(texto)} letras.")
+print(count_chrt(input("Escribe un texto.: ")))
+print("\n")
+
+# 10. Escribe una función llamada "display_messages" que reciba un número indefinido de cadenas y las imprima en mayúsculas, una por una, tal como se hizo en el archivo proporcionado.
+def display_messages(*textos):
+    for texto in textos:
+        print(texto.upper())
+display_messages("hola", "mundo", "esto es una prueba")
\ No newline at end of file
diff --git a/Basic/ARB_11_classes_exercises.py b/Basic/ARB_11_classes_exercises.py
new file mode 100644
index 00000000..ae1123de
--- /dev/null
+++ b/Basic/ARB_11_classes_exercises.py
@@ -0,0 +1,138 @@
+# 1. Crea una clase llamada "Animal" que tenga una propiedad "species" y un método "make_sound" que imprima un sonido genérico.
+class Animal:
+    def __init__(self, species):
+        self.species = species
+    
+    def make_sound(self):
+        if self.species == "Cerdo":
+            print(f"El {self.species} hace oinc! oinc!")
+        elif self.species == "Gallo":
+            print(f"El {self.species} hace cockorocock!!")
+        else:
+            print(f"El {self.species} hace un sonido de {self.species}.")
+
+
+
+
+el_cerdo = Animal("Cerdo")
+el_cerdo.make_sound()
+
+# 2. Modifica la clase "Animal" para que reciba la especie al crear un objeto y almacénala en una propiedad pública. Añade el método "make_sound" que imprima un sonido dependiendo de la especie.
+el_gallo = Animal("Gallo")
+el_gallo.make_sound()
+el_perro = Animal("Perro")
+el_perro.make_sound()
+
+# 3. Crea una clase llamada "Car" con las propiedades públicas "brand" y "model". Además, debe tener una propiedad privada "_speed" que inicialmente será 0.
+class Car:
+    def __init__(self, brand, model):
+        self.brand = brand
+        self.model = model
+        self.__speed = 0
+
+    def accelerate(self):
+        self.__speed += 10
+    def brake(self):
+        self.__speed -= 10
+
+# 4. Añade a la clase "Car" un método llamado "accelerate" que aumente la velocidad en 10 unidades. Añade también un método "brake" que reduzca la velocidad en 10 unidades. Asegúrate de que la velocidad no sea negativa.
+coche = Car("BMW", "Z4")
+coche.accelerate()
+#print(f"El {coche.brand} {coche.model} va a {coche.__speed}km/H.") # No se puede imprimir la velocidad por que es privada.
+coche.brake()
+#print(f"El {coche.brand} {coche.model} va a {coche.__speed}km/H.") # No se puede imprimir la velocidad por que es privada.
+
+# 5. Crea una clase "Book" que tenga propiedades como "title" (público) y "author" (privado). Añade un método para obtener el autor y otro para cambiar el título del libro.
+class Book:
+    def __init__(self, title, author):
+        self.title = title
+        self.__author = author
+
+    def el_autor(self):
+        print(self.__author)
+
+    def cambiar(self, nuevo):
+        self.title = nuevo
+
+libro = Book("Calambre", "Carlos")
+print(libro.title)
+libro.el_autor()
+libro.cambiar("Esperanza")
+print(libro.title)
+
+# 6. Crea una clase "Estudiante" que tenga como propiedades su nombre, apellido y una lista de notas. Añade un método para calcular y devolver la nota media del estudiante.
+class Estudiante:
+    def __init__(self, nombre, apellido, notas):
+        self.nombre = nombre
+        self.apellido = apellido
+        self.notas = notas
+
+    def media(self):
+        sumar = 0
+        for valor in self.notas:
+            sumar += valor
+        print(f"La media de {self.nombre} es {sumar / len(self.notas):.2f}")
+
+alumno = Estudiante("Jose", "Miguel", [5.6, 8, 9.4])
+alumno.media()
+
+# 7. Crea una clase "BankAccount" con propiedades como "owner" y "balance". Añade métodos para depositar y retirar dinero, asegurándote de que no se pueda retirar más de lo que hay en la cuenta.
+class BankAccount:
+    def __init__(self, owner, balance):
+        self.owner = owner
+        self.balance = balance
+
+    def ingreso(self, agregar):
+        self.balance += agregar
+        print(f"Su balance actual es de {self.balance} euros.")
+    
+    def retirar (self, sacar):
+        if (self.balance - sacar) <= 0:
+            print(f"Su balance es de {self.balance} Euros.\nNo tiene suficientes fondos para retirar {sacar} Euros.")
+        else:
+            self.balance -= sacar
+            print(f"A retirado {sacar} Euros.\nEn la cuenta le quedan {self.balance} Euros.")
+
+usuario = BankAccount("Maria", 100)
+usuario.ingreso(1000)
+usuario.retirar(200)
+usuario.retirar(20000)
+
+# 8. Crea una clase "Point" que represente un punto en el espacio 2D con coordenadas "x" e "y". Añade un método que calcule la distancia entre dos puntos.
+'''
+class Point:
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+
+punto_uno = Point(5, 9)
+punto_dos = Point(8, 5)
+'''
+# 9. Crea una clase "Employee" que tenga propiedades como "name", "hourly_wage" (pago por hora) y "hours_worked". Añade un método que calcule el pago total basado en las horas trabajadas y el salario por hora.
+class Employee:
+    def __init__(self, name, hourly_wage, hours_worked):
+        self.name = name
+        self.hourly_wage = hourly_wage
+        self.hours_worked = hours_worked
+    
+    def pago(self):
+        print(f"{self.name} hoy has ganado {self.hourly_wage * self.hours_worked:.2f} Euros.")
+
+empleado = Employee("Joseito", 12.31, 51)
+empleado.pago()
+
+# 10. Crea una clase "Store" que tenga una propiedad "inventory" (una lista de productos). Añade un método para agregar un producto al inventario y otro para mostrar todos los productos disponibles.
+class Store:
+    def __init__(self, inventory):
+        self.inventory = inventory
+
+    def add(self, nuevo):
+        self.inventory.append(nuevo)
+
+    def mostrar(self):
+        for producto in self.inventory:
+            print(producto)
+
+productos = Store(["Coca cola", "Nestea", "Fanta"])
+productos.add("Chocolate")
+productos.mostrar()
\ No newline at end of file