Intermediate Level Exercises

import requestsfrom bs4 import BeautifulSoup url = 'https://www.example.com'response = requests.get(url)soup = BeautifulSoup(response.text, 'html.parser') # Find all links on the pagelinks = soup.find_all('a')for link in links:    print(link.get('href'))

# Read data from a filewith open('input.txt', 'r') as f:    data = f.read() # Manipulate the datadata = data.upper() # Write data to a filewith open('output.txt', 'w') as f:    f.write(data)

import pandas as pd # Read data from a CSV filedata = pd.read_csv('data.csv') # Display the first 5 rows of the dataprint(data.head()) # Calculate some basic statisticsprint(data.describe())

import argparse # Create an argument parserparser = argparse.ArgumentParser()parser.add_argument('name', help='Your name')parser.add_argument('age', type=int, help='Your age')args = parser.parse_args() # Print a greetinggreeting = f'Hello, {args.name}! You are {args.age} years old.'print(greeting)

import requests # Make a GET request to an APIurl = 'https://api.example.com/users'response = requests.get(url) # Parse the response as JSONdata = response.json() # Display the datafor user in data:    print(user['name'], user['email'])

import re # Define a regular expression pattern for email validationpattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$' # Get user inputemail = input('Enter your email address: ') # Validate the input using the regular expressionif re.match(pattern, email):    print('Valid email address')else:    print('Invalid email address')

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 methodsperson = Person('Alice', 25)person.greet() student = Student('Bob', 20, 'Computer Science')student.greet()student.describe()

import threading counter = 0lock = 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}.')

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()

import matplotlib.pyplot as plt # Create some datax = [1, 2, 3, 4, 5]y = [2, 4, 6, 8, 10] # Create a line chartplt.plot(x, y) # Add labels and a titleplt.xlabel('X values')plt.ylabel('Y values')plt.title('Line chart') # Display the chartplt.show()

import sqlite3 # Connect to the databaseconn = sqlite3.connect('example.db') # Create a tableconn.execute('''CREATE TABLE IF NOT EXISTS users                (id INTEGER PRIMARY KEY,                 name TEXT,                 email TEXT)''') # Insert some dataconn.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 datacursor = conn.execute("SELECT id, name, email FROM users")for row in cursor:    print(f'{row[0]} - {row[1]} ({row[2]})') # Close the database connectionconn.close()

# Server codeimport 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 codeimport 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()

import numpy as npimport pandas as pd # Create some datadata = {'x': np.arange(10),        'y': np.random.randn(10)} # Create a DataFrame from the datadf = pd.DataFrame(data) # Calculate some statisticsprint(df.mean())print(df.std()) # Create a new column based on a calculationdf['z'] = df['x'] * df['y'] # Display the DataFrameprint(df)

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()

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()

from PIL import Image # Open an image fileimage = Image.open('image.jpg') # Display information about the imageprint(image.format)print(image.size)print(image.mode) # Convert the image to grayscalegrayscale_image = image.convert('L')grayscale_image.show() # Resize the imageresized_image = image.resize((300, 300))resized_image.show() # Save the image in a different formatresized_image.save('image.png')

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)

import requests response = requests.get('https://api.example.com/users')data = response.json() for user in data:    print(user['name'], user['email'])

from cryptography.fernet import Fernetfrom cryptography.hazmat.primitives import hashesfrom cryptography.hazmat.primitives.asymmetric import rsa, paddingfrom cryptography.hazmat.primitives.serialization import load_pem_private_key, load_pem_public_key # Symmetric encryptionkey = 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 encryptionprivate_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)

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()

# Write to a filewith open('example.txt', 'w') as file:    file.write('Hello, world!\n')    file.write('How are you today?\n') # Read from a filewith open('example.txt', 'r') as file:    for line in file:        print(line.strip())

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')

import requestsfrom 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'))

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())

import pandas as pd # Load data from a CSV filedata = pd.read_csv('example.csv') # Print the first five rows of the dataprint(data.head()) # Calculate some statistics on the dataprint(data.describe()) # Group the data by a column and calculate some statisticsgrouped_data = data.groupby('category')print(grouped_data.mean())

import re text = 'The quick brown fox jumps over the lazy dog' # Search for a pattern in the textpattern = r'\b\w{4}\b'matches = re.findall(pattern, text)print(matches) # Substitute a pattern in the textpattern = r'\bthe\b'replaced_text = re.sub(pattern, 'a', text, flags=re.IGNORECASE)print(replaced_text)

from sqlalchemy import create_engine, Column, Integer, Stringfrom sqlalchemy.orm import sessionmakerfrom sqlalchemy.ext.declarative import declarative_base # Define a database engineengine = create_engine('sqlite:///example.db') # Define a session factorySession = sessionmaker(bind=engine) # Define a declarative baseBase = declarative_base() # Define a model classclass User(Base):    __tablename__ = 'users'     id = Column(Integer, primary_key=True)    name = Column(String)    email = Column(String) # Create the tableBase.metadata.create_all(engine) # Add some datasession = Session()session.add(User(name='Alice', email='alice@example.com'))session.add(User(name='Bob', email='bob@example.com'))session.commit() # Query the datausers = session.query(User).all()for user in users:    print(user.name, user.email) 

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()

import nltkfrom nltk.tokenize import word_tokenizefrom nltk.stem import PorterStemmerfrom nltk import pos_tag nltk.download('punkt')nltk.download('averaged_perceptron_tagger') text = 'The quick brown fox jumped over the lazy dogs' # Tokenize the texttokens = word_tokenize(text)print(tokens) # Stem the tokensstemmer = PorterStemmer()stemmed_tokens = [stemmer.stem(token) for token in tokens]print(stemmed_tokens) # Perform part-of-speech tagging on the tokenspos_tags = pos_tag(tokens)print(pos_tags)

import pandas as pdfrom sklearn.model_selection import train_test_splitfrom sklearn.linear_model import LinearRegression # Load data from a CSV filedata = pd.read_csv('example.csv') # Prepare the dataX = data['x'].values.reshape(-1, 1)y = data['y'].values.reshape(-1, 1) # Split the data into training and testing setsX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0) # Train the modelmodel = LinearRegression()model.fit(X_train, y_train) # Make predictions on the test sety_pred = model.predict(X_test) # Evaluate the modelscore = model.score(X_test, y_test)print(score)

import numpy as npfrom keras.datasets import mnistfrom keras.models import Sequentialfrom keras.layers import Dense, Flatten, Conv2D, MaxPooling2Dfrom keras.utils import to_categorical # Load the MNIST dataset(X_train, y_train), (X_test, y_test) = mnist.load_data() # Preprocess the dataX_train = X_train.reshape(-1, 28, 28, 1) / 255.0X_test = X_test.reshape(-1, 28, 28, 1) / 255.0y_train = to_categorical(y_train)y_test = to_categorical(y_test) # Define the model architecturemodel = 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 modelmodel.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) # Train the modelmodel.fit(X_train, y_train, epochs=5, batch_size=64) # Evaluate the modelloss, accuracy = model.evaluate(X_test, y_test)print(accuracy)

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()

import sysfrom 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_())

import requestsfrom 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'}).textprint(title) content = soup.find('div', {'id': 'mw-content-text'}).textprint(content[:100])

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()

import numpy as np # Create a 2D arraydata = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) # Print the arrayprint(data) # Calculate some statistics on the arrayprint(np.mean(data))print(np.median(data))print(np.std(data)) # Reshape the arrayreshaped_data = data.reshape(1, 9)print(reshaped_data)

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)

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)

with open('input.txt', 'r') as f:    data = f.readlines() # Process the dataoutput = []for line in data:    line = line.strip()    words = line.split()    words.reverse()    output.append(' '.join(words)) # Write the results to a filewith open('output.txt', 'w') as f:    for line in output:        f.write(line + '\n')

import pandas as pd # Load the data from a CSV filedata = pd.read_csv('example.csv') # Filter the data to include only rows where the value is greater than 5filtered_data = data[data['value'] > 5] # Calculate the mean and standard deviation of the filtered datamean = filtered_data['value'].mean()std = filtered_data['value'].std() print(f'Mean: {mean}')print(f'Standard deviation: {std}')