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

---

Hey Python learners! 👋 Ready for Day 2 of our journey? Today, we're diving into the absolute fundamentals: **Variables and Data Types!** 🧠 Think of variables as labeled containers for storing information in your code. Data types tell Python what kind of information is inside – is it text, a whole number, a decimal, or something else? Understanding these is crucial for building any program. Let's get hands-on! 🚀

```python
# Day 2: Variables and Data Types

# 1. Variables: Containers for data
# Assigning different types of data to variables
user_name = "Alice" # String (text)
user_age = 30 # Integer (whole number)
height_in_meters = 1.75 # Float (decimal number)
is_student = True # Boolean (True/False)

print("--- Variable Values ---")
print("Name:", user_name)
print("Age:", user_age)
print("Height:", height_in_meters)
print("Is Student:", is_student)

print("n--- Data Types ---")
# Using the type() function to check a variable's data type
print("Type of user_name:", type(user_name))
print("Type of user_age:", type(user_age))
print("Type of height_in_meters:", type(height_in_meters))
print("Type of is_student:", type(is_student))

# 2. Reassigning a variable
# You can change the value (and even the type) of a variable
user_age = 31 # Alice had a birthday!
print("nNew Age:", user_age)
```

Output example:
```
--- Variable Values ---
Name: Alice
Age: 30
Height: 1.75
Is Student: True

--- Data Types ---
Type of user_name: <class 'str'>
Type of user_age: <class 'int'>
Type of height_in_meters: <class 'float'>
Type of is_student: <class 'bool'>

New Age: 31
```

💡 **Your Turn!** Create three variables: `product_name` (string), `price` (float), and `in_stock` (boolean). Assign them some sensible values (e.g., "Keyboard", 75.99, True). Then, print both their values and their data types. Share your code or output in the comments! 👇

---

Day 2: Variables and Data Types \- Code & Output

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

---

✨ Python Learning Series: Day 3! ✨

🚀 Today, we're diving into the powerful world of *Operators in Python*! Operators are special symbols that perform operations on values and variables. From basic arithmetic to making complex decisions, they are the building blocks of any program. Get ready to add, compare, and logically connect your code! Let's explore how they work! 💡

```python
# Day 3: Operators in Python

# --- Arithmetic Operators ---
a = 10
b = 3

print(f"a + b = {a + b}") # Addition
print(f"a - b = {a - b}") # Subtraction
print(f"a * b = {a * b}") # Multiplication
print(f"a / b = {a / b}") # Division (float result)
print(f"a // b = {a // b}") # Floor Division (integer result)
print(f"a % b = {a % b}") # Modulus (remainder)
print(f"a ** b = {a ** b}") # Exponentiation

# --- Comparison Operators ---
x = 5
y = 10

print(f"x == y is {x == y}") # Equal to
print(f"x != y is {x != y}") # Not equal to
print(f"x < y is {x < y}") # Less than
print(f"x > y is {x > y}") # Greater than
print(f"x <= y is {x <= y}") # Less than or equal to

# --- Logical Operators ---
is_true = True
is_false = False

print(f"is_true and is_false is {is_true and is_false}") # AND
print(f"is_true or is_false is {is_true or is_false}") # OR
print(f"not is_true is {not is_true}") # NOT
```

Output example:
```
a + b = 13
a - b = 7
a * b = 30
a / b = 3.3333333333333335
a // b = 3
a % b = 1
a ** b = 1000
x == y is False
x != y is True
x < y is True
x > y is False
x <= y is True
is_true and is_false is False
is_true or is_false is True
not is_true is False
```

Small challenge:
Can you predict the output of `(7 + 3) * 2 - 10 / 2`? Try it in your Python interpreter! 🤔

---

Day 3: Operators in Python \- Code & Output

🚀 Day 4 of our Python journey! Today, we're diving into the heart of decision-making in code: Conditional Statements! 🧠 Ever wanted your program to do different things based on different situations? That's where `if`, `elif`, and `else` come in! They allow your code to execute different blocks of statements based on whether a condition is true or false. Get ready to make your code smarter and more responsive. Let's make some choices! 👇

```python
# Let's check a student's grade based on their score
score = 85

if score >= 90:
print("Excellent! You got an A. 🥳")
elif score >= 75:
print("Good job! You got a B. 👍")
elif score >= 60:
print("You passed! You got a C. 😊")
else:
print("You need to study more. You got a D. 📚")

# Remember, Python executes the first true condition and then skips the rest!
# Try changing the 'score' variable to see different outputs!
```

Output example:
Good job! You got a B. 👍

💡 **Your Challenge:**
Modify the code above! Change the `score` variable to `55` and predict the output. Then, try setting it to `95` and see what happens. Can you add another `elif` condition for a "Fair" grade (e.g., between 50 and 59)? Share your new code or your predictions in the comments! 👇

---

Day 4: Conditional Statements \(if, elif, else\) \- Code & Output

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

---

📚 **Day 5: Loops (for and while) – Master Repetition!** 🔄🚀

Welcome back, Pythonistas! Today, we're diving into one of the most powerful concepts in programming: **loops**! Learn how `for` and `while` loops help you automate repetitive tasks, iterate through data structures, and execute code blocks multiple times. No more manual repetition – let Python do the work! Understanding loops is crucial for writing efficient and dynamic programs. Let's make our code smart and efficient! 💡

```python
# --- Python Loops: for and while ---

# 1. The 'for' loop: Iterate over a sequence (e.g., list, string, range)
print("--- For Loop Example (Fruits) ---")
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(f"I like {fruit}!")

print("n--- For Loop Example (Range) ---")
# range(start, stop, step) generates numbers. range(3) means 0, 1, 2.
for i in range(3):
print(f"Counting with for: {i}")

# 2. The 'while' loop: Execute as long as a condition is true
print("n--- While Loop Example ---")
count = 0
while count < 3: # Loop continues as long as count is less than 3
print(f"Counting with while: {count}")
count += 1 # IMPORTANT: Increment to avoid an infinite loop!

print("nLoops completed!")
```

Output example:
--- For Loop Example (Fruits) ---
I like apple!
I like banana!
I like cherry!

--- For Loop Example (Range) ---
Counting with for: 0
Counting with for: 1
Counting with for: 2

--- While Loop Example ---
Counting with while: 0
Counting with while: 1
Counting with while: 2

Loops completed!

---

Small challenge: 💪 Write a `for` loop that prints all numbers from 1 to 5, including 5. Share your solution in the comments! 👇

---

Day 5: Loops \(for and while\) \- Code & Output

🚀 Python Learning Series - Day 6! 🚀

Today, we're diving into one of Python's most powerful features: **Functions**! 🤖 Functions help us organize our code, make it reusable, and avoid repetition. Think of them as mini-programs within your program that perform a specific task. Ready to build some amazing blocks of code? Let's go! 👇

```python
# Define a function to add two numbers
def add_numbers(num1, num2):
"""
This function takes two arguments and returns their sum.
"""
sum_result = num1 + num2
return sum_result

# Define a function to greet a user
def greet_user(name):
print(f"Hello, {name}! Welcome to Day 6 of Python learning. 🎉")

# Call the functions
result = add_numbers(15, 7)
print(f"The sum of 15 and 7 is: {result}")

greet_user("Pythonista")
greet_user("Learner")
```

Output example:
```
The sum of 15 and 7 is: 22
Hello, Pythonista! Welcome to Day 6 of Python learning. 🎉
Hello, Learner! Welcome to Day 6 of Python learning. 🎉
```

💡 **Your Challenge:** Create a function called `calculate_area(length, width)` that takes two arguments (length and width) and returns the area of a rectangle. Then, call your function with example values and print the result! Good luck! 💪

---

Day 6: Functions in Python \- Code & Output

👋 Hey Python learners! Day 7️⃣ is here, and we're diving into two fundamental data structures: **Lists and Tuples**! 🤩 Both are great for storing collections, but they have a crucial difference. Lists are mutable (changeable), while tuples are immutable (unchangeable). Understanding them is key to organizing your data efficiently! Let's explore how to use them! 👇

```python
# Day 7: Lists and Tuples

# --- Lists (Mutable) ---
my_list = ["apple", "banana", "cherry"]
print("Initial list:", my_list)

# Add an element
my_list.append("date")
print("List after append:", my_list)

# Access an element
print("Second item (index 1):", my_list[1])

# Modify an element
my_list[0] = "apricot"
print("List after modification:", my_list)

# Slicing
print("Sliced list (first two):", my_list[0:2])

# --- Tuples (Immutable) ---
my_tuple = ("red", "green", "blue")
print("nInitial tuple:", my_tuple)

# Access an element (same as list)
print("First item in tuple (index 0):", my_tuple[0])

# Attempting to modify a tuple will raise an error if uncommented
# my_tuple[0] = "yellow" # This line would cause a TypeError!
print("Tuples are immutable, elements cannot be changed after creation.")

# You can concatenate tuples to create a *new* one
new_tuple = my_tuple + ("yellow", "purple")
print("New tuple from concatenation:", new_tuple)

# Convert list to tuple and vice-versa
tuple_from_list = tuple(my_list)
list_from_tuple = list(my_tuple)
print("Tuple created from list:", tuple_from_list)
print("List created from tuple:", list_from_tuple)
```

Output example:
```
Initial list: ['apple', 'banana', 'cherry']
List after append: ['apple', 'banana', 'cherry', 'date']
Second item (index 1): banana
List after modification: ['apricot', 'banana', 'cherry', 'date']
Sliced list (first two): ['apricot', 'banana']

Initial tuple: ('red', 'green', 'blue')
First item in tuple (index 0): red
Tuples are immutable, elements cannot be changed after creation.
New tuple from concatenation: ('red', 'green', 'blue', 'yellow', 'purple')
Tuple created from list: ('apricot', 'banana', 'cherry', 'date')
List created from tuple: ['red', 'green', 'blue']
```

💡 **Challenge Time!**
Create a list of your 3 favorite colors. Then, convert this list into a tuple. Print both the original list and the new tuple. Can you successfully add a 4th color to your *original* list afterwards? 🤔

---

Day 7: Lists and Tuples \- Code & Output

📚 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