Section 1.1: Creating Random Passwords

In our first example, we utilize the string and random libraries to craft a random password. We define a function named generate_password() that accepts a length parameter to produce a password of the specified length.

import string

import random

def generate_password(length):

# Define possible characters for the password

characters = string.ascii_letters + string.digits + string.punctuation

# Generate a list of unique characters using random.sample()

password_characters = random.sample(characters, length)

# Convert the list into a string and return it

password = "".join(password_characters)

return password

# Generate a 12-character password

password = generate_password(12)

print(password)

This code will generate a random password with the desired length using a mix of letters, numbers, and symbols.

Section 1.2: Sending Emails with Python

To send an email using Python, we employ the smtplib library. Initially, we establish our email address, password, recipient's email, subject, and message. Subsequently, we create a MIMEMultipart message, attach our message, and designate the sender and recipient.

We then establish a connection to the SMTP server, log in with our credentials, convert the message into a string, and utilize the sendmail() method to dispatch the email. Finally, we disconnect from the server.

import smtplib

from email.mime.text import MIMEText

from email.mime.multipart import MIMEMultipart

email = "[email protected]"

password = "yourpassword"

send_to_email = "[email protected]"

subject = "Test Email"

message = "Hello, this is a test email."

msg = MIMEMultipart()

msg['From'] = email

msg['To'] = send_to_email

msg['Subject'] = subject

msg.attach(MIMEText(message, 'plain'))

server = smtplib.SMTP('smtp.gmail.com', 587)

server.starttls()

server.login(email, password)

text = msg.as_string()

server.sendmail(email, send_to_email, text)

server.quit()

This script enables you to send an email with a defined subject and message to a designated recipient using Gmail's SMTP server.

Section 1.3: Web Scraping Essentials

Next, we will examine how to scrape web content using Python. By utilizing the requests library, we can retrieve the HTML of a webpage and parse it with BeautifulSoup, allowing us to extract all hyperlinks from the page.

import requests

from bs4 import BeautifulSoup

response = requests.get(url)

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

links = soup.find_all('a')

for link in links:

print(link.get('href'))

This code effectively scrapes and prints all the links from a specified webpage using the Requests and BeautifulSoup libraries.

This video, "Solving Beginner Python Coding Challenges," offers great insights into solving common coding problems.

Section 1.4: Weather Forecasting with APIs

In this section, we will look at how to fetch current weather data for a specific city using the OpenWeatherMap API with the requests library. The user will be prompted to enter a city name, and the script will return the current weather conditions.

import requests

def get_weather(city):

response = requests.get(url)

data = response.json()

weather = {

'description': data['weather'][0]['description'],

'temperature': data['main']['temp'],

'humidity': data['main']['humidity'],

'wind_speed': data['wind']['speed']

}

return weather

city = input('Enter city name: ')

weather = get_weather(city)

print(f"Today's weather in {city}: {weather['description']}, Temperature: {weather['temperature']} °C, Humidity: {weather['humidity']}%, Wind Speed: {weather['wind_speed']} m/s")

This code snippet retrieves the current weather conditions for a specified city and displays the temperature, humidity, and wind speed.

Section 1.5: Currency Conversion Tool

This code allows users to convert currency amounts. It prompts for the amount, input currency, and output currency, then fetches the current exchange rate from an API to perform the conversion.

import requests

def convert_currency(amount, from_currency, to_currency):

response = requests.get(url)

data = response.json()

exchange_rate = data['rates'][to_currency]

converted_amount = amount * exchange_rate

return converted_amount

amount = float(input('Enter amount: '))

from_currency = input('Enter from currency: ').upper()

to_currency = input('Enter to currency: ').upper()

converted_amount = convert_currency(amount, from_currency, to_currency)

print(f"{amount} {from_currency} = {converted_amount} {to_currency}")

This script leverages the ExchangeRate-API to convert currency and outputs the converted amount.

Section 1.6: Organizing Files Automatically

This code sorts files in a specified source directory into subdirectories based on their file types and moves them to a target directory. It uses the os, os.path, and shutil modules for file management.

import os

import shutil

def sort_files(source_dir, target_dir):

for file_name in os.listdir(source_dir):

file_path = os.path.join(source_dir, file_name)

if os.path.isfile(file_path):

file_extension = os.path.splitext(file_name)[1]

target_path = os.path.join(target_dir, file_extension)

if not os.path.exists(target_path):

os.makedirs(target_path)

shutil.move(file_path, os.path.join(target_path, file_name))

source_dir = input('Enter source directory: ')

target_dir = input('Enter target directory: ')

sort_files(source_dir, target_dir)

This script automates file organization by sorting files into folders based on their extensions.

Section 1.7: Identifying Large Files

In this example, we utilize the os library to identify the largest files within a directory. The function find_largest_files() accepts a directory path and the number of largest files to return.

import os

def find_largest_files(path, num_files=5):

files = []

for dirpath, dirnames, filenames in os.walk(path):

for filename in filenames:

filepath = os.path.join(dirpath, filename)

size = os.path.getsize(filepath)

files.append((filepath, size))

files.sort(key=lambda x: x[1], reverse=True)

return files[:num_files]

path = '.'

num_files = 5

largest_files = find_largest_files(path, num_files)

for file in largest_files:

print(file[0], file[1])

This code identifies and prints the largest files in the current directory based on size.

Section 1.8: Generating QR Codes

Using the qrcode library, you can easily generate QR codes. Below is a simple code example that prompts the user to input the text or URL for encoding.

import qrcode

# Define the data for the QR code

# Generate the QR code

img = qrcode.make(data)

# Save the QR code as a PNG file

img.save('qr_code.png')

This script creates a QR code that can be saved as an image file.

Section 1.9: Building a To-Do List Application

This code creates a to-do list application that users can interact with via a console menu. It allows tasks to be added, removed, and displayed while saving the list to a JSON file.

import json

def add_task(task_list):

task = input('Enter task: ')

task_list.append(task)

save_tasks(task_list)

def remove_task(task_list):

task_index = int(input('Enter task number to remove: '))

del task_list[task_index-1]

save_tasks(task_list)

def list_tasks(task_list):

print('To-Do List:')

for i, task in enumerate(task_list):

print(f"{i+1}. {task}")

def save_tasks(task_list):

with open('tasks.json', 'w') as f:

json.dump(task_list, f)

def load_tasks():

try:

with open('tasks.json', 'r') as f:

task_list = json.load(f)

except FileNotFoundError:

task_list = []

return task_list

task_list = load_tasks()

while True:

print('nMenu:')

print('1. Add Task')

print('2. Remove Task')

print('3. List Tasks')

print('4. Exit')

choice = int(input('Enter choice: '))

if choice == 1:

add_task(task_list)

elif choice == 2:

remove_task(task_list)

elif choice == 3:

list_tasks(task_list)

elif choice == 4:

break

else:

print('Invalid choice')

This application provides a simple interface for managing tasks and retains the list even after the program is closed.