Day 28: Asynchronous Programming \(asyncio\) \- Code & Output

Here's your Telegram post for Day 29!

---

**Python Learning Series - Day 29: Basic Database Interaction (SQLite)**

Day 29 is here! 🚀 Ever wondered how your Python apps can store and retrieve data persistently? Today, we dive into the world of databases with SQLite! 💾 We'll learn the basics of connecting, creating tables, inserting data, and fetching results using Python's built-in `sqlite3` module. Get ready to give your scripts a memory! 🧠💻

```python
import sqlite3

# 1. Connect to an SQLite database (or create one if it doesn't exist)
# Using 'my_app_data.db' will create a file. ':memory:' would create an in-memory DB.
conn = sqlite3.connect('my_app_data.db')
cursor = conn.cursor()

# 2. Create a table
# IF NOT EXISTS prevents error if table already exists
cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER
)
''')

# 3. Insert some data
# Using '?' as placeholders for parameters for safety and convenience
cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ("Alice", 30))
cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ("Bob", 24))
cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ("Charlie", 35))

# 4. Commit changes (save them to the database file)
conn.commit()

# 5. Fetch data
print("All users:")
cursor.execute("SELECT * FROM users")
rows = cursor.fetchall() # Fetch all results
for row in rows:
print(row)

# 6. Close the connection
conn.close()
print("nDatabase operations completed. 'my_app_data.db' created/updated.")
```

Output example:
```
All users:
(1, 'Alice', 30)
(2, 'Bob', 24)
(3, 'Charlie', 35)

Database operations completed. 'my_app_data.db' created/updated.
```

💡 **Challenge:**
Modify the code to:
1. Insert one more user into the `users` table.
2. Select and print only users whose age is greater than 25.

Share your solution or just let us know you tried! 👇

---

Day 29: Basic Database Interaction \(SQLite\) \- Code & Output

🥳 *Congratulations on reaching Day 30 of our Python series!* 🐍

Today is all about gearing up for your Final Project! 🎉 It's time to consolidate everything you've learned into something truly your own. We'll explore how to brainstorm ideas and review key concepts we've covered. Don't be overwhelmed – think of it as a creative challenge! Let's get those project ideas flowing! 💡

---

Here's a little helper to get your brainstorming started:

```python
import random

def generate_project_idea():
categories = [
"Web Application",
"Command-Line Tool",
"Data Analysis Script",
"Game",
"Automation Script",
"Desktop Application",
"API Integration"
]
themes = [
"personal finance tracker",
"to-do list manager",
"simple calculator",
"weather app",
"file organizer",
"quiz game",
"recipe book",
"contact manager"
]
technologies = [
"using Flask",
"with SQLite database",
"fetching data from an API",
"using object-oriented programming",
"with a GUI library like Tkinter",
"using Pandas for data manipulation"
]

idea_category = random.choice(categories)
idea_theme = random.choice(themes)
idea_tech = random.choice(technologies)

return f"💡 Your project idea: A {idea_category} that is a {idea_theme} {idea_tech}."

if __name__ == "__main__":
print(generate_project_idea())
```

Output example:
```
💡 Your project idea: A Web Application that is a recipe book using Flask.
```

---

**Your Challenge:**
1. What's one project idea you've been thinking about building with Python? Share it!
2. Expand the `generate_project_idea` function to include more categories, themes, or even suggest specific Python libraries to use. 🚀

---

Day 30: Final Project Idea and Review \- Code & Output

🚀 Day 31: Ready to peer into Python's soul? 🕵️‍♂️ Today, we're diving deep into the **Abstract Syntax Tree (AST)**! Forget just writing code; we'll learn how Python *sees* your code at its structural core. Understanding ASTs empowers you to build incredible tools: custom linters, code generators, refactoring scripts, and even new language features! ✨ This is pure metaprogramming magic. Let's crack open the parser! 🛠️

```python
import ast

# Sample Python code to analyze
code_snippet = """
def greet(name):
print(f"Hello, {name}!")

class MyClass:
def __init__(self, value):
self.value = value

def display(self):
return f"Value: {self.value}"

def calculate_sum(a, b):
# This is a comment
return a + b
"""

class NodeCounter(ast.NodeVisitor):
"""
A simple AST visitor to count different types of nodes
and find function names.
"""
def __init__(self):
self.node_counts = {}
self.function_names = []

def visit(self, node):
# Count all node types
node_type = type(node).__name__
self.node_counts[node_type] = self.node_counts.get(node_type, 0) + 1

# Specific action for FunctionDef
if isinstance(node, ast.FunctionDef):
self.function_names.append(node.name)

self.generic_visit(node) # Continue visiting children

# Parse the code into an AST
tree = ast.parse(code_snippet)

# Create an instance of our visitor and traverse the tree
counter = NodeCounter()
counter.visit(tree)

print("📊 AST Analysis Results:")
print("-----------------------")
print("Detected Function Names:")
for func_name in counter.function_names:
print(f"- {func_name}")

print("nNode Type Counts:")
for node_type, count in sorted(counter.node_counts.items()):
print(f"- {node_type}: {count}")
```

Output example:
```
📊 AST Analysis Results:
-----------------------
Detected Function Names:
- greet
- __init__
- display
- calculate_sum

Node Type Counts:
- Arg: 4
- Arguments: 4
- Assign: 1
- Attribute: 1
- BinOp: 1
- Call: 1
- ClassDef: 1
- Constant: 3
- Expr: 1
- FString: 1
- FormattedValue: 1
- FunctionDef: 4
- Load: 8
- Module: 1
- Name: 12
- Return: 2
- Store: 1
- With: 0
```

### Small Challenge 🧠
Can you modify the `NodeCounter` class to also find and list all `ClassDef` names present in the `code_snippet`? Hint: You'll need to look for `ast.ClassDef` nodes!

---

Here's your Telegram post for Day 32 on Metaclasses!

🚀 Day 32 of our Python journey takes us deep into the magic! Today, we're unveiling **Metaclasses**! 🧙‍♂️ Forget just creating objects; metaclasses let you **architect how classes themselves are created and behave**. Think frameworks, ORMs, and advanced library design. Ready to bend Python's reality? Let's dive into dynamic class creation beyond `type()`! ✨

```python
class ClassRegistryMeta(type):
# A dictionary to store all classes created by this metaclass
_registry = {}

def __new__(mcs, name, bases, attrs):
print(f"Metaclass: Preparing to create class '{name}'...")

# You can inspect/modify 'attrs' before the class is created
# For example, ensure a method exists or add new attributes
if '__str__' not in attrs:
attrs['__str__'] = lambda self: f"<Registered Object: {self.__class__.__name__}>"

# Create the class using the parent (type) __new__ method
new_class = super().__new__(mcs, name, bases, attrs)

# Add a custom class-level attribute
new_class._registered_name = name

# Register the new class in our metaclass's registry
mcs._registry[name] = new_class
print(f"Metaclass: Class '{name}' created and registered.")
return new_class

# Define classes using our custom metaclass
class MyService(metaclass=ClassRegistryMeta):
def __init__(self, id):
self.id = id

def identify(self):
print(f"{self._registered_name} instance with ID: {self.id}")

class AnotherComponent(metaclass=ClassRegistryMeta):
def __init__(self, data):
self.data = data

def show_data(self):
print(f"{self._registered_name} processing data: {self.data}")

print("n--- Class Definitions Complete ---")

# Accessing the registry via the metaclass itself
print(f"nAll registered classes: {list(ClassRegistryMeta._registry.keys())}")

# Instantiate registered classes using the registry
service_instance = ClassRegistryMeta._registry["MyService"](101)
service_instance.identify()
print(service_instance) # Uses the __str__ added by the metaclass

component_instance = ClassRegistryMeta._registry["AnotherComponent"]({"key": "value"})
component_instance.show_data()
print(component_instance)
```

Output example:
```
Metaclass: Preparing to create class 'MyService'...
Metaclass: Class 'MyService' created and registered.
Metaclass: Preparing to create class 'AnotherComponent'...
Metaclass: Class 'AnotherComponent' created and registered.

--- Class Definitions Complete ---

All registered classes: ['MyService', 'AnotherComponent']
MyService instance with ID: 101
<Registered Object: MyService>
AnotherComponent processing data: {'key': 'value'}
<Registered Object: AnotherComponent>
```

**Challenge:**
Modify the `ClassRegistryMeta` to automatically add a `VERSION = "1.0"` attribute to any class it creates, but only if the class does *not* already define a `VERSION` attribute.

---

🌟 Day 33: Prepare to go *way* beyond surface-level Python! Today, we're deconstructing the interpreter itself. Ever wondered what happens to your code before it runs? We're diving deep into Python's Abstract Syntax Trees (AST) and bytecode. Understanding these internals unlocks immense power for runtime code transformation, static analysis, and even building your own language tools! Get ready to manipulate Python at its very core. 🧙‍♂️✨

```python
import ast
import dis
import types

# 1. Original Python code string
original_code_str = """
def calculate_secret(x):
y = x * 2 + 5 # The constant '5' will be our target for modification
print(f"Original calculation for {x}: {y}")
return y
"""

# 2. Parse the code into an AST
original_ast = ast.parse(original_code_str)

# 3. Define a NodeTransformer to modify the AST
# We will change the constant '5' to '10' within the AST
class ConstantChanger(ast.NodeTransformer):
def visit_Constant(self, node):
if isinstance(node.value, int) and node.value == 5:
# Return a new Constant node with the modified value
return ast.Constant(value=10)
return node # Return the original node for others

# 4. Apply the transformation
modified_ast = ConstantChanger().visit(original_ast)
# Fix line numbers and other metadata in the modified AST
ast.fix_missing_locations(modified_ast)

# 5. Compile and execute both original and modified ASTs
# Compile the original AST and get the function
original_compiled_code = compile(original_ast, '<string>', 'exec')
original_namespace = {}
exec(original_compiled_code, original_namespace)
original_func = original_namespace['calculate_secret']

# Compile the modified AST and get the function
modified_compiled_code = compile(modified_ast, '<string>', 'exec')
modified_namespace = {}
exec(modified_compiled_code, modified_namespace)
modified_func = modified_namespace['calculate_secret']

print("--- Original Function Bytecode ---")
dis.dis(original_func)

print("n--- Modified Function Bytecode ---")
dis.dis(modified_func)

print("n--- Execution Comparison ---")
# Call both functions to observe the runtime transformation
original_func(10)
modified_func(10) # Observe the result of 'x * 2 + 10' instead of 'x * 2 + 5'
```

Output example:
(Note: `ast.dump` is verbose, so we'll highlight the key change and show `dis` and execution comparison.)
The `ast.dump` for the original AST would show `Constant(value=5)`.
The `ast.dump` for the modified AST would show `Constant(value=10)` in the corresponding place.

```
--- Original Function Bytecode ---
3 0 LOAD_FAST 0 (x)
2 LOAD_CONST 1 (2)
4 BINARY_MULTIPLY
6 LOAD_CONST 2 (5) # Original constant value
8 BINARY_ADD
10 STORE_FAST 1 (y)
...
--- Modified Function Bytecode ---
3 0 LOAD_FAST 0 (x)
2 LOAD_CONST 1 (2)
4 BINARY_MULTIPLY
6 LOAD_CONST 2 (10) # Modified constant value!
8 BINARY_ADD
10 STORE_FAST 1 (y)
...
--- Execution Comparison ---
Original calculation for 10: 25
Original calculation for 10: 30
```

Small challenge:
Can you modify the `ConstantChanger` class to not just change a constant, but to transform an arithmetic operator? For instance, change all `ast.Add` operations to `ast.Mult` operations within a specific function! 😈

---

👻 Day 34: Unmasking the "Ghost in the Machine"! Ever wondered how to manage memory efficiently in Python, especially with caches or large data structures? Today, we dive into **Weak References** and **Ephemeral Objects**! 💡 Discover how to create references to objects without preventing them from being garbage collected, crucial for preventing memory leaks and building robust, memory-sensitive applications. Let's make our Python programs lighter and smarter! 🧠✨

```python
import weakref
import gc # Import gc to manually trigger collection for demonstration

class MyEphemeralObject:
def __init__(self, name):
self.name = name
print(f"✨ Object '{self.name}' created.")

def __del__(self):
print(f"💀 Object '{self.name}' garbage collected.")

print("--- Scenario 1: Object collected when only weak references exist ---")
# 1. Create a strong reference
strong_ref = MyEphemeralObject("Ephemeral A")

# 2. Create a weak reference to the same object
# This reference will not prevent the object from being garbage collected
weak_ref = weakref.ref(strong_ref)

print(f"Weak reference currently points to: {weak_ref()}")

# 3. Delete the strong reference. Now, only the weak_ref points to the object.
print("n🔥 Deleting the strong reference 'strong_ref'...")
del strong_ref

# Manually trigger garbage collection (often happens automatically, but good for demo)
gc.collect()

print("Attempting to access object via weak reference after strong reference deletion:")
retrieved_object = weak_ref()

if retrieved_object is None:
print("✅ Object has been garbage collected!")
else:
print(f"❌ Object still exists: {retrieved_object.name}")

print("n--- Scenario 2: Object NOT collected if a strong reference persists ---")
strong_ref_2 = MyEphemeralObject("Persistent B")
weak_ref_2 = weakref.ref(strong_ref_2)

print(f"Weak reference 2 points to: {weak_ref_2()}")

# We don't delete strong_ref_2 yet.
print("Strong reference 'strong_ref_2' still exists. Object should NOT be collected.")
gc.collect() # Trigger GC, but object is still strongly referenced

retrieved_object_2 = weak_ref_2()
if retrieved_object_2 is None:
print("❌ Object unexpectedly collected!")
else:
print(f"✅ Object still exists: {retrieved_object_2.name}")

# Now, let's delete the remaining strong reference for Persistent B
print("n🔥 Deleting the strong reference 'strong_ref_2' for Persistent B...")
del strong_ref_2
gc.collect() # Trigger GC again
```

Output example:
```
--- Scenario 1: Object collected when only weak references exist ---
✨ Object 'Ephemeral A' created.
Weak reference currently points to: <__main__.MyEphemeralObject object at 0x...>

🔥 Deleting the strong reference 'strong_ref'...
💀 Object 'Ephemeral A' garbage collected.
Attempting to access object via weak reference after strong reference deletion:
✅ Object has been garbage collected!

--- Scenario 2: Object NOT collected if a strong reference persists ---
✨ Object 'Persistent B' created.
Weak reference 2 points to: <__main__.MyEphemeralObject object at 0x...>
Strong reference 'strong_ref_2' still exists. Object should NOT be collected.
✅ Object still exists: Persistent B

🔥 Deleting the strong reference 'strong_ref_2' for Persistent B...
💀 Object 'Persistent B' garbage collected.
```

🤔 **Your Challenge:** Think of a common Python use case, like a large cache, a GUI framework, or a network connection pool, where using weak references would be absolutely critical to prevent memory leaks or excessive memory consumption. How would you apply them? Share your ideas! 👇

✨ Welcome to Day 37! Ever wondered how `@property` works its magic? Or how attributes can have custom behavior on access? Today, we pull back the curtain on Python's **Descriptors**! 🤫 These "silent guardians" are objects that control how attributes are accessed, set, or deleted. They're fundamental to many powerful Python features and allow you to craft incredibly flexible and robust classes. Let's unlock their secrets! 🔑

```python
class IntegerValidator:
"""
A descriptor that validates if an attribute is an integer
and falls within a specific range (0-100).
"""
def __set_name__(self, owner, name):
# Called when the descriptor is assigned to an attribute name in a class.
# We store the public name and create a private name for storage.
self.public_name = name
self.private_name = '_' + name

def __get__(self, obj, objtype=None):
# Called when the attribute is accessed (e.g., `instance.attribute`).
# If accessed from the class (obj is None), return the descriptor itself.
if obj is None:
return self
return getattr(obj, self.private_name)

def __set__(self, obj, value):
# Called when the attribute is set (e.g., `instance.attribute = value`).
# This is where our validation logic resides.
if not isinstance(value, int):
raise ValueError(f"{self.public_name} must be an integer!")
if not (0 <= value <= 100):
raise ValueError(f"{self.public_name} must be between 0 and 100!")
setattr(obj, self.private_name, value) # Store the valid value

# __delete__ is optional, but would be called for `del instance.attribute`

class Scoreboard:
# Assigning the descriptor to class attributes
score = IntegerValidator()
level = IntegerValidator()

def __init__(self, initial_score, initial_level):
# When we assign values here, the descriptor's __set__ method is called
self.score = initial_score
self.level = initial_level

# Demonstrate usage
print("--- Valid Scores ---")
player_a = Scoreboard(50, 5)
print(f"Player A - Score: {player_a.score}, Level: {player_a.level}") # __get__ is called
player_a.score = 75 # __set__ is called
print(f"Player A updated score: {player_a.score}")

print("n--- Invalid Score Attempts ---")
try:
player_b = Scoreboard(110, 1) # This will raise an error due to score > 100
except ValueError as e:
print(f"Error creating Player B: {e}")

try:
player_a.level = "rookie" # This will raise an error due to non-integer value
except ValueError as e:
print(f"Error updating Player A level: {e}")
```

Output example:
```
--- Valid Scores ---
Player A - Score: 50, Level: 5
Player A updated score: 75

--- Invalid Score Attempts ---
Error creating Player B: score must be between 0 and 100!
Error updating Player A level: level must be an integer!
```

💡 **Your Challenge:** Modify the `IntegerValidator` descriptor to also accept an optional `min_value` and `max_value` during its definition (e.g., `score = IntegerValidator(min_value=0, max_value=1000)`). How would you pass these values to the descriptor's `__init__` method, and how would you incorporate them into the `__set__` method's validation?

---

✨ Day 38: Dive deep into the *Infinite Stream*! 🌊 Today, we unlock the true power of lazy evaluation in Python. Forget memory woes with massive datasets! We'll go beyond basic generators, explore custom iterator protocols, and leverage the incredible `itertools` module to craft highly efficient and composable data processing pipelines. Get ready to master memory-efficient computation! 🚀

```python
import itertools

# Custom infinite generator for even numbers
def infinite_even_numbers():
n = 0
while True:
yield n
n += 2

# Using itertools for a lazy pipeline
print("First 5 even numbers:")
evens = infinite_even_numbers()
first_5_evens = list(itertools.islice(evens, 5))
print(first_5_evens)

# A more complex lazy pipeline:
# Generate infinite numbers, filter out non-multiples of 3,
# then take the first 4 that are greater than 10.
def infinite_numbers():
n = 0
while True:
yield n
n += 1

numbers = infinite_numbers()

# Filter out numbers not divisible by 3 (lazy filtering)
multiples_of_3 = (num for num in numbers if num % 3 == 0)

# Take the first 4 multiples of 3 that are greater than 10 (lazy taking)
pipeline_result = list(
itertools.islice(
(num for num in multiples_of_3 if num > 10),
4
)
)
print("nFirst 4 multiples of 3 greater than 10:")
print(pipeline_result)
```

Output example:
```
First 5 even numbers:
[0, 2, 4, 6, 8]

First 4 multiples of 3 greater than 10:
[12, 15, 18, 21]
```

💡 **Challenge:** Modify the `infinite_even_numbers` generator to create `infinite_prime_numbers()`. Then, use `itertools.islice` to print the first 7 prime numbers. Share your elegant, lazy solution!

---