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

---

**Welcome to Day 13 of our Python learning journey! 🐍**

Today, we're diving into one of the most powerful and fundamental concepts: Object-Oriented Programming (OOP) with Classes and Objects! ✨ OOP allows us to structure our code by bundling data (attributes) and functions (methods) into reusable blueprints called 'classes'. Think of a class as a cookie cutter 🍪 and an object as the actual cookie. It helps model real-world entities and build robust, scalable applications. Let's create our first class! 🏗️

```python
# Define a Class named 'Dog'
class Dog:
# The __init__ method is a special method called when a new object is created.
# 'self' refers to the instance of the class being created.
def __init__(self, name, breed):
self.name = name # Assign 'name' to the object's attribute
self.breed = breed # Assign 'breed' to the object's attribute
print(f"A new dog, {self.name} the {self.breed}, has been created!")

# Define a method (a function associated with the class)
def bark(self):
return f"{self.name} says Woof! Woof!"

def describe(self):
return f"{self.name} is a friendly {self.breed}."

# Create objects (instances) of the Dog class
my_dog = Dog("Buddy", "Golden Retriever")
your_dog = Dog("Lucy", "Labrador")

# Access attributes of the objects
print(f"nMy dog's name is {my_dog.name} and breed is {my_dog.breed}.")
print(f"Your dog's name is {your_dog.name}.")

# Call methods on the objects
print(my_dog.bark())
print(your_dog.describe())
```

**Output example:**
```
A new dog, Buddy the Golden Retriever, has been created!
A new dog, Lucy the Labrador, has been created!

My dog's name is Buddy and breed is Golden Retriever.
Your dog's name is Lucy.
Buddy says Woof! Woof!
Lucy is a friendly Labrador.
```

**Small challenge: 💪**
Modify the `Dog` class:
1. Add a new attribute `age` to the `__init__` method.
2. Add a new method `celebrate_birthday` that increments the dog's `age` and prints a happy message! 🎉

---

Day 13: Object\-Oriented Programming \(Classes and Objects\) \- Code & Output

🚀 Day 14 is here! Ready to unlock the power of Object-Oriented Programming? 🧱 Today, we dive deep into *Inheritance* and *Polymorphism*! Learn how to reuse code efficiently with inheritance, creating a clear "is-a" relationship between classes. Then, discover polymorphism, allowing objects of different classes to be treated through a common interface, behaving differently based on their type. Get ready to write more flexible and maintainable Python code! ✨

```python
class Animal:
def __init__(self, name):
self.name = name

def make_sound(self):
# This method is intended to be overridden by subclasses
raise NotImplementedError("Subclass must implement the make_sound method")

class Dog(Animal):
def make_sound(self):
return f"{self.name} barks! Woof! Woof!"

class Cat(Animal):
def make_sound(self):
return f"{self.name} meows! Meow!"

class Duck(Animal):
def make_sound(self):
return f"{self.name} quacks! Quack! Quack!"

# Demonstrate Polymorphism: A function that can take any 'Animal' object
def animal_sound_party(animal):
print(animal.make_sound())

print("--- Animal Sounds Party! 🥳 ---")
my_dog = Dog("Buddy")
my_cat = Cat("Whiskers")
my_duck = Duck("Daffy")

animal_sound_party(my_dog)
animal_sound_party(my_cat)
animal_sound_party(my_duck)

print("n--- Direct Calls ---")
print(my_dog.make_sound())
print(my_cat.make_sound())
```

Output example:
```
--- Animal Sounds Party! 🥳 ---
Buddy barks! Woof! Woof!
Whiskers meows! Meow!
Daffy quacks! Quack! Quack!

--- Direct Calls ---
Buddy barks! Woof! Woof!
Whiskers meows! Meow!
```

Small Challenge:
Challenge: Add a new class `Lion` 🦁 that inherits from `Animal` and implements its own unique `make_sound()` method. Then, add a `lion` object to our `animal_sound_party` function! Share your mighty solution! 🐾

---

Day 14: Inheritance and Polymorphism \- Code & Output

Here's your Telegram post for Day 15!

---

**Day 15: Introduction to Python Libraries (requests)**

Day 15 is here! 🚀 Today, we're diving into the exciting world of Python libraries by exploring `requests`! 🌐 This powerful library makes interacting with web services and APIs incredibly easy. Forget complex built-in modules; `requests` simplifies making HTTP requests, fetching data, and much more. Get ready to connect your Python scripts to the vast internet! 💻 Let's make some web requests!

```python
import requests

# Define the URL of a public API endpoint
# This endpoint returns a sample ToDo item in JSON format
url = "https://jsonplaceholder.typicode.com/todos/1"

try:
# Make an HTTP GET request to the specified URL
response = requests.get(url)

# Check if the request was successful (status code 200)
if response.status_code == 200:
print("Request successful! 🎉")
# Parse the JSON response
data = response.json()
print("nParsed JSON Data:")
print(f"User ID: {data['userId']}")
print(f"ID: {data['id']}")
print(f"Title: {data['title']}")
print(f"Completed: {data['completed']}")
else:
print(f"Request failed with status code: {response.status_code} 😢")
print("Response text:", response.text)

except requests.exceptions.RequestException as e:
print(f"An error occurred: {e} 💔")
```

Output example:
Request successful! 🎉

Parsed JSON Data:
User ID: 1
ID: 1
Title: delectus aut autem
Completed: False

Your Challenge: 🧠
Try changing the `url` to fetch a different ToDo item (e.g., `https://jsonplaceholder.typicode.com/todos/5`) or explore a different public API. Can you print only the `title` and `completed` status for the new item? Share your findings! 👇

---

Hey Python learners! 👋 Day 17 is here, and we're diving into the world of **JSON (JavaScript Object Notation)**! 🌐 Ever wondered how web services exchange data? Often, it's through JSON – a lightweight, human-readable format. Python makes handling JSON a breeze with its built-in `json` module. Let's learn to convert Python data structures into JSON strings and parse them back! Get ready to serialize and deserialize! 🚀

```python
import json

# A Python dictionary representing some data
person_data = {
"name": "Alice Wonderland",
"age": 30,
"isStudent": False,
"courses_taken": ["Python Basics", "Web Development"],
"contact": {
"email": "alice@example.com",
"phone": None
}
}

print("--- Original Python Dictionary ---")
print(person_data)
print(f"Type: {type(person_data)}n")

# 1. Convert Python dictionary to a JSON string (Serialization)
# The 'indent' parameter makes the output pretty-printed
json_string = json.dumps(person_data, indent=4)

print("--- Python Dictionary as JSON String ---")
print(json_string)
print(f"Type: {type(json_string)}n")

# 2. Convert JSON string back to a Python dictionary (Deserialization)
parsed_data = json.loads(json_string)

print("--- JSON String parsed back to Python Dictionary ---")
print(parsed_data)
print(f"Type: {type(parsed_data)}n")

# You can now work with the parsed_data as a regular Python dictionary
print(f"Alice's age (from parsed data): {parsed_data['age']}")
```

Output example:
```
--- Original Python Dictionary ---
{'name': 'Alice Wonderland', 'age': 30, 'isStudent': False, 'courses_taken': ['Python Basics', 'Web Development'], 'contact': {'email': 'alice@example.com', 'phone': None}}
Type: <class 'dict'>

--- Python Dictionary as JSON String ---
{
"name": "Alice Wonderland",
"age": 30,
"isStudent": false,
"courses_taken": [
"Python Basics",
"Web Development"
],
"contact": {
"email": "alice@example.com",
"phone": null
}
}
Type: <class 'str'>

--- JSON String parsed back to Python Dictionary ---
{'name': 'Alice Wonderland', 'age': 30, 'isStudent': False, 'courses_taken': ['Python Basics', 'Web Development'], 'contact': {'email': 'alice@example.com', 'phone': None}}
Type: <class 'dict'>

Alice's age (from parsed data): 30
```

### Your Challenge! 🧠

Can you modify the code to:
1. Save the `person_data` dictionary directly into a file named `user_profile.json` using `json.dump()`.
2. Then, in a separate part of your script (or a new script), load the data back from `user_profile.json` using `json.load()` and print its content?

---

Day 17: JSON Data Handling \- Code & Output

🚀 Day 18: Dive into the powerful world of Regular Expressions (RegEx)! 🔍 Today, we're unlocking advanced pattern matching techniques in Python. RegEx lets you search, validate, and manipulate text based on complex patterns – a must-have skill for any developer. Get ready to transform your text processing game! ✨ Let's explore how to find specific patterns within strings with ease.

```python
import re

text = "Python is a powerful programming language. Python regular expressions are amazing for pattern matching!"

# 1. Find all occurrences of the word "Python" (case-insensitive)
pattern_python = r"[Pp]ython"
matches_python = re.findall(pattern_python, text)
print(f"Found '{pattern_python}' occurrences: {matches_python}")

# 2. Find all words that start with 'p' or 'P'
# b matches word boundaries, [Pp] matches 'P' or 'p', w* matches zero or more word characters
pattern_startswith_p = r"b[Pp]w*b"
words_starting_with_p = re.findall(pattern_startswith_p, text)
print(f"Words starting with 'P'/'p': {words_starting_with_p}")

# 3. Find all numbers (e.g., if there were any)
text_with_numbers = "I have 3 apples and 12 bananas."
pattern_numbers = r"d+" # d matches a digit, + matches one or more
numbers = re.findall(pattern_numbers, text_with_numbers)
print(f"Numbers in '{text_with_numbers}': {numbers}")
```

Output example:
```
Found '[Pp]ython' occurrences: ['Python', 'Python']
Words starting with 'P'/'p': ['Python', 'powerful', 'programming', 'Python', 'pattern']
Numbers in 'I have 3 apples and 12 bananas.': ['3', '12']
```

💡 **Small Challenge:**
Can you write a RegEx pattern to find all words in a given string that are exactly 5 characters long? For example, in "Hello World Python", it should find "Hello" and "World".

---

Here's your Telegram post for Day 19 on Virtual Environments! 🌍

---

Hey Python learners! 👋 Today is Day 19, and we're diving into a crucial topic: **Virtual Environments**! 🚀 Ever had project dependencies clash? Or needed a specific package version for one project but another for a different one? Virtual environments are your savior! They provide isolated spaces for your Python projects, keeping dependencies neat and tidy. No more global package chaos! ✨ Let's set up some order!

The standard way to create and manage virtual environments is using Python's built-in `venv` module. Here's a quick overview of the essential shell commands:

```bash
# 1. Create a virtual environment named 'myenv' in your project folder
python -m venv myenv

# 2. Activate it (Linux/macOS)
source myenv/bin/activate

# 2. Activate it (Windows PowerShell)
.myenvScriptsActivate.ps1

# 2. Activate it (Windows Cmd)
myenvScriptsactivate.bat

# Once activated, your terminal prompt usually changes to indicate the active env.
# Any packages you install with 'pip' now will go ONLY into this environment.

# 3. Deactivate it when you're done
deactivate
```

Now, let's look at some Python code you can run *inside* an activated virtual environment to see its effects:

```python
import sys
import os
import subprocess

print(f"Python interpreter location: {sys.executable}")
print(f"Virtual environment prefix: {sys.prefix}")
print(f"Is this a virtual environment? {hasattr(sys, 'real_prefix') or (hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix)}")


# Try to import a common package like 'requests'
# If it's not installed in *this specific venv*, it should fail.
try:
import requests
print("nRequests package is installed in THIS environment! 🎉")
except ImportError:
print("nRequests package is NOT installed in THIS environment. 😔")
print("Try installing it: pip install requests")

print("nCurrent packages in this environment (via 'pip list'):")
try:
# Running pip list as a subprocess to demonstrate package isolation
# This ensures we're checking packages relative to the active venv.
result = subprocess.run([sys.executable, '-m', 'pip', 'list', '--format=columns'],
capture_output=True, text=True, check=True)
print(result.stdout)
except FileNotFoundError:
print("Pip not found. Ensure it's correctly installed in the venv.")
except subprocess.CalledProcessError as e:
print(f"Error running pip: {e}")

```

Output example:
```
Python interpreter location: /path/to/your/project/myenv/bin/python
Virtual environment prefix: /path/to/your/project/myenv
Is this a virtual environment? True

Requests package is NOT installed in THIS environment. 😔
Try installing it: pip install requests

Current packages in this environment (via 'pip list'):
Package Version
---------- -------
pip 23.3.1
setuptools 68.2.2
```
*(Note: Paths and versions will vary depending on your system and Python version.)*

### Your Challenge! 🚀
1. Create a new project folder (e.g., `my_cool_project`).
2. Inside it, create and activate a virtual environment named `my_project_env`.
3. Install the `requests` library within this activated environment (`pip install requests`).
4. Run the Python code from today's lesson inside your `my_project_env` to confirm `requests` is installed and verify the environment's prefix.
5. Deactivate your virtual environment. Now, open a *new* terminal window (or ensure your current one is deactivated) and try `python -c 'import requests'`. What happens? Why? (Hint: It should fail unless `requests` was *globally* installed!) Share your findings! 👇

---

Day 19: Virtual Environments \- Code & Output

Here's your Telegram post for Day 20!

---

**Day 20: Working with Dates and Times! ⏰🗓️**

Time flies when you're coding! 🚀 Today, we're mastering how to handle dates and times in Python using the built-in `datetime` module. From getting the current moment to formatting dates and performing calculations, `datetime` is your go-to tool for temporal data. Let's synchronize our clocks and dive in! ✨

```python
import datetime

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

# Get current date only
today = datetime.date.today()
print(f"Current Date: {today}")

# Creating a specific date/time
specific_date = datetime.datetime(2024, 7, 15, 10, 30, 0)
print(f"Specific Date and Time: {specific_date}")

# Formatting dates using strftime()
formatted_now = now.strftime("%Y-%m-%d %H:%M:%S")
print(f"Formatted Current Time: {formatted_now}")

another_format = specific_date.strftime("Day %d of %B, %Y (%A)")
print(f"Another Format: {another_format}")

# Date arithmetic: Adding a timedelta
seven_days_later = now + datetime.timedelta(days=7)
print(f"Date 7 days from now: {seven_days_later.strftime('%Y-%m-%d')}")

two_hours_ago = now - datetime.timedelta(hours=2)
print(f"Time 2 hours ago: {two_hours_ago.strftime('%H:%M:%S')}")
```

Output example:
```
Current Date and Time: 2023-10-27 10:30:45.123456
Current Date: 2023-10-27
Specific Date and Time: 2024-07-15 10:30:00
Formatted Current Time: 2023-10-27 10:30:45
Another Format: Day 15 of July, 2024 (Monday)
Date 7 days from now: 2023-11-03
Time 2 hours ago: 08:30:45
```

**Small Challenge:** 🎯
Can you calculate and print the date that is **30 hours from now**, formatted as `HH:MM on DD-MM-YYYY`? 🤔

---

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

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

---

**Day 21: Decorators ✨ Unlocking Python Magic!**

Ready to add powerful functionality to your functions without changing their core code? Today, we're diving into Python Decorators! 🪄 These amazing tools act as wrappers, allowing you to modify or enhance functions—think logging, authentication, or performance timing—with a simple `@` syntax. It's a clean and elegant way to extend behavior. Let's see them in action! 👇

```python
def my_logger_decorator(func):
"""A simple decorator that logs function calls."""
def wrapper(*args, **kwargs):
print(f"🚀 Calling function: {func.__name__} with args: {args}, kwargs: {kwargs}")
result = func(*args, **kwargs)
print(f"✅ Function {func.__name__} finished. Result: {result}")
return result
return wrapper

@my_logger_decorator
def add(a, b):
"""Adds two numbers."""
return a + b

@my_logger_decorator
def say_hello(name, greeting="Hello"):
"""Greets a person."""
print(f"{greeting}, {name}!")
return f"{greeting}, {name}!"

# Using our decorated functions
print("--- Calling add(5, 3) ---")
sum_result = add(5, 3)
print(f"Add function returned: {sum_result}n")

print("--- Calling say_hello('Alice', greeting='Hi') ---")
hello_message = say_hello('Alice', greeting='Hi')
print(f"Say_hello function returned: {hello_message}")
```

Output example:
```
--- Calling add(5, 3) ---
🚀 Calling function: add with args: (5, 3), kwargs: {}
✅ Function add finished. Result: 8
Add function returned: 8

--- Calling say_hello('Alice', greeting='Hi') ---
🚀 Calling function: say_hello with args: ('Alice',), kwargs: {'greeting': 'Hi'}
Hi, Alice!
✅ Function say_hello finished. Result: Hi, Alice!
Say_hello function returned: Hi, Alice!
```

**Small challenge:**
Can you create a decorator called `@timer` that measures and prints the execution time of the decorated function? ⏱️ Share your solution in the comments! 👇

---

Day 21: Decorators \- Code & Output