50 Everyday Tasks to Automate with Python (Nguyen) – PDF

,Backup system
Bulk image resizer
Chatbot for customer service
Code syntax checker
Custom alert system
Daily news aggregator
Data analysis
Data cleaning tool
Document converter
E-commerce price comparator
Email automation system
Email sorter and filter
Essay grader
Event reminder
Expense tracker
File organizer
Financial data visualizer
Inventory management tool
Job applications
Language translation tool
Math problem solver
Meeting scheduler
Music library organizer
Network speed tester
Password manager
PDF file merger
PDF to Word converter
Personal fitness tracker
Quiz generator
Real estate price tracker
Real-time currency converter
Recipe finder and organizer
Remote desktop controller
Report generator
Sentiment analysis tool

,SEO keyword monitor
Social media bot
Social network analysis
Speech recognition system
Stock market analyzer
Survey analysis
Task scheduler
Text-to-speech converter
Time tracker
Travel itinerary planner
Virtual study buddy
Voice-activated assistant
Weather notification service
Web forum analyzer
Website content scraper

,Backup system
Creating a universal backup system that can serve a wide audience
requires a balance between simplicity and functionality. A highly
rated approach among Python programmers would be to create a
script that can back up files and directories to a local drive, network
share, or even a cloud storage service. To keep it broadly applicable
and understandable, I'll focus on a local backup solution, which can be
the foundation for more complex systems, including those involving
cloud services like AWS S3, Google Drive, or Dropbox.
This example will demonstrate how to back up a directory to another
location on your local machine. This script can easily be adapted for
various environments and needs, such as incorporating cloud storage
APIs or adding more sophisticated error handling and logging.
Example
The script below copies an entire directory (source) to another
location (destination), preserving the directory structure. It's a good
practice for making periodic backups of personal data, project files, or
any other important information.
import os
import shutil
from datetime import datetime

def backup_directory(source_dir, backup_dir):
"""
Back up the specified directory to a backup location.

:param source_dir: The directory whose contents are to be backed up.
:param backup_dir: The directory where backups will be stored.
"""
# Check if the source directory exists
if not os.path.exists(source_dir):
raise Exception(f"The source directory {source_dir} does not exist.")

# Create a timestamped backup directory
timestamp = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
backup_subdir = os.path.join(backup_dir, f"backup_{timestamp}")
os.makedirs(backup_subdir, exist_ok=True)

# Copy the contents of the source directory to the backup directory
try:

, shutil.copytree(source_dir, backup_subdir)
print(f"Backup of '{source_dir}' was successfully created at
'{backup_subdir}'.")
except Exception as e:
print(f"Failed to back up '{source_dir}' to '{backup_subdir}': {e}")

# Example usage
source_directory = '/path/to/your/source/directory'
backup_directory = '/path/to/your/backup/directory'
backup_directory(source_directory, backup_directory)


Key points
➢ Timestamps: the script generates a unique subdirectory for each
backup by appending a timestamp. This prevents overwriting previous
backups and allows you to track when each backup was made.
➢ Error handling: basic error handling is included. It checks if the
source directory exists and catches any errors that occur during the
backup process.
➢ Extendibility: this script can be extended to include additional
features such as:

• Compressing the backup directory into a ZIP file for space
efficiency.
• Adding logging to record backup history or errors.
• Incorporating cloud storage APIs to back up to cloud
services.
• Implementing more sophisticated error handling and
notifications (e.g., sending an email if the backup fails).
This script provides a solid foundation for a backup system. It's simple
enough to be understood and used by beginners but can be expanded
to meet more complex needs. Always test backup systems thoroughly
in a safe environment before relying on them for critical backups.

,Bulk image resizer
A bulk image resizer is an invaluable tool for many users, especially
for those working in web development, digital marketing, or any field
where managing and optimizing images is a regular task. The key to a
highly rated and widely useful program is simplicity, efficiency, and
adaptability. Python, with its rich ecosystem of libraries, offers a
straightforward way to build such a tool. The `Pillow` library (an
extension of PIL - Python Imaging Library) is commonly used for
image processing tasks, including resizing images.
Below is an example of a Python script that resizes all the images in a
specified directory to a particular size. This script is designed to be
both simple for beginners to understand and modify, and robust
enough for more experienced users to integrate into larger workflows.
➢ Installation of Pillow
First, you need to install the Pillow library if you haven't already. You
can do this via pip:
pip install Pillow
Example
from PIL import Image
import os

def bulk_image_resizer(input_directory, output_directory, size=(1024,
768)):
"""
Resize all images in the specified directory to the specified size and
save them to the output directory.

:param input_directory: Directory containing the original images.
:param output_directory: Directory where resized images will be saved.
:param size: A tuple indicating the new size (width, height) of the
images.
"""
# Ensure output directory exists
if not os.path.exists(output_directory):
os.makedirs(output_directory)

# Iterate over all files in the input directory
for filename in os.listdir(input_directory):
if not filename.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.bmp')):

, continue # Skip non-image files

full_path = os.path.join(input_directory, filename)
with Image.open(full_path) as img:
# Resize the image
resized_img = img.resize(size, Image.ANTIALIAS)

# Save the resized image to the output directory
output_path = os.path.join(output_directory, filename)
resized_img.save(output_path)
print(f"Resized and saved {filename} to {output_path}")

# Example usage
input_dir = '/path/to/your/input/directory'
output_dir = '/path/to/your/output/directory'
bulk_image_resizer(input_dir, output_dir, size=(800, 600))
Key points

• **Library**: Uses `Pillow` for image processing tasks.
• **Flexibility**: The script accepts input and output
directories, making it easy to use for different batches of
images. It also allows specifying the desired size for the
resized images.
• **File Type Filtering**: It filters files to process only
common image formats (PNG, JPG, JPEG, GIF, BMP).
• **Error Handling**: While this script is straightforward,
adding try-except blocks around file operations could
enhance its robustness by handling potential errors, such
as issues opening an image file.
• **Quality Preservation**: The use of `Image.ANTIALIAS`
(a high-quality downsampling filter) when resizing helps
to preserve the quality of the images.
This script can serve as a standalone tool or be integrated into larger
projects requiring image resizing functionality. It's designed to be
accessible to users with varying levels of programming experience,
from beginners looking for a simple utility to more advanced users
who may wish to expand its capabilities further.

,Chatbot for customer service
Creating a Chatbot for customer service involves various technologies
and approaches, depending on the complexity and the specific needs
of the service it's intended for. A highly rated and broadly applicable
approach for a wide user base would involve using Natural Language
Processing (NLP) to understand and respond to user queries. In
Python, one of the most popular and accessible libraries for building
chatbots is `ChatterBot`. `ChatterBot`'s simplicity and flexibility make
it an excellent choice for beginners and experienced developers alike.
It can learn from input and improve its responses over time, making it
more effective the more it is used.
➢ Installation
First, you'll need to install `ChatterBot`:
pip install chatterbot
pip install chatterbot_corpus
Example
Below is a simple example of a Python script that creates a basic
customer service chatbot. This script initializes the chatbot, trains it
with some predefined conversations, and then runs a simple console-
based loop to accept user inputs and provide responses.
from chatterbot import ChatBot
from chatterbot.trainers import ChatterBotCorpusTrainer

# Create a new instance of a ChatBot
bot = ChatBot("CustomerServiceBot")

# Create a new trainer for the chatbot
trainer = ChatterBotCorpusTrainer(bot)

# Train the chatbot based on the english corpus
trainer.train("chatterbot.corpus.english")

# Train the chatbot with custom customer service conversations
trainer.train([
["Hi", "Hello! How can I assist you today?"],
["I have a problem with my order", "I'm sorry to hear that. Can you
provide me with your order number?"],
["How can I return an item?", "To return an item, please follow the
instructions on our Returns & Refunds page."]

, ])

def get_response(message):
# Get a response to the input text 'message'
response = bot.get_response(message)
return response

# Example conversation
print("Hello, I'm the Customer Service Bot. Type something to start a
conversation.")
while True:
try:
user_input = input()
print(f"Bot: {get_response(user_input)}")
except (KeyboardInterrupt, EOFError, SystemExit):
break
Key points

• Library usage: utilizes `ChatterBot`, which is easy to
use and powerful for building chatbots.
• Training: the bot is trained using both the English
corpus provided by `ChatterBot` and custom training
data relevant to customer service. This mix helps the bot
understand general English and specific responses.
• Custom conversations: by including custom training
conversations, you tailor the bot's responses to be more
aligned with common customer service queries.
• Extensibility: this basic example can be significantly
expanded. For instance, you could integrate it with web
frameworks (like Flask or Django) to provide a web-
based interface, or connect it to a database to retrieve
order details and provide more personalized assistance.
• Improvement over time: `ChatterBot` supports
continuous learning. By feeding it more conversations or
by allowing it to learn from interactions with real users,
its responses can become more accurate and helpful over
time.
This example provides a foundation for a customer service chatbot.
However, for a real-world application, you would likely need to
customize and expand it significantly. This could include integrating it
with your customer service database, refining the training data to
cover more specific scenarios, or implementing additional features like
handling multiple languages or understanding more complex queries.

, Code syntax checker
Creating a code syntax checker in Python that is broadly useful
involves leveraging tools and libraries designed for parsing and
analyzing code. For Python code, a highly regarded tool is `pylint`, a
static code analysis tool that checks for syntax errors, enforces a
coding standard, looks for code smells, offers simple refactoring
suggestions, and more. It's widely used in the Python community for
maintaining high code quality.
For this example, I'll show you how to create a simple Python script
that uses `pylint` to check the syntax of another Python file. This
script will be a practical tool for developers looking to quickly
validate their Python code's syntax and adhere to Python coding
standards.
➢Installation of Pylint
First, ensure you have `pylint` installed. You can install it via pip:
pip install pylint
Example
This script will invoke `pylint` on a specified Python file to check for
syntax errors and code quality issues. It demonstrates how to run
`pylint` programmatically and parse its output to present to the user.
import subprocess
import sys

def check_syntax(filename):
"""
Checks the syntax of a Python file using pylint.

:param filename: The path to the Python file to check.
"""
try:
# Run pylint on the specified file
result = subprocess.run(['pylint', filename], capture_output=True,
text=True)

# Print the output from pylint
print("Pylint Output:")
print(result.stdout)

# Optionally, you can parse the output to customize the display of