Day 26: Basic Web Scraping \(Beautiful Soup\) \- Code & Output

🚀 Day 27: Diving into Web Development with Python! 🌐 Today, we're getting a sneak peek at the powerful world of Python web frameworks: Flask and Django! ✨ These frameworks are your go-to tools for building dynamic and interactive web applications, from simple APIs to complex websites. Flask is known for its simplicity and flexibility (a microframework), while Django offers a full-stack solution with everything included. Let's write our first tiny Flask app! 👇

```python
# First, if you haven't, install Flask:
# pip install Flask

from flask import Flask

# Create a Flask application instance
app = Flask(__name__)

# Define a route for the homepage ('/')
@app.route('/')
def hello_world():
return 'Hello, Flask World! 👋'

# Run the application if this script is executed directly
if __name__ == '__main__':
# debug=True allows for automatic reloading and provides a debugger
# For production, set debug=False
app.run(debug=True)
```

Output example:
To run this:
1. Save the code as `app.py` (or any `.py` file).
2. Open your terminal in the same directory.
3. Run: `python app.py`

You'll see output like:
```
* Debug mode: on
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
* Restarting with stat
* Debugger is active!
* Debugger PIN: XXX-XXX-XXX
```
Open `http://127.0.0.1:5000/` in your browser to see "Hello, Flask World! 👋"

💡 **Challenge:** Add another route to the Flask application! Create a new route `@app.route('/greet/<name>')` that takes a name as a URL parameter (e.g., `/greet/Alice`) and returns a personalized greeting like `Hello, Alice!` Try it out! 🧑‍💻

---

Day 27: Introduction to Flask/Django \- Code & Output

🚀 Day 28: Dive into the fascinating world of Asynchronous Programming with `asyncio`! 🐢 Tired of your program waiting? `asyncio` lets your Python code perform multiple tasks *seemingly* at once, especially great for I/O-bound operations like network requests or file operations. Say goodbye to blocking and hello to efficiency! 💨 Let's make your code run smarter, not harder.

```python
import asyncio
import time

async def perform_task(name, delay):
"""Simulates an I/O-bound operation."""
print(f"[{name}] Starting...")
await asyncio.sleep(delay) # Yield control back to the event loop
print(f"[{name}] Finished after {delay} seconds!")
return f"{name} done"

async def main():
start_time = time.time()
print("Main: Kicking off async tasks...")

# Run tasks concurrently
results = await asyncio.gather(
perform_task("Task A", 2),
perform_task("Task B", 1),
perform_task("Task C", 3)
)

end_time = time.time()
print(f"nMain: All tasks completed in {end_time - start_time:.2f} seconds.")
print(f"Main: Results: {results}")

if __name__ == "__main__":
asyncio.run(main())
```

Output example:
Main: Kicking off async tasks...
[Task A] Starting...
[Task B] Starting...
[Task C] Starting...
[Task B] Finished after 1 seconds!
[Task A] Finished after 2 seconds!
[Task C] Finished after 3 seconds!

Main: All tasks completed in 3.00 seconds.
Main: Results: ['Task A done', 'Task B done', 'Task C done']

💡 **Small Challenge:** Add another `async` function that attempts to read a (non-existent) file using `asyncio.to_thread` to simulate a blocking file read. How would you integrate it into the `asyncio.gather` call? What's the benefit of `asyncio.to_thread` here?

---

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

Here's your Telegram post for Day 29:

---

**Day 29: Basic Database Interaction (SQLite) 💾**

Ever wondered how applications store all that important information? Today, we dive into the world of databases with Python's built-in `sqlite3` module! 🚀 SQLite is a super lightweight, file-based database – perfect for learning and small projects. You'll learn to connect, create tables, insert data, and retrieve it. Let's get persistent! ✨

```python
import sqlite3

# 1. Connect to the database (or create it if it doesn't exist)
# This will create a file named 'my_items.db' in your script's directory.
conn = sqlite3.connect('my_items.db')
cursor = conn.cursor()

# 2. Create a table (IF NOT EXISTS prevents errors if you run this multiple times)
cursor.execute('''
CREATE TABLE IF NOT EXISTS products (
id INTEGER PRIMARY KEY,
item_name TEXT NOT NULL,
quantity INTEGER NOT NULL
)
''')

# 3. Insert some data into the table
# Using placeholders (?) is crucial to prevent SQL injection vulnerabilities.
cursor.execute("INSERT INTO products (item_name, quantity) VALUES (?, ?)", ("Laptop", 5))
cursor.execute("INSERT INTO products (item_name, quantity) VALUES (?, ?)", ("Mouse", 12))
cursor.execute("INSERT INTO products (item_name, quantity) VALUES (?, ?)", ("Keyboard", 8))
cursor.execute("INSERT INTO products (item_name, quantity) VALUES (?, ?)", ("Monitor", 3))


# Important: Commit the changes to save them permanently to the database file
conn.commit()

# 4. Retrieve and print all data from the 'products' table
print("All products in the database:")
cursor.execute("SELECT * FROM products")
items = cursor.fetchall() # Fetches all rows from the last executed query

for item in items:
print(item)

# 5. Close the database connection
conn.close()
```

Output example:
```
All products in the database:
(1, 'Laptop', 5)
(2, 'Mouse', 12)
(3, 'Keyboard', 8)
(4, 'Monitor', 3)
```

Challenge Time! 🧠 Can you modify the `SELECT` query in the code to retrieve *only* products with a `quantity` greater than 10? Share your solution! 👇

---

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

🎉 Wow, we've made it to Day 30! 🎉

Congratulations on completing a month of consistent Python learning! Today isn't just about new syntax, but about reflecting, consolidating, and dreaming big. It's time to start thinking about your *final project* – the culmination of everything you've learned. Let's get those creative juices flowing and brainstorm some ideas, then review what makes a good project. What will you build? 🤔💡

```python
import random

def generate_project_idea():
"""Generates a random Python project idea from a predefined list."""
ideas = [
"A simple To-Do List application (CLI or basic GUI)",
"A calculator program with basic operations",
"A password generator (with options for length, symbols, numbers)",
"A unit converter (e.g., Celsius to Fahrenheit, meters to feet)",
"A basic 'Guess the Number' game",
"A text-based adventure game",
"A file organizer (e.g., sort files by type)",
"A simple web scraper for product prices on a specific site",
"A weather app (using a public API like OpenWeatherMap)",
"A basic contact book with add/view/delete functionality"
]
return random.choice(ideas)

print("🚀 Your potential project idea for today is:")
print(f"👉 {generate_project_idea()}")
```

Output example:
🚀 Your potential project idea for today is:
👉 A password generator (with options for length, symbols, numbers)
*(Note: Your actual output will vary each time you run the code!)*

**Small Challenge:**
Pick one of the generated ideas (or come up with your own awesome project concept!) and list 3 core features you would implement first. How would you start planning the steps to build it? Share your thoughts! 👇

---

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

🌟 Day 32: Unlock the ultimate power of Python! 🌟 Ever wondered how frameworks create magical APIs or enforce specific class structures? Today, we dive deep into the #MetaclassMultiverse! 🤯 We'll explore how to forge custom type systems, going far beyond simple `type` calls to control class creation itself. Get ready to redefine what a Python class can be! Let's build some powerful magic together. ✨ #PythonLearning #AdvancedPython #Metaclasses

Metaclasses allow you to intercept class creation and inject behavior, attributes, or methods before the class is even fully defined. This enables powerful patterns for validation, registration, and framework building!

```python
import datetime

# 🚀 Our custom metaclass
class MyMeta(type):
"""
A metaclass that automatically adds a creation timestamp and a 'greet' method
to any class that uses it.
"""
def __new__(cls, name, bases, dct):
# 1. Add a creation timestamp to the class dictionary
dct['_creation_timestamp'] = datetime.datetime.now()

# 2. Add a default 'greet' method if not already defined
if 'greet' not in dct:
def greet_method(self):
return (f"Hello from {self.__class__.__name__}! "
f"Created at {self._creation_timestamp.strftime('%Y-%m-%d %H:%M:%S')}")
dct['greet'] = greet_method

# 3. Call the base type's __new__ to complete class creation
return super().__new__(cls, name, bases, dct)

# 🧙‍♀️ Classes using our custom metaclass
class Character(metaclass=MyMeta):
def __init__(self, name):
self.name = name

class Item(metaclass=MyMeta):
def __init__(self, name):
self.name = name

# This class defines its own greet, which will override the metaclass's
def greet(self):
return f"Hello, I am {self.name}, an item created magically!"

# ✨ Let's see them in action!
hero = Character("Alice")
sword = Item("Excalibur")

print(hero.greet())
print(sword.greet()) # Notice how Item's custom greet takes precedence!
print(f"Character created at: {Character._creation_timestamp}")
```

Output example:
```
Hello from Character! Created at 2023-10-27 10:30:00 # (Timestamp will vary)
Hello, I am Excalibur, an item created magically!
Character created at: 2023-10-27 10:30:00 # (Timestamp will vary)
```

💡 **Your Challenge:** Modify `MyMeta` to automatically add a class-level `_registry` dictionary. For every class that uses `MyMeta`, register the class itself in this `_registry` using its `name` as the key. How would you then access this registry from another part of your code to list all registered classes?

---

🎉 Day 34: Unlocking Python's Object Model! 🐍 Ever wondered how `@property` works its magic, or why methods behave like they do? Today, we dive into the **Descriptor Protocol**! 🕵️‍♂️ This powerful mechanism allows you to customize attribute access (`__get__`, `__set__`, `__delete__`) for class variables. Master descriptors, and you'll gain unparalleled control over your objects' behavior, laying the groundwork for elegant and robust designs. Ready to peek behind the curtain? ✨

```python
class LoggingDescriptor:
"""
A simple descriptor that logs attribute access.
"""
def __set_name__(self, owner, name):
# Called when the descriptor is assigned to a class attribute
self.public_name = name
self.private_name = '_' + name # Store value in a private attribute

def __get__(self, obj, obj_type=None):
# Called when the attribute is accessed (e.g., obj.value)
if obj is None:
return self # Accessing descriptor directly from class (MyClass.value)
print(f"Accessing '{self.public_name}' from {obj_type.__name__}")
return getattr(obj, self.private_name, None)

def __set__(self, obj, value):
# Called when the attribute is assigned (e.g., obj.value = 10)
print(f"Setting '{self.public_name}' to {value} in {obj.__class__.__name__}")
setattr(obj, self.private_name, value)

def __delete__(self, obj):
# Called when the attribute is deleted (e.g., del obj.value)
print(f"Deleting '{self.public_name}' from {obj.__class__.__name__}")
delattr(obj, self.private_name)

class MyClass:
value = LoggingDescriptor() # 'value' is an instance of our descriptor
another_value = LoggingDescriptor()

def __init__(self, initial_value):
self.value = initial_value # This assignment triggers LoggingDescriptor.__set__

# Demonstrate usage
print("--- Creating instance ---")
obj = MyClass(10)

print("n--- Accessing attributes ---")
print(f"obj.value: {obj.value}")
print(f"obj.another_value: {obj.another_value}") # Accessing an unset descriptor

print("n--- Modifying attribute ---")
obj.value = 20

print("n--- Accessing again ---")
print(f"obj.value: {obj.value}")

print("n--- Deleting attribute ---")
del obj.value

print("n--- Accessing after delete ---")
try:
print(obj.value)
except AttributeError as e:
print(f"Error accessing deleted attribute: {e}")

print("n--- Accessing descriptor directly from class ---")
print(MyClass.value)
```

Output example:
```
--- Creating instance ---
Setting 'value' to 10 in MyClass

--- Accessing attributes ---
Accessing 'value' from MyClass
obj.value: 10
Accessing 'another_value' from MyClass
obj.another_value: None

--- Modifying attribute ---
Setting 'value' to 20 in MyClass

--- Accessing again ---
Accessing 'value' from MyClass
obj.value: 20

--- Deleting attribute ---
Deleting 'value' from MyClass

--- Accessing after delete ---
Error accessing deleted attribute: 'MyClass' object has no attribute '_value'

--- Accessing descriptor directly from class ---
<__main__.LoggingDescriptor object at 0x...>
```

💡 **Your Challenge:** Modify the `LoggingDescriptor` to add **type validation**. For instance, ensure `value` can only be set to integers. If a non-integer is assigned, raise a `TypeError`! Can you make it even more generic to accept a type hint during descriptor instantiation (e.g., `value = ValidatedDescriptor(int)`)? 🚀

Hey Pythonistas! 🐍 Get ready to unlock some serious processing power!

### Day 35: Coroutine Superpowers: Building High-Performance Data Pipelines with Asynchronous Generators 🚀

Beyond basic `asyncio`, today we dive into the magic of **Asynchronous Generators**. ✨ They combine the power of `async/await` for non-blocking operations with the memory efficiency of generators, making them perfect for building high-performance, back-pressured data pipelines. Imagine processing huge datasets or real-time streams without blocking your event loop! Let's see how to chain these powerful constructs for efficient data flow. ⚡️

```python
import asyncio
import random

async def produce_data(count: int, delay: float):
"""An asynchronous generator that yields simulated data."""
print("Producer started 📦")
for i in range(1, count + 1):
# Simulate async I/O or a network call
await asyncio.sleep(delay + random.uniform(0, 0.1))
print(f" Producer yielded: {i}")
yield i
print("Producer finished ✅")

async def process_data(data_stream):
"""An asynchronous generator that processes data from another async generator."""
print("Processor started ⚙️")
async for item in data_stream:
if item % 2 == 0: # Only process even numbers
processed_item = item * 10
print(f" Processor transformed: {item} -> {processed_item}")
yield processed_item
else:
print(f" Processor skipped: {item} (odd)")
print("Processor finished ✅")

async def consume_data(processed_stream):
"""An asynchronous function that consumes data from an async generator."""
print("Consumer started 📈")
total_processed = 0
async for item in processed_stream:
print(f" Consumer received: {item}")
total_processed += 1
print(f"Consumer finished. Total items received: {total_processed} ✅")

async def main():
print("--- Starting Pipeline ---")
data_source = produce_data(5, 0.2)
# Chain async generators: producer -> processor -> consumer
processed_pipeline = process_data(data_source)
await consume_data(processed_pipeline)
print("--- Pipeline Finished ---")

if __name__ == "__main__":
asyncio.run(main())

```

Output example:
```
--- Starting Pipeline ---
Consumer started 📈
Processor started ⚙️
Producer started 📦
Producer yielded: 1
Processor skipped: 1 (odd)
Producer yielded: 2
Processor transformed: 2 -> 20
Consumer received: 20
Producer yielded: 3
Processor skipped: 3 (odd)
Producer yielded: 4
Processor transformed: 4 -> 40
Consumer received: 40
Producer yielded: 5
Processor skipped: 5 (odd)
Producer finished ✅
Processor finished ✅
Consumer finished. Total items received: 2 ✅
--- Pipeline Finished ---
```

**Small Challenge:**
Add another asynchronous generator `log_data(processed_stream)` between `process_data` and `consume_data`. This new generator should simply print each item it receives before yielding it again, simulating logging or inspection without modification. Chain it into the pipeline! 🕵️‍♀️

---

Here's your Telegram post for Day 36 of the Python learning series!

---

🔥🐍 **Day 36: Cracking the CPython Egg!** 🤯🚀

Ready to peel back the layers of Python and truly understand how it works under the hood? Today, we're not just coding; we're *cracking the CPython egg* and exploring the advanced mechanisms that power your applications. Get ready to peek into bytecode, manipulate runtime, and sculpt complex systems with meta-programming. This isn't your average Python – it's the stuff that builds robust frameworks! ⚙️🔍

Let's start by looking at Python's bytecode, the low-level instructions the CPython interpreter executes. The `dis` module is our secret weapon here!

```python
import dis

def calculate_and_decide(a, b):
"""
A simple function to demonstrate Python bytecode.
It calculates a sum and applies a conditional transformation.
"""
intermediate_result = a + b
if intermediate_result > 10:
return intermediate_result * 2
else:
return intermediate_result + 1

print("--- Disassembling 'calculate_and_decide' function ---")
dis.dis(calculate_and_decide)
```

Output example:
```
--- Disassembling 'calculate_and_decide' function ---
8 0 LOAD_FAST 0 (a)
2 LOAD_FAST 1 (b)
4 BINARY_ADD
6 STORE_FAST 2 (intermediate_result)

9 8 LOAD_FAST 2 (intermediate_result)
10 LOAD_CONST 1 (10)
12 COMPARE_OP 4 (>)
14 POP_JUMP_IF_FALSE 24

10 16 LOAD_FAST 2 (intermediate_result)
18 LOAD_CONST 2 (2)
20 BINARY_MULTIPLY
22 RETURN_VALUE

12 24 LOAD_FAST 2 (intermediate_result)
26 LOAD_CONST 3 (1)
28 BINARY_ADD
30 RETURN_VALUE
```

### Small Challenge:
Try disassembling a function that uses a `for` loop or a `while` loop. Can you identify the bytecode instructions responsible for the iteration, comparison, and jumping logic? Share your insights and which specific instructions you found interesting!

---