Python Tips

To simplify checking if a Python object is of different types, you can group those types into a tuple within an instance call.

If these types are related, you can give them a descriptive name to enhance readability.

Python offers three primary mutable collection types: lists, sets, and dictionaries. Each has unique characteristics suited for different use cases.

Lists

Ordered collections allowing duplicate elements

Use cases:

Storing sequences in a specific order

Keeping collections with potential duplicates

Algorithms requiring indexed element access

Example: Tracking visitor entries chronologically

visitors = ["Alice", "Bob", "Charlie", "David", "Alice", "Eve"]

# Get the 3rd visitor
third_visitor = visitors[2] # "Charlie"

# Add a new visitor
visitors.append("Frank")

# Find the first occurrence of Alice
first_alice_index = visitors.index("Alice") # 0

# Count how many times Alice visited
alice_visits = visitors.count("Alice") # 2

print(f"Total visitors today: {len(visitors)}")
print(f"Visitors in order: {', '.join(visitors)}")

Output:

Total visitors today: 7
Visitors in order: Alice, Bob, Charlie, David, Alice, Eve, Frank

Sets

Unordered collections of unique items

Use cases:

Removing duplicates

Membership testing

Set operations (union, intersection, difference)

Storing unique values without order importance

Example: Tracking unique daily visitors

unique_visitors = {"Alice", "Bob", "Charlie", "David", "Alice", "Eve"}

# Check if Frank has visited
has_frank_visited = "Frank" in unique_visitors # False

# Add a new unique visitor
unique_visitors.add("Frank")

# Try to add Alice again (won't change the set)
unique_visitors.add("Alice")

# Get the total number of unique visitors
total_unique_visitors = len(unique_visitors)

print(f"Total unique visitors: {total_unique_visitors}")
print(f"Unique visitors: {', '.join(unique_visitors)}")

# Set operations
yesterday_visitors = {"Alice", "Bob", "George", "Hannah"}
new_visitors_today = unique_visitors – yesterday_visitors
returning_visitors = unique_visitors.intersection(yesterday_visitors)

print(f"New visitors today: {', '.join(new_visitors_today)}")
print(f"Returning visitors: {', '.join(returning_visitors)}")

Output:

Total unique visitors: 6
Unique visitors: Alice, Charlie, Bob, David, Frank, Eve
New visitors today: David, Frank, Charlie, Eve
Returning visitors: Alice, Bob

Dictionaries

Unordered key-value pairs (keys must be unique and immutable)

Use cases:

Storing associated data

Fast value lookups by key

Counting item occurrences

Example: Managing detailed visitor information

visitor_info = {
"Alice": {"age": 28, "membership": "Gold", "visits": 3},
"Bob": {"age": 35, "membership": "Silver", "visits": 1},
"Charlie": {"age": 42, "membership": "Bronze", "visits": 2},
"David": {"age": 31, "membership": None, "visits": 1}
}

# Get Alice's information
alice_info = visitor_info["Alice"]
print(f"Alice's membership: {alice_info['membership']}")

# Update Bob's visit count
visitor_info["Bob"]["visits"] += 1

# Add a new visitor
visitor_info["Eve"] = {"age": 39, "membership": "Gold", "visits": 1}

# Get all Gold members
gold_members = [name for name, info in visitor_info.items() if info["membership"] == "Gold"]
print(f"Gold members: {', '.join(gold_members)}")

# Calculate average age of visitors
total_age = sum(info["age"] for info in visitor_info.values())
average_age = total_age / len(visitor_info)
print(f"Average visitor age: {average_age:.1f}")

# Find the visitor with the most visits
most_frequent_visitor = max(visitor_info, key=lambda x: visitor_info[x]["visits"])
print(f"Most frequent visitor: {most_frequent_visitor}")

Output:

Alice's membership: Gold
Gold members: Alice, Eve
Average visitor age: 35.0
Most frequent visitor: Alice

These examples demonstrate how each data structure can be used effectively in a visitor tracking system:

Lists are great for maintaining the order of visitors and allowing duplicate entries.

Sets are perfect for quickly checking unique visitors and performing set operations.

Dictionaries are ideal for storing and retrieving complex visitor information, with fast lookups based on visitor names.

Extracting data from nested structures often leads to complex, error-prone code with multiple checks and conditionals. Consider this traditional approach:

def get_youngest_pet(pet_info):
if isinstance(pet_info, list) and len(pet_info) == 2:
if all("age" in pet for pet in pet_info):
print("Age is extracted from a list")
return min(pet_info[0]["age"], pet_info[1]["age"])
elif isinstance(pet_info, dict) and "age" in pet_info:
if isinstance(pet_info["age"], dict):
print("Age is extracted from a dict")
ages = pet_info["age"].values()
return min(ages)
raise ValueError("Invalid input format")

# Usage
pet_info1 = [{"name": "bim", "age": 1}, {"name": "pepper", "age": 9}]
print(get_youngest_pet(pet_info1)) # Output: 1

pet_info2 = {'age': {"bim": 1, "pepper": 9}}
print(get_youngest_pet(pet_info2)) # Output: 1

Python 3.10’s pattern matching provides a more declarative and readable way to handle complex data structures, reducing the need for nested conditionals and type checks.

def get_youngest_pet(pet_info):
match pet_info:
case [{"age": age1}, {"age": age2}]:
print("Age is extracted from a list")
return min(age1, age2)
case {'age': ages} if isinstance(ages, dict):
print("Age is extracted from a dict")
return min(ages.values())
case _:
raise ValueError("Invalid input format")

# Usage remains the same
pet_info1 = [{"name": "bim", "age": 1}, {"name": "pepper", "age": 9}]
print(get_youngest_pet(pet_info1)) # Output: 1

pet_info2 = {'age': {"bim": 1, "pepper": 9}}
print(get_youngest_pet(pet_info2)) # Output: 1

To define the behaviors that are executed when a class attribute is set, use the property decorator.

When checking if a condition is true for any list element in Python, use any with a list comprehension instead of a for loop and if-else statements for more readable code.

Try out this code.

When unpacking values from an iterable, you may only be interested in a few of the elements. Using the *_ wildcard allows you to ignore the remaining elements without having to assign them to named variables. This helps keep the code clean and concise.

To ensure that all subclasses implement a set of methods and properties, use abstract methods within an abstract class. This promotes code reusability and a consistent interface across different implementations.

In the code above, Drink serves as an abstract class with an abstract method consume.

To sort a list of tuples, use the sort() method and pass in the key parameter to indicate which item to sort by.

When working with slices in Python, it can be difficult to keep track of the meaning behind each index. To make your code more readable, consider naming your slices using Python’s built-in slice function.