Preface
After mastering Python classes and objects, the next step is to deeply understand modular development and exception handling. Modules and packages help us organize our code and enhance the maintainability and reusability of our code, while exception handling is an important skill in writing robust code. This article will systematically explain the core concepts and practical techniques of modules, packages and exception handling in Python.
1. Module: The basic unit of code organization
1.1 What is a module?
Module is the basic unit used in Python to organize code, a.pyA file is a module. Through modules, we can put the code of related functions together for easy reuse and maintenance.
For example, a name ismath_utils.pyThe module may contain some mathematical related functions:
# math_utils.py
def add(a, b):
return a + b
def subtract(a, b):
return a - b
1.2 How to import modules?
Python usageimportKeyword import module. The following are common import methods:
# Import the entire moduleimport math_utils print(math_utils.add(2, 3)) # Output: 5 # Import specific functions in the modulefrom math_utils import subtract print(subtract(5, 2)) # Output: 3 # Import with an aliasimport math_utils as mu print((4, 6)) # Output: 10
1.3 Python built-in modules
The Python standard library contains many built-in modules, such as:
-
math: Provide mathematical functions. -
os: Operating system interface. -
random: Random number generation. -
datetime: Processing date and time.
import math import random print((16)) # Output: 4.0print((1, 10)) # Output: Random integers between 1 and 10
2. Package: Collection of modules
2.1 What is a package?
Packages are collections of multiple modules for building larger-scale projects. A package is a contains__init__.pyThe directory of the file.
The structure of the package is as follows:
my_package/
__init__.py
math_utils.py
string_utils.py
2.2 Creating and using packages
Create a package:
# File structuremy_package/
__init__.py
math_utils.py
string_utils.py
# math_utils.py
def add(a, b):
return a + b
# string_utils.py
def to_uppercase(s):
return ()
Import package:
# Import modules in the entire packagefrom my_package import math_utils, string_utils
print(math_utils.add(3, 4)) # Output: 7print(string_utils.to_uppercase("hello")) #Output: HELLO
# Import specific functions from modulesfrom my_package.math_utils import add
print(add(5, 6)) #Output: 113. Exception handling: write robust code
3.1 What is an exception?
Exception is an error that occurs when the program is running. For example, dividing by zero will causeZeroDivisionError, accessing undefined variables will causeNameError。
print(10 / 0) # ZeroDivisionError: division by zero print(undefined_variable) # NameError: name 'undefined_variable' is not defined
3.2 Catch exceptions
usetry-exceptStatements catch and handle exceptions to avoid program crashes.
try:
print(10 / 0)
except ZeroDivisionError:
print("Cannot divide by zero!") # Output: Cannot divide by zero!3.3 Catch multiple exceptions
Multiple types of exceptions can be caught simultaneously.
try:
print(undefined_variable)
except (ZeroDivisionError, NameError) as e:
print(f"An error occurred: {e}")
3.4 Using else and finally
-
else: Execute when there is no exception. -
finally: Whether there is an exception or not, it will be executed.
try:
result = 10 / 2
except ZeroDivisionError:
print("Cannot divide by zero!")
else:
print(f"Result is {result}") # Output: Result is 5.0finally:
print("Execution completed.") # Output: Execution completed.3.5 Custom exceptions
Can be inheritedExceptionClass creates a custom exception.
class CustomError(Exception):
pass
def check_positive(value):
if value < 0:
raise CustomError("Value must be positive!")
try:
check_positive(-10)
except CustomError as e:
print(e) # Output: Value must be positive!4. Practical combat: build modular applications
Suppose we want to develop a simple calendar tool that supports the following features:
- Add an event.
- List events.
- Delete the event.
Project structure:
calendar_app/
__init__.py
event_manager.py
event_manager.py
class EventManager:
def __init__(self):
= []
def add_event(self, event):
(event)
def list_events(self):
return
def delete_event(self, event):
if event in :
(event)
else:
raise ValueError("Event not found!")
def format_event(event):
return f"Event: {event}"
Main program:
from calendar_app.event_manager import EventManager
from calendar_app.utils import format_event
manager = EventManager()
# Add eventsmanager.add_event("Meeting at 10 AM")
manager.add_event("Lunch at 12 PM")
# List eventsevents = manager.list_events()
for event in events:
print(format_event(event)) # Format output events
# Delete Eventmanager.delete_event("Lunch at 12 PM")
print(manager.list_events()) # Output: ['Meeting at 10 AM']V. Best Practices
- Modular code: Split the code into logically clear modules or packages for easy reuse and maintenance.
-
Elegant exception handling: Catch specific exceptions and avoid using naked
exceptStatement. - Keep the directory clean: Reasonably organize project structure and use packages to manage complex projects.
- Write test code: Write unit tests for modules and functions to ensure code quality.
Summarize
Modules and packages are the cornerstones of Python code organization, which make the code clearer and easier to maintain. Exception handling is an important tool to improve code robustness. By understanding and applying these features, you can develop more efficient and reliable Python applications.
This is the article about the advanced Python modules, packages and exception handling. For more related Python modules, packages and exception handling content, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!