Section 1.1: The Disappearing Data Dilemma

Imagine a common scenario: you are overwhelmed with old log files that seem to multiply endlessly. The solution? A Python script to delete anything older than a month. Sounds simple, right?

Bad Code Example:

import os

import datetime

LOG_DIRECTORY = "C:/super/important/logs" # Your log folder path

def delete_old_logs():

today = datetime.date.today()

for file in os.listdir(LOG_DIRECTORY):

file_path = os.path.join(LOG_DIRECTORY, file)

if os.path.isfile(file_path):

creation_date = datetime.date.fromtimestamp(os.path.getctime(file_path))

if (today - creation_date).days > 30:

os.remove(file_path)

delete_old_logs()

Uh-oh! Can you identify the flaws? The direct use of os.remove poses a danger. One incorrect path or a bug in the date calculations could lead to the loss of vital files. Plus, there's no safety net!

Testing? What testing? This script assumes flawless operation, which is a classic setup for a disaster.

The Safer Approach:

import os

import datetime

import shutil

TEST_DIRECTORY = "C:/test/logs" # Always use a test area!

def safe_delete_old_logs():

today = datetime.date.today()

for file in os.listdir(TEST_DIRECTORY):

file_path = os.path.join(TEST_DIRECTORY, file)

if os.path.isfile(file_path):

creation_date = datetime.date.fromtimestamp(os.path.getctime(file_path))

if (today - creation_date).days > 30:

print(f"Would delete: {file_path}") # Log before deleting

if input("Are you sure? (yes/no): ").lower() == "yes":

shutil.move(file_path, "C:/trash") # Move to trash first

safe_delete_old_logs()

Key Adjustments:

• Test Environment: Always run tests on non-critical data.
• Logging: Review what will be deleted before executing.
• User Confirmation: Require explicit confirmation before deletion.
• Trash, Not Delete: Using shutil.move allows for recovery if necessary.

Your future self will appreciate your caution when automating tasks!

Section 1.2: The Endless Email Loop

Now consider this scenario: you’ve automated a daily report that used to consume a lot of time. You set the script to run, thinking it's all set. Hours later, your inbox is inundated with hundreds of identical reports. Yikes!

Bad Code Example:

import smtplib

import time

def send_daily_report():

# (Code to generate the report content)...

with smtplib.SMTP("your_email_server.com") as server:

server.sendmail("[email protected]", "[email protected]", report_content)

while True:

send_daily_report()

time.sleep(60) # Wait a minute... or so we think

Can you see the issue? The infinite loop guarantees the report will keep sending indefinitely. Even if it did end, time.sleep(60) isn’t precise enough for daily scheduling.

The Solution:

import smtplib

import datetime

import time

def send_daily_report():

# ... (Report generation) ...

with smtplib.SMTP("your_email_server.com") as server:

server.sendmail("[email protected]", "[email protected]", report_content)

while True:

now = datetime.datetime.now()

target_time = now.replace(hour=9, minute=0, second=0) # Send at 9 AM

if now > target_time:

send_daily_report()

target_time += datetime.timedelta(days=1) # Schedule next day

time.sleep(60) # Check every minute

Improvements Made:

• Purposeful Scheduling: Use datetime to target precise send times.
• Controlled Loop: The loop now checks for specific conditions before executing.

Bonus Tip: Incorporate basic logging! A simple print statement can save you hours of debugging.

Mistake 3: When Assumptions Lead to Errors

You’ve developed a sleek script to process CSV files, extracting data and performing calculations seamlessly. However, one day, a user joyfully uploads an Excel file (.xlsx), and your script crashes dramatically.

Bad Code Example:

def process_data(file_path):

data = []

with open(file_path, 'r') as file:

for line in file:

fields = line.strip().split(',') # Uh oh, hardcoded comma!

data.append(fields)

# ... (Rest of your processing logic) ...

The Problem: This code is strictly for CSV files, and the hardcoded comma will cause issues with other formats. If the format is incorrect, it results in a crash without any error handling.

The Flexible Fix:

import pandas as pd

def process_data(file_path):

try:

df = pd.read_csv(file_path) # Tries CSV first

except pd.errors.ParserError:

try:

df = pd.read_excel(file_path) # Fallback to Excel

except Exception as e: # Catch-all for other issues

print(f"Error reading file: {e}")

return

# ... (Proceed to process your data in 'df') ...

Improvements:

• Pandas for Versatility: This library adeptly handles various formats (CSV, Excel, etc.).
• Error Handling: Attempts to read CSV first, falling back to Excel if necessary, thereby avoiding abrupt crashes.
• User-Friendly Feedback: Inform the user about errors instead of leaving them in silence.

It's crucial to communicate the supported file formats to your users!

Mistake 4: The Permission Puzzle

After hours of perfecting your Python automation, it runs smoothly on your local machine. You confidently deploy it to the server, only to have it crash with an obscure error. What went wrong?

Bad Code Example:

import openpyxl # For working with Excel files

def process_sales_data():

workbook = openpyxl.load_workbook("C:/Users/YourName/Desktop/sales_report.xlsx")

# ... (Rest of your data processing) ...

Where It Fails: The hardcoded path "C:/Users/YourName/Desktop…" only exists on your machine. The server has a different structure. Additionally, you may have installed 'openpyxl' locally, but forgotten to do so on the server.

The Portable Solution:

import openpyxl

import os

def process_sales_data():

script_dir = os.path.dirname(__file__) # Directory of the script

data_file = os.path.join(script_dir, "data", "sales_report.xlsx")

workbook = openpyxl.load_workbook(data_file)

# ... (Rest of your data processing) ...

Key Changes:

• Relative Paths: Build file paths based on where the script is running.
• Dependency Management: Use a requirements.txt file to specify libraries needed and install them on the server.

Extra Tip: Always conduct deployment tests! Even a simple script that confirms it's running can catch errors early.

Mistake 5: The "Quick Fix" Trap

You need to perform a quick data transformation. "This will only take a minute," you think, skipping comments for a supposed quick solution. Fast forward six months, and you're staring at incomprehensible code.

Bad Code Example:

import pandas as pd

df = pd.read_csv('data.csv')

df['col1'] = df['col1'].apply(lambda x: str(x).zfill(5))

df['new_col'] = df['col2'] * 0.01

for i in range(len(df)):

if df.loc[i, 'col3'] == 'A':

df.loc[i, 'col4'] = 10

df.to_excel('output.xlsx')

The Problems: Vague variable names, no comments explaining the logic, and difficult-to-modify code.

The Improved Version:

import pandas as pd

# Load the data

sales_df = pd.read_csv('sales_data.csv')

# Pad order numbers for consistency

sales_df['order_number'] = sales_df['order_number'].apply(lambda x: str(x).zfill(5))

# Calculate commission (assuming 'sales_amount' exists)

sales_df['commission'] = sales_df['sales_amount'] * 0.01

# Flag premium customers

for i in range(len(sales_df)):

if sales_df.loc[i, 'customer_tier'] == 'A':

sales_df.loc[i, 'premium'] = True

# Save the results

sales_df.to_excel('updated_sales_report.xlsx')

Improvements:

• Clear Variable Names: Offer insight into the data represented.
• Concise Comments: Provide context behind each step rather than merely restating code.
• Readability: Adding whitespace enhances clarity.

Remember: Your future self (and anyone who inherits your code) will be grateful for your attention to detail!