Prerequisites
- Basic understanding of programming concepts 📝
- Python installation (3.8+) 🐍
- VS Code or preferred IDE 💻
What you'll learn
- Understand the concept fundamentals 🎯
- Apply the concept in real projects 🏗️
- Debug common issues 🐛
- Write clean, Pythonic code ✨
🎯 Introduction
Welcome to this exciting tutorial on Python Path and Module Search! 🎉 In this guide, we’ll explore how Python finds and imports modules, one of the most fundamental aspects of Python programming.
You’ll discover how Python’s module search mechanism works, allowing you to organize code into reusable components. Whether you’re building web applications 🌐, data science projects 📊, or automation scripts 🤖, understanding how Python finds modules is essential for writing maintainable, scalable code.
By the end of this tutorial, you’ll feel confident managing Python paths and creating well-organized projects! Let’s dive in! 🏊♂️
📚 Understanding Python Path and Module Search
🤔 What is Python Path?
Python path is like a treasure map 🗺️ that Python uses to find modules. Think of it as a GPS system that helps Python navigate through your computer to locate the code you want to import.
In Python terms, the module search path is a list of directories where Python looks for modules when you use the import statement. This means you can:
- ✨ Import modules from multiple locations
- 🚀 Organize code into logical packages
- 🛡️ Avoid naming conflicts between modules
💡 Why Understanding Python Path Matters?
Here’s why developers need to master Python’s module search:
- Project Organization 📁: Structure code into clean, manageable modules
- Code Reusability ♻️: Share code between different projects
- Debugging Import Errors 🐛: Quickly fix “ModuleNotFoundError”
- Package Development 📦: Create and distribute your own Python packages
Real-world example: Imagine building a recipe app 🍳. With proper module organization, you can separate ingredients, cooking methods, and recipe storage into different modules that work together seamlessly!
🔧 Basic Syntax and Usage
📝 Viewing the Python Path
Let’s start by exploring Python’s module search path:
# 👋 Hello, Python Path!
import sys
# 🔍 View the current Python path
print("Python will search for modules in these locations:")
for i, path in enumerate(sys.path, 1):
print(f"{i}. 📁 {path}")
# 🎨 The first item is usually the current directory
print(f"\n✨ Current script directory: {sys.path[0]}")💡 Explanation: sys.path is a list containing all directories where Python searches for modules. The search happens in order - Python checks each directory until it finds the module!
🎯 How Module Search Works
Here’s the search process Python follows:
# 🏗️ Understanding import mechanics
import os
# 📍 Step 1: Python checks built-in modules
import math # ✅ Found in built-ins!
# 📍 Step 2: Python checks sys.path directories
# Let's create a simple module
module_content = '''
# 🎮 game_utils.py - A fun game utilities module!
def roll_dice():
"""Roll a six-sided dice 🎲"""
import random
return random.randint(1, 6)
def get_player_emoji(player_number):
"""Get emoji for player 🎯"""
emojis = ["🦸", "🧙", "🦹", "🧚", "🦾"]
return emojis[player_number % len(emojis)]
'''
# 💾 Save our module
with open('game_utils.py', 'w') as f:
f.write(module_content)
# 🎯 Now we can import it!
import game_utils
print(f"Dice roll: {game_utils.roll_dice()} 🎲")
print(f"Player 1: {game_utils.get_player_emoji(1)}")🚀 Modifying Python Path
You can add directories to Python’s search path:
# 🛠️ Adding custom directories to sys.path
import sys
import os
# 📁 Create a custom modules directory
custom_path = os.path.join(os.getcwd(), 'my_modules')
os.makedirs(custom_path, exist_ok=True)
# ➕ Add it to Python path
sys.path.append(custom_path)
print(f"✅ Added {custom_path} to Python path!")
# 🎨 Now modules in my_modules/ can be imported
# Create a test module
test_module = '''
# 🌟 awesome_tools.py
def celebrate():
return "🎉 Success! You've mastered Python paths! 🚀"
'''
module_path = os.path.join(custom_path, 'awesome_tools.py')
with open(module_path, 'w') as f:
f.write(test_module)
# 🎯 Import from our custom path
import awesome_tools
print(awesome_tools.celebrate())💡 Practical Examples
🛒 Example 1: E-commerce Module System
Let’s build a modular e-commerce system:
# 🛍️ Project structure for our shop
import os
import sys
# 📁 Create project structure
def create_shop_structure():
"""Create an organized shop module structure 🏪"""
# 🏗️ Define our structure
structure = {
'shop': {
'__init__.py': '# 🛒 Shop package',
'products.py': '''
# 📦 Product management module
class Product:
def __init__(self, name, price, emoji):
self.name = name
self.price = price
self.emoji = emoji
def display(self):
return f"{self.emoji} {self.name} - ${self.price:.2f}"
# 🎨 Product catalog
PRODUCTS = [
Product("Python Book", 29.99, "📘"),
Product("Coffee Mug", 12.99, "☕"),
Product("Keyboard", 79.99, "⌨️"),
Product("Mouse Pad", 9.99, "🖱️")
]
''',
'cart.py': '''
# 🛒 Shopping cart module
class ShoppingCart:
def __init__(self):
self.items = []
print("🛒 Created new shopping cart!")
def add_item(self, product, quantity=1):
self.items.append({
'product': product,
'quantity': quantity
})
print(f"✅ Added {quantity}x {product.display()}")
def get_total(self):
total = sum(item['product'].price * item['quantity']
for item in self.items)
return total
def checkout(self):
print("\\n🛍️ Your Order:")
for item in self.items:
product = item['product']
qty = item['quantity']
subtotal = product.price * qty
print(f" {product.display()} x{qty} = ${subtotal:.2f}")
print(f"\\n💰 Total: ${self.get_total():.2f}")
print("✨ Thanks for shopping! 🎉")
''',
'utils': {
'__init__.py': '# 🔧 Utilities package',
'discounts.py': '''
# 🏷️ Discount calculations
def apply_discount(price, discount_percent):
"""Apply percentage discount 💸"""
discount = price * (discount_percent / 100)
final_price = price - discount
print(f"🎯 {discount_percent}% off! Save ${discount:.2f}")
return final_price
def get_seasonal_discount():
"""Get current seasonal discount 🎄"""
import datetime
month = datetime.datetime.now().month
# 🎁 Holiday discounts!
if month == 12: # December
return 25 # 25% off!
elif month in [6, 7, 8]: # Summer
return 15 # 15% off!
else:
return 10 # Regular 10% off
'''
}
}
}
# 🏗️ Create the structure
for root_dir, contents in structure.items():
create_directory_structure(root_dir, contents)
print("✅ Shop module structure created!")
def create_directory_structure(base_path, contents):
"""Recursively create directory structure 📁"""
os.makedirs(base_path, exist_ok=True)
for name, content in contents.items():
path = os.path.join(base_path, name)
if isinstance(content, dict):
# 📁 It's a subdirectory
create_directory_structure(path, content)
else:
# 📄 It's a file
with open(path, 'w') as f:
f.write(content)
# 🚀 Create our shop!
create_shop_structure()
# 🎮 Now let's use our modular shop
from shop.products import PRODUCTS
from shop.cart import ShoppingCart
from shop.utils.discounts import apply_discount, get_seasonal_discount
# 🛒 Start shopping!
cart = ShoppingCart()
# 🎯 Add some items
cart.add_item(PRODUCTS[0], 2) # 2 Python books
cart.add_item(PRODUCTS[1], 1) # 1 Coffee mug
# 🏷️ Apply seasonal discount
original_total = cart.get_total()
discount = get_seasonal_discount()
final_total = apply_discount(original_total, discount)
print(f"\n🎊 Final price after seasonal discount: ${final_total:.2f}")🎮 Example 2: Game Module Loader
Let’s create a dynamic game module loader:
# 🎯 Dynamic module loading for games
import importlib
import os
import sys
class GameModuleLoader:
"""Load game modules dynamically 🎮"""
def __init__(self, games_directory='games'):
self.games_dir = games_directory
self.loaded_games = {}
# 📁 Ensure games directory exists
os.makedirs(self.games_dir, exist_ok=True)
# ➕ Add to Python path
if self.games_dir not in sys.path:
sys.path.insert(0, self.games_dir)
print(f"🎮 Game Module Loader initialized!")
print(f"📁 Games directory: {os.path.abspath(self.games_dir)}")
def create_game(self, name, code):
"""Create a new game module 🎨"""
filename = f"{name.lower().replace(' ', '_')}.py"
filepath = os.path.join(self.games_dir, filename)
with open(filepath, 'w') as f:
f.write(code)
print(f"✅ Created game: {name} ({filename})")
return filename
def load_game(self, module_name):
"""Load a game module dynamically 🚀"""
try:
# 🔄 Remove .py extension if present
if module_name.endswith('.py'):
module_name = module_name[:-3]
# 🎯 Import the module
game_module = importlib.import_module(module_name)
# 🔄 Reload if already loaded
if module_name in self.loaded_games:
game_module = importlib.reload(game_module)
self.loaded_games[module_name] = game_module
print(f"✅ Loaded game: {module_name}")
return game_module
except ImportError as e:
print(f"❌ Failed to load {module_name}: {e}")
return None
def list_available_games(self):
"""List all available game modules 📋"""
print("\n🎮 Available Games:")
for file in os.listdir(self.games_dir):
if file.endswith('.py') and not file.startswith('__'):
game_name = file[:-3].replace('_', ' ').title()
print(f" 🎯 {game_name} ({file})")
# 🎮 Let's create some games!
loader = GameModuleLoader()
# 🎲 Game 1: Dice Roller
dice_game = '''
# 🎲 Dice Rolling Game
import random
def play():
"""Roll dice and get your fortune! 🎰"""
print("\\n🎲 Welcome to Dice Fortune!")
roll = random.randint(1, 6)
fortunes = {
1: ("😢", "Try again! Better luck next time!"),
2: ("😐", "Not bad, but you can do better!"),
3: ("🙂", "Good roll! Things are looking up!"),
4: ("😊", "Great roll! Fortune smiles upon you!"),
5: ("🎉", "Amazing! You're on fire!"),
6: ("🏆", "JACKPOT! You're the champion!")
}
emoji, message = fortunes[roll]
print(f"You rolled: {roll} {emoji}")
print(f"{message}")
return roll
'''
# 🃏 Game 2: Card Picker
card_game = '''
# 🃏 Card Picking Game
import random
def play():
"""Pick a card and test your luck! 🎴"""
print("\\n🃏 Welcome to Lucky Card!")
suits = ["♠️", "♥️", "♦️", "♣️"]
ranks = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"]
suit = random.choice(suits)
rank = random.choice(ranks)
print(f"Your card: {rank}{suit}")
# 🎯 Special combinations
if rank == "A" and suit == "♠️":
print("🌟 ACE OF SPADES! Ultimate luck!")
elif rank in ["J", "Q", "K"]:
print("👑 Royalty! You're destined for greatness!")
elif suit == "♥️":
print("❤️ Hearts! Love is in the air!")
return f"{rank}{suit}"
'''
# 🎨 Create the games
loader.create_game("Dice Fortune", dice_game)
loader.create_game("Lucky Card", card_game)
# 📋 List available games
loader.list_available_games()
# 🎮 Load and play games!
dice_module = loader.load_game("dice_fortune")
if dice_module:
dice_module.play()
card_module = loader.load_game("lucky_card")
if card_module:
card_module.play()🚀 Advanced Concepts
🧙♂️ Package Development with init.py
When you’re ready to create professional packages:
# 🎯 Advanced package structure
import os
def create_advanced_package():
"""Create a professional Python package 📦"""
package_structure = {
'awesome_toolkit': {
'__init__.py': '''
# 🚀 Awesome Toolkit Package
"""A collection of awesome Python tools! ✨"""
__version__ = "1.0.0"
__author__ = "Python Master 🧙"
# 🎯 Convenient imports
from .core import ToolkitCore
from .helpers import magic_function, super_helper
from .constants import MAGIC_NUMBER, EMOJI_LIST
# 📋 Define what gets imported with "from awesome_toolkit import *"
__all__ = ['ToolkitCore', 'magic_function', 'super_helper',
'MAGIC_NUMBER', 'EMOJI_LIST']
print(f"✨ Awesome Toolkit v{__version__} loaded!")
''',
'core.py': '''
# 🎯 Core functionality
class ToolkitCore:
"""The heart of our toolkit 💚"""
def __init__(self):
self.power_level = 9000 # 🔥 It's over 9000!
print("🚀 ToolkitCore initialized!")
def do_magic(self):
return "✨ Magic performed! 🎩"
''',
'helpers.py': '''
# 🛠️ Helper functions
def magic_function(x):
"""Apply magical transformation 🪄"""
return x ** 2 + 42 # The answer to everything!
def super_helper(data):
"""Super helpful function 🦸"""
return f"🎯 Processed: {data}"
''',
'constants.py': '''
# 📊 Package constants
MAGIC_NUMBER = 42 # 🌟 The answer!
EMOJI_LIST = ["🚀", "✨", "🎯", "💡", "🏆"]
DEFAULT_TIMEOUT = 30 # seconds ⏱️
''',
'utils': {
'__init__.py': '''
# 🔧 Utilities subpackage
from .validators import validate_input
from .formatters import format_output
''',
'validators.py': '''
# ✅ Input validation
def validate_input(value):
"""Validate user input 🛡️"""
if not value:
raise ValueError("❌ Input cannot be empty!")
return True
''',
'formatters.py': '''
# 🎨 Output formatting
def format_output(data):
"""Format output beautifully 💅"""
return f"📦 {data} ✨"
'''
}
}
}
# 🏗️ Create the package
for package, contents in package_structure.items():
create_directory_structure(package, contents)
return package_structure
# 🎯 Create our advanced package
create_advanced_package()
# 🚀 Now let's use it!
import awesome_toolkit
# ✨ Use the convenient imports
toolkit = awesome_toolkit.ToolkitCore()
print(toolkit.do_magic())
# 🎯 Access everything we exposed
result = awesome_toolkit.magic_function(10)
print(f"Magic result: {result}")
# 📋 Check what's available
print(f"\n📦 Available in awesome_toolkit:")
for item in awesome_toolkit.__all__:
print(f" ✅ {item}")🏗️ PYTHONPATH Environment Variable
For permanent path modifications:
# 🌍 Working with PYTHONPATH
import os
import sys
import subprocess
# 📍 Check current PYTHONPATH
pythonpath = os.environ.get('PYTHONPATH', 'Not set')
print(f"🌍 Current PYTHONPATH: {pythonpath}")
# 🎯 Demonstrate PYTHONPATH usage
def demonstrate_pythonpath():
"""Show how PYTHONPATH affects module search 🔍"""
# 📁 Create a test structure
test_dir = 'pythonpath_demo'
os.makedirs(test_dir, exist_ok=True)
# 🎨 Create a module
module_content = '''
# 🌟 special_module.py
def greet():
return "👋 Hello from PYTHONPATH module!"
'''
with open(os.path.join(test_dir, 'special_module.py'), 'w') as f:
f.write(module_content)
# 🧪 Test 1: Without PYTHONPATH
print("\n🧪 Test 1: Importing without PYTHONPATH")
try:
import special_module
print("✅ Imported successfully!")
except ImportError:
print("❌ Import failed (expected)")
# 🧪 Test 2: With PYTHONPATH
print("\n🧪 Test 2: Importing with PYTHONPATH")
# 🔧 Create a test script
test_script = '''
import sys
print(f"🔍 Python is searching in: {sys.path[0:3]}...")
try:
import special_module
print(f"✅ Success! {special_module.greet()}")
except ImportError as e:
print(f"❌ Failed: {e}")
'''
with open('test_import.py', 'w') as f:
f.write(test_script)
# 🚀 Run with modified PYTHONPATH
env = os.environ.copy()
env['PYTHONPATH'] = test_dir
result = subprocess.run(
[sys.executable, 'test_import.py'],
env=env,
capture_output=True,
text=True
)
print("📋 Output with PYTHONPATH set:")
print(result.stdout)
# 🧹 Cleanup
os.remove('test_import.py')
# 🎮 Run the demonstration
demonstrate_pythonpath()
# 💡 Pro tip: Setting PYTHONPATH
print("\n💡 How to set PYTHONPATH:")
print("🐧 Linux/Mac: export PYTHONPATH=/path/to/modules:$PYTHONPATH")
print("🪟 Windows: set PYTHONPATH=C:\\path\\to\\modules;%PYTHONPATH%")⚠️ Common Pitfalls and Solutions
😱 Pitfall 1: Circular Imports
# ❌ Wrong way - circular import nightmare!
# file: module_a.py
# from module_b import function_b # 💥 This creates a circle!
# def function_a():
# return function_b()
# file: module_b.py
# from module_a import function_a # 💥 Circle complete!
# def function_b():
# return function_a()
# ✅ Correct way - break the circle!
# file: module_a.py
def function_a():
from module_b import function_b # 🎯 Import when needed
return function_b()
# file: module_b.py
def function_b():
return "✨ No circular import!"
# 🛡️ Or restructure your code
# file: shared_functions.py
def shared_function():
return "🎯 Shared functionality!"
# Both modules can safely import from shared_functions🤯 Pitfall 2: Name Conflicts
# ❌ Dangerous - module name conflicts!
# Don't name your file 'math.py' if you need the built-in math module
import os
# 🎯 Demonstrate the problem
conflict_code = '''
# math.py - This shadows the built-in math module! 😱
def sqrt(x):
return "🚫 This is not the real sqrt!"
'''
# ✅ Safe way - use unique names!
safe_code = '''
# my_math_utils.py - Clear, unique name! ✨
import math # Can still use built-in math
def custom_sqrt(x):
"""Our custom square root with emojis! 🎯"""
result = math.sqrt(x)
return f"√{x} = {result} 🎉"
'''
print("📋 Module naming best practices:")
print("✅ Use descriptive, unique names")
print("✅ Avoid built-in module names")
print("✅ Use underscores for multi-word names")
print("❌ Don't use: math.py, string.py, sys.py")
print("✅ Do use: my_math.py, string_utils.py, system_helpers.py")🐛 Pitfall 3: Relative Import Confusion
# ❌ Wrong - confusing relative imports
# from ..parent_module import something # 💥 Can fail in scripts!
# ✅ Correct - clear import strategy
print("📦 Package structure for relative imports:")
print("""
my_package/
__init__.py
core/
__init__.py
module_a.py # from . import module_b ✅
module_b.py # from ..utils import helper ✅
utils/
__init__.py
helper.py
""")
# 🎯 Best practice for scripts vs packages
print("\n🎯 Import best practices:")
print("📄 For scripts: Use absolute imports")
print("📦 For packages: Use relative imports within the package")
print("🚀 For clarity: Always use absolute imports when possible")🛠️ Best Practices
- 📁 Organize with Packages: Group related modules in directories with
__init__.py - 📝 Clear Module Names: Use descriptive names that indicate purpose
- 🛡️ Avoid Name Conflicts: Never shadow built-in module names
- 🎯 Use Virtual Environments: Keep project dependencies isolated
- ✨ Document Your Modules: Add docstrings to modules and functions
# 🎯 Example of well-organized project
print("""
📁 Best Project Structure:
my_project/
📄 README.md # 📖 Project documentation
📄 requirements.txt # 📦 Dependencies
📄 setup.py # 🚀 Package setup
📁 src/ # 💻 Source code
📁 my_package/
📄 __init__.py
📄 core.py # 🎯 Core functionality
📄 utils.py # 🛠️ Utilities
📁 tests/ # 🧪 Test files
📄 test_core.py
📄 test_utils.py
📁 docs/ # 📚 Documentation
📄 getting_started.md
📄 api_reference.md
""")🧪 Hands-On Exercise
🎯 Challenge: Build a Plugin System
Create a dynamic plugin system that loads modules on demand:
📋 Requirements:
- ✅ Plugin directory that’s automatically scanned
- 🏷️ Each plugin has name, version, and execute() method
- 👤 Plugin registration system
- 📊 Plugin dependency management
- 🎨 Each plugin has its own emoji identifier!
🚀 Bonus Points:
- Add plugin enable/disable functionality
- Implement plugin configuration files
- Create a plugin marketplace simulator
💡 Solution
🔍 Click to see solution
# 🎯 Dynamic Plugin System
import os
import json
import importlib.util
from abc import ABC, abstractmethod
class Plugin(ABC):
"""Base plugin class 🔌"""
@abstractmethod
def execute(self):
pass
@property
@abstractmethod
def name(self):
pass
@property
@abstractmethod
def version(self):
pass
@property
@abstractmethod
def emoji(self):
pass
class PluginManager:
"""Manage plugins dynamically 🎮"""
def __init__(self, plugin_dir='plugins'):
self.plugin_dir = plugin_dir
self.plugins = {}
self.enabled_plugins = set()
# 📁 Create plugin directory
os.makedirs(plugin_dir, exist_ok=True)
# 📄 Load configuration
self.config_file = os.path.join(plugin_dir, 'config.json')
self.load_config()
print(f"🔌 Plugin Manager initialized!")
print(f"📁 Plugin directory: {os.path.abspath(self.plugin_dir)}")
def load_config(self):
"""Load plugin configuration 📋"""
if os.path.exists(self.config_file):
with open(self.config_file, 'r') as f:
config = json.load(f)
self.enabled_plugins = set(config.get('enabled', []))
else:
self.save_config()
def save_config(self):
"""Save plugin configuration 💾"""
config = {
'enabled': list(self.enabled_plugins)
}
with open(self.config_file, 'w') as f:
json.dump(config, f, indent=2)
def create_plugin(self, name, code):
"""Create a new plugin file 🎨"""
filename = f"{name.lower().replace(' ', '_')}_plugin.py"
filepath = os.path.join(self.plugin_dir, filename)
with open(filepath, 'w') as f:
f.write(code)
print(f"✅ Created plugin: {name} ({filename})")
return filename
def discover_plugins(self):
"""Discover all available plugins 🔍"""
self.plugins.clear()
for filename in os.listdir(self.plugin_dir):
if filename.endswith('_plugin.py'):
self._load_plugin(filename)
print(f"\n📊 Discovered {len(self.plugins)} plugins!")
return self.plugins
def _load_plugin(self, filename):
"""Load a single plugin 📦"""
filepath = os.path.join(self.plugin_dir, filename)
plugin_name = filename[:-10] # Remove '_plugin.py'
try:
# 🎯 Load the module
spec = importlib.util.spec_from_file_location(
plugin_name, filepath
)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
# 🔍 Find Plugin subclasses
for attr_name in dir(module):
attr = getattr(module, attr_name)
if (isinstance(attr, type) and
issubclass(attr, Plugin) and
attr is not Plugin):
plugin_instance = attr()
self.plugins[plugin_name] = plugin_instance
print(f"✅ Loaded: {plugin_instance.emoji} {plugin_instance.name} v{plugin_instance.version}")
break
except Exception as e:
print(f"❌ Failed to load {filename}: {e}")
def enable_plugin(self, plugin_name):
"""Enable a plugin 🟢"""
if plugin_name in self.plugins:
self.enabled_plugins.add(plugin_name)
self.save_config()
print(f"🟢 Enabled: {self.plugins[plugin_name].name}")
else:
print(f"❌ Plugin not found: {plugin_name}")
def disable_plugin(self, plugin_name):
"""Disable a plugin 🔴"""
if plugin_name in self.enabled_plugins:
self.enabled_plugins.remove(plugin_name)
self.save_config()
print(f"🔴 Disabled: {self.plugins[plugin_name].name}")
def execute_plugin(self, plugin_name):
"""Execute a specific plugin 🚀"""
if plugin_name not in self.plugins:
print(f"❌ Plugin not found: {plugin_name}")
return
if plugin_name not in self.enabled_plugins:
print(f"⚠️ Plugin is disabled: {plugin_name}")
return
plugin = self.plugins[plugin_name]
print(f"\n🎯 Executing: {plugin.emoji} {plugin.name}")
return plugin.execute()
def execute_all_enabled(self):
"""Execute all enabled plugins 🎆"""
print(f"\n🎆 Executing all enabled plugins...")
for plugin_name in self.enabled_plugins:
if plugin_name in self.plugins:
self.execute_plugin(plugin_name)
def list_plugins(self):
"""List all plugins with status 📋"""
print("\n📋 Plugin Status:")
for name, plugin in self.plugins.items():
status = "🟢 Enabled" if name in self.enabled_plugins else "🔴 Disabled"
print(f" {plugin.emoji} {plugin.name} v{plugin.version} - {status}")
# 🎨 Create some example plugins
manager = PluginManager()
# 🎯 Plugin 1: Greeting Plugin
greeting_plugin = '''
from plugin_system import Plugin
class GreetingPlugin(Plugin):
@property
def name(self):
return "Greeting Master"
@property
def version(self):
return "1.0.0"
@property
def emoji(self):
return "👋"
def execute(self):
greetings = ["Hello!", "Hi there!", "Greetings!", "Welcome!"]
import random
greeting = random.choice(greetings)
print(f" {self.emoji} {greeting} This is the Greeting Plugin!")
return greeting
'''
# 🎲 Plugin 2: Fortune Plugin
fortune_plugin = '''
from plugin_system import Plugin
class FortunePlugin(Plugin):
@property
def name(self):
return "Fortune Teller"
@property
def version(self):
return "2.1.0"
@property
def emoji(self):
return "🔮"
def execute(self):
fortunes = [
"Today brings new opportunities! 🌟",
"Your code will run perfectly! 💻",
"A bug will reveal itself to you! 🐛",
"Documentation will save the day! 📚"
]
import random
fortune = random.choice(fortunes)
print(f" {self.emoji} {fortune}")
return fortune
'''
# 📊 Plugin 3: Stats Plugin
stats_plugin = '''
from plugin_system import Plugin
import datetime
class StatsPlugin(Plugin):
@property
def name(self):
return "System Stats"
@property
def version(self):
return "3.0.5"
@property
def emoji(self):
return "📊"
def execute(self):
stats = {
"time": datetime.datetime.now().strftime("%H:%M:%S"),
"date": datetime.datetime.now().strftime("%Y-%m-%d"),
"python": "3.x"
}
print(f" {self.emoji} Current Stats:")
for key, value in stats.items():
print(f" {key}: {value}")
return stats
'''
# 🚀 Create and manage plugins
manager.create_plugin("greeting", greeting_plugin)
manager.create_plugin("fortune", fortune_plugin)
manager.create_plugin("stats", stats_plugin)
# 🔍 Discover plugins
manager.discover_plugins()
# 📋 List all plugins
manager.list_plugins()
# 🟢 Enable some plugins
manager.enable_plugin("greeting")
manager.enable_plugin("fortune")
# 🎆 Execute all enabled
manager.execute_all_enabled()
# 🎯 Execute specific plugin
manager.execute_plugin("stats")🎓 Key Takeaways
You’ve learned so much! Here’s what you can now do:
- ✅ Understand Python’s module search path with confidence 💪
- ✅ Create and organize packages like a pro 📦
- ✅ Debug import errors quickly and effectively 🐛
- ✅ Build modular applications with clean architecture 🏗️
- ✅ Develop plugin systems and dynamic loaders! 🚀
Remember: Good module organization is the foundation of maintainable Python code! 🤝
🤝 Next Steps
Congratulations! 🎉 You’ve mastered Python paths and module search!
Here’s what to do next:
- 💻 Practice creating your own package structure
- 🏗️ Build a small project with multiple modules
- 📚 Move on to our next tutorial: Python Package Distribution
- 🌟 Share your modular projects with the community!
Remember: Every Python expert started by understanding how imports work. Keep organizing, keep modularizing, and most importantly, have fun! 🚀
Happy coding! 🎉🚀✨