Best Practices and Design Principles

Hey there! Today, we’re going to learn about some important rules and tips that make our code better. Think of these like the rules of a game. If you follow these rules, your code will be easier to understand, fix, and share with others. We’ll also see some examples in Python to make it all clear. Ready? Let’s go!

1. Write Clean and Readable Code

Imagine you wrote a story and want your friends to read it. You’d want it to be neat, right? The same goes for code. Clean and readable code means that anyone (including future you!) can understand it easily.

Example:

# Good example
def calculate_area_of_circle(radius):
    pi = 3.14159
    area = pi * (radius ** 2)
    return area

# Bad example
def calc(r):
    p = 3.14159
    a = p * (r ** 2)
    return a

In the good example, the function name and variable names tell us exactly what they do.

2. Use Meaningful Names

Always use names that describe what the variable or function is for. This helps anyone reading your code understand it without guessing.

Example:

# Good example
total_price = 100
discount_rate = 0.1

# Bad example
tp = 100
dr = 0.1

3. Avoid Repetition

If you find yourself writing the same code more than once, put it in a function. This is called DRY (Don’t Repeat Yourself).

Example:

# Without DRY principle
area1 = 3.14159 * (5 ** 2)
area2 = 3.14159 * (10 ** 2)

# With DRY principle
def calculate_area(radius):
    pi = 3.14159
    return pi * (radius ** 2)

area1 = calculate_area(5)
area2 = calculate_area(10)

4. Write Comments

Comments are notes you leave in your code to explain what it does. They are especially helpful when the code is complicated. But don’t overdo it; too many comments can make the code messy.

Example:

def calculate_area_of_rectangle(length, width):
    # This function calculates the area of a rectangle
    return length * width

5. Use Functions

Functions are like little machines that do a specific job. They help to break down big problems into smaller, manageable pieces.

Example:

def greet(name):
    return f"Hello, {name}!"

print(greet("Alice"))
print(greet("Bob"))

6. Keep Functions Small

A function should do one thing and do it well. If it’s doing too much, break it into smaller functions.

Example:

# Too big function
def process_data(data):
    clean_data = [d.strip() for d in data]
    filtered_data = [d for d in clean_data if d]
    result = sum([int(d) for d in filtered_data])
    return result

# Smaller functions
def clean_data(data):
    return [d.strip() for d in data]

def filter_data(data):
    return [d for d in data if d]

def process_data(data):
    clean_data = clean_data(data)
    filtered_data = filter_data(clean_data)
    return sum([int(d) for d in filtered_data])

7. Handle Errors Gracefully

Sometimes things go wrong. Your code should be prepared for this and handle errors in a way that doesn’t break the whole program.

Example:

try:
    result = 10 / 0
except ZeroDivisionError:
    result = None
    print("You can't divide by zero!")

print(result)

Practice Questions

Now, let’s practice what we’ve learned!

Question 1

Write a function named multiply_numbers that takes two numbers and returns their product. Make sure the function name and variable names are meaningful.

Solution:

def multiply_numbers(a, b):
    return a * b

print(multiply_numbers(3, 4))  # Output: 12

Question 2

Rewrite the following code to use a function and follow the DRY principle:

area1 = 3.14159 * (5 ** 2)
area2 = 3.14159 * (10 ** 2)

Solution:

def calculate_area(radius):
    pi = 3.14159
    return pi * (radius ** 2)

area1 = calculate_area(5)
area2 = calculate_area(10)
print(area1, area2)

Question 3

Write a function named safe_divide that takes two numbers and returns their division result. If the second number is zero, return None and print “You can’t divide by zero!”

Solution:

def safe_divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        print("You can't divide by zero!")
        return None

print(safe_divide(10, 2))  # Output: 5.0
print(safe_divide(10, 0))  # Output: None

Great job! Now you know some of the best practices and design principles to make your Python code clean, readable, and efficient. Keep practicing and happy coding!