Python Basics Notes 🐍📚

https://t.me/pythonRe 🔗

#Python #Coding #Programming #LearnPython #Tech #DevCommunity

If you work with Python, remember a simple rule: do not modify a list while iterating over it. 🐍🛑 This can lead to unexpected results because the iterator does not track structural changes.

Here is an example that looks logical but works incorrectly: 🤔

items = [1, 2, 2, 3, 4]
for item in items:
    if item == 2:
        items.remove(item)
print(items)
# Output: [1, 2, 3, 4]

It seems that all 2s should disappear, but one remains. ❓ Why?

After removing an element, the list shifts, but the loop moves on — as a result, some values are simply skipped. 🔄🚫

How to do it correctly — iterate over a copy: ✅

for item in items[:]:
    if item == 2:
          items.remove(item)
print(items)
# Output: [1, 3, 4]

Even better — use list comprehension: 🚀

items = [x for x in items if x != 2]

Conclusion: 🏁 do not modify a collection during iteration. This can lead to skipped elements, duplication, or even errors during execution. 🛠️🚧

#Python #Coding #Programming #Debugging #TechTips #PythonTips

The Python library itertools contains many useful functions. 🐍✨

One of them is compress(), which returns an iterator over the elements from data, for which the corresponding element in selectors is equal to True. 🔍💻

Here's an example: 📝👇

#Python #Programming #Itertools #Coding #Tech #DataScience

Cheat sheet on the basics of Python: 🐍📚

basic syntax and language rules 📝
scalar types — basic data types (int, float, bool, str, NoneType) 🔢

datetime — working with date and time 📅⏰

data structures — Python data structures (list, tuple, dict, set) 🗄

list — mutable lists for storing data collections 📋
tuple — immutable sequences of values 🔒
dict (hash map) — storing data in a key-value format 🗝
set — unique elements without order 🔘

slicing — obtaining parts of sequences through indices and step ✂️

module/library — connecting modules and libraries 🔌

help functions — using help() and dir() to explore the Python API 🛠

#Python #Coding #DataScience #Programming #Tech #DevCommunity

Do you know that Python can shift sequences without slicing and creating new lists? 🤔

When you need to cyclically shift data, many use slicing:

data = data[-1:] + data[:-1]

But deque.rotate() does this at the level of the data structure and usually works more efficiently for cyclical operations. 🚀

q.rotate(1)

A negative value rotates the queue in the other direction. ⬅️

q.rotate(-2)

This is useful for ring buffers, task schedulers, cyclical queues, and round-robin algorithms. 🔄

workers.rotate(-1)

🔥 deque.rotate() allows you to implement cyclical data structures without manual index logic and without creating new lists. 💡

#Python #Programming #Deque #CodingTips #Tech #DevCommunity

How to check for the presence of subclasses in Python? 🐍🧐

Here's how you can do it:

import inspect

def has_subclasses(cls):
    return any(issubclass(sub, cls) for sub in inspect.getmembers(sys.modules[cls.__module__], inspect.isclass))

This function uses the inspect module to find all subclasses of the given class. 🛠️

#Python #Programming #Subclasses #Coding #Dev #Tech

📂 Reminder about Python map()!

map() — a built-in function that applies the specified function to each element of an iterable object (list, tuple, set, etc.).

The picture shows the basic syntax, an example of use with lambda, and a typical case — data transformation without a manual for loop.

Save it to quickly remember the syntax!

🐍💻🗺️ #Python #Coding #Programming #LearnToCode #DevTips #Tech

If you're working with data pipelines, these repositories are very useful: 🚀📊

ibis: A Python API that allows you to write queries once and run them on different data backends, such as DuckDB, BigQuery, and Snowflake. 🐍🔗
https://github.com/ibis-project/ibis

pygwalker: Instantly turns a DataFrame into an interactive UI for visual data exploration. 📈🖥️
https://github.com/Kanaries/pygwalker

katana: A fast and scalable web crawler, often used for security testing and large-scale data collection/search. 🕷️🔒
https://github.com/projectdiscovery/katana

#dataengineering #python #opensource #devtools #dataviz #security

"Introduction to Algorithms" 📘 - an outstanding university resource for everyone studying algorithms and computer science. 🎓💻

The book covers computational complexity, data structures, algorithms on graphs, dynamic programming, divide-and-conquer methods, greedy algorithms, randomized algorithms, and many mathematical foundations of modern computer science. 🧮📊🔍

What's particularly valuable here is the combination of mathematical rigor and practical algorithmic thinking. 🧠✨ This is one of those books that greatly change the approach to problem analysis, efficiency, and computing itself. 🚀🛠

An essential tool in the library of any developer and engineer working in the field of computer science. 🏗💾

https://www.cs.mcgill.ca/~akroit/math/compsci/Cormen%20Introduction%20to%20Algorithms.pdf 🔗

#Algorithms #ComputerScience #Programming #CSStudent #TechEducation #DevTools

Why is enumerate() used in Python? 🤔🐍

It allows you to simultaneously obtain the value of an element and its index when iterating through a list. 📊✨

This is more convenient and more readable than manually working with a counter. ✅🚀

for i, item in enumerate(items):
    print(i, item)

#Python #Coding #Programming #Dev #Tech #Code

✨ Join Best TG Channels
https://t.me/addlist/0f6vfFbEMdAwODBk

⭐️ Join Our WhatsApp Channel
https://whatsapp.com/channel/0029VaC7Weq29753hpcggW2A

Data validation with Pydantic! 🐍✨

In the early stages of development, data validation usually doesn't cause problems. In many Python projects, validation initially looks simple:

if not isinstance(age, int):
    raise ValueError("age must be an int")

But then come email, JSON from APIs, query parameters, nested objects, configs, nullable fields, and type conversion. At some point, the code turns into a set of if/else and manual checks.

For such tasks, Pydantic is often used. Installation:

pip install pydantic
pip install "pydantic[email]"

Create a model:

from pydantic import BaseModel

class User(BaseModel):
    name: str
    age: int

Now the data is validated automatically:

user = User(
    name="Alex",
    age="30"
)

print(user.age)
print(type(user.age))

The result:
30
<class 'int'>

Pydantic will automatically convert the string "30" to an int. If you pass an incorrect value, you'll get a ValidationError:

User(
    name="Alex",
    age="test"
)

This is especially convenient when working with APIs, JSON, query parameters, and incoming data from outside.

A common production case is checking email:

from pydantic import BaseModel, EmailStr

class User(BaseModel):
    email: EmailStr

User(email="alex@test.com")

If the email is invalid, Pydantic will throw a ValidationError. You can set default values:

from pydantic import BaseModel

class Config(BaseModel):
    host: str = "localhost"
    port: int = 5432

And allow None:

from pydantic import BaseModel

class User(BaseModel):
    nickname: str | None = None

This field becomes optional. A practical example is processing an API response:

from pydantic import BaseModel

class Product(BaseModel):
    id: int
    title: str
    price: float

data = {
    "id": "1",
    "title": "Keyboard",
    "price": "99.5"
}

product = Product(**data)

print(product)

The types will be automatically converted. For nested model structures, you can combine:

from pydantic import BaseModel

class Address(BaseModel):
    city: str
    zip_code: str

class User(BaseModel):
    name: str
    address: Address

user = User(
    name="Alex",
    address={
        "city": "Berlin",
        "zip_code": "10115"
    }
)

print(user)

The nested object will also be validated. Serialization in Pydantic v2:

print(user.model_dump())
print(user.model_dump_json())

Pydantic is actively used in FastAPI, ETL, microservices, data pipelines, and API clients.

For working with environment variables in Pydantic v2, a separate package is usually used:

pip install pydantic-settings

It's important to understand: Pydantic is not an ORM and does not replace business logic. Its task is to validate data, convert types, and describe schemas.

🔥 Pydantic significantly reduces the amount of manual data validation and makes processing incoming structures more predictable.

#Python #Pydantic #DataValidation #FastAPI #Coding #DevOps

✨ Join Best TG Channels https://t.me/addlist/0f6vfFbEMdAwODBk
⭐️ Join Our WhatsApp Channel https://whatsapp.com/channel/0029VaC7Weq29753hpcggW2A

# Cheat sheet on high-order functions in Python:

🐍 map() - applies a function to every element of an iterable and returns an iterator with the results
🔍 filter() - filters elements based on a condition and leaves only those for which the function returns True
🔄 reduce() - successively combines all elements of an iterable into a single value
⚡ lambda functions - anonymous functions for short expressions and working with map/filter/reduce
📦 iterable objects - lists, tuples, and other collections for processing
📚 functools - a Python module that contains reduce()
🧠 functional programming - an approach to programming through functions and data processing without changing the state

```python
# Example usage
from functools import reduce

# map
squared = map(lambda x: x**2, [1, 2, 3, 4])
print(list(squared))

# filter
evens = filter(lambda x: x % 2 == 0, [1, 2, 3, 4, 5])
print(list(evens))

# reduce
total = reduce(lambda x, y: x + y, [1, 2, 3, 4])
pr

int(total)```

#Python #Programming #HighOrderFunctions #FunctionalProgramming #Coding #MapFilterReduce

✨ Join Best TG Channels https://t.me/addlist/0f6vfFbEMdAwODBk
⭐️ Join Our WhatsApp Channel https://whatsapp.com/channel/0029VaC7Weq29753hpcggW2A

❤️ Architecture Patterns — an informative repository on backend architecture in Python!

Here, they excellently demonstrate how to properly separate application logic, work with complex architecture, build a scalable backend, and maintain a codebase in an adequate state as the project grows. Instead of dry theory, the authors gradually build a full-fledged application and show how the architecture evolves as the project grows.

I'll leave a link: https://github.com/cosmicpython/book

#Python #Backend #Architecture #Coding #DevCommunity #OpenSource

✨ Join Best TG Channels https://t.me/addlist/0f6vfFbEMdAwODBk

⭐️ Join Our WhatsApp Channel https://whatsapp.com/channel/0029VaC7Weq29753hpcggW2A

🚀 HelloEncyclo Presale is LIVE!

Master the skills that matter — Gen-AI, Data Science, Machine Learning and more — all in one place.

🎁 First 250 members get a flat 40% OFF

Use code: PRESALE-BOOK-WAVE-2GFG

✅ 13 full courses live right now

✅ 40+ more dropping in the next 2–3 weeks

✅ Complete library within 2 months — built and refined by industry experts

✅ 15-day money-back guarantee — don't love it? Get a full refund.

⚠️ Coupon works only after you log in with Gmail, and it's valid once per member.

👉 Log in now and start learning:

https://helloencyclo.com

Don't wait — the 40% deal disappears after the first 250 seats. 🔥

Why in Python it is better to check None using is 🐍

In Python, you should not write obj == None, even if sometimes it works the same ⚠️

The reason is that == calls the comparison method eq, which can be overridden in the class — and then the behavior becomes unpredictable 🎲

For example:

class Weird:
    def eq(self, other):
        return True  # always says "equal"

obj = Weird()

print(obj == None)  # True
print(obj is None)  # False

Here obj == None gives a false result due to custom logic 🤔

Instead:

obj is None

is checks the identity of the object and cannot be overridden. Since None is a singleton, such a check is always correct and predictable ✅

Conclusion: to check for None always use is None — it is the right and safe approach 🛡️

✨ Join Best TG Channels https://t.me/addlist/0f6vfFbEMdAwODBk

⭐️ Join Our WhatsApp Channel https://whatsapp.com/channel/0029VaC7Weq29753hpcggW2A

#Python #Programming #Coding #SoftwareDevelopment #TechTips #DevCommunity

Deep copying of objects with the copy module 🐍📦

import copy

# Original list with nested structure
original = [[1, 2, 3], [4, 5, 6]]

# 1. Shallow copy
shallow = copy.copy(original)
shallow[0][0] = 'X'
# Oh no! Both lists have changed, because the nested list wasn't copied, but passed by reference
print(f"Original after shallow: {original}") # [['X', 2, 3], [4, 5, 6]]

# Restore the data
original = [[1, 2, 3], [4, 5, 6]]

# 2. Deep copy
deep = copy.deepcopy(original)
deep[0][0] = 'X'
# Everything is fine! Only deep has changed, the original remains untouched
print(f"Original after deep:    {original}") # [[1, 2, 3], [4, 5, 6]]

The link trap in Python 🔗🕳️

When you assign a list to another variable (A = B) or make a regular slice (A = B[:]), Python doesn't physically copy the data. It simply creates a new reference to the same objects in memory. If the list contains other mutable objects (lists, dictionaries, custom classes), standard copying methods will only create a shallow copy. The copy module allows you to control this process.

— Breaking the links: The deepcopy function recursively traverses the entire data structure and creates honest, independent duplicates for each nested element. This ensures that changes in the copy will not harm the original data. 🔓🔒
— Safe state: The use of deep copying is critical when implementing design patterns (for example, Snapshot/Memento), creating game state backups, or when you pass complex configurations to functions that may modify them accidentally. 🛡️💾
— A sensible balance: It's worth remembering that deepcopy works slower and consumes more memory than shallow copying, as it spends resources on creating new objects and checking for cyclic references. Use it specifically when there are nested mutable containers within the structure. ⚖️🧠

#Python #Programming #DeepCopy #Coding #Tech #Dev

✨ Join Best TG Channels https://t.me/addlist/0f6vfFbEMdAwODBk

⭐️ Join Our WhatsApp Channel https://whatsapp.com/channel/0029VaC7Weq29753hpcggW2A

Regular for-loops are versatile but not always optimal: they add extra interpreter overhead, which is especially noticeable on large data 🐍

In such cases, it's better to use standard Python tools, for example itertools ⚙️

For example, to get all unique pairs from a list, nested loops are not needed — just combinations():

from itertools import combinations

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

print(get_unique_pairs(['A', 'B', 'C', 'D']))

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

Conclusion: instead of manual loops, it's better to use ready-made tools from the standard library — it's cleaner and more efficient 🚀

#Python #Coding #Programming #Developer #Tech #Optimization

✨ Join Best TG Channels https://t.me/addlist/0f6vfFbEMdAwODBk

⭐️ Join Our WhatsApp Channel https://whatsapp.com/channel/0029VaC7Weq29753hpcggW2A