DEV Community: Mohammad Nadeem

🛠️ Real-World Use Cases of Sets and Dicts in APIs & Data Processing

Mohammad Nadeem — Wed, 09 Jul 2025 11:32:55 +0000

You’ve learned about sets and dictionaries — but where do they shine in real-world Python projects, especially in APIs and data pipelines? Let’s look at practical, production-friendly use cases.

🚀 1. Fast Duplicate Removal with Sets

✅ Example: Cleaning up email list before sending campaign

emails = ['alice@example.com', 'bob@example.com', 'alice@example.com']
unique_emails = list(set(emails))

🔍 2. Efficient Membership Checks
✅ Example: Check if a user has access to a resource

authorized_user_ids = {1001, 1002, 1003}
if user_id in authorized_user_ids:
    return "Access granted"

✅ Sets make this check O(1) — way faster than a list.

🔁 3. Grouping API Records with Dictionaries
✅ Example: Group transactions by user ID

from collections import defaultdict

transactions = [
    {'user_id': 1, 'amount': 100},
    {'user_id': 2, 'amount': 50},
    {'user_id': 1, 'amount': 70}
]

grouped = defaultdict(list)
for txn in transactions:
    grouped[txn['user_id']].append(txn)

# grouped = {1: [...], 2: [...]}

🔄 4. Remapping or Normalizing API Payloads
✅ Example: Renaming keys from snake_case to camelCase

def to_camel_case(snake_str):
    parts = snake_str.split('_')
    return parts[0] + ''.join(x.title() for x in parts[1:])

payload = {'user_id': 123, 'user_name': 'alice'}
normalized = {to_camel_case(k): v for k, v in payload.items()}

🔀 5. Mapping IDs to Names for API Response Enrichment

user_map = {1: 'Alice', 2: 'Bob'}
transactions = [{'user_id': 1, 'amount': 50}, {'user_id': 2, 'amount': 100}]

for txn in transactions:
    txn['user_name'] = user_map.get(txn['user_id'], 'Unknown')

✅ 6. Detecting Shared Items Between Datasets
✅ Example: Users active in both services

service_a_users = {1, 2, 3}
service_b_users = {3, 4, 5}

both = service_a_users & service_b_users  # {3}

✨ Summary

Problem	Tool Used
Remove duplicates	`set()`
Fast lookup	`set`
Group by field	`dict`, `defaultdict`
Rename JSON keys	Dictionary comprehension
Enrich API payloads	`dict.get()`
Find common users/items	Set intersection (`&`)

Sets and dictionaries are workhorses in backend engineering, especially when building scalable APIs or ETL systems. Use them wisely to improve performance, readability, and efficiency.

Follow for more real-world backend Python tips 🐍⚙️

Dictionary Comprehensions in Python: Powerful, Elegant, and Fast

Mohammad Nadeem — Wed, 09 Jul 2025 11:24:17 +0000

If you love list comprehensions in Python, you're going to love dictionary comprehensions too. They're concise, expressive, and often much faster than traditional for-loops.

📘 What Is a Dictionary Comprehension?

A dictionary comprehension is a concise way to create dictionaries using an expression inside curly braces.

{key_expr: value_expr for item in iterable}

✅ Basic Example
Let’s create a dictionary where keys are numbers and values are their squares:

squares = {x: x**2 for x in range(5)}
print(squares)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

🔄 Reversing a Dictionary

original = {'a': 1, 'b': 2, 'c': 3}
reversed_dict = {v: k for k, v in original.items()}
print(reversed_dict)  # {1: 'a', 2: 'b', 3: 'c'}

🧼 Filtering with Conditions
Only include even keys:

even_squares = {x: x**2 for x in range(10) if x % 2 == 0}

📦 Nested Dictionary Comprehensions
Creating a grid (2D dict):

grid = {(x, y): x*y for x in range(3) for y in range(3)}

💡 Use Case: Rename JSON Keys

api_data = {'user_id': 1, 'user_name': 'alice'}
mapped = {k.replace('user_', ''): v for k, v in api_data.items()}
# {'id': 1, 'name': 'alice'}

⏱️ Why Use Them?

Cleaner and more expressive
Often faster than loops
Ideal for transformations, filters, or small data manipulations

🧪 Pro Tip

Use dictionary comprehensions when:
You’re transforming or filtering a dictionary
You’re building one from another iterable
You want to keep your code elegant and Pythonic

Follow for more Python deep dives! 🐍⚡

🧠 Advanced Set Operations in Python — Beyond the Basics

Mohammad Nadeem — Wed, 09 Jul 2025 11:14:05 +0000

You probably know that Python sets are great for storing unique values and checking membership fast. But sets are far more powerful when you start using advanced operations like unions, intersections, symmetric differences, and more. Let's dive deep into what makes sets an underrated gem in Python's standard library.

📦 Quick Refresher: What is a Set?
A set is an unordered, mutable, and duplicate-free collection:

a = {1, 2, 3}
b = set([3, 4, 5])

Sets are perfect when:

You want to remove duplicates
You care about fast membership checks
You want to compare data collections

🔄 1. Union: | or .union()
Combine elements from both sets — no duplicates.

a = {1, 2, 3}
b = {3, 4, 5}
print(a | b)  # {1, 2, 3, 4, 5}

Or:

a.union(b)

🔁 2. Intersection: & or .intersection()
Get common elements between sets.

print(a & b)  # {3}

Or:

a.intersection(b)

🔀 3. Difference: - or .difference()
Get items in a but not in b.

print(a - b)  # {1, 2}

This is order-sensitive: a - b ≠ b - a.

✖️ 4. Symmetric Difference: ^ or .symmetric_difference()
Elements that are in either set but not both.

print(a ^ b)  # {1, 2, 4, 5}

✅ 5. Subset and Superset

a = {1, 2}
b = {1, 2, 3, 4}

print(a <= b)  # True (a is subset of b)
print(b >= a)  # True (b is superset of a)

You can also use:

a.issubset(b)
b.issuperset(a)

🚫 6. Disjoint Sets
Check if two sets have no elements in common.

a = {1, 2}
b = {3, 4}
print(a.isdisjoint(b))  # True

⚙️ 7. Set Comprehensions
Build sets on the fly:

squares = {x * x for x in range(6)}
print(squares)  # {0, 1, 4, 9, 16, 25}

Filter during construction:

evens = {x for x in range(10) if x % 2 == 0}

💥 8. Updating Sets In-Place
Mutating operations:

a = {1, 2, 3}
b = {3, 4, 5}

a.update(b)       # Like union
a.intersection_update({2, 3, 4})  # Keep only shared items
a.difference_update({3})         # Remove common items
a.symmetric_difference_update({2, 5})  # Replace with symmetric diff

🧪 Real-World Example: Finding Unique vs Shared Users

logged_in_users = {'alice', 'bob', 'carol'}
purchased_users = {'carol', 'dave'}

# Who logged in but didn't purchase
print(logged_in_users - purchased_users)  # {'alice', 'bob'}

# Who both logged in and purchased
print(logged_in_users & purchased_users)  # {'carol'}

# Everyone involved
print(logged_in_users | purchased_users)  # {'alice', 'bob', 'carol', 'dave'}

🔍 Pro Tips

Sets are faster than lists for membership checks (in).
Use frozenset() when you need an immutable set (e.g., as a dict key).
Avoid using sets when order matters (use list or OrderedDict instead).

🧠 Summary

Operation	Symbol	Method Equivalent
Union	a \| b	a.union(b)
Intersection	a & b	a.intersection(b)
Difference	a - b	a.difference(b)
Symmetric Difference	a ^ b	a.symmetric_difference(b)
Subset / Superset	a <= b, a >= b	a.issubset(b), a.issuperset(b)
Disjoint	(no symbol)	a.isdisjoint(b)

🏁 Final Thoughts
Python sets are simple but powerful tools for data comparison, filtering, and logic. If you're writing code that needs to compare or filter collections — chances are, sets will make your life easier and your code cleaner.

🗨️ What’s Next?
Want to explore more?

Using Counter for multiset behavior
Building set-based recommendation systems
Performance benchmarking: list vs set lookup

Follow for more Python deep dives! 🐍⚡

Custom Sorting in Python: Lists and Dictionaries Demystified

Mohammad Nadeem — Wed, 09 Jul 2025 10:49:07 +0000

Sorting data in Python is easy with sorted(), but what if you want to sort by custom logic? In this post, we’ll explore how to sort lists and dictionaries in Python using custom keys and lambda functions.

🔢 Sorting Lists in Python

✅ Default List Sorting

numbers = [5, 2, 9, 1]
print(sorted(numbers))  # [1, 2, 5, 9]

This works great for simple data. But what about sorting by length, reverse order, or object properties?

🧠 Custom Sorting with key=
1. Sort strings by length

words = ['banana', 'apple', 'kiwi', 'strawberry']
sorted_by_length = sorted(words, key=len)
print(sorted_by_length)
# ['kiwi', 'apple', 'banana', 'strawberry']

2. Sort strings by last character

sorted_by_last_char = sorted(words, key=lambda x: x[-1])
print(sorted_by_last_char)
# ['banana', 'kiwi', 'apple', 'strawberry']

3. Sort a list of tuples by second value

pairs = [(1, 3), (2, 2), (4, 1)]
sorted_pairs = sorted(pairs, key=lambda x: x[1])
print(sorted_pairs)
# [(4, 1), (2, 2), (1, 3)]

🧰 Sorting Lists of Dicts
This is common in APIs or tabular data:

users = [
    {'name': 'Alice', 'age': 30},
    {'name': 'Bob', 'age': 25},
    {'name': 'Charlie', 'age': 35}
]

🔽 Sort by age:

sorted_users = sorted(users, key=lambda x: x['age'])

🔼 Sort by name (descending):

sorted_users = sorted(users, key=lambda x: x['name'], reverse=True)

🧠 Sorting Dictionaries by Keys or Values
By default, dictionaries in Python 3.7+ maintain insertion order. But we can sort them for display or processing.

scores = {'Alice': 82, 'Bob': 91, 'Charlie': 78}

🔤 Sort by key:

sorted_by_key = dict(sorted(scores.items()))
# {'Alice': 82, 'Bob': 91, 'Charlie': 78}

🔢 Sort by value:

sorted_by_value = dict(sorted(scores.items(), key=lambda item: item[1]))
# {'Charlie': 78, 'Alice': 82, 'Bob': 91}

🔄 In-Place Sorting with .sort()
If you want to sort a list in-place (not return a new one):

numbers = [4, 1, 3]
numbers.sort()
print(numbers)  # [1, 3, 4]

With custom key:

words.sort(key=lambda x: len(x))

⚠️ .sort() works only on lists, not on dict or tuple.

⚙️ Pro Tip: Use operator.itemgetter for cleaner syntax
from operator import itemgetter

sorted_users = sorted(users, key=itemgetter('age'))

Works well when sorting by multiple keys too:

sorted_users = sorted(users, key=itemgetter('age', 'name'))

✨ Final Thoughts
Mastering custom sorting in Python helps you handle data more efficiently — especially when working with APIs, CSVs, or databases. Whether you’re sorting by value, custom rules, or multiple fields, Python gives you all the tools you need.

🚀 Next up?
In the next post, I’ll dive into:

Sorting with multiple criteria
Using functools.cmp_to_key
Performance tips when sorting large datasets

Follow for more Python tricks, clean code tips, and backend dev guides! 🐍💻

Mastering Python Collections: List, Tuple, Set, and Dictionary

Mohammad Nadeem — Wed, 09 Jul 2025 10:31:53 +0000

1. Python Lists – The Ordered All-Rounder
A list is a mutable, ordered collection that can store items of different types.

✅ Key Features:

Ordered
Mutable (can change)
Allows duplicates

💡 Syntax & Example:

fruits = ['apple', 'banana', 'cherry']
fruits.append('mango')
print(fruits)  # ['apple', 'banana', 'cherry', 'mango']

🔧 Common List Operations:

fruits[0]         # Access first item → 'apple'
fruits[-1]        # Last item → 'mango'
len(fruits)       # 4
'banana' in fruits  # True
fruits.remove('apple')

🔒 2. Python Tuples – The Immutable Sibling

A tuple is like a list, but immutable (cannot be changed after creation).

✅ Key Features:

Ordered
Immutable
Allows duplicates

💡 Syntax & Example:

person = ('Alice', 30, 'Engineer')
print(person[1])  # 30

⚠️ Single-Element Tuples:

t = ('hello',)  # With comma — valid tuple
not_a_tuple = ('hello')  # Just a string!

When to use:

Fixed data structures (e.g., coordinates, DB rows)
As keys in dictionaries (if they contain only immutable types)

🧹 3. Python Sets – The Unique Collection
A set is an unordered, mutable collection of unique items.

✅ Key Features:

Unordered
No duplicates
Fast membership tests

💡 Syntax & Example:

colors = {'red', 'green', 'blue'}
colors.add('yellow')
colors.add('red')  # Ignored, already exists
print(colors)  # {'green', 'blue', 'red', 'yellow'}

🔧 Common Set Operations:

colors.remove('blue')
'aqua' in colors         # False
colors.union({'black'})  # New set with combined items

⚠️ Empty set:

s = set()     # ✅ This is an empty set
s2 = {}       # ⚠️ This is an empty dictionary!

🧠 4. Python Dictionaries – The Key-Value Store

A dictionary (or dict) stores data as key-value pairs.

✅ Key Features:

Unordered (in < Python 3.7)
Keys must be unique and immutable
Values can be of any type

💡 Syntax & Example:

user = {
    'name': 'John',
    'age': 25,
    'email': 'john@example.com'
}
print(user['name'])  # John

🔧 Common Dictionary Operations:

user['age'] = 26         # Update
user.get('city', 'N/A')  # Safe lookup → 'N/A'
del user['email']        # Remove key
'user' in user           # False

Nested Dict Example:

employee = {
    'id': 101,
    'profile': {'name': 'Jane', 'role': 'Manager'}
}
print(employee['profile']['name'])  # Jane

✨ Final Thoughts
Understanding these core Python data structures is essential for effective programming. Choose the right one based on your needs:

Use lists for general-purpose ordered data
Use tuples for fixed-size, immutable groups
Use sets for fast membership checks and unique values
Use dictionaries when you need to map keys to values

🗨️ What’s Next?
Want to go deeper? In future posts, I’ll cover:

Custom sorting of lists/dicts
Advanced set operations
Dictionary comprehensions
Real-world use cases in APIs and data processing

Follow me for more Python tips and tricks! 🐍✨