📚 Day 8 is here! ✨ Today we dive into two powerful Python data structures: **Dictionaries** and **Sets**! 🧠

Dictionaries are all about `key:value` pairs, perfect for storing related information like user profiles or configurations. Sets, on the other hand, are collections of *unique* elements, great for membership testing and easily eliminating duplicates. Let's unlock their potential! 👇

```python
# --- Dictionaries ---
print("--- Dictionaries ---")
my_dict = {
"name": "Alice",
"age": 30,
"city": "New York"
}
print(f"Original Dictionary: {my_dict}")

# Accessing values
print(f"Alice's age: {my_dict['age']}") # Using key to get value

# Adding a new key-value pair
my_dict["occupation"] = "Engineer"
print(f"Dictionary after adding occupation: {my_dict}")

# Updating an existing value
my_dict["age"] = 31
print(f"Dictionary after updating age: {my_dict}")

# Iterating through a dictionary
print("Dictionary keys and values:")
for key, value in my_dict.items():
print(f" {key}: {value}")

# --- Sets ---
print("n--- Sets ---")
my_set = {1, 2, 3, 4, 4, 5} # Duplicates (like the second 4) are automatically removed
print(f"Original Set: {my_set}") # Output might be {1, 2, 3, 4, 5} or {1, 2, 3, 5, 4} due to unordered nature

# Adding elements
my_set.add(6)
my_set.add(1) # Already present, won't change the set
print(f"Set after adding 6 and 1: {my_set}")

# Removing elements
my_set.discard(3) # .discard() doesn't raise an error if item not found
print(f"Set after removing 3: {my_set}")

# Set operations (Union, Intersection, Difference)
set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

print(f"Set A: {set_a}")
print(f"Set B: {set_b}")
print(f"Union (A | B): {set_a.union(set_b)}") # Elements in A OR B
print(f"Intersection (A & B): {set_a.intersection(set_b)}") # Elements in A AND B
print(f"Difference (A - B): {set_a.difference(set_b)}") # Elements in A but NOT in B
```

Output example:
```
--- Dictionaries ---
Original Dictionary: {'name': 'Alice', 'age': 30, 'city': 'New York'}
Alice's age: 30
Dictionary after adding occupation: {'name': 'Alice', 'age': 30, 'city': 'New York', 'occupation': 'Engineer'}
Dictionary after updating age: {'name': 'Alice', 'age': 31, 'city': 'New York', 'occupation': 'Engineer'}
Dictionary keys and values:
name: Alice
age: 31
city: New York
occupation: Engineer

--- Sets ---
Original Set: {1, 2, 3, 4, 5}
Set after adding 6 and 1: {1, 2, 3, 4, 5, 6}
Set after removing 3: {1, 2, 4, 5, 6}
Set A: {1, 2, 3, 4}
Set B: {3, 4, 5, 6}
Union (A | B): {1, 2, 3, 4, 5, 6}
Intersection (A & B): {3, 4}
Difference (A - B): {1, 2}
```

🤔 **Your Challenge:**
Create a dictionary to store details of a book (title, author, year). Then, create a set of programming languages you know. Add a new language to your set and update the book's year to a new value! Share your code! 👇

***

Day 8: Dictionaries and Sets \- Code & Output

Here's your Telegram post and quiz question!

---

🌟 Day 9: String Manipulation - Master Text Handling! 📝

Hey Python learners! 👋 Today we dive into the fascinating world of String Manipulation. Strings are everywhere, and knowing how to work with them is a superpower! ✨ From cleaning data to formatting output, Python's string methods make it incredibly easy. Let's explore some essential techniques to transform and process your text like a pro! 🚀

```python
# Our sample string
message = " Hello, Pythonista! Welcome to Day 9. "
print(f"Original: '{message}'")

# 1. Removing leading/trailing whitespace with .strip()
cleaned_message = message.strip()
print(f"Stripped: '{cleaned_message}'")

# 2. Replacing parts of a string with .replace()
replaced_message = cleaned_message.replace("Day 9", "String Manipulation Day")
print(f"Replaced: '{replaced_message}'")

# 3. Changing case to uppercase with .upper()
upper_message = replaced_message.upper()
print(f"Uppercase: '{upper_message}'")

# 4. Splitting a string into a list of words with .split()
words = replaced_message.split(" ")
print(f"Words list: {words}")

# 5. Joining a list of words back into a string with .join()
joined_message = "-".join(words)
print(f"Joined with '-': '{joined_message}'")
```

Output example:
```
Original: ' Hello, Pythonista! Welcome to Day 9. '
Stripped: 'Hello, Pythonista! Welcome to Day 9.'
Replaced: 'Hello, Pythonista! Welcome to String Manipulation Day.'
Uppercase: 'HELLO, PYTHONISTA! WELCOME TO STRING MANIPULATION DAY.'
Words list: ['Hello,', 'Pythonista!', 'Welcome', 'to', 'String', 'Manipulation', 'Day.']
Joined with '-': 'Hello,-Pythonista!-Welcome-to-String-Manipulation-Day.'
```

💡 **Your Challenge:**
Given the string `challenge_str = "Python is AWESOME for text processing!"`.
1. Convert the entire string to lowercase.
2. Replace "AWESOME" with "superb".
3. Split the resulting string into a list of words.

Share your code or the output in the comments! 👇 Happy coding! 💻

---

Day 9: String Manipulation \- Code & Output

Here's your Telegram post and quiz question!

---

**Day 10: File I/O (Input/Output) 📁✍️📖**

Hello Python learners! 🚀 Welcome to Day 10, where we tackle the super practical topic of File I/O! Ever wondered how programs save data permanently, or read existing files? Today's the day! We'll learn how to write to files and read from them, giving your Python scripts the power to interact with the real world beyond the console. Let's dive in! Remember the `with open()` statement for safe file handling!

```python
# --- Writing to a file ---
# 'w' mode opens for writing. If the file exists, it truncates (empties) it.
# If it doesn't exist, it creates it.
with open("my_notes.txt", "w") as file:
file.write("Python is awesome!n")
file.write("File I/O is super useful for data persistence.n")
file.write("Always remember to close files, or use 'with' statement.n")
print("Content written to my_notes.txt")

# --- Reading from a file ---
# 'r' mode opens for reading.
print("n--- Reading file content ---")
with open("my_notes.txt", "r") as file:
content_lines = file.readlines() # Reads all lines into a list
for line in content_lines:
print(line.strip()) # .strip() removes leading/trailing whitespace (like newlines)
```

Output example:
```
Content written to my_notes.txt

--- Reading file content ---
Python is awesome!
File I/O is super useful for data persistence.
Always remember to close files, or use 'with' statement.
```

**Small challenge: 💪**
Your turn! Modify the code to *append* a new line of text to `my_notes.txt` (hint: use the `'a'` mode), and then read and print the *entire* file content again to confirm the changes. Happy coding! ✨

---

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

Here's your Telegram post and quiz question!

---

🚀 Day 11 of our Python journey! Today, we're tackling a crucial skill for writing robust and user-friendly code: **Error Handling**! 🚫 Nobody likes unexpected crashes. With `try` and `except` blocks, you can gracefully manage errors, provide helpful feedback, and keep your programs running smoothly. Let's dive in! 💪✨

```python
def safe_divide():
try:
# Code that might raise an error goes in the 'try' block
num1 = float(input("Enter the first number: "))
num2 = float(input("Enter the second number: "))
result = num1 / num2
print(f"The result of {num1} / {num2} is: {result}")
except ValueError:
# This block executes if a ValueError occurs (e.g., non-numeric input)
print("🚫 Invalid input! Please enter valid numbers.")
except ZeroDivisionError:
# This block executes if a ZeroDivisionError occurs
print("❌ Cannot divide by zero! Please enter a non-zero second number.")
except Exception as e:
# A general except block to catch any other unexpected errors
print(f"An unexpected error occurred: {e}")

safe_divide()
```

Output example:
```
# Scenario 1: Valid input
Enter the first number: 10
Enter the second number: 2
The result of 10.0 / 2.0 is: 5.0

# Scenario 2: Invalid number input
Enter the first number: hello
🚫 Invalid input! Please enter valid numbers.

# Scenario 3: Division by zero
Enter the first number: 5
Enter the second number: 0
❌ Cannot divide by zero! Please enter a non-zero second number.
```

💡 **Your Challenge:** Modify the `safe_divide` function. Add an `else` block to the `try-except` statement. If no exceptions occur, print "✅ Division successful!" inside the `else` block. Happy coding! 👨‍💻👩‍💻

---

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

🎉 Day 12: Modules & Packages! 📦✨

Ever wondered how Python keeps things organized and reusable? 🤔 Modules are like single files containing Python code (functions, classes, variables), while packages are collections of related modules within directories. They're essential for writing clean, maintainable, and scalable code! Today, we'll learn how to bring external functionality into our scripts using the `import` statement. Let's make our code more modular! 🚀

```python
# First, imagine you have a file named 'my_utils.py' with the following content:
#
# # my_utils.py
# def greet(name):
# return f"Hello, {name}!"
#
# def multiply(a, b):
# return a * b
#
# Now, in your main script (e.g., main.py), you can import and use it:

import my_utils # Imports our custom module
import math # Imports a built-in Python module

# Using functions from our custom module
message = my_utils.greet("Pythonista")
product = my_utils.multiply(4, 5)

print(message)
print(f"4 multiplied by 5 is: {product}")

# Using a function from the built-in 'math' module
square_root = math.sqrt(25)
print(f"The square root of 25 is: {square_root}")
```

Output example:
```
Hello, Pythonista!
4 multiplied by 5 is: 20
The square root of 25 is: 5.0
```

Small challenge:
Your turn! 💪 Create a new Python file named `calculator.py`. Inside it, define functions for `add(a, b)`, `subtract(a, b)`, and `divide(a, b)`. Then, in a separate main script, import your `calculator` module and use all three functions. Share your code in the comments! 👇

---

Day 12: Modules and Packages \- Code & Output

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

---

🚀 Day 13: Dive into the world of Object-Oriented Programming (OOP)! 🐍 Today, we unravel the magic of Classes and Objects. Think of a Class as a blueprint 🏗️ for creating things, and an Object as a real-world item built from that blueprint. OOP helps us structure code, make it reusable, and manage complexity like a pro! Get ready to create your own custom data types. ✨

```python
class Car:
# Class attribute (shared by all instances)
wheels = 4

def __init__(self, make: str, model: str, year: int):
# Instance attributes (unique to each object)
self.make = make
self.model = model
self.year = year
self.speed = 0
print(f"A new {self.year} {self.make} {self.model} has been created!")

def accelerate(self, increment: int):
self.speed += increment
return f"The {self.make} {self.model} accelerates to {self.speed} km/h."

def brake(self, decrement: int):
self.speed = max(0, self.speed - decrement)
return f"The {self.make} {self.model} slows down to {self.speed} km/h."

def get_description(self):
return f"This is a {self.year} {self.make} {self.model}."

# Creating objects (instances) of the Car class
my_car = Car("Toyota", "Camry", 2022)
your_car = Car("Honda", "Civic", 2023)

# Accessing attributes and calling methods
print(my_car.get_description())
print(my_car.accelerate(50))
print(my_car.brake(20))
print(f"My car's current speed: {my_car.speed} km/h")

print(f"n{your_car.get_description()}")
print(your_car.accelerate(70))
print(f"Your car has {your_car.wheels} wheels.") # Accessing a class attribute
```

Output example:
```
A new 2022 Toyota Camry has been created!
A new 2023 Honda Civic has been created!
This is a 2022 Toyota Camry.
The Toyota Camry accelerates to 50 km/h.
The Toyota Camry slows down to 30 km/h.
My car's current speed: 30 km/h

This is a 2023 Honda Civic.
The Honda Civic accelerates to 70 km/h.
Your car has 4 wheels.
```

**Challenge:**
Extend the `Car` class by adding a new method, for example, `honk()`, that prints a "Beep! Beep!" message along with the car's model. Then, create another `Car` object and try out your new method! 🚘

---

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

Here's your Telegram post and quiz question:

---

🌟 **Day 14: Diving into Inheritance & Polymorphism!** 🚀

Today, we unlock the power of Object-Oriented Programming (OOP) to build more scalable and organized code. Inheritance allows new classes to inherit properties and methods from existing ones, promoting code reusability. Polymorphism, on the other hand, lets us treat objects of different classes in a uniform way, making our code flexible and adaptable. Get ready to master these fundamental OOP pillars! 👇

```python
# Base Class (Parent Class)
class Animal:
def __init__(self, name):
self.name = name

def speak(self):
return f"{self.name} makes a generic sound."

# Derived Class (Child Class) - inherits from Animal
class Dog(Animal):
def __init__(self, name, breed):
super().__init__(name) # Call parent's constructor
self.breed = breed

def speak(self): # Method Overriding (Polymorphism)
return f"{self.name} barks loudly!"

# Another Derived Class - also inherits from Animal
class Cat(Animal):
def __init__(self, name, color):
super().__init__(name)
self.color = color

def speak(self): # Method Overriding (Polymorphism)
return f"{self.name} meows softly."

# A function demonstrating Polymorphism
# It can take any object that has a 'speak' method
def animal_action(animal):
print(animal.speak())

# Creating objects
my_generic_animal = Animal("Beast")
my_dog = Dog("Buddy", "Golden Retriever")
my_cat = Cat("Whiskers", "Tabby")

# Demonstrating Polymorphism: calling animal_action with different object types
print("--- Polymorphism in action ---")
animal_action(my_generic_animal)
animal_action(my_dog)
animal_action(my_cat)

print("n--- Inheritance example ---")
print(f"{my_dog.name} is a {my_dog.breed}.")
print(f"{my_cat.name} is a {my_cat.color} cat.")
```

**Output example:**
```
--- Polymorphism in action ---
Beast makes a generic sound.
Buddy barks loudly!
Whiskers meows softly.

--- Inheritance example ---
Buddy is a Golden Retriever.
Whiskers is a Tabby cat.
```

💡 **Your Challenge:**
Create a new class called `Bird` 🐦 that also inherits from `Animal`. Give it a unique attribute (like `wingspan`) and override the `speak` method to make it chirp! Then, create an instance of your `Bird` and pass it to the `animal_action` function. Show us your creative animals! 🚀

---