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://news.1rj.ru/str/addlist/8_rRW2scgfRhOTc0

✅ https://news.1rj.ru/str/Codeprogrammer

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://news.1rj.ru/str/addlist/8_rRW2scgfRhOTc0

✅ https://news.1rj.ru/str/Codeprogrammer

🧠 How to Slow Down Python to a Snail's Pace?

Do you dream of making your noscript run in slow motion? Use these proven methods to turn fast code into annoyingly slow crap.

Don't do this (the obvious and boring way)

import time

for i in range(10):
    time.sleep(1)  # Just wait a second on each iteration
    print(i)

The Problem:
It's too predictable. Any stupid reviewer will immediately notice it and delete it.

✔️ The Right Way (Creative Slowing Down)

import random
import threading
import sys

class GlobalSlowdown:
    def __init__(self):
        self.lock = threading.Lock()
    def heavy_calc(self, x):
        with self.lock:  # Imitate the GIL squared
            return sum(i * 0.000001 for i in range(int(x * 10000)))

def main():
    slowdown = GlobalSlowdown()
    data = list(range(1000))
    # Process each element in a random thread with a delay
    threads = []
    for item in data:
        t = threading.Thread(target=lambda: slowdown.heavy_calc(random.random()))
        t.start()
        threads.append(t)
        if random.choice([True, False]):
            sys.stdout.flush()  # A useless call for show
    for t in threads:
        t.join()  # Wait for everything

if __name__ == '__main__':
    main()

How it works:
We create a bunch of threads for a trivial operation. The global lock ensures that they won't work in parallel, but sequentially, but with the overhead of context switching. The perfect storm of inefficiency.

Let's complicate it: recursion + cache misses:

from functools import lru_cache

@lru_cache(maxsize=2)  # Cache for only 2 elements
def fib(n):
    if n <= 1:
        return n
    # Call it twice with the same arguments to hit the cache misses
    return fib(n-1) + fib(n-2)

# The calculation will take forever
print(fib(50))

The cache is too small to help. The algorithm slows down exponentially, wasting time on constant cache misses.

Pro Tip: Killing the Garbage Collector:

🔵Create cyclic references in huge object graphs

🔵Disable GC: gc.disable()

🔵Use globals() to store everything so the memory never gets freed

Important:
These tricks won't just slow down execution, they'll make the code completely unsupported. Your colleague will curse the day he decided to debug this.

👩‍💻 https://news.1rj.ru/str/DataScience4

👨‍💻 Removing the background from any image in a few seconds with Python!

Do you want to automate image processing without Photoshop? 
A noscript project based on the rembg library:

📦 Installation:

pip install rembg

Example code:

from rembg import remove


def remove_background(input_path: str, output_path: str) -> None:
    """Removes the background from the image and saves the result."""
    with open(input_path, 'rb') as input_file:
        with open(output_path, 'wb') as output_file:
            image_bytes: bytes = input_file.read()
            output_bytes: bytes = remove(image_bytes)
            output_file.write(output_bytes)

if __name__ == "__main__":
    remove_background('input.png', 'output.png')

🟢Opens the file;
🟢Removes the background;
🟢Saves the finished image.

5️⃣ GitHub/Instructions

#python #soft #code

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://news.1rj.ru/str/addlist/8_rRW2scgfRhOTc0

✅ https://news.1rj.ru/str/Codeprogrammer

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