Add exercises 11

Signed-off-by: Manuel Vergara <manuel@vergaracarmona.es>

30-days-of-python/10_Bucles/data/countries.py

@@ -1,195 +0,0 @@
-countries = [
-  'Afghanistan',
-  'Albania',
-  'Algeria',
-  'Andorra',
-  'Angola',
-  'Antigua and Barbuda',
-  'Argentina',
-  'Armenia',
-  'Australia',
-  'Austria',
-  'Azerbaijan',
-  'Bahamas',
-  'Bahrain',
-  'Bangladesh',
-  'Barbados',
-  'Belarus',
-  'Belgium',
-  'Belize',
-  'Benin',
-  'Bhutan',
-  'Bolivia',
-  'Bosnia and Herzegovina',
-  'Botswana',
-  'Brazil',
-  'Brunei',
-  'Bulgaria',
-  'Burkina Faso',
-  'Burundi',
-  'Cambodia',
-  'Cameroon',
-  'Canada',
-  'Cape Verde',
-  'Central African Republic',
-  'Chad',
-  'Chile',
-  'China',
-  'Colombi',
-  'Comoros',
-  'Congo (Brazzaville)',
-  'Congo',
-  'Costa Rica',
-  "Cote d'Ivoire",
-  'Croatia',
-  'Cuba',
-  'Cyprus',
-  'Czech Republic',
-  'Denmark',
-  'Djibouti',
-  'Dominica',
-  'Dominican Republic',
-  'East Timor (Timor Timur)',
-  'Ecuador',
-  'Egypt',
-  'El Salvador',
-  'Equatorial Guinea',
-  'Eritrea',
-  'Estonia',
-  'Ethiopia',
-  'Fiji',
-  'Finland',
-  'France',
-  'Gabon',
-  'Gambia, The',
-  'Georgia',
-  'Germany',
-  'Ghana',
-  'Greece',
-  'Grenada',
-  'Guatemala',
-  'Guinea',
-  'Guinea-Bissau',
-  'Guyana',
-  'Haiti',
-  'Honduras',
-  'Hungary',
-  'Iceland',
-  'India',
-  'Indonesia',
-  'Iran',
-  'Iraq',
-  'Ireland',
-  'Israel',
-  'Italy',
-  'Jamaica',
-  'Japan',
-  'Jordan',
-  'Kazakhstan',
-  'Kenya',
-  'Kiribati',
-  'Korea, North',
-  'Korea, South',
-  'Kuwait',
-  'Kyrgyzstan',
-  'Laos',
-  'Latvia',
-  'Lebanon',
-  'Lesotho',
-  'Liberia',
-  'Libya',
-  'Liechtenstein',
-  'Lithuania',
-  'Luxembourg',
-  'Macedonia',
-  'Madagascar',
-  'Malawi',
-  'Malaysia',
-  'Maldives',
-  'Mali',
-  'Malta',
-  'Marshall Islands',
-  'Mauritania',
-  'Mauritius',
-  'Mexico',
-  'Micronesia',
-  'Moldova',
-  'Monaco',
-  'Mongolia',
-  'Morocco',
-  'Mozambique',
-  'Myanmar',
-  'Namibia',
-  'Nauru',
-  'Nepal',
-  'Netherlands',
-  'New Zealand',
-  'Nicaragua',
-  'Niger',
-  'Nigeria',
-  'Norway',
-  'Oman',
-  'Pakistan',
-  'Palau',
-  'Panama',
-  'Papua New Guinea',
-  'Paraguay',
-  'Peru',
-  'Philippines',
-  'Poland',
-  'Portugal',
-  'Qatar',
-  'Romania',
-  'Russia',
-  'Rwanda',
-  'Saint Kitts and Nevis',
-  'Saint Lucia',
-  'Saint Vincent',
-  'Samoa',
-  'San Marino',
-  'Sao Tome and Principe',
-  'Saudi Arabia',
-  'Senegal',
-  'Serbia and Montenegro',
-  'Seychelles',
-  'Sierra Leone',
-  'Singapore',
-  'Slovakia',
-  'Slovenia',
-  'Solomon Islands',
-  'Somalia',
-  'South Africa',
-  'Spain',
-  'Sri Lanka',
-  'Sudan',
-  'Suriname',
-  'Swaziland',
-  'Sweden',
-  'Switzerland',
-  'Syria',
-  'Taiwan',
-  'Tajikistan',
-  'Tanzania',
-  'Thailand',
-  'Togo',
-  'Tonga',
-  'Trinidad and Tobago',
-  'Tunisia',
-  'Turkey',
-  'Turkmenistan',
-  'Tuvalu',
-  'Uganda',
-  'Ukraine',
-  'United Arab Emirates',
-  'United Kingdom',
-  'United States',
-  'Uruguay',
-  'Uzbekistan',
-  'Vanuatu',
-  'Vatican City',
-  'Venezuela',
-  'Vietnam',
-  'Yemen',
-  'Zambia',
-  'Zimbabwe',
-];

30-days-of-python/11_Funciones/01_funcion.py

@@ -0,0 +1,228 @@
+"""
+01_funcion.py
+"""
+import math
+
+# Ejercicios: Nivel 1
+
+# 1. Declara una función llamada add_two_numbers.
+# Toma dos parámetros y devuelve la suma.
+
+
+def add_two_numbers(a, b):
+    return a + b
+
+
+print(f"La suma de los parámetros es igual a {add_two_numbers(2, 3)}")
+
+# 2. El área de un círculo se calcula de la siguiente manera:
+# área = π x r x r.
+# Escribe una función que calcule area_of_circle.
+
+
+def area_of_circle(r):
+    return math.pi * r * r
+
+
+radio = 5
+print(
+    f"El área del círculo con el radio {radio} es igual a {area_of_circle(radio)}")
+
+
+# 3. Escribe una función llamada add_all_nums que tome
+# un número arbitrario de argumentos y sume todos los argumentos.
+# Verifica si todos los elementos de la lista son de tipo numérico.
+# Si no lo son, proporciona un mensaje de retroalimentación razonable.
+
+
+def add_all_nums(*args):
+    total = 0
+    for num in args:
+        if isinstance(num, (int, float)):
+            total += num
+
+        else:
+            return "No todos los elementos son numéricos"
+    return f"La suma de los parámetros es igual a {total}"
+
+
+print(f"{add_all_nums(1, 2, 3, 4, '5')}")
+
+# 4. La temperatura en °C se puede convertir a °F
+# utilizando la siguiente fórmula:
+# °F = (°C x 9/5) + 32.
+# Escribe una función que convierta de °C a °F,
+# convert_celsius_to_fahrenheit.
+
+
+def convert_celsius_to_fahrenheit(celsius):
+    return (celsius * 9/5) + 32
+
+
+temperatura = 36
+print(
+    f"La temperatura de {temperatura} °C en fahrenheit es igual a {convert_celsius_to_fahrenheit(temperatura)}")
+
+# 5. Escribe una función llamada check_season.
+# Toma un parámetro de mes y devuelve la estación:
+# Otoño, Invierno, Primavera o Verano.
+
+
+def check_season(month):
+    if month in [12, 1, 2]:
+        return "Invierno"
+    elif month in [3, 4, 5]:
+        return "Primavera"
+    elif month in [6, 7, 8]:
+        return "Verano"
+    elif month in [9, 10, 11]:
+        return "Otoño"
+    else:
+        return "Mes no válido"
+
+
+mes = 1
+print(f"El mes {mes} es de {check_season(mes)}")
+
+# 6. Escribe una función llamada calculate_slope
+# que devuelva la pendiente de una ecuación lineal.
+
+
+def calculate_slope(x1, y1, x2, y2):
+    return (y2 - y1) / (x2 - x1)
+
+
+print(
+    f"La pendiente de la ecuación lineal es igual a {calculate_slope(2, 3, 6, 7)}")
+
+# 7. La ecuación cuadrática se calcula de la siguiente manera: ax² + bx + c = 0.
+# Escribe una función que calcule el conjunto de soluciones de una ecuación cuadrática, solve_quadratic_eqn.
+
+
+def solve_quadratic_eqn(a, b, c):
+    discriminant = b**2 - 4*a*c
+    if discriminant > 0:
+        x1 = (-b + math.sqrt(discriminant)) / (2*a)
+        x2 = (-b - math.sqrt(discriminant)) / (2*a)
+        return (x1, x2)
+    elif discriminant == 0:
+        x1 = -b / (2*a)
+        return (x1,)
+    else:
+        return "No hay soluciones reales"
+
+
+print(
+    f"Las soluciones de la ecuación cuadrática son {solve_quadratic_eqn(5, 8, 1)}")
+
+# 8. Declara una función llamada print_list.
+# Toma una lista como parámetro
+# y imprime cada elemento de la lista.
+
+
+def print_list(my_list):
+    for item in my_list:
+        print(f" - {item}")
+
+
+lista_frutas = ["Manzana", "Pera", "Naranja", "Plátano", "Kiwi"]
+print_list(lista_frutas)
+
+# 9. Declara una función llamada reverse_list.
+# Toma un arreglo como parámetro
+# y devuelve el arreglo invertido (usa bucles).
+
+
+def reverse_list(my_list):
+    reversed_list = []
+    i = len(my_list) - 1
+    while i >= 0:
+        reversed_list.append(my_list[i])
+        i -= 1
+    return reversed_list
+
+
+lista_numeros = [1, 2, 3, 4, 5]
+lista_letras = ["A", "B", "C"]
+print(reverse_list(lista_numeros))
+print(reverse_list(lista_letras))
+
+
+# 10. Declara una función llamada
+# capitalize_list_items.
+# Toma una lista como parámetro
+# y devuelve una lista de elementos en mayúsculas.
+
+
+def capitalize_list_items(my_list):
+    return [item.upper() for item in my_list]
+
+
+print(capitalize_list_items(lista_frutas))
+
+# 11. Declara una función llamada add_item.
+# Toma una lista y un parámetro de elemento.
+# Devuelve una lista con el elemento agregado al final.
+
+
+def add_item(my_list, item):
+    my_list.append(item)
+    return my_list
+
+
+print(add_item(lista_frutas, "Melón"))
+print(add_item(lista_numeros, 6))
+
+# 12. Declara una función llamada remove_item.
+# Toma una lista y un parámetro de elemento.
+# Devuelve una lista con el elemento eliminado de ella.
+
+
+def remove_item(my_list, item):
+    if item in my_list:
+        my_list.remove(item)
+    return my_list
+
+
+print(remove_item(lista_frutas, "Pera"))
+print(remove_item(lista_numeros, 2))
+
+# 13. Declara una función llamada sum_of_numbers.
+# Toma un número como parámetro
+# y suma todos los números en ese rango.
+
+
+def sum_of_numbers(n):
+    return sum(range(1, n+1))
+
+
+print(sum_of_numbers(7))
+
+# 14. Declara una función llamada sum_of_odds.
+# Toma un número como parámetro
+# y suma todos los números impares en ese rango.
+
+
+def sum_of_odds(n):
+    sum = 0
+    for i in range(1, n+1, 2):
+        sum += i
+    return sum
+
+
+print(sum_of_odds(7))
+
+
+# 15. Declara una función llamada sum_of_even.
+# Toma un número como parámetro
+# y suma todos los números pares en ese rango.
+
+
+def sum_of_even(n):
+    sum = 0
+    for i in range(2, n+1, 2):
+        sum += i
+    return sum
+
+
+print(sum_of_even(7))

30-days-of-python/11_Funciones/02_funcion.py

@@ -0,0 +1,116 @@
+"""
+02_funcion.py
+"""
+
+
+# Ejercicios: Nivel 2
+
+# 1. Declara una función llamada evens_and_odds.
+# Toma un número entero positivo como parámetro
+# y cuenta el número de pares e impares en ese número.
+
+
+def evens_and_odds(n):
+    evens = 0
+    odds = 0
+    for i in range(1, n+1):
+        if i % 2 == 0:
+            evens += 1
+        else:
+            odds += 1
+    return f"El número de impares es {odds}.\nEl número de pares es {evens}."
+
+
+print(evens_and_odds(101))
+
+# 2. Llama a tu función factorial,
+# toma un número entero como parámetro
+# y devuelve el factorial de ese número.
+
+
+def factorial(n):
+    if n == 0:
+        return 1
+    else:
+        return n * factorial(n-1)
+
+
+num_factorial = 5
+print(f"El factorial de {num_factorial} es {factorial(num_factorial)}.")
+
+# 3. Llama a tu función is_empty,
+# toma un parámetro
+# y verifica si está vacío o no.
+
+
+def is_empty(item):
+    if not item:
+        return "La variable está vacía."
+    else:
+        return "La variable no está vacía."
+
+
+print(is_empty(""))
+
+# 4. Escribe diferentes funciones que tomen listas.
+# Deben calcular la media, mediana, moda, rango,
+# varianza y desviación estándar.
+# Las funciones se llaman calculate_mean,
+# calculate_median, calculate_mode,
+# calculate_range, calculate_variance
+# y calculate_std (desviación estándar).
+
+
+def calculate_mean(my_list):
+    return sum(my_list) / len(my_list)
+
+
+def calculate_median(my_list):
+    sorted_list = sorted(my_list)
+    n = len(my_list)
+    if n % 2 == 0:
+        return (sorted_list[n//2-1] + sorted_list[n//2]) / 2
+    else:
+        return sorted_list[n//2]
+
+
+def calculate_mode(my_list):
+    freq_dict = {}
+    for num in my_list:
+        if num in freq_dict:
+            freq_dict[num] += 1
+        else:
+            freq_dict[num] = 1
+    max_freq = max(freq_dict.values())
+    mode_list = [num for num, freq in freq_dict.items() if freq == max_freq]
+    if len(mode_list) == len(my_list):
+        return None
+    elif len(mode_list) == 1:
+        return mode_list[0]
+    else:
+        return mode_list
+
+
+def calculate_range(my_list):
+    return max(my_list) - min(my_list)
+
+
+def calculate_variance(my_list):
+    mean = calculate_mean(my_list)
+    return sum([(x - mean)**2 for x in my_list]) / (len(my_list) - 1)
+
+
+def calculate_std(my_list):
+    return calculate_variance(my_list) ** 0.5
+
+
+my_list = [1, 2, 3, 4, 5, 5, 6, 7, 8, 9]
+
+print(f"""De la lista {my_list} obtenemos:
+ - Media: {calculate_mean(my_list)}
+ - Mediana: {calculate_median(my_list)}
+ - Moda: {calculate_mode(my_list)}
+ - Rango: {calculate_range(my_list)}
+ - Varianza: {calculate_variance(my_list)}
+ - Desviación estándar: {calculate_std(my_list)}
+""")

30-days-of-python/11_Funciones/03_funcion.py

@@ -0,0 +1,133 @@
+"""
+03_funcion.py
+"""
+import countries_data
+
+# Ejercicios: Nivel 3
+
+# 1. Escribe una función llamada is_prime
+# que compruebe si un número es primo.
+
+
+def is_prime(num):
+    if num <= 1:
+        return "No"
+    elif num == 2:
+        return "Sí"
+    elif num % 2 == 0:
+        return "No"
+    else:
+        for i in range(3, int(num**0.5) + 1, 2):
+            if num % i == 0:
+                return "No"
+        return "Sí"
+
+
+numero_primo = 19
+
+print(f"¿El número {numero_primo} es primo? {is_prime(numero_primo)}")
+
+# 2. Escribe una función que compruebe
+# si todos los elementos de una lista son únicos.
+
+
+def are_elements_unique(my_list):
+    if len(my_list) == len(set(my_list)):
+        return "Sí"
+    else:
+        return "No"
+
+
+lista_elementos = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+print(
+    f"¿Los elementos de la lista {lista_elementos} son únicos? {are_elements_unique(lista_elementos)}")
+
+# 3. Escribe una función que compruebe
+# si todos los elementos de una lista
+# son del mismo tipo de dato.
+
+
+def are_elements_same_type(my_list):
+    first_type = type(my_list[0])
+    if not my_list:
+        return "Esto no es una lista."
+    elif all(isinstance(x, first_type) for x in my_list):
+        return "Sí"
+    else:
+        return "No"
+
+
+print(
+    f"¿Los elementos de la lista {lista_elementos} son del mismo tipo de dato? {are_elements_same_type(lista_elementos)}")
+
+# 4. Escribe una función que compruebe
+# si una variable proporcionada
+# es una variable válida en Python.
+
+
+def is_valid_variable_name(variable_name):
+    try:
+        exec(f"{variable_name} = None")
+        del locals()[variable_name]
+        return "Sí"
+    except:
+        return "No"
+
+
+print(
+    f"¿La variable 'variable_name' es válida? {is_valid_variable_name('variable_name')}")
+
+# 5. Ve a la carpeta de datos
+# y accede al archivo countries-data.py.
+# Crea una función llamada
+# most_spoken_languages_in_the_world.
+# Debe devolver las 10 o 20 lenguas
+# más habladas en orden descendente.
+# Crea una función llamada
+# most_populated_countries.
+# Debe devolver los 10 o 20 países
+# más poblados en orden descendente.
+# Suponiendo que los datos están almacenados
+# en una lista llamada "countries_data".
+
+
+# Función para obtener las lenguas
+# más habladas en el mundo.
+
+def most_spoken_languages_in_the_world():
+    all_languages = []
+    for country in countries_data.countries_data:
+        all_languages.extend(country['languages'])
+
+    language_count = {}
+
+    for language in all_languages:
+        if language in language_count:
+            language_count[language] += 1
+        else:
+            language_count[language] = 1
+
+    sorted_languages = sorted(language_count.items(),
+                              key=lambda x: x[1],
+                              reverse=True)[:10]
+
+    language_list = [f"{i+1}. {language[0]}" for i,
+                     language in enumerate(sorted_languages)]
+    return "\n".join(language_list)
+
+
+print(most_spoken_languages_in_the_world())
+
+# Función para obtener los países
+# más poblados en el mundo.
+
+
+def most_populated_countries():
+    sorted_countries = sorted(
+        countries_data.countries_data, key=lambda x: x['population'], reverse=True)[:10]
+    country_list = [f"{i+1}. {country['name']}" for i,
+                    country in enumerate(sorted_countries)]
+    return "\n".join(country_list)
+
+
+print(most_populated_countries())