Add exercises 21

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

30-days-of-python/20_Gestor_de_paquetes_de_Python/01_gestor_paquetes.py

@@ -0,0 +1,137 @@
+"""
+01_gestor_paquetes.py
+"""
+import requests
+from collections import Counter
+import statistics
+import pandas as pd
+from bs4 import BeautifulSoup
+
+# 1. Lee esta URL y encuentra las 10 palabras más frecuentes.
+# Romeo y Julieta: 'http://www.gutenberg.org/files/1112/1112.txt'
+
+url_romeo_julieta = 'http://www.gutenberg.org/files/1112/1112.txt'
+response_romeo_julieta = requests.get(url_romeo_julieta)
+words = response_romeo_julieta.text.split()
+word_counts = Counter(words)
+top_10_words = word_counts.most_common(10)
+
+print("10 palabras más frecuentes:")
+for word, count in top_10_words:
+    print(word, "-", count)
+
+print()
+
+# 2. Lee la API de gatos y la URL:
+# 'https://api.thecatapi.com/v1/breeds'
+# y encuentra:
+
+url_gatos = 'https://api.thecatapi.com/v1/breeds'
+response_gatos = requests.get(url_gatos)
+data_gatos = response_gatos.json()
+
+# - El mínimo, máximo, promedio,
+# mediana y desviación estándar
+# del peso de los gatos en unidades métricas.
+
+weights = [cat['weight']['metric'] for cat in data_gatos]
+weights = [float(w.split()[0]) for w in weights]
+min_weight = min(weights)
+max_weight = max(weights)
+avg_weight = statistics.mean(weights)
+med_weight = statistics.median(weights)
+std_weight = statistics.stdev(weights)
+
+print("Peso de los gatos en unidades métricas:")
+print("Mínimo:", min_weight)
+print("Máximo:", max_weight)
+print("Promedio:", avg_weight)
+print("Mediana:", med_weight)
+print("Desviación estándar:", std_weight)
+print()
+
+# - El mínimo, máximo, promedio,
+# mediana y desviación estándar
+# de la esperanza de vida
+# de los gatos en años.
+
+lifespans = [cat['life_span'] for cat in data_gatos]
+lifespans = [int(l.split()[0]) for l in lifespans if l != '']
+min_lifespan = min(lifespans)
+max_lifespan = max(lifespans)
+avg_lifespan = statistics.mean(lifespans)
+med_lifespan = statistics.median(lifespans)
+std_lifespan = statistics.stdev(lifespans)
+
+print("Esperanza de vida de los gatos en años:")
+print("Mínimo:", min_lifespan)
+print("Máximo:", max_lifespan)
+print("Promedio:", avg_lifespan)
+print("Mediana:", med_lifespan)
+print("Desviación estándar:", std_lifespan)
+print()
+
+# - Crea una tabla de frecuencias
+# de países y razas de gatos.
+
+country_counts = Counter([cat['origin']
+                         for cat in data_gatos if cat['origin'] != ''])
+breed_counts = Counter([cat['name'] for cat in data_gatos])
+
+print("Tabla de frecuencias de países:")
+print(pd.DataFrame.from_dict(country_counts, orient='index'))
+print()
+
+print("Tabla de frecuencias de razas:")
+print(pd.DataFrame.from_dict(breed_counts, orient='index'))
+print()
+
+# 3. Lee la [API de países](https://restcountries.eu/rest/v2/all)
+# y encuentra:
+
+# El enlace está caído, uso otra versión
+url_countries = 'https://restcountries.com/v3.1/all'
+response_countries = requests.get(url_countries)
+data_countries = response_countries.json()
+
+# - Los 10 países más grandes.
+
+df = pd.DataFrame(data_countries)
+df['area'] = pd.to_numeric(df['area'])
+largest_countries = df.nlargest(10, 'area')
+
+print("Los 10 países más grandes:")
+for country in largest_countries['name']:
+    print(country['common'])
+print()
+
+# - Los 10 idiomas más hablados.
+
+most_spoken_languages = df.explode('languages').groupby(
+    'languages').size().nlargest(10)
+
+print("Los 10 idiomas más hablados:")
+print(most_spoken_languages)
+print()
+
+# - El número total de idiomas en la API de países.
+
+total_languages = len(df.explode('languages')['languages'].unique())
+
+print("Número total de idiomas en la API de países:", total_languages)
+print()
+
+
+# 4. La Universidad de California en Irvine (UCI)
+# es uno de los lugares más comunes para obtener
+# conjuntos de datos para ciencia de datos
+# y aprendizaje automático.
+# Lee el contenido de UCI
+# (https://archive.ics.uci.edu/ml/datasets.php).
+# Sin bibliotecas adicionales, puede ser difícil,
+# por lo que puedes intentarlo con BeautifulSoup4.
+
+url = 'https://archive.ics.uci.edu/ml/datasets.php'
+response = requests.get(url)
+soup = BeautifulSoup(response.content, 'html.parser')
+links = [a['href'] for a in soup.find_all('a') if a.has_attr('href')]

30-days-of-python/20_Gestor_de_paquetes_de_Python/README.md

@@ -20,4 +20,6 @@ Documento original en inglés: [python package manager](https://github.com/Asabe
 
 4. La Universidad de California en Irvine (UCI) es uno de los lugares más comunes para obtener conjuntos de datos para ciencia de datos y aprendizaje automático. Lee el contenido de UCI (https://archive.ics.uci.edu/ml/datasets.php). Sin bibliotecas adicionales, puede ser difícil, por lo que puedes intentarlo con BeautifulSoup4.
 
+[Solución](01_gestor_paquetes.py)
+
 [<< Day 19](../19_Manipulación_de_archivos/README.md) | [Day 21 >>](../21_Clases_y_objetos/README.md)

30-days-of-python/21_Clases_y_objetos/01_clases_objetos.py

@@ -0,0 +1,137 @@
+"""
+01_clases_objetos.py
+"""
+import statistics
+
+
+# 1. Python tiene el módulo llamado estadísticas
+# y podemos usar este módulo para realizar todos
+# los cálculos estadísticos. Sin embargo,
+# para aprender a crear funciones y reutilizar funciones,
+# intentemos desarrollar un programa
+# que calcule la medida de tendencia central de una muestra
+# (media, mediana, moda) y la medida de variabilidad
+# (rango, varianza, desviación estándar).
+# Además de esas medidas, encuentra el mínimo, máximo,
+# recuento, percentil y distribución de frecuencia de la muestra.
+# Puedes crear una clase llamada Estadísticas
+# y crear todas las funciones que realicen cálculos estadísticos
+# como métodos para la clase Estadísticas.
+
+class Estadisticas:
+    def __init__(self, data):
+        self.data = data
+
+    def count(self):
+        return len(self.data)
+
+    def sum(self):
+        return sum(self.data)
+
+    def min(self):
+        return min(self.data)
+
+    def max(self):
+        return max(self.data)
+
+    def range(self):
+        return max(self.data) - min(self.data)
+
+    def mean(self):
+        return statistics.mean(self.data)
+
+    def median(self):
+        return statistics.median(self.data)
+
+    def mode(self):
+        mode = statistics.mode(self.data)
+        count = self.data.count(mode)
+        return {'moda': mode, 'recuento': count}
+
+    def std(self):
+        return statistics.stdev(self.data)
+
+    def var(self):
+        return statistics.variance(self.data)
+
+    def freq_dist(self):
+        freq = {}
+        for value in self.data:
+            freq[value] = freq.get(value, 0) + 1
+        freq_dist = [(freq[value], value) for value in freq]
+        freq_dist.sort(reverse=True)
+        return freq_dist
+
+
+edades = [
+    31, 26, 34, 37, 27,
+    26, 32, 32, 26, 27,
+    27, 24, 32, 33, 27,
+    25, 26, 38, 37, 31,
+    34, 24, 33, 29, 26
+]
+
+estadisticas = Estadisticas(edades)
+
+print('Recuento:', estadisticas.count())
+print('Suma: ', estadisticas.sum())
+print('Mínimo: ', estadisticas.min())
+print('Máximo: ', estadisticas.max())
+print('Rango: ', estadisticas.range())
+print('Media: ', estadisticas.mean())
+print('Mediana: ', estadisticas.median())
+print('Moda:')
+for key, value in estadisticas.mode().items():
+    print(f'\t - {key}: {value}')
+print('Desviación Estándar: ', estadisticas.std())
+print('Varianza: ', estadisticas.var())
+freq_dist = estadisticas.freq_dist()
+print('Distribución de Frecuencia:')
+for freq, value in freq_dist:
+    print(f'\t - {freq}, {value}')
+print()
+
+# 2. Crea una clase llamada CuentaPersona.
+# Tiene propiedades de nombre, apellido,
+# ingresos, gastos y tiene métodos de total_ingreso,
+# total_gasto, info_cuenta, agregar_ingreso,
+# agregar_gasto y saldo_cuenta.
+# Ingresos es un conjunto de ingresos y su descripción.
+# Lo mismo ocurre con los gastos.
+
+
+class CuentaPersona:
+    def __init__(self, nombre, apellido):
+        self.nombre = nombre
+        self.apellido = apellido
+        self.ingresos = {}
+        self.gastos = {}
+
+    def total_ingreso(self):
+        return sum(self.ingresos.values())
+
+    def total_gasto(self):
+        return sum(self.gastos.values())
+
+    def info_cuenta(self):
+        print(f'Nombre: {self.nombre} {self.apellido}')
+        print(f'Total de ingresos: {self.total_ingreso()}')
+        print(f'Total de gastos: {self.total_gasto()}')
+        print(f'Saldo de cuenta: {self.total_ingreso() - self.total_gasto()}')
+
+    def agregar_ingreso(self, descripcion, monto):
+        self.ingresos[descripcion] = monto
+
+    def agregar_gasto(self, descripcion, monto):
+        self.gastos[descripcion] = monto
+
+    def saldo_cuenta(self):
+        return self.total_ingreso() - self.total_gasto()
+
+
+cuenta = CuentaPersona('Juan', 'Pérez')
+cuenta.agregar_ingreso('Salario', 5000)
+cuenta.agregar_ingreso('Venta de acciones', 2000)
+cuenta.agregar_gasto('Alquiler', 1500)
+cuenta.agregar_gasto('Comida', 500)
+cuenta.info_cuenta()

30-days-of-python/21_Clases_y_objetos/README.md

@@ -44,4 +44,6 @@ Distribución de Frecuencia: [(20.0, 26), (16.0, 27), (12.0, 32), (8.0, 37), (8.
 
 1. Crea una clase llamada CuentaPersona. Tiene propiedades de nombre, apellido, ingresos, gastos y tiene métodos de total_ingreso, total_gasto, info_cuenta, agregar_ingreso, agregar_gasto y saldo_cuenta. Ingresos es un conjunto de ingresos y su descripción. Lo mismo ocurre con los gastos.
 
+[Solución](01_clases_objetos.py)
+
 [<< Day 20](../20_Gestor_de_paquetes_de_Python/README.md) | [Day 22 >>](../22_Web_scraping/README.md)