#5: Python Modern Features Mastery: Part 1 - Essential Syntax and Operations

1# Basic function that accepts multiple arguments
2def greet(first, last, title="Mr."):
3  return f"{title} {first} {last}"
4
5# Traditional way
6names = ["John", "Doe"]
7result = greet(names[0], names[1])  # Manual indexing
8
9# With unpacking
10result = greet(*names)  # Much cleaner!
11print(result)  # Output: Mr. John Doe
12
13# Can mix with keyword arguments
14result = greet(*names, title="Dr.")
15print(result)  # Output: Dr. John Doe

1# Using dictionary for keyword arguments
2person = {
3  "first": "Jane",
4  "last": "Smith",
5  "title": "Prof."
6}
7
8# Unpack dictionary as keyword arguments
9result = greet(**person)
10print(result)  # Output: Prof. Jane Smith
11
12# Combine both types of unpacking
13def create_user(id, name, email, **kwargs):
14  user = {
15      "id": id,
16      "name": name,
17      "email": email
18  }
19  user.update(kwargs)
20  return user
21
22basic_info = ("123", "Alice", "alice@example.com")
23extra_info = {"age": 30, "department": "Engineering"}
24
25user = create_user(*basic_info, **extra_info)
26# Result: {'id': '123', 'name': 'Alice', 'email': 'alice@example.com', 'age': 30, 'department': 'Engineering'}

1# Multiple unpacking in a single call
2def process_data(*args, **kwargs):
3  print(f"Positional arguments: {args}")
4  print(f"Keyword arguments: {kwargs}")
5
6list1 = [1, 2]
7list2 = [3, 4]
8dict1 = {"a": 1}
9dict2 = {"b": 2}
10
11# Unpack multiple sources
12process_data(*list1, *list2, **dict1, **dict2)
13# Output:
14# Positional arguments: (1, 2, 3, 4)
15# Keyword arguments: {'a': 1, 'b': 2}
16
17# Unpacking in variable assignment (Python 3.0+)
18first, *middle, last = [1, 2, 3, 4, 5]
19print(f"First: {first}, Middle: {middle}, Last: {last}")
20# Output: First: 1, Middle: [2, 3, 4], Last: 5

1# Real-world example: API configuration
2def make_api_request(endpoint, method="GET", **kwargs):
3  # kwargs might include headers, params, data, etc.
4  return requests.request(method, endpoint, **kwargs)
5
6# Configuration from file
7api_config = {
8  "headers": {"Authorization": "Bearer token"},
9  "params": {"limit": 100},
10  "timeout": 30
11}
12
13# Clean API call
14response = make_api_request("/api/users", **api_config)

1# Basic set comprehension
2numbers = [1, 2, 2, 3, 3, 4, 5]
3unique_squares = {x**2 for x in numbers}
4print(unique_squares)  # Output: {1, 4, 9, 16, 25}
5
6# With condition
7even_squares = {x**2 for x in range(10) if x % 2 == 0}
8print(even_squares)  # Output: {0, 4, 16, 36, 64}
9
10# Practical example: Extract unique file extensions
11files = ['doc.txt', 'image.jpg', 'data.csv', 'backup.txt', 'photo.jpg']
12extensions = {file.split('.')[-1] for file in files}
13print(extensions)  # Output: {'txt', 'jpg', 'csv'}

1# Basic dictionary comprehension
2words = ['apple', 'banana', 'cherry']
3word_lengths = {word: len(word) for word in words}
4print(word_lengths)  # Output: {'apple': 5, 'banana': 6, 'cherry': 6}
5
6# With condition
7filtered_lengths = {word: len(word) for word in words if len(word) > 5}
8print(filtered_lengths)  # Output: {'banana': 6, 'cherry': 6}
9
10# Transform existing dictionary
11original = {'a': 1, 'b': 2, 'c': 3}
12squared = {k: v**2 for k, v in original.items()}
13print(squared)  # Output: {'a': 1, 'b': 4, 'c': 9}

1# Nested dictionary comprehension
2matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
3
4# Create dictionary mapping coordinates to values
5coord_map = {(row, col): matrix[row][col]
6           for row in range(len(matrix))
7           for col in range(len(matrix[row]))}
8print(coord_map)
9# Output: {(0, 0): 1, (0, 1): 2, (0, 2): 3, (1, 0): 4, ...}
10
11# More complex example: Group data by category
12data = [
13  {'name': 'Alice', 'department': 'Engineering', 'salary': 100000},
14  {'name': 'Bob', 'department': 'Engineering', 'salary': 90000},
15  {'name': 'Charlie', 'department': 'Sales', 'salary': 80000},
16]
17
18dept_salaries = {
19  dept: [emp['salary'] for emp in data if emp['department'] == dept]
20  for dept in {emp['department'] for emp in data}
21}
22print(dept_salaries)
23# Output: {'Engineering': [100000, 90000], 'Sales': [80000]}

1import timeit
2
3# Dictionary comprehension vs. for loop
4def with_comprehension():
5  return {x: x**2 for x in range(1000)}
6
7def with_for_loop():
8  result = {}
9  for x in range(1000):
10      result[x] = x**2
11  return result
12
13# Benchmark
14comp_time = timeit.timeit(with_comprehension, number=10000)
15loop_time = timeit.timeit(with_for_loop, number=10000)
16
17print(f"Comprehension: {comp_time:.4f}s")
18print(f"For loop: {loop_time:.4f}s")
19# Comprehensions are typically 20-30% faster

1# Traditional way
2age = 25
3if age >= 18 and age <= 65:
4  print("Working age")
5
6# Python's chained comparison
7if 18 <= age <= 65:
8  print("Working age")
9
10# More complex chains
11score = 85
12if 80 <= score < 90:
13  print("Grade B")
14elif 90 <= score <= 100:
15  print("Grade A")
16
17# Multiple different operators
18x, y, z = 5, 10, 15
19if x < y < z:
20  print("Ascending order")  # This executes

1# Range validation
2def validate_percentage(value):
3  return 0 <= value <= 100
4
5# Date range checking
6from datetime import datetime
7start_date = datetime(2025, 1, 1)
8end_date = datetime(2025, 12, 31)
9current_date = datetime.now()
10
11if start_date <= current_date <= end_date:
12  print("Date is within range")
13
14# Multiple conditions
15def is_valid_triangle(a, b, c):
16  # Check if three sides can form a triangle
17  return (a > 0 and b > 0 and c > 0 and
18          a + b > c and b + c > a and a + c > b)
19
20# Can be written more elegantly
21def is_valid_triangle_clean(a, b, c):
22  # Sort the sides to simplify comparison
23  sides = sorted([a, b, c])
24  return sides[0] > 0 and sides[0] + sides[1] > sides[2]

1# Chaining with any comparison operator
2def check_hierarchy(junior, senior, manager):
3  # Check if salaries are in proper hierarchy
4  return junior < senior < manager
5
6# Mixed operators in chain
7def validate_password_requirements(password):
8  length = len(password)
9  # Check multiple conditions
10  if (8 <= length <= 128 and
11      any(c.isupper() for c in password) and
12      any(c.islower() for c in password) and
13      any(c.isdigit() for c in password)):
14      return True
15  return False
16
17# Using in functions for cleaner code
18def clamp(value, min_val, max_val):
19  """Ensure value is within [min_val, max_val] range"""
20  return min_val <= value <= max_val

1# Pitfall 1: Order matters!
2x = 5
3# This works as expected
4print(1 < x < 10)  # True
5
6# This doesn't work as you might expect
7print(10 > x > 1)  # True, but confusing
8
9# Pitfall 2: Be careful with floating-point comparisons
10import math
11
12def almost_equal(a, b, tolerance=1e-9):
13  return abs(a - b) <= tolerance
14
15# Don't do this with floats
16# if expected_result == calculated_result:
17
18# Do this instead
19if almost_equal(expected_result, calculated_result):
20  print("Values are approximately equal")

1# Simple decorator
2def my_decorator(func):
3  def wrapper():
4      print("Before function call")
5      result = func()
6      print("After function call")
7      return result
8  return wrapper
9
10# Traditional way to apply decorator
11def say_hello():
12  print("Hello!")
13
14say_hello = my_decorator(say_hello)
15
16# Python's decorator syntax
17@my_decorator
18def say_goodbye():
19  print("Goodbye!")
20
21say_goodbye()
22# Output:
23# Before function call
24# Goodbye!
25# After function call

1# Decorator that preserves function arguments
2import functools
3
4def timer(func):
5  @functools.wraps(func)
6  def wrapper(*args, **kwargs):
7      import time
8      start = time.time()
9      result = func(*args, **kwargs)
10      end = time.time()
11      print(f"{func.__name__} took {end - start:.4f} seconds")
12      return result
13  return wrapper
14
15@timer
16def slow_function(n):
17  total = 0
18  for i in range(n):
19      total += i * i
20  return total
21
22result = slow_function(1000000)
23# Output: slow_function took 0.1234 seconds

1# Parameterized decorator
2def repeat(times):
3  def decorator(func):
4      @functools.wraps(func)
5      def wrapper(*args, **kwargs):
6          for _ in range(times):
7              result = func(*args, **kwargs)
8          return result
9      return wrapper
10  return decorator
11
12@repeat(3)
13def greet(name):
14  print(f"Hello, {name}!")
15
16greet("Alice")
17# Output:
18# Hello, Alice!
19# Hello, Alice!
20# Hello, Alice!
21
22# Retry decorator for resilience
23def retry(max_attempts=3, delay=1):
24  def decorator(func):
25      @functools.wraps(func)
26      def wrapper(*args, **kwargs):
27          last_exception = None
28          for attempt in range(max_attempts):
29              try:
30                  return func(*args, **kwargs)
31              except Exception as e:
32                  last_exception = e
33                  if attempt < max_attempts - 1:
34                      time.sleep(delay)
35                  else:
36                      raise last_exception
37      return wrapper
38  return decorator
39
40@retry(max_attempts=3, delay=0.5)
41def unreliable_api_call():
42  # Simulated API call that might fail
43  import random
44  if random.random() < 0.7:
45      raise Exception("API Error")
46  return {"status": "success"}

1# Class-based decorator for more complex behavior
2class CountCalls:
3  def __init__(self, func):
4      self.func = func
5      self.count = 0
6      functools.update_wrapper(self, func)
7
8  def __call__(self, *args, **kwargs):
9      self.count += 1
10      print(f"{self.func.__name__} has been called {self.count} times")
11      return self.func(*args, **kwargs)
12
13@CountCalls
14def say_hello(name):
15  print(f"Hello, {name}!")
16
17say_hello("Alice")  # say_hello has been called 1 times
18say_hello("Bob")    # say_hello has been called 2 times

1# Common built-in decorators
2class MyClass:
3  def __init__(self, value):
4      self._value = value
5
6  @property
7  def value(self):
8      """Getter for value"""
9      return self._value
10
11  @value.setter
12  def value(self, new_value):
13      """Setter with validation"""
14      if new_value < 0:
15          raise ValueError("Value must be non-negative")
16      self._value = new_value
17
18  @staticmethod
19  def utility_function(x, y):
20      """Function that doesn't depend on instance"""
21      return x + y
22
23  @classmethod
24  def from_string(cls, string_value):
25      """Alternative constructor"""
26      return cls(int(string_value))
27
28# Usage
29obj = MyClass(10)
30print(obj.value)  # 10
31
32obj.value = 20    # Uses setter
33print(obj.value)  # 20
34
35# Static method call
36result = MyClass.utility_function(5, 3)  # 8
37
38# Class method call
39obj2 = MyClass.from_string("42")

1# Authentication decorator
2def require_auth(func):
3  @functools.wraps(func)
4  def wrapper(*args, **kwargs):
5      # In a real app, check authentication
6      if not is_authenticated():
7          raise PermissionError("Authentication required")
8      return func(*args, **kwargs)
9  return wrapper
10
11# Caching decorator
12def memoize(func):
13  cache = {}
14  @functools.wraps(func)
15  def wrapper(*args, **kwargs):
16      # Create a hashable key
17      key = str(args) + str(sorted(kwargs.items()))
18      if key not in cache:
19          cache[key] = func(*args, **kwargs)
20      return cache[key]
21  return wrapper
22
23@memoize
24def fibonacci(n):
25  if n < 2:
26      return n
27  return fibonacci(n-1) + fibonacci(n-2)
28
29# Validation decorator
30def validate_types(**expected_types):
31  def decorator(func):
32      @functools.wraps(func)
33      def wrapper(*args, **kwargs):
34          # Get function signature
35          sig = inspect.signature(func)
36          bound = sig.bind(*args, **kwargs)
37          bound.apply_defaults()
38
39          # Validate types
40          for param_name, expected_type in expected_types.items():
41              if param_name in bound.arguments:
42                  value = bound.arguments[param_name]
43                  if not isinstance(value, expected_type):
44                      raise TypeError(f"{param_name} must be {expected_type.__name__}")
45
46          return func(*args, **kwargs)
47      return wrapper
48  return decorator
49
50@validate_types(name=str, age=int)
51def create_user(name, age):
52  return {"name": name, "age": age}