✨ Day 9 of our Python journey! ✨ Today, we're diving into the incredibly powerful world of *String Manipulation*! 🐍 Strings are fundamental, and knowing how to slice, dice, transform, and clean them is a super valuable skill for handling text data. Get ready to master methods like `upper()`, `lower()`, `replace()`, `split()`, and more. Let's make our text data sing! 🎶

```python
message = " Hello, Python Learners! Welcome to Day 9! "

print(f"Original string: '{message}'")
print(f"Length of original: {len(message)}")

# 1. Stripping whitespace from ends
cleaned_message = message.strip()
print(f"Stripped string: '{cleaned_message}'")

# 2. Converting case
print(f"Uppercase: {cleaned_message.upper()}")
print(f"Lowercase: {cleaned_message.lower()}")

# 3. Slicing parts of the string
print(f"First 5 characters: {cleaned_message[0:5]}")
print(f"Last 5 characters: {cleaned_message[-5:]}")
print(f"Substring 'Python': {cleaned_message[7:13]}") # Extracts "Python"

# 4. Replacing parts of the string
new_message = cleaned_message.replace("Day 9", "String Manipulation Day")
print(f"After replacement: {new_message}")

# 5. Splitting the string into a list
words = new_message.split(" ")
print(f"Split by space: {words}")

sentence_parts = cleaned_message.split("!")
print(f"Split by '!': {sentence_parts}")
```

Output example:
```
Original string: ' Hello, Python Learners! Welcome to Day 9! '
Length of original: 45
Stripped string: 'Hello, Python Learners! Welcome to Day 9!'
Uppercase: HELLO, PYTHON LEARNERS! WELCOME TO DAY 9!
Lowercase: hello, python learners! welcome to day 9!
First 5 characters: Hello
Last 5 characters: Day 9!
Substring 'Python': Python
After replacement: Hello, Python Learners! Welcome to String Manipulation Day!
Split by space: ['Hello,', 'Python', 'Learners!', 'Welcome', 'to', 'String', 'Manipulation', 'Day!']
Split by '!': ['Hello, Python Learners', ' Welcome to Day 9', '']
```

🚀 **Small Challenge:** Can you write a Python one-liner to reverse the `cleaned_message` string (`'Hello, Python Learners! Welcome to Day 9!'`)? Share your solution in the comments! 👇

---

Day 9: String Manipulation \- Code & Output

Here's your Telegram post for Day 10 on File I/O!

---

📣 **Day 10: Unlocking File I/O in Python!** 📂

Hey there, Python Explorers! 👋 On Day 10, we're diving into how Python interacts with files on your computer! This is crucial for storing data, loading configurations, or processing logs. Imagine saving game scores, user settings, or processing large datasets – File I/O makes it all possible.

Today's code will show you how to write content to a new file, read its content back, and even add more data to an existing file. We'll use the `with open(...)` statement, which is your best friend for safely handling files, ensuring they close automatically. Let's get hands-on! 💾✍️📖

```python
# --- Python File I/O Example ---

file_name = "my_python_notes.txt"

# 1. Writing to a file (mode 'w' - writes from scratch, overwrites if exists)
print(f"Creating/overwriting '{file_name}' and writing content...")
with open(file_name, 'w') as file:
file.write("Hello, Python learners!n")
file.write("Welcome to Day 10 of our series.n")
file.write("File I/O is powerful! 💪n")
print("Content written successfully.")

# 2. Reading from a file (mode 'r')
print(f"nReading content from '{file_name}'...")
with open(file_name, 'r') as file:
content = file.read()
print("--- Start of File Content ---")
print(content)
print("--- End of File Content ---n")

# 3. Appending to a file (mode 'a' - adds to the end)
print(f"Appending new content to '{file_name}'...")
with open(file_name, 'a') as file:
file.write("This line was appended later.n")
file.write("See how easy it is to add more! ✨")
print("Content appended successfully.")

# 4. Reading again to see the appended content
print(f"nReading updated content from '{file_name}'...")
with open(file_name, 'r') as file:
updated_content = file.read()
print("--- Start of Updated File Content ---")
print(updated_content)
print("--- End of Updated File Content ---")

```

Output example:
```
Creating/overwriting 'my_python_notes.txt' and writing content...
Content written successfully.

Reading content from 'my_python_notes.txt'...
--- Start of File Content ---
Hello, Python learners!
Welcome to Day 10 of our series.
File I/O is powerful! 💪

--- End of File Content ---

Appending new content to 'my_python_notes.txt'...
Content appended successfully.

Reading updated content from 'my_python_notes.txt'...
--- Start of Updated File Content ---
Hello, Python learners!
Welcome to Day 10 of our series.
File I/O is powerful! 💪
This line was appended later.
See how easy it is to add more! ✨
--- End of Updated File Content ---
```

### 🧠 Small Challenge:
Modify the reading part of the code to read `my_python_notes.txt` line by line instead of reading the whole file at once. Can you also print each line prefixed with its line number (starting from 1)? For example:
```
1: Hello, Python learners!
2: Welcome to Day 10 of our series.
...
```
Give it a try! You might find `readlines()` or iterating directly over the file object useful. Good luck! 🚀

---

Here's your quiz question:

Day 10: File I/O \(Input/Output\) \- Code & Output

🚀 Day 11: Error Handling (try, except) 🐍

Even the best code can encounter unexpected situations – like invalid user input or network issues. Today, we're diving into **Error Handling** with `try` and `except` blocks! ✨ This powerful duo allows your programs to gracefully recover from errors instead of crashing, providing a much smoother user experience. Learn to anticipate problems and keep your code robust! 💪

```python
def safe_divide(numerator, denominator):
"""
Attempts to divide two numbers, handling common division errors.
"""
try:
result = numerator / denominator
print(f"The result of {numerator} / {denominator} is: {result}")
except ZeroDivisionError:
print("Error: Cannot divide by zero! Please provide a non-zero denominator. 🚫")
except TypeError:
print("Error: Both inputs for division must be numbers. 🔢")
except Exception as e: # Catch any other unexpected errors
print(f"An unexpected error occurred: {e} 🐛")
else:
print("Division successful! 🎉")
finally:
print("Operation complete. ✅")

print("--- Example 1: Successful division ---")
safe_divide(11, 2)

print("n--- Example 2: Division by zero ---")
safe_divide(10, 0)

print("n--- Example 3: Invalid input type ---")
safe_divide(20, "five")

print("n--- Example 4: Another successful division ---")
safe_divide(15, 3)
```

Output example:
```
--- Example 1: Successful division ---
The result of 11 / 2 is: 5.5
Division successful! 🎉
Operation complete. ✅

--- Example 2: Division by zero ---
Error: Cannot divide by zero! Please provide a non-zero denominator. 🚫
Operation complete. ✅

--- Example 3: Invalid input type ---
Error: Both inputs for division must be numbers. 🔢
Operation complete. ✅

--- Example 4: Another successful division ---
The result of 15 / 3 is: 5.0
Division successful! 🎉
Operation complete. ✅
```

💡 *Your Challenge:*
Modify the `safe_divide` function to also:
1. Prompt the user to `input()` the numerator and denominator.
2. Handle `ValueError` if the user enters text that cannot be converted to a number (e.g., `int("hello")`). 🤔

---

Day 11: Error Handling \(try, except\) \- Code & Output

Here's your Telegram post for Day 12 of the Python learning series, followed by the quiz question in JSON format:

---

### Day 12: Modules and Packages! 🎉

Hello Python learners! Today, we're unlocking the secret to writing organized, reusable, and scalable code: **Modules and Packages!** 📦 They help you break down large projects into smaller, manageable, and logical units. Think of modules as single Python files containing functions, classes, and variables, and packages as collections of related modules within a directory structure. Mastering them is crucial for any real-world Python development. Let's see them in action! 👇

```python
### File: my_utility.py ###
# This is a simple Python module
GREETING = "Hello from my_utility!"

def square(num):
"""Returns the square of a number."""
return num * num

def cube(num):
"""Returns the cube of a number."""
return num * num * num

### File: my_package/__init__.py ###
# This file can be empty, but it signifies that 'my_package' is a Python package.

### File: my_package/geometry.py ###
# This is a module inside 'my_package'
PI = 3.14159

def circle_area(radius):
"""Calculates the area of a circle."""
return PI * radius * radius

### File: main_script.py ###
# This is the script you would run

# 1. Importing an entire module
import my_utility
print(f"From my_utility: {my_utility.GREETING}")
print(f"Square of 6: {my_utility.square(6)}")

print("-" * 25)

# 2. Importing specific items from a module, optionally with an alias
from my_utility import cube as power_of_3
print(f"Cube of 4 (using alias): {power_of_3(4)}")

print("-" * 25)

# 3. Importing a module from a package
# (Requires 'my_package' directory with __init__.py and geometry.py inside)
from my_package import geometry
print(f"Circle area with radius 4: {geometry.circle_area(4):.2f}")

print("-" * 25)

# 4. Importing specific items from a package module
from my_package.geometry import circle_area
print(f"Circle area with radius 7 (direct import): {circle_area(7):.2f}")
```

Output example:
```
From my_utility: Hello from my_utility!
Square of 6: 36
-------------------------
Cube of 4 (using alias): 64
-------------------------
Circle area with radius 4: 50.27
-------------------------
Circle area with radius 7 (direct import): 153.94
```

---

### Small Challenge: 🚀
Your turn! Create a simple package named `math_operations`. Inside it, create a module `basic.py` with functions for `add(a, b)`, `subtract(a, b)`, `multiply(a, b)`, and `divide(a, b)`. Remember to handle division by zero! 😉
Then, in a separate `main.py` file outside your package, import and use these functions to perform some calculations. Share your elegant solutions!

---

Day 12: Modules and Packages \- Code & Output

📣 **Python Learning Series - Day 13!** 🐍🏗️

Welcome back, learners! Today, we're diving into one of Python's most powerful paradigms: **Object-Oriented Programming (OOP)**! 🚀

OOP helps us structure our code into reusable, modular pieces. Think of a `class` as a blueprint or a template – it defines the characteristics (attributes) and behaviors (methods) that an entity can have. An `object` is an actual instance created from that blueprint. Let's create our first class and objects! 👇

```python
class Dog:
# The constructor method, called when a new object is created
def __init__(self, name, breed):
self.name = name # Attribute 1
self.breed = breed # Attribute 2
self.is_hungry = True # Default attribute

# A method (behavior) of the Dog class
def bark(self):
print(f"{self.name} says Woof! Woof!")

def eat(self):
if self.is_hungry:
print(f"{self.name} is eating. Yum!")
self.is_hungry = False
else:
print(f"{self.name} is not hungry right now.")

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

# Access attributes and call methods
print(f"My dog's name is {my_dog.name} and she is a {my_dog.breed}.")
my_dog.bark()
my_dog.eat()
my_dog.eat() # Try to eat again

print(f"nYour dog's name is {your_dog.name} and he is a {your_dog.breed}.")
your_dog.bark()
```

Output example:
```
My dog's name is Buddy and she is a Golden Retriever.
Buddy says Woof! Woof!
Buddy is eating. Yum!
Buddy is not hungry right now.

Your dog's name is Lucy and he is a Poodle.
Lucy says Woof! Woof!
```

**Small Challenge:**
Add a new method `play()` to the `Dog` class that prints a message like "Buddy is playing fetch!" and sets `is_hungry` back to `True`. Then, call `play()` for `my_dog` and observe the effect on its hunger! 🐶🎾

---

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

🚀 Day 14 is here, and we're diving into two foundational pillars of Object-Oriented Programming: Inheritance and Polymorphism! 🏗️

Inheritance lets new classes (children) inherit properties and behaviors from existing ones (parents), promoting code reuse and establishing clear relationships ("is-a" relationship). 🦆 Polymorphism, on the other hand, allows objects of different classes to be treated as objects of a common type, enabling flexible and extensible code. Let's see them in action!

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

def speak(self):
# This method will be overridden by child classes
raise NotImplementedError("Subclass must implement abstract method 'speak'")

class Dog(Animal):
def __init__(self, name, breed):
super().__init__(name) # Call parent constructor
self.breed = breed

def speak(self):
return f"{self.name} says Woof!"

class Cat(Animal):
def __init__(self, name, color):
super().__init__(name) # Call parent constructor
self.color = color

def speak(self):
return f"{self.name} says Meow!"

# Polymorphism in action: A function that can work with any Animal object
def make_animal_speak(animal):
print(animal.speak())

# Create instances
my_dog = Dog("Buddy", "Golden Retriever")
my_cat = Cat("Whiskers", "Tabby")

# Demonstrate inheritance: Dog inherits 'name' from Animal
print(f"My dog's name is {my_dog.name}.")

# Demonstrate polymorphism: calling speak() on different animal types
print("n--- Animals Speaking ---")
make_animal_speak(my_dog)
make_animal_speak(my_cat)

# A list of various animals demonstrates polymorphism too!
zoo_animals = [my_dog, my_cat, Dog("Max", "German Shepherd")]

print("n--- Animal Parade ---")
for animal in zoo_animals:
make_animal_speak(animal)
```

Output example:
```
My dog's name is Buddy.

--- Animals Speaking ---
Buddy says Woof!
Whiskers says Meow!

--- Animal Parade ---
Buddy says Woof!
Whiskers says Meow!
Max says Woof!
```

Small challenge: 🤔 Create a `Bird` class that inherits from `Animal` and implements its own `speak()` method (e.g., "Chirp!"). Then, add a `Bird` instance to the `zoo_animals` list and run the code! 🐦

---

Day 14: Inheritance and Polymorphism \- Code & Output

Here's your Telegram post and quiz question!

---

🎉 Day 15 of our Python learning journey! Today we unlock the power of Python Libraries! 📚

We're diving into `requests`, the most popular library for making HTTP requests. Say goodbye to complex manual web interactions – `requests` makes fetching data from websites or interacting with APIs incredibly simple and intuitive! 🚀 Let's see it in action! 👇

```python
import requests
import json # For pretty printing the JSON response

# Define the URL for the API endpoint (httpbin.org is great for testing!)
url = "https://httpbin.org/get"

# Make a simple GET request
print(f"Making a GET request to {url}...")
response = requests.get(url)

# Check if the request was successful (status code 200 means OK)
if response.status_code == 200:
print("Request successful! ✅")
print(f"Status Code: {response.status_code}")
print("Response JSON:")
# httpbin.org/get returns JSON, so we can use .json() method
print(json.dumps(response.json(), indent=2))
else:
print(f"Error: Request failed with status code {response.status_code} ❌")
print("Response text:", response.text)
```

Output example:
```
Making a GET request to https://httpbin.org/get...
Request successful! ✅
Status Code: 200
Response JSON:
{
"args": {},
"headers": {
"Accept": "*/*",
"Accept-Encoding": "gzip, deflate",
"Host": "httpbin.org",
"User-Agent": "python-requests/2.31.0",
"X-Amzn-Trace-Id": "Root=1-65c3d9f0-1a2b3c4d5e6f7g8h9i0j"
},
"origin": "192.168.1.1",
"url": "https://httpbin.org/get"
}
```

**Small Challenge:**
Can you modify the code to send some data using a `POST` request to `https://httpbin.org/post`? You'll need to pass a `data` or `json` argument to `requests.post()`! 💪 What does the response look like then? 🤔

---

Day 15: Introduction to Python Libraries \(requests\) \- Code & Output