🚀 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! 💪
---
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! 💪
---
Which keyword is used to define a function in Python?
Anonymous Quiz
0%
function
50%
def
50%
func
0%
define
👋 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? 🤔
---
```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? 🤔
---
Which of the following statements accurately describes a key difference between Python lists and tuples?
Anonymous Quiz
0%
A. Lists can only store numbers, while tuples can store any data type.
0%
B. Tuples are mutable (changeable), while lists are immutable (unchangeable).
0%
C. Lists are ordered collections, while tuples are unordered collections.
0%
D. Lists are mutable (changeable), while tuples are immutable (unchangeable).
📚 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! 👇
***
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! 👇
***
Which of the following is a key characteristic of a Python `set`?
Anonymous Quiz
0%
Elements are stored in a specific order.
0%
It allows duplicate elements.
0%
It stores data as key-value pairs.
0%
It stores only unique, unordered elements.
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 - 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! 💻
---
Which Python string method is used to convert all characters in a string to lowercase?
Anonymous Quiz
0%
.capitalize()
0%
.title()
100%
.lower()
0%
.casefold()
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) 📁✍️📖**
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! ✨
---
What is the primary benefit of using the `with open(...)` statement for file operations in Python?
Anonymous Quiz
50%
It automatically closes the file, even if errors occur.
50%
It makes file operations faster.
0%
It encrypts the file content for security.
0%
It prevents write permissions from being needed.
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 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! 👨💻👩💻
---
What is the primary purpose of a `try` block in Python's error handling?
Anonymous Quiz
0%
A) To define code that must always execute, regardless of errors.
0%
B) To enclose code that might raise an exception.
0%
C) To specify different error types to handle.
0%
D) To re-raise an exception after handling it.
🎉 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! 👇
---
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! 👇
---