Ejercicios de Nivel Avanzado Parte 2

Click here to view the next lesson.

Ejercicios de Nivel Avanzado Parte 2

Ejercicio 26: Aprendizaje Automático

Conceptos:

Aprendizaje Automático
Biblioteca Scikit-Learn
Preprocesamiento de Datos
Ingeniería de Características
Entrenamiento de Modelos
Evaluación de Modelos

Descripción: Escribe un script en Python que utilice técnicas de aprendizaje automático para entrenar un modelo y hacer predicciones sobre nuevos datos.

Solución:

pythonCopy code
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score

# Read the data into a pandas dataframe
df = pd.read_csv('data.csv')

# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(df.drop('target', axis=1), df['target'], test_size=0.2, random_state=42)

# Scale the data using standardization
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Train a logistic regression model
model = LogisticRegression(random_state=42)
model.fit(X_train_scaled, y_train)

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

# Evaluate the model performance
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)

print('Accuracy:', accuracy)
print('Precision:', precision)
print('Recall:', recall)
print('F1 score:', f1)

En este ejercicio, primero leemos un conjunto de datos en un dataframe de pandas. Dividimos los datos en conjuntos de entrenamiento y prueba utilizando la función train_test_split del módulo sklearn.model_selection. Escalamos los datos utilizando la estandarización utilizando la clase StandardScaler del módulo sklearn.preprocessing. Entrenamos un modelo de regresión logística utilizando la clase LogisticRegression del módulo sklearn.linear_model y hacemos predicciones sobre el conjunto de pruebas. Finalmente, evaluamos el rendimiento del modelo utilizando métricas como la precisión, la exhaustividad, la sensibilidad y la puntuación F1 utilizando las funciones apropiadas del módulo sklearn.metrics.

Ejercicio 27: Desarrollo Web

Conceptos:

Desarrollo Web
Framework Flask
Plantillas HTML
Enrutamiento
Métodos HTTP
Manipulación de Formularios

Descripción: Escribe un script en Python que cree una aplicación web utilizando el framework Flask.

Solución:

pythonCopy code
from flask import Flask, render_template, request

app = Flask(__name__)

# Define a route for the home page
@app.route('/')
def home():
    return render_template('home.html')

# Define a route for the contact page
@app.route('/contact', methods=['GET', 'POST'])
def contact():
    if request.method == 'POST':
        name = request.form['name']
        email = request.form['email']
        message = request.form['message']
        # TODO: Process the form data
        return 'Thanks for contacting us!'
    else:
        return render_template('contact.html')

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

En este ejercicio, primero importamos la clase Flask del módulo flask y creamos una nueva aplicación Flask. Definimos rutas para la página de inicio y la página de contacto utilizando el decorador route. Utilizamos la función render_template para renderizar plantillas HTML para la página de inicio y la página de contacto. Manejamos envíos de formularios en la página de contacto utilizando el objeto request y el método POST. Finalmente, iniciamos la aplicación Flask utilizando el método run.

Ejercicio 28: Streaming de Datos

Conceptos:

Streaming de Datos
Kafka
Biblioteca PyKafka
Procesamiento de Flujo

Descripción: Escribe un script en Python que transmita datos desde una fuente y los procese en tiempo real.

Solución:

pythonCopy code
from pykafka import KafkaClient
import json

# Connect to the Kafka broker
client = KafkaClient(hosts='localhost:9092')

# Get a reference to the topic
topic = client.topics['test']

# Create a consumer for the topic
consumer = topic.get_simple_consumer()

# Process messages in real-time
for message in consumer:
    if message is not None:
        data = json.loads(message.value)
        # TODO: Process the data in real-time

En este ejercicio, primero nos conectamos a un broker de Kafka utilizando la clase KafkaClient de la biblioteca pykafka. Obtenemos una referencia a un tema y creamos un consumidor para el tema utilizando el método get_simple_consumer. Procesamos mensajes en tiempo real utilizando un bucle y el atributo value de los mensajes. Analizamos los datos del mensaje utilizando la función json.loads y procesamos los datos en tiempo real.

Ejercicio 29: Procesamiento del Lenguaje Natural

Conceptos:

Procesamiento del Lenguaje Natural
Biblioteca NLTK
Tokenización
Derivación
Eliminación de Palabras Vacías

Descripción: Escribe un script en Python que realice tareas de procesamiento del lenguaje natural en un corpus de texto.

Solución:

pythonCopy code
import nltk
from nltk.tokenize import word_tokenize
from nltk.stem import PorterStemmer
from nltk.corpus import stopwords

# Download NLTK data
nltk.download('punkt')
nltk.download('stopwords')

# Load the text corpus
with open('corpus.txt', 'r') as f:
    corpus = f.read()

# Tokenize the corpus
tokens = word_tokenize(corpus)

# Remove stop words
stop_words = set(stopwords.words('english'))
filtered_tokens = [token for token in tokens if token.lower() not in stop_words]

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

# Print the results
print('Original tokens:', tokens[:10])
print('Filtered tokens:', filtered_tokens[:10])
print('Stemmed tokens:', stemmed_tokens[:10])

En este ejercicio, primero descargamos los datos necesarios de la biblioteca NLTK utilizando la función nltk.download. Cargamos un corpus de texto desde un archivo y tokenizamos el corpus utilizando la función word_tokenize del módulo nltk.tokenize. Eliminamos las palabras vacías utilizando el corpus stopwords de la biblioteca NLTK y aplicamos derivación a los tokens utilizando la clase PorterStemmer del módulo nltk.stem. Finalmente, imprimimos los resultados para los tokens originales, filtrados y derivados.

Ejercicio 30: Sistemas Distribuidos

Conceptos:

Sistemas Distribuidos
Biblioteca Pyro
Invocación Remota de Métodos
Arquitectura Cliente-Servidor

Descripción: Escribe un script en Python que implemente un sistema distribuido utilizando la biblioteca Pyro.

Solución:

pythonCopy code
import Pyro4

# Define a remote object class
@Pyro4.expose
class MyObject:
    def method1(self, arg1):
        # TODO: Implement the method
        return result1

    def method2(self, arg2):
        # TODO: Implement the method
        return result2

# Register the remote object
daemon = Pyro4.Daemon()
uri = daemon.register(MyObject)

# Start the name server
ns = Pyro4.locateNS()
ns.register('myobject', uri)

# Start the server
daemon.requestLoop()

En este ejercicio, primero definimos una clase de objeto remoto utilizando el decorador expose de la biblioteca Pyro4. Implementamos dos métodos que pueden ser invocados remotamente por un cliente. Registramos el objeto remoto utilizando el método register de un demonio Pyro4. Iniciamos el servidor de nombres utilizando la función locateNS de la biblioteca Pyro4 y registramos el objeto remoto con un nombre. Finalmente, iniciamos el servidor utilizando el método requestLoop del demonio.

Espero que encuentres útiles estos ejercicios. ¡Avísame si tienes alguna otra pregunta!

Ejercicio 31: Visualización de Datos

Conceptos:

Visualización de Datos
Biblioteca Plotly
Gráfico de Línea
Gráfico de Dispersión
Gráfico de Barras
Mapa de Calor
Subgráficos

Descripción: Escribe un script en Python que cree visualizaciones interactivas de datos utilizando la biblioteca Plotly.

Solución:

pythonCopy code
import plotly.graph_objs as go
import plotly.subplots as sp
import pandas as pd

# Load the data into a pandas dataframe
df = pd.read_csv('data.csv')

# Create a line chart
trace1 = go.Scatter(x=df['year'], y=df['sales'], mode='lines', name='Sales')

# Create a scatter chart
trace2 = go.Scatter(x=df['year'], y=df['profit'], mode='markers', name='Profit')

# Create a bar chart
trace3 = go.Bar(x=df['year'], y=df['expenses'], name='Expenses')

# Create a heatmap
trace4 = go.Heatmap(x=df['year'], y=df['quarter'], z=df['revenue'], colorscale='Viridis', name='Revenue')

# Create subplots
fig = sp.make_subplots(rows=2, cols=2, subplot_titles=('Sales', 'Profit', 'Expenses', 'Revenue'))
fig.append_trace(trace1, 1, 1)
fig.append_trace(trace2, 1, 2)
fig.append_trace(trace3, 2, 1)
fig.append_trace(trace4, 2, 2)

# Set the layout
fig.update_layout(title='Financial Performance', height=600, width=800)

# Display the chart
fig.show()

En este ejercicio, primero cargamos un conjunto de datos en un dataframe de pandas. Creamos varios objetos de gráfico utilizando las clases Scatter, Bar y Heatmap del módulo plotly.graph_objs. Creamos subgráficos utilizando la función make_subplots del módulo plotly.subplots y agregamos los objetos de gráfico a los subgráficos utilizando el método append_trace. Establecemos el diseño del gráfico utilizando el método update_layout y mostramos el gráfico utilizando el método show.

Ejercicio 32: Ingeniería de Datos

Conceptos:

Ingeniería de Datos
SQLite
Biblioteca Pandas
Transformación de Datos
Integración de Datos

Descripción: Escribe un script en Python que procese datos de múltiples fuentes y los almacene en una base de datos.

Solución:

pythonCopy code
import sqlite3
import pandas as pd

# Load data from multiple sources into pandas dataframes
df1 = pd.read_csv('data1.csv')
df2 = pd.read_excel('data2.xlsx')
df3 = pd.read_json('data3.json')

# Transform the data
df1['date'] = pd.to_datetime(df1['date'])
df2['amount'] = df2['amount'] / 100
df3['description'] = df3['description'].str.upper()

# Combine the data
df = pd.concat([df1, df2, df3], axis=0)

# Store the data in a SQLite database
conn = sqlite3.connect('mydb.db')
df.to_sql('mytable', conn, if_exists='replace', index=False)

En este ejercicio, primero cargamos datos de múltiples fuentes en dataframes de pandas utilizando funciones como read_csv, read_excel y read_json. Transformamos los datos utilizando funciones de pandas como to_datetime, str.upper y operaciones aritméticas. Combinamos los datos en un solo dataframe de pandas utilizando la función concat. Finalmente, almacenamos los datos en una base de datos SQLite utilizando el método to_sql del dataframe de pandas.

Ejercicio 33: Generación de Lenguaje Natural

Conceptos:

Generación de Lenguaje Natural
Cadenas de Markov
Biblioteca NLTK
Corpus de Texto

Descripción: Escribe un script en Python que genere texto utilizando técnicas de generación de lenguaje natural.

Solución:

pythonCopy code
import nltk
import random

# Download NLTK data
nltk.download('punkt')

# Load the text corpus
with open('corpus.txt', 'r') as f:
    corpus = f.read()

# Tokenize the corpus
tokens = nltk.word_tokenize(corpus)

# Build a dictionary of word transitions
chain = {}
for i in range(len(tokens) - 1):
    word1 = tokens[i]
    word2 = tokens[i + 1]
    if word1 in chain:
        chain[word1].append(word2)
    else:
        chain[word1] = [word2]

# Generate text using Markov chains
start_word = random.choice(list(chain.keys()))
sentence = start_word.capitalize()
while len(sentence) < 100:
    next_word = random.choice(chain[sentence.split()[-1]])
    sentence += ' ' + next_word

# Print the generated text
print(sentence)

En este ejercicio, primero descargamos los datos necesarios de la biblioteca NLTK utilizando la función nltk.download. Cargamos un corpus de texto desde un archivo y tokenizamos el corpus utilizando la función word_tokenize de la biblioteca nltk. Construimos un diccionario de transiciones de palabras utilizando un bucle y generamos texto utilizando cadenas de Markov. Comenzamos seleccionando una palabra aleatoria del diccionario y luego seleccionamos aleatoriamente una siguiente palabra de la lista de transiciones posibles. Continuamos agregando palabras a la oración hasta que alcance una longitud especificada. Finalmente, imprimimos el texto generado.

Ejercicio 34: Aprendizaje Automático

Conceptos:

Aprendizaje Automático
Biblioteca Scikit-learn
Clasificador de Árboles de Decisión
Entrenamiento de Modelos
Evaluación de Modelos

Descripción: Escribe un script en Python que entrene un modelo de aprendizaje automático utilizando la biblioteca scikit-learn.

Solución:

pythonCopy code
from sklearn import datasets
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Load the iris dataset
iris = datasets.load_iris()

# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.3, random_state=42)

# Train a decision tree classifier
clf = DecisionTreeClassifier()
clf.fit(X_train, y_train)

# Evaluate the model
y_pred = clf.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print('Accuracy:', accuracy)

En este ejercicio, primero cargamos el conjunto de datos iris desde la biblioteca scikit-learn utilizando la función load_iris. Dividimos los datos en conjuntos de entrenamiento y prueba utilizando la función train_test_split. Entrenamos un clasificador de árboles de decisión utilizando la clase DecisionTreeClassifier y el método fit. Evaluamos el modelo utilizando el método predict y la función accuracy_score del módulo sklearn.metrics.

Ejercicio 35: Visión por Computadora

Conceptos:

Visión por Computadora
Biblioteca OpenCV
Carga de Imágenes
Filtrado de Imágenes
Segmentación de Imágenes

Descripción: Escribe un script en Python que realice tareas de visión por computadora en imágenes utilizando la biblioteca OpenCV.

Solución:

pythonCopy code
import cv2

# Load an image
img = cv2.imread('image.jpg')

# Convert the image to grayscale
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Apply a median filter to the image
filtered = cv2.medianBlur(gray, 5)

# Apply adaptive thresholding to the image
thresh = cv2.adaptiveThreshold(filtered, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2)

# Apply morphological operations to the image
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
closed = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel)

# Find contours in the image
contours, hierarchy = cv2.findContours(closed, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

# Draw the contours on the original image
cv2.drawContours(img, contours, -1, (0, 0, 255), 2)

# Display the images
cv2.imshow('Original', img)
cv2.imshow('Thresholded', thresh)
cv2.imshow('Closed', closed)
cv2.waitKey(0)

En este ejercicio, primero cargamos una imagen utilizando la función imread de la biblioteca OpenCV. Convertimos la imagen a escala de grises utilizando la función cvtColor y aplicamos un filtro de mediana a la imagen utilizando la función medianBlur. Aplicamos umbral adaptativo a la imagen utilizando la función adaptiveThreshold y operaciones morfológicas a la imagen utilizando las funciones getStructuringElement y morphologyEx. Encontramos los contornos en la imagen utilizando la función findContours y dibujamos los contornos en la imagen original utilizando la función drawContours. Finalmente, mostramos las imágenes utilizando la función imshow.

Espero que encuentres útiles estos ejercicios. ¡Avísame si tienes alguna otra pregunta!

Ejercicio 36: Programación de Redes

Conceptos:

Programación de Redes
Biblioteca Socket
Arquitectura Cliente-Servidor
Implementación de Protocolos

Descripción: Escribe un script en Python que se comunique con un servidor remoto utilizando la biblioteca de sockets.

Solución:

pythonCopy code
import socket

# Create a socket object
s = socket.socket()

# Define the server address and port number
host = 'localhost'
port = 12345

# Connect to the server
s.connect((host, port))

# Send data to the server
s.send(b'Hello, server!')

# Receive data from the server
data = s.recv(1024)

# Close the socket
s.close()

# Print the received data
print('Received:', data.decode())

En este ejercicio, primero creamos un objeto de socket utilizando la función socket de la biblioteca de sockets. Definimos la dirección y el número de puerto del servidor al que queremos conectarnos. Nos conectamos al servidor utilizando el método connect del objeto de socket. Enviamos datos al servidor utilizando el método send y recibimos datos del servidor utilizando el método recv. Finalmente, cerramos el socket utilizando el método close e imprimimos los datos recibidos.

Ejercicio 37: Computación en la Nube

Conceptos:

Computación en la Nube
Heroku
Flask
Implementación de Aplicaciones Web

Descripción: Escribe un script en Python que implemente una aplicación web Flask en la plataforma de nube Heroku.

Solución:

pythonCopy code
# Install the required libraries
!pip install Flask gunicorn

# Import the Flask library
from flask import Flask

# Create a Flask application
app = Flask(__name__)

# Define a route
@app.route('/')
def hello():
    return 'Hello, world!'

# Run the application
if __name__ == '__main__':
    app.run()

En este ejercicio, primero instalamos las bibliotecas necesarias para implementar una aplicación web Flask en la plataforma de nube Heroku. Creamos una aplicación Flask simple que define una sola ruta. Utilizamos el método run del objeto Flask para ejecutar la aplicación localmente. Para implementar la aplicación en la plataforma de nube Heroku, necesitamos seguir las instrucciones proporcionadas por Heroku y enviar nuestro código a un repositorio remoto.

Ejercicio 38: Procesamiento de Lenguaje Natural

Conceptos:

Procesamiento de Lenguaje Natural
Biblioteca spaCy
Reconocimiento de Entidades Nombradas
Procesamiento de Texto

Descripción: Escribe un script en Python que realice reconocimiento de entidades nombradas en texto utilizando la biblioteca spaCy.

Solución:

pythonCopy code
import spacy

# Load the English language model
nlp = spacy.load('en_core_web_sm')

# Define some text to process
text = 'Barack Obama was born in Hawaii.'

# Process the text
doc = nlp(text)

# Extract named entities from the text
for ent in doc.ents:
    print(ent.text, ent.label_)

En este ejercicio, primero cargamos el modelo del idioma inglés utilizando la función load de la biblioteca spaCy. Definimos un texto para procesar y procesamos el texto utilizando la función nlp de la biblioteca spaCy. Extraemos las entidades nombradas del texto utilizando el atributo ents del texto procesado e imprimimos el texto y la etiqueta de cada entidad nombrada.

Ejercicio 39: Aprendizaje Profundo

Conceptos:

Aprendizaje Profundo
Biblioteca TensorFlow
Redes Neuronales Convolucionales
Entrenamiento de Modelos
Evaluación de Modelos

Descripción: Escribe un script en Python que entrene un modelo de aprendizaje profundo utilizando la biblioteca TensorFlow.

Solución:

pythonCopy code
import tensorflow as tf
from tensorflow.keras import datasets, layers, models

# Load the CIFAR-10 dataset
(train_images, train_labels), (test_images, test_labels) = datasets.cifar10.load_data()

# Normalize the pixel values
train_images, test_images = train_images / 255.0, test_images / 255.0

# Define the model architecture
model = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10)
])

# Compile the model
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

# Train the model
model.fit(train_images, train_labels, epochs=10,
          validation_data=(test_images, test_labels))

# Evaluate the model
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
print('Test accuracy:', test_acc)

En este ejercicio, primero cargamos el conjunto de datos CIFAR-10 de la biblioteca TensorFlow utilizando la función load_data. Normalizamos los valores de píxeles de las imágenes dividiéndolos por 255.0. Definimos una arquitectura de modelo de aprendizaje profundo utilizando la clase Sequential de la biblioteca TensorFlow y varias capas como Conv2D, MaxPooling2D, Flatten y Dense. Compilamos el modelo utilizando el método compile y entrenamos el modelo utilizando el método fit. Evaluamos el modelo utilizando el método evaluate e imprimimos la precisión de la prueba.

Exercise 40: Análisis de Datos

Conceptos:

Análisis de Datos
Biblioteca Pandas
Limpieza de Datos
Manipulación de Datos
Visualización de Datos

Descripción: Escribe un script en Python que analice datos utilizando la biblioteca pandas.

Solución:

pythonCopy code
import pandas as pd
import matplotlib.pyplot as plt

# Load the data
df = pd.read_csv('data.csv')

# Clean the data
df.dropna(inplace=True)

# Manipulate the data
df['total_sales'] = df['price'] * df['quantity']
monthly_sales = df.groupby(pd.Grouper(key='date', freq='M')).sum()

# Visualize the data
plt.plot(monthly_sales['total_sales'])
plt.xlabel('Month')
plt.ylabel('Total Sales')
plt.show()

En este ejercicio, primero cargamos los datos de un archivo CSV utilizando la función read_csv de la biblioteca pandas. Luego, limpiamos los datos eliminando cualquier fila con valores faltantes utilizando el método dropna. Posteriormente, manipulamos los datos calculando las ventas totales para cada transacción y agrupando los datos por mes utilizando el método groupby. Finalmente, visualizamos los datos trazando las ventas totales para cada mes utilizando la función plot de la biblioteca matplotlib.

Ejercicio 41: Ciencia de Datos

Conceptos:

Ciencia de Datos
Biblioteca NumPy
Biblioteca pandas
Biblioteca Matplotlib
Limpieza de Datos
Manipulación de Datos
Visualización de Datos

Descripción: Escribe un script en Python que realice análisis de datos en un conjunto de datos utilizando las bibliotecas NumPy, pandas y Matplotlib.

Solución:

pythonCopy code
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# Load the data
df = pd.read_csv('data.csv')

# Clean the data
df.dropna(inplace=True)

# Manipulate the data
df['total_sales'] = df['price'] * df['quantity']
monthly_sales = df.groupby(pd.Grouper(key='date', freq='M')).sum()

# Analyze the data
print('Total Sales:', df['total_sales'].sum())
print('Average Price:', df['price'].mean())
print('Median Quantity:', df['quantity'].median())

# Visualize the data
plt.plot(monthly_sales['total_sales'])
plt.xlabel('Month')
plt.ylabel('Total Sales')
plt.show()

En este ejercicio, primero cargamos datos desde un archivo CSV utilizando la función read_csv de la biblioteca pandas. Luego, limpiamos los datos eliminando cualquier fila con valores faltantes utilizando el método dropna. Posteriormente, manipulamos los datos calculando las ventas totales para cada transacción y agrupando los datos por mes utilizando el método groupby. Realizamos un análisis de datos básico calculando las ventas totales, el precio promedio y la cantidad mediana. Visualizamos los datos trazando las ventas totales para cada mes utilizando la función plot de la biblioteca matplotlib.

Ejercicio 42: Aprendizaje Automático

Conceptos:

Aprendizaje Automático
Biblioteca scikit-learn
Máquinas de Vectores de Soporte
Entrenamiento de Modelos
Evaluación de Modelos

Descripción: Escribe un script en Python que entrene un modelo de aprendizaje automático utilizando la biblioteca scikit-learn.

Solución:

pythonCopy code
import numpy as np
from sklearn import datasets, svm
from sklearn.model_selection import train_test_split

# Load the iris dataset
iris = datasets.load_iris()

# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=42)

# Train a support vector machine classifier
clf = svm.SVC(kernel='linear')
clf.fit(X_train, y_train)

# Evaluate the classifier
score = clf.score(X_test, y_test)
print('Accuracy:', score)

En este ejercicio, primero cargamos el conjunto de datos iris desde la biblioteca scikit-learn utilizando la función load_iris. Luego, dividimos los datos en conjuntos de entrenamiento y prueba utilizando la función train_test_split de la biblioteca scikit-learn. Entrenamos un clasificador de máquinas de vectores de soporte utilizando la clase SVC de la biblioteca scikit-learn con un kernel lineal. Evaluamos el clasificador utilizando el método score e imprimimos la precisión.

Ejercicio 43: Web Scraping

Conceptos:

Web Scraping
Biblioteca BeautifulSoup
Análisis HTML
Extracción de Datos

Descripción: Escribe un script en Python que extraiga datos de un sitio web utilizando la biblioteca BeautifulSoup.

Solución:

pythonCopy code
import requests
from bs4 import BeautifulSoup

# Fetch the HTML content of the website
url = 'https://en.wikipedia.org/wiki/Python_(programming_language)'
r = requests.get(url)
html_content = r.text

# Parse the HTML content using BeautifulSoup
soup = BeautifulSoup(html_content, 'html.parser')

# Extract data from the HTML content
title = soup.title.string
links = soup.find_all('a')
for link in links:
    print(link.get('href'))

En este ejercicio, primero obtenemos el contenido HTML de un sitio web utilizando la función get de la biblioteca requests. Luego, analizamos el contenido HTML utilizando la clase BeautifulSoup de la biblioteca BeautifulSoup. Extraemos datos del contenido HTML utilizando varios métodos como title y find_all.

Ejercicio 44: Programación de Bases de Datos

Conceptos:

Programación de Bases de Datos
Biblioteca SQLite
SQL
Recuperación de Datos
Manipulación de Datos

Descripción: Escribe un script en Python que interactúe con una base de datos utilizando la biblioteca SQLite.

Solución:

pythonCopy code
import sqlite3

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

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

# Insert data into the table
conn.execute("INSERT INTO users (name, age) VALUES ('John Doe', 30)")
conn.execute("INSERT INTO users (name, age) VALUES ('Jane Doe', 25)")

# Retrieve data from the table
cur = conn.execute('SELECT * FROM users')
for row in cur:
    print(row)

# Update data in the table
conn.execute("UPDATE users SET age = 35 WHERE name = 'John Doe'")

# Delete data from the table
conn.execute("DELETE FROM users WHERE name = 'Jane Doe'")

# Commit the changes and close the connection
conn.commit()
conn.close()

En este ejercicio, primero nos conectamos a una base de datos SQLite utilizando la función connect de la biblioteca SQLite. Creamos una tabla utilizando comandos SQL e insertamos datos en la tabla utilizando comandos SQL. Recuperamos datos de la tabla utilizando comandos SQL e imprimimos los datos. Actualizamos datos en la tabla y eliminamos datos de la tabla utilizando comandos SQL. Finalmente, confirmamos los cambios en la base de datos y cerramos la conexión.

Ejercicio 45: Computación en la Nube

Conceptos:

Computación en la Nube
AWS
Biblioteca Flask
Biblioteca Boto3
Implementación de Aplicaciones Web

Descripción: Escribe un script en Python que implemente una aplicación web en la plataforma de computación en la nube de AWS utilizando las bibliotecas Flask y Boto3.

Solución:

pythonCopy code
# Install the required libraries
!pip install Flask boto3

# Import the required libraries
from flask import Flask
import boto3

# Create a Flask application
app = Flask(__name__)

# Define a route
@app.route('/')
def hello():
    return 'Hello, world!'

# Deploy the application to AWS
s3 = boto3.client('s3')
s3.upload_file('app.py', 'my-bucket', 'app.py')

En este ejercicio, primero instalamos las bibliotecas requeridas para implementar una aplicación web Flask en la plataforma de computación en la nube de AWS. Creamos una aplicación Flask simple que define una sola ruta. Utilizamos el método upload_file de la biblioteca Boto3 para cargar la aplicación en un bucket de AWS S3. Es importante tener en cuenta que este es solo un ejemplo básico y que hay muchos pasos adicionales involucrados en la implementación de una aplicación web en la plataforma de computación en la nube de AWS, como crear una instancia EC2, configurar un balanceador de carga, configurar grupos de seguridad y más.

Ejercicio 46: Procesamiento del Lenguaje Natural

Conceptos:

Procesamiento del Lenguaje Natural
Biblioteca NLTK
Tokenización
Etiquetado de Partes del Discurso
Reconocimiento de Entidades Nombradas

Descripción: Escribe un script en Python que realice procesamiento del lenguaje natural en datos de texto utilizando la biblioteca NLTK.

Solución:

pythonCopy code
import nltk

# Load the text data
text = '''Apple Inc. is an American multinational technology company headquartered in Cupertino, California, that designs, develops, and sells consumer electronics, computer software, and online services. The company's hardware products include the iPhone smartphone, the iPad tablet computer, the Mac personal computer, the iPod portable media player, the Apple Watch smartwatch, the Apple TV digital media player, and the HomePod smart speaker. Apple's software includes the macOS and iOS operating systems, the iTunes media player, the Safari web browser, and the iLife and iWork creativity and productivity suites. Its online services include the iTunes Store, the iOS App Store, and Mac App Store, Apple Music, and iCloud.'''

# Tokenize the text
tokens = nltk.word_tokenize(text)

# Perform part-of-speech tagging
pos_tags = nltk.pos_tag(tokens)

# Perform named entity recognition
ne_tags = nltk.ne_chunk(pos_tags)

# Print the named entities
for chunk in ne_tags:
    if hasattr(chunk, 'label') and chunk.label() == 'ORGANIZATION':
        print('Organisation:', ' '.join(c[0] for c in chunk))
    elif hasattr(chunk, 'label') and chunk.label() == 'PERSON':
        print('Person:', ' '.join(c[0] for c in chunk))

En este ejercicio, primero cargamos algunos datos de texto. Tokenizamos el texto utilizando la función word_tokenize de la biblioteca NLTK. Realizamos el etiquetado de partes del discurso utilizando la función pos_tag de la biblioteca NLTK. Luego, realizamos el reconocimiento de entidades nombradas utilizando la función ne_chunk de la biblioteca NLTK. Imprimimos las entidades nombradas en los datos de texto verificando si cada fragmento tiene una etiqueta de 'ORGANIZATION' o 'PERSON' utilizando la función hasattr y el atributo label.

Ejercicio 47: Big Data

Conceptos:

Big Data
PySpark
Apache Spark
Procesamiento de Datos
MapReduce

Descripción: Escribe un script de PySpark que procese datos utilizando el framework Spark.

Solución:

pythonCopy code
from pyspark import SparkContext, SparkConf

# Configure the Spark context
conf = SparkConf().setAppName('wordcount').setMaster('local[*]')
sc = SparkContext(conf=conf)

# Load the text data
text = sc.textFile('data.txt')

# Split the text into words and count the occurrences of each word
word_counts = text.flatMap(lambda line: line.split(' ')).map(lambda word: (word, 1)).reduceByKey(lambda a, b: a + b)

# Print the word counts
for word, count in word_counts.collect():
    print(word, count)

# Stop the Spark context
sc.stop()

En este ejercicio, primero configuramos el contexto de Spark utilizando las clases SparkConf y SparkContext de la biblioteca PySpark. Cargamos algunos datos de texto utilizando el método textFile. Dividimos el texto en palabras y contamos las ocurrencias de cada palabra utilizando los métodos flatMap, map, y reduceByKey. Imprimimos los recuentos de palabras utilizando el método collect. Finalmente, detenemos el contexto de Spark utilizando el método stop.

Ejercicio 48: Ciberseguridad

Conceptos:

Ciberseguridad
Biblioteca Scapy
Análisis de Redes
Captura de Paquetes

Descripción: Escribe un script de Python que realice análisis de seguridad en una red utilizando la biblioteca Scapy.

Solución:

pythonCopy code
from scapy.all import *

# Define a packet handler function
def packet_handler(packet):
    if packet.haslayer(TCP):
        if packet[TCP].flags & 2:
            print('SYN packet detected:', packet.summary())

# Start the packet sniffer
sniff(prn=packet_handler, filter='tcp', store=0)

En este ejercicio, utilizamos la biblioteca Scapy para realizar análisis de seguridad en una red. Definimos una función de controlador de paquetes que se llama para cada paquete que se detecta. Verificamos si el paquete es un paquete TCP y si tiene el indicador SYN establecido. Si es así, imprimimos un mensaje indicando que se ha detectado un paquete SYN, junto con un resumen del paquete.

Ejercicio 49: Aprendizaje Automático

Conceptos:

Aprendizaje Automático
Biblioteca Scikit-learn
Entrenamiento de Modelos
Validación Cruzada
Búsqueda de Cuadrícula

Descripción: Escribe un script de Python que entrene un modelo de aprendizaje automático utilizando la biblioteca scikit-learn.

Solución:

pythonCopy code
from sklearn import datasets
from sklearn.model_selection import cross_val_score, GridSearchCV
from sklearn.neighbors import KNeighborsClassifier

# Load the dataset
iris = datasets.load_iris()

# Split the dataset into features and target
X = iris.data
y = iris.target

# Define the hyperparameters to search
param_grid = {'n_neighbors': [3, 5, 7, 9], 'weights': ['uniform', 'distance']}

# Create a KNN classifier
knn = KNeighborsClassifier()

# Perform a grid search with cross-validation
grid_search = GridSearchCV(knn, param_grid, cv=5)
grid_search.fit(X, y)

# Print the best hyperparameters and the accuracy score
print('Best Hyperparameters:', grid_search.best_params_)
print('Accuracy Score:', grid_search.best_score_)

En este ejercicio, utilizamos la biblioteca scikit-learn para entrenar un modelo de aprendizaje automático. Cargamos un conjunto de datos utilizando la función load_iris del módulo datasets. Dividimos el conjunto de datos en características y objetivo. Definimos un diccionario de hiperparámetros para buscar utilizando la variable param_grid. Creamos un clasificador KNN utilizando la clase KNeighborsClassifier. Realizamos una búsqueda de cuadrícula con validación cruzada utilizando la clase GridSearchCV. Imprimimos los mejores hiperparámetros y el puntaje de precisión utilizando los atributos best_params_ y best_score_.

Ejercicio 50: Visión por Computadora

Conceptos:

Visión por Computadora
Biblioteca OpenCV
Procesamiento de Imágenes
Detección de Objetos

Descripción: Escribe un script de Python que realice procesamiento de imágenes utilizando la biblioteca OpenCV.

Solución:

pythonCopy code
import cv2

# Load the image
img = cv2.imread('image.jpg')

# Convert the image to grayscale
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Define a classifier for face detection
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')

# Detect faces in the image
faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5)

# Draw rectangles around the detected faces
for (x, y, w, h) in faces:
    cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)

# Display the image with the detected faces
cv2.imshow('image', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

En este ejercicio, utilizamos la biblioteca OpenCV para realizar procesamiento de imágenes. Cargamos una imagen utilizando la función imread. Convertimos la imagen a escala de grises utilizando la función cvtColor. Definimos un clasificador para la detección de rostros utilizando la clase CascadeClassifier y un archivo de clasificador preentrenado. Detectamos rostros en la imagen utilizando la función detectMultiScale. Dibujamos rectángulos alrededor de los rostros detectados utilizando la función rectangle. Mostramos la imagen con los rostros detectados utilizando las funciones imshow, waitKey y destroyAllWindows.