Use itertools instead of loops

Although loops are cool, they have limitations, especially in modern programming styles and for certain types of tasks. Understanding these limitations helps to choose the right tool for the task. Each iteration of a loop in Python incurs interpreter overhead, such as type checking and memory management. On large datasets, this can add up significantly.

To circumvent this limitation, Python has a convenient built-in library called itertools. For example, suppose you need to generate all unique pairs from a given list. The order doesn't matter, and no element should form a pair with itself.

To avoid bloated code and reduce the risk of bugs, you can use the itertools library. The function itertools.combinations() directly generates all unique combinations of elements from an iterable without duplicates and without considering order.

Here's how to rewrite the code using combinations from itertools:

from itertools import combinations

def get_unique_pairs_itertools(items):
    return list(combinations(items, 2))

my_list = ['A', 'B', 'C', 'D']
print(get_unique_pairs_itertools(my_list))

Output:
[('A', 'B'), ('A', 'C'), ('A', 'D'), ('B', 'C'), ('B', 'D'), ('C', 'D')]

👉 @datascience4

This channels is for Programmers, Coders, Software Engineers.

0️⃣ Python
1️⃣ Data Science
2️⃣ Machine Learning
3️⃣ Data Visualization
4️⃣ Artificial Intelligence
5️⃣ Data Analysis
6️⃣ Statistics
7️⃣ Deep Learning
8️⃣ programming Languages

✅ https://t.iss.one/addlist/8_rRW2scgfRhOTc0

✅ https://t.iss.one/Codeprogrammer

In Python 3.15, there will be a fully immutable dictionary.

A new public immutable type, frozendict, is added to the builtins module.

It is expected that frozendict will be "safe by design", because it prevents any unintended changes. This is useful not only for the CPython standard library, but also for third-party maintainers: you can rely on a reliable immutable dictionary type.

Why is this needed at all:

▪️Do you want to use a map as a key in another dict or put it in a set? A regular dict is not allowed, but a frozendict is (if the values are also hashable).
▪️ @functools.lru_cache() and arguments-dictionaries: it's difficult with a dict, but normal with a frozendict.
▪️Defaults in function arguments: instead of a "mutable default", you can give frozendict(...) and not get surprises.

How it looks in the API:

▪️The constructor "like a dict": frozendict(), frozendict(**kwargs), frozendict(mapping) or iterable pairs, plus you can mix with **kwargs.
▪️The order of insertion is preserved (as in a regular dict).
▪️The hash does not depend on the order of elements (logic via frozenset(items)), and the comparison is also based on the content, not on the order.
▪️There is a union via | and an "update" |= (but |= does not mutate the object, but creates a new one).
▪️.copy() in CPython essentially returns the same object (shallow), and if you need deep copying, then copy.deepcopy().
An important point: frozendict is NOT inherited from dict. This is done on purpose, so that you can't bypass the "immutability" by calling dict.__setitem__ and similar tricks.

And a bonus for the stdlib: the authors have marked places where you can replace constant/public maps with frozendict (including where MappingProxyType is now used).

👉 @DataScience4