Summary  
This chapter covers identifying and replacing common Python anti-patterns with more efficient and maintainable Pythonic idioms, exemplified by using sets for duplicate checking instead of nested loops.

General domain of usage  
data validation

Understanding and avoiding **anti-patterns** is essential for writing high-quality Python code. An **anti-pattern** is a common but ineffective or counterproductive coding practice that often emerges from a lack of experience or misunderstanding of best practices.

In Python, anti-patterns can take many forms, but some of the most prevalent include:

- Unnecessary complexity: code that is more complicated than needed, making it harder to read, test, and maintain;
- Misuse of data structures: using lists where sets would be more appropriate, or vice versa, leading to inefficient and confusing code;
- Poor exception handling: catching overly broad exceptions or ignoring exceptions altogether, which can mask errors and make debugging difficult.

By recognizing these patterns and replacing them with more **Pythonic** solutions, you can write code that is clearer, more efficient, and easier to maintain.

# Anti-pattern: Using unnecessary loops and complexity to check for duplicates
def has_duplicates(lst):
    for i in range(len(lst)):
        for j in range(i + 1, len(lst)):
            if lst[i] == lst[j]:
                return True
    return False

# Pythonic version: Using a set for efficient duplicate checking
def has_duplicates_pythonic(lst):
    return len(lst) != len(set(lst))

# Example usage
numbers = [1, 2, 3, 2]
print(has_duplicates(numbers))         # Output: True
print(has_duplicates_pythonic(numbers))  # Output: True

Which of the following best describes an anti-pattern?

Master the principles of writing clean, maintainable, and efficient Python code. Learn to identify code smells, apply refactoring techniques, and adopt best practices for code quality. Practice your skills with hands-on tasks designed for those familiar with basic Python syntax.

Explore the fundamental concepts of code quality, why it matters, and how to recognize poor code in Python.

Delve into practical refactoring methods to enhance Python code structure and eliminate code smells.

Adopt Pythonic conventions and idioms to write elegant, efficient, and maintainable code.

Learn strategies for maintaining code quality over time, including documentation, testing, and code reviews.

Avoiding Anti-Patterns

1. Which of the following best describes an anti-pattern?

2. Fill in the blank to identify the anti-pattern in the exception handling in this code snippet.