Day 19: Virtual Environments \- Code & Output

Here's your Telegram post and quiz question!

---

🚀 Day 20: Mastering Dates & Times in Python! 📅⏰

Time flies, but you can definitely manage it in your Python programs! Today, we're diving into the powerful `datetime` module to handle dates and times with ease. Learn to fetch the current moment, format it just how you like, and even parse date strings back into objects. Get ready to conquer time! 🗓️✨

```python
import datetime

# Get current date and time
current_dt = datetime.datetime.now()
print(f"Current Date & Time: {current_dt}")

# Format the date and time into a readable string
formatted_dt = current_dt.strftime("%Y-%m-%d %H:%M:%S")
print(f"Formatted Date & Time: {formatted_dt}")

# Format for a different style (e.g., Day, Month Day, Year Hour:Minute AM/PM)
custom_format = current_dt.strftime("%A, %B %d, %Y %I:%M %p")
print(f"Custom Formatted: {custom_format}")

# Parse a string into a datetime object
date_string = "2024-07-20 14:30:00"
parsed_dt = datetime.datetime.strptime(date_string, "%Y-%m-%d %H:%M:%S")
print(f"Parsed Date & Time: {parsed_dt}")
```

Output example:
```
Current Date & Time: 2023-10-27 10:30:45.123456
Formatted Date & Time: 2023-10-27 10:30:45
Custom Formatted: Friday, October 27, 2023 10:30 AM
Parsed Date & Time: 2024-07-20 14:30:00
```

Small challenge:
Can you create a `datetime` object for January 1st, 2025, at 00:00:00, and then format it to display as "Wednesday, Jan 1, 2025"? Share your code! 👇

---

Day 20: Working with Dates and Times \- Code & Output

Here's your Telegram post for Day 21 on Decorators!

---

**Day 21: Decorators! 🎩✨**

Today we're diving into one of Python's most elegant and powerful features. Decorators allow you to modify or extend the functionality of a function or method without explicitly changing its source code. Think of them as wrappers! They're super useful for logging, authentication, performance measurement, and more. Get ready to elevate your functions! 🚀

```python
import time

# Our first decorator: a simple timer!
def timer(func):
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs) # Call the original function
end_time = time.time()
print(f"⏱️ '{func.__name__}' ran in {end_time - start_time:.4f} seconds.")
return result
return wrapper

# Applying the decorator using the '@' syntax
@timer
def simulate_task(duration):
"""Simulates a task that takes some time."""
print(f"Executing task for {duration} seconds...")
time.sleep(duration)
print("Task completed!")
return f"Simulated task finished in {duration}s"

@timer
def calculate_sum(a, b):
"""Calculates the sum of two numbers."""
time.sleep(0.05) # A tiny delay
return a + b

print("--- Calling decorated functions ---")
simulate_task(1.5)
simulate_task(0.8)

sum_result = calculate_sum(10, 20)
print(f"Result of calculation: {sum_result}")
```

Output example:
```
--- Calling decorated functions ---
Executing task for 1.5 seconds...
Task completed!
⏱️ 'simulate_task' ran in 1.5034 seconds.
Executing task for 0.8 seconds...
Task completed!
⏱️ 'simulate_task' ran in 0.8012 seconds.
⏱️ 'calculate_sum' ran in 0.0510 seconds.
Result of calculation: 30
```

**Small challenge:**
Can you modify the `timer` decorator to also print the arguments (`args` and `kwargs`) that the decorated function was called with? Hint: Access them inside the `wrapper` function! 🧐 Good luck!

---

Day 21: Decorators \- Code & Output

🚀 Day 22: Unlocking Python's Power with Generators & Iterators! 🐍 Ever needed to process huge datasets without hogging all your RAM? Or wanted to create your own iterable objects? Today's your day! We're diving into the magic of **Iterators** and **Generators**. ✨

They allow for *lazy evaluation*, producing items one by one only when needed, making your code super efficient and memory-friendly. No more loading entire massive lists into memory! Get ready to `yield` some amazing results. Let's see them in action! 👇

```python
# --- Custom Iterator Example ---
class MyRange:
def __init__(self, start, end):
self.current = start
self.end = end

def __iter__(self):
# An iterator *is* an iterable that returns itself
return self

def __next__(self):
if self.current < self.end:
num = self.current
self.current += 1
return num
else:
# Signal the end of iteration
raise StopIteration

print("--- Custom Iterator Output ---")
for num in MyRange(1, 4):
print(num)

# --- Generator Function Example ---
# Generators are functions that contain one or more 'yield' statements.
# They pause execution and return a value, resuming from where they left off.
def countdown(n):
print("Starting countdown...")
while n > 0:
yield n # Pause, return n, remember state
n -= 1
print("Countdown finished!")

print("n--- Generator Output ---")
gen = countdown(3) # This creates a generator object, doesn't execute yet
print(next(gen)) # Executes until the first yield
print(next(gen)) # Resumes from where it left off
for val in gen: # Continues iteration until StopIteration is raised internally
print(val)
```

Output example:
```
--- Custom Iterator Output ---
1
2
3

--- Generator Output ---
Starting countdown...
3
2
1
Countdown finished!
```

💡 **Your Challenge:** Modify the `countdown` generator to also yield "Blast Off!" as its very last item, just before "Countdown finished!" is printed. How would you insert that `yield`? Share your elegant solution!

---

Day 22: Generators and Iterators \- Code & Output

Here's your Telegram post for Day 23 on Context Managers:

---

🚀 Day 23 of our Python journey! Today, we dive into the elegant world of *Context Managers* and the powerful `with` statement. 🎩 Ever wondered how to automatically manage resources like files or network connections, ensuring they're properly opened and closed, even if errors occur? The `with` statement is your answer! It simplifies resource handling, making your code cleaner and safer. ✨ Get ready to make your resource management effortless!

```python
# Day 23: Context Managers (with statement)

print("--- Using with statement for file handling ---")

# The 'with' statement ensures the file is automatically closed
# even if errors occur during its processing.
with open("my_data.txt", "w") as file:
file.write("Hello, Python learners!n")
file.write("Context managers make resource handling easy.n")
print("File 'my_data.txt' written successfully.")

print("n--- Reading the file with 'with' ---")
try:
with open("my_data.txt", "r") as file:
content = file.read()
print("Content of 'my_data.txt':")
print(content)
except FileNotFoundError:
print("Error: my_data.txt not found. Please run the writing part first.")

print("--- File operations completed ---")
# The file 'my_data.txt' is guaranteed to be closed here.
# You don't need to call file.close() explicitly.
```

Output example:
```
--- Using with statement for file handling ---
File 'my_data.txt' written successfully.

--- Reading the file with 'with' ---
Content of 'my_data.txt':
Hello, Python learners!
Context managers make resource handling easy.

--- File operations completed ---
```

🤔 Small Challenge: Can you modify the file writing part to *append* new lines to `my_data.txt` each time the code runs, instead of overwriting its content? (Hint: check file modes!)

---

Here's your quiz question:

Day 23: Context Managers \(with statement\) \- Code & Output

🚀 Day 24 is here, and we're diving into two of Python's most powerful features for writing concise and efficient code: Lambda Functions and List Comprehensions! 💡

Lambda functions let you create small, anonymous functions on the fly, perfect for quick operations. List comprehensions, on the other hand, provide a compact and readable way to create lists based on existing iterables. Master these, and your Python code will shine! ✨ Let's explore how they make your code cleaner and more Pythonic.

```python
# Data to work with
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
words = ["apple", "banana", "kiwi", "grape", "avocado"]

# Lambda Function example: Using with filter() to get even numbers
evens_lambda = list(filter(lambda x: x % 2 == 0, numbers))
print(f"Even numbers (lambda): {evens_lambda}")

# List Comprehension example: Squaring only the odd numbers
squares_of_odds = [x**2 for x in numbers if x % 2 != 0]
print(f"Squares of odd numbers (list comprehension): {squares_of_odds}")

# List Comprehension example: Filtering words starting with 'a' and converting to uppercase
a_words_uppercase = [word.upper() for word in words if word.startswith('a')]
print(f"Words starting with 'a' (uppercase LC): {a_words_uppercase}")
```

Output example:
```
Even numbers (lambda): [2, 4, 6, 8, 10]
Squares of odd numbers (list comprehension): [1, 9, 25, 49, 81]
Words starting with 'a' (uppercase LC): ['APPLE', 'AVOCADO']
```

Small challenge:
Can you use a list comprehension to create a new list containing the lengths of only those words from `words` that have more than 4 characters? 🤯

---

Day 24: Lambda Functions and List Comprehensions \- Code & Output

Here's your Telegram post and quiz question!

---

🚀 Day 25: Unit Testing! 🧪

Today, we dive into one of the most crucial aspects of robust software development: Unit Testing in Python! 🛡️ Learn how to write tests that verify individual components of your code work exactly as expected. We'll use Python's built-in `unittest` module to ensure our functions are reliable and bug-free. Get ready to build more resilient applications! 💪

```python
import unittest

# The function we want to test
def add(a, b):
"""Adds two numbers."""
return a + b

# Our test class, inheriting from unittest.TestCase
class TestAddFunction(unittest.TestCase):

def test_positive_numbers(self):
# Test with positive integers
self.assertEqual(add(2, 3), 5)
self.assertEqual(add(10, 20), 30)

def test_negative_numbers(self):
# Test with negative integers
self.assertEqual(add(-1, -1), -2)
self.assertEqual(add(-5, -10), -15)

def test_zero_values(self):
# Test with zeros
self.assertEqual(add(0, 0), 0)

def test_positive_and_negative(self):
# Test with mixed signs
self.assertEqual(add(5, -3), 2)
self.assertEqual(add(-7, 2), -5)

# This block allows you to run the tests directly from the script
if __name__ == '__main__':
unittest.main()
```

Output example:
```
......
----------------------------------------------------------------------
Ran 6 tests in 0.000s

OK
```

**Small Challenge:** Try adding another function, `subtract(a, b)`, to our script and write a new `test_subtract` method within `TestAddFunction` (or create a new `TestSubtractFunction` class!) to test it thoroughly. Think about edge cases like `subtract(5, 0)` or `subtract(0, 5)`! 🧠

---

Day 25: Unit Testing \- Code & Output

Here's your Telegram post and quiz question:

---

💡 Day 26: Basic Web Scraping with Beautiful Soup! 🕸️

Ever wondered how to extract data from websites programmatically? Today, we dive into the fascinating world of web scraping using Python's incredible Beautiful Soup library. It simplifies parsing HTML and XML documents, making it easy to navigate, search, and modify the parse tree. Get ready to turn unstructured web content into usable data! 🔍

```python
from bs4 import BeautifulSoup
import requests # Often used with Beautiful Soup to fetch web pages

# For demonstration, we'll use a simple HTML string
html_doc = """
<html>
<head>
<title>My First Scraping Adventure</title>
</head>
<body>
<h1>Welcome to Day 26!</h1>
<p class="intro">Let's learn web scraping with Beautiful Soup.</p>
<a href="https://www.python.org">Visit Python.org</a>
<p>Beautiful Soup is excellent for parsing HTML and XML documents.</p>
</body>
</html>
"""

# Create a BeautifulSoup object, specifying the parser
soup = BeautifulSoup(html_doc, 'html.parser')

# 1. Find the title tag and print its text
title_tag = soup.find('title')
print(f"Page Title: {title_tag.text}")

# 2. Find the first paragraph tag with a specific class
intro_paragraph = soup.find('p', class_='intro')
print(f"Intro Paragraph: {intro_paragraph.text}")

# 3. Find all paragraph tags and print their text
all_paragraphs = soup.find_all('p')
print("nAll Paragraphs:")
for p in all_paragraphs:
print(f"- {p.text}")

# 4. Find an anchor tag and get its 'href' attribute
link_tag = soup.find('a')
if link_tag:
print(f"nLink Text: {link_tag.text}")
print(f"Link URL: {link_tag['href']}")
```

Output example:
```
Page Title: My First Scraping Adventure
Intro Paragraph: Let's learn web scraping with Beautiful Soup.

All Paragraphs:
- Let's learn web scraping with Beautiful Soup.
- Beautiful Soup is excellent for parsing HTML and XML documents.

Link Text: Visit Python.org
Link URL: https://www.python.org
```

---

**Small Challenge:** 🚀
Modify the code to find *all* `<a>` tags on a webpage (you can use our example HTML or try `http://quotes.toscrape.com` with `requests.get().text`) and print both their text and `href` attributes!

---

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