🚀 Day 17: Diving into JSON Data Handling! 🌐 Ever wondered how web services exchange data or how structured information is stored? JSON (JavaScript Object Notation) is your answer! Today, we'll master Python's built-in `json` module to effortlessly convert between JSON strings and Python dictionaries. This skill is crucial for working with APIs, web development, and persistent data storage. Let's make your Python scripts data-savvy! ✨

```python
import json

# Sample JSON data as a string
json_string = '''
{
"name": "Alice",
"age": 30,
"isStudent": false,
"courses": ["Python", "Data Science"],
"address": {
"city": "Techville",
"zip": "12345"
}
}
'''

print("--- Parsing JSON String to Python Dictionary ---")
# Convert JSON string to Python dictionary
data_dict = json.loads(json_string)
print(f"Python Dictionary: {data_dict}")
print(f"Name: {data_dict['name']}")
print(f"First Course: {data_dict['courses'][0]}")

print("n--- Converting Python Dictionary to JSON String ---")
# Modify the dictionary
data_dict['age'] += 1
data_dict['new_field'] = 'Hello JSON!'

# Convert Python dictionary back to JSON string
# 'indent' makes the output human-readable
new_json_string = json.dumps(data_dict, indent=4)
print(f"New JSON String:n{new_json_string}")
```

Output example:
```
--- Parsing JSON String to Python Dictionary ---
Python Dictionary: {'name': 'Alice', 'age': 30, 'isStudent': False, 'courses': ['Python', 'Data Science'], 'address': {'city': 'Techville', 'zip': '12345'}}
Name: Alice
First Course: Python

--- Converting Python Dictionary to JSON String ---
New JSON String:
{
"name": "Alice",
"age": 31,
"isStudent": false,
"courses": [
"Python",
"Data Science"
],
"address": {
"city": "Techville",
"zip": "12345"
},
"new_field": "Hello JSON!"
}
```

💡 Your Challenge: Try adding another course, 'Machine Learning', to the `courses` list in `data_dict` *before* dumping it back to JSON. See how the output changes!

---

Day 17: JSON Data Handling \- Code & Output

👋 Hey Python Learners! It's Day 18 of our series, and today we're unlocking the power of Regular Expressions (RegEx)! 🚀

RegEx might seem intimidating at first, but it's an incredibly powerful tool for searching, matching, and manipulating text patterns. From validating emails to extracting specific data, RegEx is your go-to. We'll use Python's built-in `re` module. Let's dive in! 🧐

```python
import re

text = "My phone number is 123-456-7890. Call me soon! Another number: 987.654.3210. My email is example@domain.com."

# 1. Searching for the first occurrence of a pattern (a phone number)
# d{3} matches exactly 3 digits, [-.] matches a hyphen or a period
match_phone = re.search(r'd{3}[-.]d{3}[-.]d{4}', text)
if match_phone:
print(f"Found first phone number: {match_phone.group()}")

# 2. Finding all occurrences of a pattern (all sequences of digits)
# d+ matches one or more digits
all_digits = re.findall(r'd+', text)
print(f"All sequences of digits found: {all_digits}")

# 3. Finding all occurrences of a more complex pattern (all valid phone numbers)
all_phones = re.findall(r'd{3}[-.]d{3}[-.]d{4}', text)
print(f"All phone numbers found: {all_phones}")

# 4. Finding a simple word
word_match = re.search(r'email', text)
if word_match:
print(f"Found word: '{word_match.group()}'")
```

Output example:
```
Found first phone number: 123-456-7890
All sequences of digits found: ['123', '456', '7890', '987', '654', '3210']
All phone numbers found: ['123-456-7890', '987.654.3210']
Found word: 'email'
```

✨ Challenge:
Given the text: "The meeting is scheduled for 2023-10-27 at 10:30 AM."
Use `re.search` to extract *only the year* (i.e., "2023") using a regular expression! Share your code! 👇

---

Day 18: Regular Expressions \- Code & Output

🎉 **Day 19: Virtual Environments!** 🎉

Ever found yourself in "dependency hell" where one project's requirements clash with another's? 🤯 Python virtual environments are your ultimate lifesaver! They create isolated spaces for each project, ensuring that dependencies for one don't interfere with another. Today, we'll master `venv` to keep your projects clean, consistent, and conflict-free. Get ready to streamline your workflow like a pro! 🐍✨📦

---

```python
# 1. Create a virtual environment named 'myproject_env'
# (Run this command in your project's root directory)
python3 -m venv myproject_env

# 2. Activate the virtual environment
# On Linux/macOS:
source myproject_env/bin/activate

# On Windows (Command Prompt):
# myproject_envScriptsactivate.bat

# On Windows (PowerShell):
# myproject_envScriptsActivate.ps1

# 3. Once activated, your terminal prompt will show the environment name.
# Now, any package you install with 'pip' will be confined to THIS environment.
# (myproject_env) pip install requests

# 4. When you're done working in the environment, deactivate it:
# (myproject_env) deactivate
```

---

Output example:

```
# After running 'python3 -m venv myproject_env':
# (No direct output, creates the directory)

# After running 'source myproject_env/bin/activate':
(myproject_env) user@host:~/your_project$

# After running '(myproject_env) pip install requests':
(myproject_env) user@host:~/your_project$ pip install requests
Collecting requests
Downloading requests-2.31.0-py3-none-any.whl (62 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 62.6/62.6 KB 1.1 MB/s eta 0:00:00
... (other dependency installations)
Successfully installed charset-normalizer-3.3.2 idna-3.6 requests-2.31.0 urllib3-2.1.0

# After running '(myproject_env) deactivate':
user@host:~/your_project$
```

---

🚀 **Your Challenge Today:**
1. Create a new directory for a project (e.g., `my_flask_app`).
2. Navigate into that directory.
3. Create a virtual environment called `flask_env` inside it.
4. Activate `flask_env`.
5. Install the `flask` library (`pip install flask`) within this environment.
6. Verify that `flask` is indeed installed by running `pip list`.
7. Deactivate the environment.

Share your success! 👇

---

Day 19: Virtual Environments \- Code & Output

🚀 **Day 20: Working with Dates and Times in Python!** ⏰

Hello Python adventurers! Today, we're unlocking the secrets of time with Python's incredibly useful `datetime` module. 🗓️ From logging events to scheduling tasks or analyzing time-series data, mastering dates and times is a fundamental skill. We'll learn how to grab the current moment, format it just the way we like, parse date strings, and even perform time-based calculations. Let's make time management simple! ✨

```python
from datetime import datetime, timedelta

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

# Format the datetime object into a specific string
# %Y - Year, %m - Month, %d - Day, %H - Hour (24-hour), %M - Minute, %S - Second
formatted_string = current_time.strftime("%Y-%m-%d %H:%M:%S")
print(f"Formatted Date & Time: {formatted_string}")

# Parse a date string back into a datetime object
date_str = "2024-07-20 10:00:00"
parsed_date = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
print(f"Parsed Date from string: {parsed_date}")

# Perform date arithmetic using timedelta
future_time = current_time + timedelta(days=5, hours=2, minutes=30)
print(f"5 days, 2 hours, 30 minutes from now: {future_time}")
```

Output example:
```
Current Date & Time: 2024-07-20 12:34:56.789012
Formatted Date & Time: 2024-07-20 12:34:56
Parsed Date from string: 2024-07-20 10:00:00
5 days, 2 hours, 30 minutes from now: 2024-07-25 14:04:56.789012
```

💡 **Challenge:**
Write a Python script that calculates and prints your exact age in days from your birthdate to today! 🎂 Don't forget to use `timedelta`! Share your solution in the comments! 👇

---

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

✨ **Python Learning Series - Day 21: Decorators** ✨

Ready to level up your Python skills? Today we dive into `Decorators`! 🚀

Decorators are powerful syntactic sugar that allow you to modify or enhance other functions without changing their source code. Think of them as functions that wrap around other functions, adding extra functionality before or after the original function executes. They're incredibly useful for logging, authentication, performance measurement, and more, helping you write cleaner, more reusable code! 🛠️

```python
def log_execution(func):
"""A decorator that logs when a function starts and finishes."""
def wrapper(*args, **kwargs):
print(f"🚀 Calling function: {func.__name__}")
result = func(*args, **kwargs)
print(f"✅ Finished function: {func.__name__}")
return result
return wrapper

@log_execution
def greet(name):
"""A simple function to greet someone."""
print(f"Hello, {name}!")
return f"Greeting for {name}"

@log_execution
def add_numbers(a, b):
"""Adds two numbers and returns the sum."""
print(f"Adding {a} and {b}...")
return a + b

# Call the decorated functions
greet("Alice")
print("-" * 20)
sum_result = add_numbers(10, 5)
print(f"Sum result: {sum_result}")
```

Output example:
```
🚀 Calling function: greet
Hello, Alice!
✅ Finished function: greet
--------------------
🚀 Calling function: add_numbers
Adding 10 and 5...
✅ Finished function: add_numbers
Sum result: 15
```

**Small Challenge:** Can you create a decorator that measures and prints the execution time of any function it wraps? (Hint: The `time` module might be useful! `time.time()`)

---

Day 21: Decorators \- Code & Output

Hello Python Learners! 👋

It's **Day 22** of our Python journey, and today we're diving into some advanced but incredibly useful concepts: **Generators and Iterators**! 🚀

Ever wondered how Python handles huge datasets without hogging all your memory? That's where these come in! Iterators give you a way to access elements one by one, while generators are a super-convenient way to create iterators, making your code more memory-efficient and performant by generating values on-the-fly, only when needed. Think "lazy evaluation" – powerful stuff! Let's see them in action. 👇

```python
# --- Understanding Iterators ---
# An iterator is an object that can be iterated upon.
# It implements __iter__() and __next__() methods.
class MyRangeIterator:
def __init__(self, start, end):
self.current = start
self.end = end

def __iter__(self):
return self

def __next__(self):
if self.current <= self.end:
value = self.current
self.current += 1
return value
else:
raise StopIteration

print("--- Custom Iterator (MyRangeIterator) ---")
for num in MyRangeIterator(1, 3):
print(f"Iterator value: {num}")

# --- Understanding Generators ---
# Generators are functions that use the 'yield' keyword.
# They produce a sequence of results instead of a single value.
# Each 'yield' statement pauses the function and saves its state.
def simple_generator(start, end):
current = start
while current <= end:
yield current # Pause here, return 'current', resume later
current += 1

print("n--- Simple Generator ---")
gen_obj = simple_generator(1, 3)
print(f"Generator object: {gen_obj}")
for val in gen_obj:
print(f"Generator value: {val}")

# Another common use: infinite sequences or data streams
def infinite_sequence():
num = 0
while True:
yield num
num += 1

print("n--- Infinite Sequence (first 5) ---")
inf_gen = infinite_sequence()
for _ in range(5):
print(f"Infinite value: {next(inf_gen)}")

```

Output example:
```
--- Custom Iterator (MyRangeIterator) ---
Iterator value: 1
Iterator value: 2
Iterator value: 3

--- Simple Generator ---
Generator object: <generator object simple_generator at 0x...>
Generator value: 1
Generator value: 2
Generator value: 3

--- Infinite Sequence (first 5) ---
Infinite value: 0
Infinite value: 1
Infinite value: 2
Infinite value: 3
Infinite value: 4
```

🔥 **Small Challenge:**
Modify the `simple_generator` function to yield only **even numbers** within a given range. Or, create a generator that yields the first `n` terms of the Fibonacci sequence! Share your code! 🧑‍💻

---

Day 22: Generators and Iterators \- Code & Output

✨🐍 **Python Learning Series - Day 23: Context Managers (with statement)!** 📚

Today, we're diving into the incredibly powerful `with` statement! 💪 This Pythonic gem simplifies resource management, ensuring that resources like files, network connections, or database locks are properly acquired and, most importantly, *reliably released*, even if errors occur. No more forgotten `.close()` calls! The `with` statement handles the setup (`__enter__`) and teardown (`__exit__`) for you, making your code cleaner and safer. ✅ Let's explore!

```python
print("--- File Handling Example ---")
file_name = "day23_notes.txt"

try:
# Using 'with' to open a file for writing
# The file will be automatically closed when the 'with' block exits
with open(file_name, "w") as f:
f.write("Day 23: Exploring Python Context Managers.n")
f.write("The 'with' statement simplifies resource management significantly!n")
print(f"Content successfully written to '{file_name}'.")

# Using 'with' to open a file for reading
with open(file_name, "r") as f:
content = f.read()
print(f"nContent read from '{file_name}':")
print(content.strip())

except IOError as e:
print(f"An error occurred while accessing the file: {e}")
```

Output example:
```
--- File Handling Example ---
Content successfully written to 'day23_notes.txt'.

Content read from 'day23_notes.txt':
Day 23: Exploring Python Context Managers.
The 'with' statement simplifies resource management significantly!
```

💡 **Your Challenge:**
Create a *simple custom context manager* using a class with `__enter__` and `__exit__` methods. Make `__enter__` print "Resource acquired!" and `__exit__` print "Resource released!". Then, use it with a `with` statement and show the output! 👇

---

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

Here's your Telegram post for Day 24:

---

🚀 Python Learning Series - Day 24! ✨ Today, we're unlocking two incredibly powerful and Pythonic features: Lambda Functions and List Comprehensions! 💡 Lambda functions let you create small, anonymous, single-expression functions on the fly. List comprehensions offer a concise and efficient way to create lists. Master these, and your Python code will become much cleaner and more efficient! Let's dive in! 📚

```python
# Day 24: Lambda Functions & List Comprehensions

# --- Lambda Functions ---
# 1. Simple lambda function
add_five = lambda x: x + 5
print(f"Lambda: 10 + 5 = {add_five(10)}")

# 2. Using lambda with map() to apply a function to all items
numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x**2, numbers))
print(f"Map with lambda (squared): {squared_numbers}")

# 3. Using lambda with filter() to select items
filtered_list = list(filter(lambda x: x > 3, numbers))
print(f"Filter with lambda (numbers > 3): {filtered_list}")

# --- List Comprehensions ---
# 4. Basic list comprehension (squares)
squares_lc = [x**2 for x in range(1, 6)]
print(f"List comprehension (squares 1-5): {squares_lc}")

# 5. List comprehension with a condition (even numbers)
even_numbers_lc = [num for num in numbers if num % 2 == 0]
print(f"List comprehension (even numbers): {even_numbers_lc}")
```

Output example:
```
Lambda: 10 + 5 = 15
Map with lambda (squared): [1, 4, 9, 16, 25]
Filter with lambda (numbers > 3): [4, 5]
List comprehension (squares 1-5): [1, 4, 9, 16, 25]
List comprehension (even numbers): [2, 4]
```

💡 Small Challenge: From our `numbers` list, create a new list containing only numbers greater than 2, and then cube each of those numbers. Try to achieve this in a single line using a *list comprehension*! Can you also think about how `map` and `filter` with *lambda functions* could achieve the same result?

---