Python Programming

1. Merging Dictionaries

This program shows how to merge two dictionaries. We'll use the | operator, available in Python 3.9 and later, for a concise way to combine them. For older versions, the ** operator within a new dictionary is a common method.

# Program to merge two dictionaries

dict1 = {'a': 1, 'b': 2}

dict2 = {'c': 3, 'd': 4}

# Python 3.9+ method

merged_dict = dict1 | dict2

print(f"Merged Dictionary (Python 3.9+): {merged_dict}")

# Older Python version method

merged_dict_old = {**dict1, **dict2}

print(f"Merged Dictionary (Older versions): {merged_dict_old}")

2. Finding the Most Frequent Element

This program counts the frequency of each element in a list and then finds the element with the highest frequency using a dictionary.

# Program to find the most frequent element in a list

from collections import Counter

my_list = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']

# Use Counter to get frequencies

frequency_dict = Counter(my_list)

print(f"Frequency Dictionary: {frequency_dict}")

# Find the most common element

most_common = frequency_dict.most_common(1)[0]

print(f"Most frequent element: '{most_common[0]}' with count {most_common[1]}")

3. Inverting a Dictionary

This example demonstrates how to swap keys and values of a dictionary. This is useful for creating a reverse lookup structure. Note that this might lead to data loss if the original values are not unique.

# Program to invert a dictionary

my_dict = {'a': 1, 'b': 2, 'c': 3}

# Use a dictionary comprehension for a concise inversion

inverted_dict = {value: key for key, value in my_dict.items()}

print(f"Original Dictionary: {my_dict}")

print(f"Inverted Dictionary: {inverted_dict}")

4. Grouping Data by a Specific Key

Here's how to process a list of dictionaries and group them based on a common key. This is a common task when working with structured data.

# Program to group a list of dictionaries by a key

from collections import defaultdict

data = [

    {'name': 'Alice', 'city': 'New York'},

    {'name': 'Bob', 'city': 'London'},

    {'name': 'Charlie', 'city': 'New York'},

    {'name': 'David', 'city': 'London'},

]

grouped_by_city = defaultdict(list)

for item in data:

    grouped_by_city[item['city']].append(item['name'])

print(f"Grouped by city: {dict(grouped_by_city)}")

5. Filtering a Dictionary

This program shows how to create a new dictionary containing only the key-value pairs that satisfy a specific condition. Dictionary comprehensions are ideal for this.

# Program to filter a dictionary

my_dict = {'a': 10, 'b': 25, 'c': 5, 'd': 30}

# Filter to keep only items where the value is greater than 15

filtered_dict = {key: value for key, value in my_dict.items() if value > 15}

print(f"Original Dictionary: {my_dict}")

print(f"Filtered Dictionary: {filtered_dict}")

6. Combining Values with a Common Key

This example demonstrates how to combine values from multiple dictionaries if they share a common key. Here, we'll sum the values.

# Program to combine values from multiple dictionaries

from collections import defaultdict

dict1 = {'a': 10, 'b': 20}

dict2 = {'b': 30, 'c': 40}

dict3 = {'a': 50, 'c': 60}

combined_dict = defaultdict(int)

for d in [dict1, dict2, dict3]:

    for key, value in d.items():

        combined_dict[key] += value

print(f"Combined Dictionary: {dict(combined_dict)}")

7. Sorting a Dictionary by Value

While dictionaries themselves are not ordered (pre-Python 3.7), we can get a sorted list of their items. This program sorts a dictionary by its values in descending order.

# Program to sort a dictionary by its values

my_dict = {'a': 10, 'b': 5, 'c': 20}

# Get a sorted list of key-value pairs

sorted_items = sorted(my_dict.items(), key=lambda item: item[1], reverse=True)

# Create a new dictionary from the sorted list

sorted_dict = dict(sorted_items)

print(f"Original Dictionary: {my_dict}")

print(f"Sorted Dictionary (by value): {sorted_dict}")

8. Performing Element-wise Operations

This program shows how to perform an operation on the values of a dictionary, such as squaring each value. This can be done efficiently with a dictionary comprehension.

# Program to perform element-wise operations on values

my_dict = {'a': 2, 'b': 3, 'c': 4}

# Create a new dictionary with squared values

squared_dict = {key: value ** 2 for key, value in my_dict.items()}

print(f"Original Dictionary: {my_dict}")

print(f"Dictionary with squared values: {squared_dict}")

9. Nested Dictionary Operations

This example demonstrates how to access and modify values within a nested dictionary structure.

# Program for nested dictionary operations

nested_dict = {

    'user1': {'name': 'Alice', 'age': 30},

    'user2': {'name': 'Bob', 'age': 25}

}

# Access a nested value

print(f"User 1's age: {nested_dict['user1']['age']}")

# Modify a nested value

nested_dict['user2']['age'] = 26

print(f"Modified User 2's age: {nested_dict['user2']['age']}")

# Add a new key-value pair to a nested dictionary

nested_dict['user1']['city'] = 'London'

print(f"Updated User 1 data: {nested_dict['user1']}")

10. Flattening a Nested Dictionary

This program takes a nested dictionary and flattens it into a single-level dictionary. This is a more advanced task requiring recursion or iteration.

# Program to flatten a nested dictionary

def flatten_dict(d, parent_key='', sep='_'):

    """    Flattens a nested dictionary.    """

    items = []

    for k, v in d.items():

        new_key = f"{parent_key}{sep}{k}" if parent_key else k

        if isinstance(v, dict):

            items.extend(flatten_dict(v, new_key, sep=sep).items())

        else:

            items.append((new_key, v))

    return dict(items)

nested_dict = {

    'a': 1,

    'b': {

        'c': 2,

        'd': {

            'e': 3,

            'f': 4

        }

    }

}

flattened_dict = flatten_dict(nested_dict)

print(f"Flattened Dictionary: {flattened_dict}")