Section 1.1: Using namedtuple

A practical application of namedtuple is in creating a bank account representation with attributes like name, balance, and currency.

from collections import namedtuple

# Define a namedtuple for a bank account Account = namedtuple('Account', ['name', 'balance', 'currency'])

# Create an account instance my_acc = Account(name='John Doe', balance=100.0, currency='USD')

# Display the account print(my_acc) # Output: Account(name='John Doe', balance=100.0, currency='USD')

# Access account fields print(my_acc.name) # Output: 'John Doe' print(my_acc.balance) # Output: 100.0 print(my_acc.currency) # Output: 'USD'

# Update the account balance my_acc = my_acc._replace(balance=my_acc.balance + 100)

# Show the updated balance print(my_acc.balance) # Output: 200.0

In this example, we use namedtuple to define a lightweight class named Account. The fields are immutable but can be updated using the _replace() method, creating a new instance.

Section 1.2: Implementing a deque

deque is ideal for features like "Recent Documents" in applications, allowing efficient management of items.

from collections import deque

# Create a deque with a maximum length of N N = 5 recent_items = deque(maxlen=N)

# Add items to the deque recent_items.append("item1") recent_items.append("item2") recent_items.append("item3") recent_items.append("item4") recent_items.append("item5")

# Adding an additional item will remove the oldest recent_items.append("item6")

# Display current items print(recent_items) # Output: deque(['item2', 'item3', 'item4', 'item5', 'item6'], maxlen=5)

# Remove the oldest item recent_items.popleft()

# Display the updated items print(recent_items) # Output: deque(['item3', 'item4', 'item5', 'item6'], maxlen=5)

This example demonstrates how deque can maintain a fixed number of recent items, automatically purging the oldest when new ones are added.

Section 2.1: Using ChainMap

ChainMap is useful for managing configuration settings from multiple sources.

from collections import ChainMap

# Define two dictionaries with settings default_settings = {'setting1': 'default1', 'setting2': 'default2'} user_settings = {'setting2': 'user2', 'setting3': 'user3'}

# Create a ChainMap config = ChainMap(user_settings, default_settings)

# Access settings print(config['setting1']) # Output: 'default1' print(config['setting2']) # Output: 'user2' print(config['setting3']) # Output: 'user3'

This example illustrates how ChainMap merges user-specific and default settings, prioritizing user settings when conflicts arise.

Section 2.2: Counting with Counter

Counter can be particularly effective for tallying word occurrences in a text.

from collections import Counter

# Sample text text = "This is some text. This text contains some words."

# Tokenizing text into words words = text.split()

# Create a Counter from the words word_counts = Counter(words)

# Retrieve the most common words print(word_counts.most_common(3)) # Output: [('This', 2), ('text', 2), ('some', 2)]

Here, Counter efficiently counts and retrieves the most frequently used words from a given text, showcasing its powerful analytical capabilities.

Section 2.3: Scheduling Tasks with OrderedDict

OrderedDict is perfect for maintaining the order of tasks in a scheduler.

from collections import OrderedDict import time

class TaskScheduler:

def __init__(self):

self.scheduler = OrderedDict()

def add_task(self, task_name: str, run_time: float):

self.scheduler[task_name] = run_time

def run(self):

while self.scheduler:

task_name, run_time = self.scheduler.popitem(last=False)

print(f'Running task {task_name}...')

time.sleep(run_time)

print(f'Task {task_name} completed.')

def reschedule(self, task_name: str, new_run_time: float):

if task_name in self.scheduler:

self.scheduler.move_to_end(task_name)

self.scheduler[task_name] = new_run_time

# Create a scheduler instance scheduler = TaskScheduler()

# Add tasks scheduler.add_task("Task 1", 2) scheduler.add_task("Task 2", 3) scheduler.add_task("Task 3", 1)

# Reschedule Task 2 scheduler.reschedule("Task 2", 1)

# Execute the scheduler scheduler.run()

This example demonstrates how to use OrderedDict to create a task scheduler that retains the order of tasks while allowing for rescheduling.

Section 2.4: Counting with defaultdict

The defaultdict can streamline counting occurrences in lists.

from collections import defaultdict

# List of items items = ['apple', 'banana', 'orange', 'apple', 'banana']

# Create a defaultdict with a default value of 0 item_counts = defaultdict(int)

# Count occurrences for item in items:

item_counts[item] += 1

# Access counts print(item_counts['apple']) # Output: 2 print(item_counts['grape']) # Output: 0

By using defaultdict, we can efficiently count occurrences of items while automatically handling missing values.

Connect with Me

Follow me on LinkedIn and Twitter for more valuable resources in Data Science and programming!