modular programming exists in Python too. It helps us organize related code in a clean, maintainable, and scalable way. Let’s learn how to do this step by step in Python.

---

Step 1: Create a Module File

Create a new file called string_utils.py and write related functions inside it:

# string_utils.py

def to_uppercase(s):
    return s.upper()

def to_lowercase(s):
    return s.lower()

---

Step 2: Use the Module in the Main File

Create another file called main.py and import the functions from string_utils:

# main.py

from string_utils import to_uppercase, to_lowercase

print(to_uppercase("hello"))   # Output: HELLO
print(to_lowercase("WORLD"))   # Output: world

---

Step 3: Run the Code

To run the program, just execute the following command in your terminal or in an IDE like VS Code:

python main.py

---

Practice:

Now it’s your turn!

1. Create a new file called math_utils.py.
2. Define functions like add, subtract, and multiply inside it.
3. Import and test them in main.py.



⭐️ https://t.iss.one/DataScienceQ

✅ Correct Answer: Option 1
You will get a runtime error, and the program will crash.

---

📕 Explanation:

In Python, if you attempt to import a module that doesn't exist, the interpreter will raise a runtime error called ModuleNotFoundError. This error immediately stops the execution of the program—unless it is properly handled using a try-except block.

---

🔎 Example:

import my_fake_module

📌 Output:

ModuleNotFoundError: No module named 'my_fake_module'

---

🔓 How to handle the error?

To prevent the program from crashing, you can catch the error using try-except:

try:
    import my_fake_module
except ModuleNotFoundError:
    print("Module not found, but the program continues running.")

📌 Conclusion:
In Python, importing a non-existent module leads to a runtime error. If not handled, it will crash the program.

🚀 Keep learning one question at a time!
Stay tuned for tomorrow’s question 🔥

🌟 https://t.iss.one/DataScienceQ

✅️ How to Reload a Modified Module in Python

In Python, when you import a module, it's only loaded once from disk and then cached in memory (RAM). So if you modify that module later, Python won’t reload it automatically — even if you import it again!

---

💡 Example:

Let’s say you have a file called mathutils.py with:

def add(a, b):
    return a + b

You import it in main.py like this:

import mathutils

Later, you update mathutils.py and add a new function:

def subtract(a, b):
    return a - b

If you now run import mathutils again in main.py, Python will not see the new subtract() function. It uses the cached version already loaded in memory.

---

✅ The Right Way to Reload:

import importlib
import mathutils

importlib.reload(mathutils)  # Forces Python to reload the updated module

# Now the new function is accessible
print(mathutils.subtract(10, 3))  # ➡️ Output: 7

---

🧠 Why Does This Happen?

To improve performance, Python loads modules from disk only once, and then stores them in memory (RAM).
If the module file changes, Python doesn’t detect it unless you explicitly tell it to reload.

📌 Summary:

- Re-importing a module doesn’t reload its changes.
- Use importlib.reload() to reload the updated version from disk.


🌟 https://t.iss.one/DataScienceQ 💯

This channels is for Programmers, Coders, Software Engineers.

0️⃣ Python
1️⃣ Data Science
2️⃣ Machine Learning
3️⃣ Data Visualization
4️⃣ Artificial Intelligence
5️⃣ Data Analysis
6️⃣ Statistics
7️⃣ Deep Learning
8️⃣ programming Languages

✅ https://t.iss.one/addlist/8_rRW2scgfRhOTc0

✅ https://t.iss.one/Codeprogrammer