Ejercicios de Nivel Intermedio

Click here to view the next lesson.

Ejercicios de Nivel Intermedio

Exercise 1: Web Scraping
Exercise 2: File I/O
Exercise 3: Data Analysis
Exercise 4: Command-Line Interface
Exercise 5: API Integration
Exercise 6: Regular Expressions
Exercise 7: Object-Oriented Programming
Exercise 8: Concurrency
Exercise 9: Testing
Exercise 10: Data Visualization
Exercise 11: Database Operations
Exercise 12: Networking
Exercise 13: Data Science
Exercise 14: Web Development
Exercise 15: Asynchronous Programming
Exercise 16: Image Processing
Exercise 17: Email Sending
Exercise 18: Web API Integration
Exercise 19: Data Encryption
Exercise 20: GUI Programming
Exercise 21: File I/O
Exercise 22: Logging
Exercise 23: Web Scraping
Exercise 24: Concurrency with asyncio
Exercise 25: Data Analysis with Pandas
Exercise 26: Regular Expressions
Exercise 27: Database ORM
Exercise 28: Web Scraping with Selenium
Exercise 29: Natural Language Processing
Exercise 30: Machine Learning
Exercise 31: Image Recognition with Deep Learning
Exercise 32: Web APIs with Flask
Exercise 33: GUI Programming with PyQt
Exercise 34: Web Scraping with Beautiful Soup and Requests
Exercise 35: Data Visualization with Matplotlib
Exercise 36: Data Analysis with NumPy
Exercise 37: Object-Oriented Programming
Exercise 38: Regular Expressions
Exercise 39: File I/O
Exercise 40: Data Manipulation with Pandas

Web Scraping
E/S de Archivos
Análisis de Datos
Interfaz de Línea de Comandos
Integración de API
Expresiones Regulares
Programación Orientada a Objetos
Concurrencia
Pruebas
Visualización de Datos
Operaciones de Base de Datos
Redes
Ciencia de Datos
Desarrollo Web
Programación Asíncrona
Procesamiento de Imágenes
Envío de Correos Electrónicos
Integración de API Web
Encriptación de Datos
Programación de GUI
Registro
Web Scraping
Concurrencia con asyncio
Análisis de Datos con Pandas
Expresiones Regulares
ORM de Base de Datos
Web Scraping con Selenium
Procesamiento de Lenguaje Natural
Aprendizaje Automático
Reconocimiento de Imágenes con Aprendizaje Profundo
API Web con Flask
Programación de GUI con PyQt
Web Scraping con Beautiful Soup y Requests
Visualización de Datos con Matplotlib
Análisis de Datos con NumPy
Programación Orientada a Objetos
Expresiones Regulares
E/S de Archivos
Manipulación de Datos con Pandas

Ejercicio 1: Web Scraping

Conceptos:

Solicitudes HTTP utilizando el módulo requests
Análisis HTML utilizando BeautifulSoup

Descripción: El web scraping es una tarea común para muchos programadores de Python. En este ejercicio, escribirás un script que extrae datos de un sitio web.

Solución:

pythonCopy code
import requests
from bs4 import BeautifulSoup

url = 'https://www.example.com'
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')

# Find all links on the page
links = soup.find_all('a')
for link in links:
    print(link.get('href'))

Ejercicio 2: E/S de Archivos

Conceptos:

Lectura y escritura de archivos utilizando la función open() integrada de Python
Manipulación de cadenas

Descripción: Trabajar con archivos es una parte esencial de cualquier lenguaje de programación. En este ejercicio, escribirás un script que lee datos de un archivo y escribe datos en un archivo.

Solución:

pythonCopy code
# Read data from a file
with open('input.txt', 'r') as f:
    data = f.read()

# Manipulate the data
data = data.upper()

# Write data to a file
with open('output.txt', 'w') as f:
    f.write(data)

Ejercicio 3: Análisis de Datos

Conceptos:

Lectura de datos desde un archivo CSV utilizando Pandas
Manipulación de datos utilizando Pandas
Análisis de datos básico utilizando Pandas

Descripción: Python tiene un vasto ecosistema de bibliotecas para el análisis de datos. En este ejercicio, utilizarás la biblioteca Pandas para leer datos desde un archivo CSV y realizar algunos análisis de datos básicos.

Solución:

pythonCopy code
import pandas as pd

# Read data from a CSV file
data = pd.read_csv('data.csv')

# Display the first 5 rows of the data
print(data.head())

# Calculate some basic statistics
print(data.describe())

Ejercicio 4: Interfaz de Línea de Comandos

Conceptos:

Argumentos de línea de comandos utilizando el módulo argparse
Manipulación de cadenas de texto

Descripción: Python puede ser utilizado para crear herramientas de línea de comandos. En este ejercicio, escribirás un script que acepta argumentos de línea de comandos y realiza una tarea basada en esos argumentos.

Solución:

pythonCopy code
import argparse

# Create an argument parser
parser = argparse.ArgumentParser()
parser.add_argument('name', help='Your name')
parser.add_argument('age', type=int, help='Your age')
args = parser.parse_args()

# Print a greeting
greeting = f'Hello, {args.name}! You are {args.age} years old.'
print(greeting)

Ejercicio 5: Integración de API

Conceptos:

Solicitudes HTTP utilizando el módulo requests
Análisis de JSON

Descripción: Muchas aplicaciones modernas tienen APIs a las que se puede acceder programáticamente. En este ejercicio, escribirás un script que interactúa con una API RESTful.

Solución:

pythonCopy code
import requests

# Make a GET request to an API
url = 'https://api.example.com/users'
response = requests.get(url)

# Parse the response as JSON
data = response.json()

# Display the data
for user in data:
    print(user['name'], user['email'])

Ejercicio 6: Expresiones Regulares

Conceptos:

Expresiones regulares utilizando el módulo re
Validación de entrada de usuario

Descripción: Las expresiones regulares son herramientas poderosas para la coincidencia de patrones y la validación de datos. En este ejercicio, escribirás un script que utilice expresiones regulares para validar la entrada del usuario.

Solución:

pythonCopy code
import re

# Define a regular expression pattern for email validation
pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'

# Get user input
email = input('Enter your email address: ')

# Validate the input using the regular expression
if re.match(pattern, email):
    print('Valid email address')
else:
    print('Invalid email address')

Ejercicio 7: Programación Orientada a Objetos

Conceptos:

Clases y objetos
Encapsulamiento
Herencia

Descripción: La programación orientada a objetos es un concepto fundamental en Python. En este ejercicio, escribirás una clase simple que demuestra los principios de la programación orientada a objetos.

Solución:

rubyCopy code
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        print(f'Hello, my name is {self.name} and I am {self.age} years old.')

class Student(Person):
    def __init__(self, name, age, major):
        super().__init__(name, age)
        self.major = major

    def describe(self):
        print(f'I am a student majoring in {self.major}.')

# Create objects and call methods
person = Person('Alice', 25)
person.greet()

student = Student('Bob', 20, 'Computer Science')
student.greet()
student.describe()

Ejercicio 8: Concurrencia

Conceptos:

Hilos utilizando el módulo threading
Sincronización utilizando bloqueos

Descripción: Python tiene características poderosas de concurrencia que te permiten escribir programas concurrentes y paralelos. En este ejercicio, escribirás un script que demuestra la programación concurrente utilizando hilos.

Solución:

scssCopy code
import threading

counter = 0
lock = threading.Lock()

def increment():
    global counter
    with lock:
        counter += 1

threads = []
for i in range(10):
    t = threading.Thread(target=increment)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(f'The counter is {counter}.')

Ejercicio 9: Pruebas

Conceptos:

Pruebas unitarias utilizando el módulo unittest
Desarrollo guiado por pruebas

Descripción: Las pruebas son una parte crucial del desarrollo de software. En este ejercicio, escribirás pruebas unitarias para una función simple.

Solución:

rubyCopy code
import unittest

def is_palindrome(s):
    return s == s[::-1]

class TestPalindrome(unittest.TestCase):
    def test_is_palindrome(self):
        self.assertTrue(is_palindrome('racecar'))
        self.assertFalse(is_palindrome('hello'))

if __name__ == '__main__':
    unittest.main()

Ejercicio 10: Visualización de datos

Conceptos:

Visualización de datos utilizando Matplotlib
Gráficos de líneas

Descripción: La visualización de datos es una parte esencial del análisis de datos. En este ejercicio, utilizarás la biblioteca Matplotlib para crear un gráfico de líneas simple.

Solución:

pythonCopy code
import matplotlib.pyplot as plt

# Create some data
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]

# Create a line chart
plt.plot(x, y)

# Add labels and a title
plt.xlabel('X values')
plt.ylabel('Y values')
plt.title('Line chart')

# Display the chart
plt.show()

Ejercicio 11: Operaciones de Base de Datos

Conceptos:

Conexión a una base de datos utilizando el módulo SQLite3
Creación de tablas e inserción de datos
Consulta de datos utilizando SQL

Descripción: Python cuenta con una amplia variedad de bibliotecas para trabajar con bases de datos. En este ejercicio, escribirás un script que realice algunas operaciones comunes de bases de datos.

Solución:

pythonCopy code
import sqlite3

# Connect to the database
conn = sqlite3.connect('example.db')

# Create a table
conn.execute('''CREATE TABLE IF NOT EXISTS users
                (id INTEGER PRIMARY KEY,
                 name TEXT,
                 email TEXT)''')

# Insert some data
conn.execute("INSERT INTO users (name, email) VALUES (?, ?)", ('Alice', 'alice@example.com'))
conn.execute("INSERT INTO users (name, email) VALUES (?, ?)", ('Bob', 'bob@example.com'))

# Query the data
cursor = conn.execute("SELECT id, name, email FROM users")
for row in cursor:
    print(f'{row[0]} - {row[1]} ({row[2]})')

# Close the database connection
conn.close()

Ejercicio 12: Redes

Conceptos:

Programación de sockets utilizando el módulo socket
Arquitectura cliente-servidor

Descripción: Python tiene excelentes capacidades de redes, lo que te permite construir aplicaciones de red. En este ejercicio, escribirás un script que implementa un servidor y un cliente simples.

Solución:

scssCopy code
# Server code
import socket

server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(('localhost', 8000))
server_socket.listen(1)

while True:
    client_socket, address = server_socket.accept()
    data = client_socket.recv(1024)
    response = data.upper()
    client_socket.sendall(response)
    client_socket.close()

# Client code
import socket

client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect(('localhost', 8000))
client_socket.sendall(b'Hello, server!')
response = client_socket.recv(1024)
print(response)
client_socket.close()

Ejercicio 13: Ciencia de Datos

Conceptos:

Manipulación de datos utilizando NumPy y Pandas
Análisis de datos utilizando Pandas

Descripción: Python es un lenguaje popular para la ciencia de datos debido a sus poderosas bibliotecas. En este ejercicio, utilizarás las bibliotecas NumPy y Pandas para realizar análisis de datos.

Solución:

bashCopy code
import numpy as np
import pandas as pd

# Create some data
data = {'x': np.arange(10),
        'y': np.random.randn(10)}

# Create a DataFrame from the data
df = pd.DataFrame(data)

# Calculate some statistics
print(df.mean())
print(df.std())

# Create a new column based on a calculation
df['z'] = df['x'] * df['y']

# Display the DataFrame
print(df)

Ejercicio 14: Desarrollo Web

Conceptos:

Desarrollo web utilizando el framework Flask
Métodos HTTP y enrutamiento

Descripción: Python se puede utilizar para construir aplicaciones web utilizando una variedad de frameworks web. En este ejercicio, escribirás una aplicación web simple utilizando Flask.

Solución:

pythonCopy code
from flask import Flask, request

app = Flask(__name__)

@app.route('/', methods=['GET'])
def home():
    return 'Hello, world!'

@app.route('/greet', methods=['POST'])
def greet():
    name = request.form.get('name')
    return f'Hello, {name}!'

if __name__ == '__main__':
    app.run()

Ejercicio 15: Programación Asincrónica

Conceptos:

Programación asincrónica utilizando asyncio
Corrutinas

Descripción: Python tiene características poderosas para la programación asincrónica, lo que te permite escribir programas eficientes y escalables. En este ejercicio, escribirás un script que demuestra la programación asincrónica utilizando asyncio.

Solución:

scssCopy code
import asyncio

async def coroutine():
    print('Coroutine started')
    await asyncio.sleep(1)
    print('Coroutine ended')

loop = asyncio.get_event_loop()
loop.run_until_complete(coroutine())
loop.close()

Este script define una corutina utilizando la palabra clave async. La corutina espera un segundo usando la función asyncio.sleep(). La función asyncio.get_event_loop() se utiliza para crear un bucle de eventos, y el método loop.run_until_complete() se utiliza para ejecutar la corutina hasta que se complete. Finalmente, el bucle de eventos se cierra usando el método loop.close().

Ten en cuenta que el código anterior solo demuestra los conceptos básicos de la programación asincrónica con asyncio. Programas más complejos pueden requerir conceptos y técnicas adicionales, como bucles de eventos, futuros y devoluciones de llamada.

Ejercicio 16: Procesamiento de Imágenes

Conceptos:

Procesamiento de imágenes utilizando la biblioteca Pillow
Manipulación y conversión de imágenes

Descripción: Python tiene muchas bibliotecas para trabajar con imágenes. En este ejercicio, usarás la biblioteca Pillow para realizar algunas tareas básicas de procesamiento de imágenes.

Solución:

pythonCopy code
from PIL import Image

# Open an image file
image = Image.open('image.jpg')

# Display information about the image
print(image.format)
print(image.size)
print(image.mode)

# Convert the image to grayscale
grayscale_image = image.convert('L')
grayscale_image.show()

# Resize the image
resized_image = image.resize((300, 300))
resized_image.show()

# Save the image in a different format
resized_image.save('image.png')

Ejercicio 17: Envío de Correos Electrónicos

Conceptos:

Envío de correos electrónicos utilizando la biblioteca smtplib
Servidores SMTP y autenticación de correo electrónico

Descripción: Python cuenta con bibliotecas para enviar correos electrónicos de forma programática. En este ejercicio, escribirás un script que envía un correo electrónico utilizando la biblioteca smtplib.

Solución:

pythonCopy code
import smtplib

sender_email = 'your_email@example.com'
sender_password = 'your_password'
receiver_email = 'recipient_email@example.com'
message = 'Hello, world!'

with smtplib.SMTP('smtp.gmail.com', 587) as server:
    server.starttls()
    server.login(sender_email, sender_password)
    server.sendmail(sender_email, receiver_email, message)

Ejercicio 18: Integración de API web

Conceptos:

APIs RESTful y solicitudes HTTP
Integración de API web utilizando la biblioteca requests

Descripción: Python se puede utilizar para integrarse con muchas APIs web diferentes. En este ejercicio, escribirás un script que interactúa con una API web RESTful utilizando la biblioteca requests.

Solución:

kotlinCopy code
import requests

response = requests.get('https://api.example.com/users')
data = response.json()

for user in data:
    print(user['name'], user['email'])

Ejercicio 19: Encriptación de Datos

Conceptos:

Encriptación de datos utilizando la biblioteca cryptography
Encriptación simétrica y asimétrica

Descripción: Python cuenta con bibliotecas integradas para encriptar y desencriptar datos. En este ejercicio, escribirás un script que encripta y desencripta algunos datos utilizando la biblioteca cryptography.

Solución:

scssCopy code
from cryptography.fernet import Fernet
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives.serialization import load_pem_private_key, load_pem_public_key

# Symmetric encryption
key = Fernet.generate_key()
fernet = Fernet(key)
plaintext = b'This is a secret message'
ciphertext = fernet.encrypt(plaintext)
decrypted_plaintext = fernet.decrypt(ciphertext)
print(decrypted_plaintext)

# Asymmetric encryption
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048
)
public_key = private_key.public_key()

plaintext = b'This is a secret message'
ciphertext = public_key.encrypt(
    plaintext,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

decrypted_plaintext = private_key.decrypt(
    ciphertext,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)
print(decrypted_plaintext)

Ejercicio 20: Programación de GUI

Conceptos:

Programación de GUI utilizando la biblioteca Tkinter
Widgets y manejo de eventos

Descripción: Python cuenta con bibliotecas para construir interfaces gráficas de usuario (GUIs). En este ejercicio, escribirás un script que utiliza la biblioteca Tkinter para crear una GUI simple.

Solución:

scssCopy code
import tkinter as tk

def button_clicked():
    label.config(text='Hello, world!')

root = tk.Tk()

label = tk.Label(root, text='Welcome to my GUI')
label.pack()

button = tk.Button(root, text='Click me!', command=button_clicked)
button.pack()

root.mainloop()

Este script crea una ventana utilizando el método tkinter.Tk(). Luego, crea un widget Label y un widget Button y los empaqueta en la ventana utilizando el método pack(). Finalmente, entra en el bucle principal de eventos utilizando el método mainloop().

Cuando se hace clic en el botón, se llama a la función button_clicked(), que actualiza el texto del widget de etiqueta utilizando el método config().

Ejercicio 21: Entrada/Salida de Archivos

Conceptos:

Entrada/salida de archivos en Python
Lectura y escritura de archivos

Descripción: Python tiene soporte incorporado para leer y escribir archivos. En este ejercicio, escribirás un script que lee desde y escribe en un archivo.

Solución:

pythonCopy code
# Write to a file
with open('example.txt', 'w') as file:
    file.write('Hello, world!\n')
    file.write('How are you today?\n')

# Read from a file
with open('example.txt', 'r') as file:
    for line in file:
        print(line.strip())

Ejercicio 22: Registro

Conceptos:

Registro en Python
Niveles de registro y controladores

Descripción: Python tiene soporte incorporado para el registro. En este ejercicio, escribirás un script que registra algunos mensajes en un archivo.

Solución:

vbnetCopy code
import logging

logging.basicConfig(filename='example.log', level=logging.DEBUG)

logging.debug('This is a debug message')
logging.info('This is an info message')
logging.warning('This is a warning message')
logging.error('This is an error message')
logging.critical('This is a critical message')

Ejercicio 23: Web Scraping

Conceptos:

Web scraping utilizando BeautifulSoup
Análisis y navegación de HTML

Descripción: Python puede ser utilizado para hacer web scraping, lo que implica extraer datos de sitios web. En este ejercicio, utilizarás la biblioteca BeautifulSoup para hacer scraping de datos de un sitio web.

Solución:

pythonCopy code
import requests
from bs4 import BeautifulSoup

response = requests.get('https://en.wikipedia.org/wiki/Python_(programming_language)')
soup = BeautifulSoup(response.text, 'html.parser')
print(soup.title.string)

links = soup.find_all('a')
for link in links:
    print(link.get('href'))

Ejercicio 24: Concurrencia con asyncio

Conceptos:

Programación asíncrona utilizando asyncio
Corrutinas y bucles de eventos

Descripción: Python tiene un sólido soporte para la programación asíncrona utilizando la biblioteca asyncio. En este ejercicio, escribirás un script que demuestra el uso de asyncio para la programación concurrente.

Solución:

pythonCopy code
import asyncio

async def coroutine(id):
    print(f'Coroutine {id} started')
    await asyncio.sleep(1)
    print(f'Coroutine {id} ended')

async def main():
    tasks = []
    for i in range(10):
        tasks.append(asyncio.create_task(coroutine(i)))
    await asyncio.gather(*tasks)

asyncio.run(main())

Exercise 25: Data Analysis with Pandas

Concepts:

Data analysis with Pandas
Loading and manipulating data with DataFrames

Description: Pandas is a powerful library for data analysis and manipulation in Python. In this exercise, you'll use Pandas to perform some data analysis tasks.

Solution:

Conceptos:
• Análisis de datos con Pandas
• Carga y manipulación de datos con DataFrames
Descripción: Pandas es una biblioteca poderosa para el análisis y manipulación de datos en Python. En este ejercicio, utilizarás Pandas para realizar algunas tareas de análisis de datos.
Solución:

pythonCopy code
import pandas as pd

# Load data from a CSV file
data = pd.read_csv('example.csv')

# Print the first five rows of the data
print(data.head())

# Calculate some statistics on the data
print(data.describe())

# Group the data by a column and calculate some statistics
grouped_data = data.groupby('category')
print(grouped_data.mean())

En este script, cargamos datos desde un archivo CSV en un DataFrame de Pandas. Luego, imprimimos las primeras cinco filas de los datos usando el método head(), y calculamos algunas estadísticas sobre los datos usando el método describe().

Finalmente, agrupamos los datos por la columna category usando el método groupby() y calculamos algunas estadísticas sobre cada grupo usando el método mean().

Ejercicio 26: Expresiones Regulares

Conceptos:

Expresiones regulares en Python
Búsqueda de patrones y sustitución

Descripción: Las expresiones regulares son una herramienta poderosa para buscar y manipular texto. En este ejercicio, escribirás un script que utiliza expresiones regulares para buscar patrones en el texto.

Solución:

pythonCopy code
import re

text = 'The quick brown fox jumps over the lazy dog'

# Search for a pattern in the text
pattern = r'\b\w{4}\b'
matches = re.findall(pattern, text)
print(matches)

# Substitute a pattern in the text
pattern = r'\bthe\b'
replaced_text = re.sub(pattern, 'a', text, flags=re.IGNORECASE)
print(replaced_text)

Ejercicio 27: ORM de Base de Datos

Conceptos:

Mapeo objeto-relacional usando SQLAlchemy
Creación de tablas y consulta de datos

Descripción: Python tiene muchas bibliotecas de mapeo objeto-relacional (ORM) para trabajar con bases de datos. En este ejercicio, escribirás un script que utiliza el ORM SQLAlchemy para interactuar con una base de datos.

Solución:

sqlCopy code
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

# Define a database engine
engine = create_engine('sqlite:///example.db')

# Define a session factory
Session = sessionmaker(bind=engine)

# Define a declarative base
Base = declarative_base()

# Define a model class
class User(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True)
    name = Column(String)
    email = Column(String)

# Create the table
Base.metadata.create_all(engine)

# Add some data
session = Session()
session.add(User(name='Alice', email='alice@example.com'))
session.add(User(name='Bob', email='bob@example.com'))
session.commit()

# Query the data
users = session.query(User).all()
for user in users:
    print(user.name, user.email)

Ejercicio 28: Web Scraping con Selenium

Conceptos:

Web scraping con Selenium
Automatización del navegador y manipulación del DOM

Descripción: Selenium es una biblioteca popular para el web scraping que te permite controlar un navegador web de forma programática. En este ejercicio, escribirás un script que utiliza Selenium para extraer datos de un sitio web.

Solución:

scssCopy code
from selenium import webdriver

driver = webdriver.Chrome()

driver.get('https://en.wikipedia.org/wiki/Python_(programming_language)')

heading = driver.find_element_by_tag_name('h1')
print(heading.text)

links = driver.find_elements_by_tag_name('a')
for link in links:
    print(link.get_attribute('href'))

driver.close()

Ejercicio 29: Procesamiento del Lenguaje Natural

Conceptos:

Procesamiento del lenguaje natural utilizando la biblioteca NLTK
Tokenización, derivación y etiquetado de partes del discurso (POS)

Descripción: Python tiene muchas bibliotecas para el procesamiento del lenguaje natural (NLP, por sus siglas en inglés). En este ejercicio, utilizarás la biblioteca NLTK para realizar algunas tareas básicas de NLP.

Solución:

pythonCopy code
import nltk
from nltk.tokenize import word_tokenize
from nltk.stem import PorterStemmer
from nltk import pos_tag

nltk.download('punkt')
nltk.download('averaged_perceptron_tagger')

text = 'The quick brown fox jumped over the lazy dogs'

# Tokenize the text
tokens = word_tokenize(text)
print(tokens)

# Stem the tokens
stemmer = PorterStemmer()
stemmed_tokens = [stemmer.stem(token) for token in tokens]
print(stemmed_tokens)

# Perform part-of-speech tagging on the tokens
pos_tags = pos_tag(tokens)
print(pos_tags)

Ejercicio 30: Machine Learning

Conceptos:

Machine Learning utilizando scikit-learn
Preparación de datos, entrenamiento de modelos y predicción

Descripción: Python tiene muchas bibliotecas para el aprendizaje automático, incluyendo scikit-learn. En este ejercicio, usarás scikit-learn para entrenar un modelo de aprendizaje automático simple.

Solución:

pythonCopy code
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression

# Load data from a CSV file
data = pd.read_csv('example.csv')

# Prepare the data
X = data['x'].values.reshape(-1, 1)
y = data['y'].values.reshape(-1, 1)

# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

# Train the model
model = LinearRegression()
model.fit(X_train, y_train)

# Make predictions on the test set
y_pred = model.predict(X_test)

# Evaluate the model
score = model.score(X_test, y_test)
print(score)

En este script, cargamos datos desde un archivo CSV en un DataFrame de Pandas. Luego, preparamos los datos dividiéndolos en variables de entrada (X) y salida (y), y los dividimos en conjuntos de entrenamiento y prueba usando el método train_test_split().

A continuación, entrenamos un modelo de regresión lineal utilizando los datos de entrenamiento y hacemos predicciones sobre los datos de prueba utilizando el método predict(). Finalmente, evaluamos el rendimiento del modelo utilizando el método score(), que calcula el coeficiente de determinación (R^2) para el modelo.

Ejercicio 31: Reconocimiento de Imágenes con Aprendizaje Profundo

Conceptos:

Aprendizaje profundo con Keras
Redes neuronales convolucionales y reconocimiento de imágenes

Descripción: El aprendizaje profundo es una técnica poderosa para el reconocimiento de imágenes. En este ejercicio, utilizarás la biblioteca Keras para entrenar un modelo de aprendizaje profundo para reconocer imágenes.

Solución:

pythonCopy code
import numpy as np
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Flatten, Conv2D, MaxPooling2D
from keras.utils import to_categorical

# Load the MNIST dataset
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# Preprocess the data
X_train = X_train.reshape(-1, 28, 28, 1) / 255.0
X_test = X_test.reshape(-1, 28, 28, 1) / 255.0
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)

# Define the model architecture
model = Sequential()
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(MaxPooling2D((2, 2)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(Flatten())
model.add(Dense(64, activation='relu'))
model.add(Dense(10, activation='softmax'))

# Compile the model
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# Train the model
model.fit(X_train, y_train, epochs=5, batch_size=64)

# Evaluate the model
loss, accuracy = model.evaluate(X_test, y_test)
print(accuracy)

Exercise 32: Web APIs con Flask

Conceptos:

Web APIs con Flask
Arquitectura RESTful y métodos HTTP

Descripción: Flask es un marco de trabajo web ligero para Python. En este ejercicio, escribirás una aplicación Flask simple que expone una API web.

Solución:

pythonCopy code
from flask import Flask, request

app = Flask(__name__)

@app.route('/hello', methods=['GET'])
def hello():
    name = request.args.get('name')
    if name:
        return f'Hello, {name}!'
    else:
        return 'Hello, world!'

if __name__ == '__main__':
    app.run()

Exercise 33: Programación de GUI con PyQt

Conceptos:

Programación de GUI con PyQt
Widgets y manejo de eventos

Descripción: PyQt es una biblioteca potente para construir interfaces de usuario gráficas (GUIs) con Python. En este ejercicio, escribirás un script que utiliza PyQt para crear una GUI simple.

Solución:

pythonCopy code
import sys
from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QLineEdit, QPushButton

class MyWindow(QWidget):
    def __init__(self):
        super().__init__()

        self.label = QLabel('Enter your name:', self)
        self.label.move(50, 50)

        self.textbox = QLineEdit(self)
        self.textbox.move(50, 80)

        self.button = QPushButton('Say hello', self)
        self.button.move(50, 110)
        self.button.clicked.connect(self.button_clicked)

        self.setWindowTitle('Hello, world!')
        self.setGeometry(100, 100, 200, 150)

    def button_clicked(self):
        name = self.textbox.text()
        self.label.setText(f'Hello, {name}!')

app = QApplication(sys.argv)
window = MyWindow()
window.show()
sys.exit(app.exec_())

Exercise 34: Web Scraping con Beautiful Soup y Requests

Conceptos:

Web scraping con Beautiful Soup y Requests
Análisis y navegación de HTML

Descripción: Beautiful Soup y Requests son bibliotecas populares para hacer web scraping. En este ejercicio, escribirás un script que utiliza estas bibliotecas para extraer datos de un sitio web.

Solución:

pythonCopy code
import requests
from bs4 import BeautifulSoup

url = 'https://en.wikipedia.org/wiki/Python_(programming_language)'

response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')

title = soup.find('h1', {'id': 'firstHeading'}).text
print(title)

content = soup.find('div', {'id': 'mw-content-text'}).text
print(content[:100])

Ejercicio 35: Visualización de datos con Matplotlib

Conceptos:

Visualización de datos con Matplotlib
Gráficos de líneas y etiquetas

Descripción: Matplotlib es una biblioteca popular para la visualización de datos en Python. En este ejercicio, escribirás un script que utiliza Matplotlib para crear un gráfico de líneas simple.

Solución:

scssCopy code
import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5]
y = [1, 4, 9, 16, 25]

plt.plot(x, y)
plt.xlabel('x')
plt.ylabel('y')
plt.title('A Simple Line Plot')
plt.show()

Ejercicio 36: Análisis de datos con NumPy

Conceptos:

Análisis de datos con NumPy
Creación y manipulación de matrices

Descripción: NumPy es una biblioteca poderosa para computación numérica en Python. En este ejercicio, escribirás un script que utiliza NumPy para realizar algunas tareas básicas de análisis de datos.

Solución:

pythonCopy code
import numpy as np

# Create a 2D array
data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Print the array
print(data)

# Calculate some statistics on the array
print(np.mean(data))
print(np.median(data))
print(np.std(data))

# Reshape the array
reshaped_data = data.reshape(1, 9)
print(reshaped_data)

Ejercicio 37: Programación Orientada a Objetos

Conceptos:

Programación orientada a objetos en Python
Clases, objetos y herencia

Descripción: Python es un lenguaje de programación orientado a objetos. En este ejercicio, escribirás un script que demuestre el uso de la programación orientada a objetos en Python.

Solución:

pythonCopy code
class Shape:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def move(self, dx, dy):
        self.x += dx
        self.y += dy

class Rectangle(Shape):
    def __init__(self, x, y, width, height):
        super().__init__(x, y)
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

class Circle(Shape):
    def __init__(self, x, y, radius):
        super().__init__(x, y)
        self.radius = radius

    def area(self):
        return 3.14159 * self.radius ** 2

rect = Rectangle(0, 0, 10, 5)
print(rect.area())
rect.move(1, 1)
print(rect.x, rect.y)

circ = Circle(0, 0, 5)
print(circ.area())
circ.move(2, 2)
print(circ.x, circ.y)

En este script, definimos una clase Shape que tiene coordenadas x e y, y un método move() que mueve la forma por una cantidad especificada en las direcciones x e y.

Luego definimos una clase Rectangle que hereda de Shape, y agrega atributos de width y height, así como un método area() que calcula el área del rectángulo.

También definimos una clase Circle que hereda de Shape, y agrega un atributo de radius, así como un método area() que calcula el área del círculo.

Finalmente, creamos instancias de las clases Rectangle y Circle, y llamamos a sus métodos area() y move().

Ejercicio 38: Expresiones Regulares

Conceptos:

Expresiones regulares en Python
Búsqueda de patrones en texto

Descripción: Las expresiones regulares son una herramienta poderosa para el procesamiento de texto en Python. En este ejercicio, escribirás un script que utiliza expresiones regulares para buscar patrones en un archivo de texto.

Solución:

pythonCopy code
import re

with open('example.txt', 'r') as f:
    data = f.read()

pattern = r'\d{3}-\d{2}-\d{4}'
matches = re.findall(pattern, data)

for match in matches:
    print(match)

En este script, abrimos un archivo de texto y leemos su contenido en una variable. Luego definimos un patrón de expresión regular que coincide con un número de seguro social en el formato XXX-XX-XXXX.

Utilizamos la función findall() del módulo re para encontrar todas las ocurrencias del patrón en el texto, y las imprimimos.

Ejercicio 39: Entrada/Salida de Archivos

Conceptos:

Entrada/Salida de archivos en Python
Lectura y escritura de archivos de texto

Descripción: La entrada/salida de archivos es una tarea común en la programación en Python. En este ejercicio, escribirás un script que lee datos de un archivo, realiza algún procesamiento y escribe los resultados en otro archivo.

Solución:

pythonCopy code
with open('input.txt', 'r') as f:
    data = f.readlines()

# Process the data
output = []
for line in data:
    line = line.strip()
    words = line.split()
    words.reverse()
    output.append(' '.join(words))

# Write the results to a file
with open('output.txt', 'w') as f:
    for line in output:
        f.write(line + '\n')

En este script, abrimos un archivo de entrada y leemos su contenido en una lista de cadenas. Luego procesamos los datos dividiendo cada línea en palabras, invirtiendo el orden de las palabras y volviéndolas a unir en una sola cadena.

Escribimos las cadenas resultantes en un archivo de salida, con cada cadena en una línea separada.

Ejercicio 40: Manipulación de Datos con Pandas

Conceptos:

Manipulación de datos con Pandas
Lectura y filtrado de datos

Descripción: Pandas es una poderosa biblioteca para la manipulación de datos en Python. En este ejercicio, escribirás un script que utiliza Pandas para cargar, procesar y analizar un conjunto de datos.

Solución:

pythonCopy code
import pandas as pd

# Load the data from a CSV file
data = pd.read_csv('example.csv')

# Filter the data to include only rows where the value is greater than 5
filtered_data = data[data['value'] > 5]

# Calculate the mean and standard deviation of the filtered data
mean = filtered_data['value'].mean()
std = filtered_data['value'].std()

print(f'Mean: {mean}')
print(f'Standard deviation: {std}')

En este script, cargamos un conjunto de datos desde un archivo CSV en un DataFrame de Pandas. Luego filtramos los datos para incluir solo las filas donde el valor es mayor que 5.

Calculamos la media y la desviación estándar de los datos filtrados utilizando los métodos mean() y std() del DataFrame, e imprimimos los resultados.