PYTHON MODULES:
 |
| Python Modules |
Code Organization: Modules are a way to organize your Python code. They allow you to group related functions, classes, and variables together in separate files.
File-Based: Each module corresponds to a single .py file. The name of the module is the filename without the .py extension.
Namespace: A module creates its own namespace. All the functions, classes, and variables defined in the module are contained within this namespace.
Importing: You can use the import statement to bring the definitions from a module into another module or script. This makes the code in the module available for use.
Accessing Definitions: You access definitions from an imported module using the module's name as a prefix, like module_name.definition_name.
Function and Variable Reusability: Modules promote code reusability. You can define functions and variables in a module and use them across different parts of your program.
Module Namespacing: Modules prevent naming conflicts by providing a separate namespace. You can have multiple modules with functions or variables of the same name, and they won't interfere with each other.
Encapsulation: Modules allow you to encapsulate related code together. This helps in making code more organized, readable, and maintainable.
Standalone Execution: Modules can be executed as standalone scripts or used as imported libraries. The __name__ attribute is used to distinguish whether a module is being executed directly or imported.
Standard Library: Python's standard library includes a variety of modules for common tasks like file I/O, string manipulation, math operations, networking, etc.
Third-Party Libraries: You can extend Python's capabilities by using third-party libraries. These libraries are essentially modules created by other developers to solve specific problems.
Sharing Code: Modules allow you to share code between different projects or with other developers. This promotes code sharing and collaboration.
Documentation and Readability: Well-structured modules with proper docstrings (documentation strings) enhance the readability of your code and make it easier for others (and your future self) to understand.
IMPORT STATEMENT:
SYNTAX:
Import with Alias: You can provide an alias (shorter name) to the module using the keyword. This is useful for modules with long names:
EXAMPLE:
import math_operations as mo
result = mo.add(3, 5)
Import Specific Definitions: If you only need specific functions or variables from a module, We can import them directly.
EXAMPLE:
from math_operations import add, subtract
result_add = add(3, 5)
result_sub = subtract(10, 4)
Import All Definitions: You can import all definitions from a module using the '*' wildcard. However, this is generally discouraged because it can lead to namespace pollution and naming conflicts.
EXAMPLE:
from math_operations import *
result_add = add(3, 5)
result_sub = subtract(10, 4)
Importing Standard Library Modules: Python comes with a rich set of standard library modules. You can import them just like any other module.
EXAMPLE:
import math
sqrt_result = math.sqrt(25)
FROM........IMPORT........STATEMENT:
EXAMPLE:
DIR( ) FUNCTION:
SYNTAX:
dir(object)
- 'object': The object you want to inspect. It can be a module, class, instance, or any other Python object.
When you call dir() with an object, it returns a list of names that represent the attributes and methods associated with that object. This includes both the names defined in the object and the names inherited from its classes or superclasses.
EXAMPLE:
PYTHON PACKAGE:
EXAMPLE:
my_package/
├── __init__.py
├── module1.py
├── module2.py
└── subpackage/
├── __init__.py
├── submodule1.py
└── submodule2.py
NAMESPACES AND SCOPING:
Namespaces and scoping are fundamental concepts in Python that help manage the visibility and accessibility of variables, functions, classes, and other objects in your code. They ensure that names are organized and don't conflict with each other, allowing you to create modular and organized code.
1. Namespace:
A namespace is a container that holds a set of identifiers (names) and their corresponding objects. It acts as a mapping between names and the objects they refer to. Namespaces prevent naming conflicts and provide a way to group related names together.
- Built-in Namespace: Contains all the built-in functions and objects like print(), len(), int, str, etc.
- Global Namespace: This is the namespace at the top level of a module or script. It contains all the names defined at the module level.
- Local Namespace: Created when a function is called. It contains the function's parameters and local variables.
- Enclosing Namespace: Pertains to nested functions. It contains the variables of the enclosing (outer) function.
- Class Namespace: Contains class-level attributes and methods.
- Instance Namespace: Contains instance-level attributes and methods.
2. Scoping:
Scoping refers to the region of your code where a particular namespace is accessible. Python uses indentation (whitespace) to define the scope of various blocks of code. Scopes help determine which namespace should be used when a name is referenced.
- Local Scope: The innermost scope, defined within a function. Local variables are only accessible within the function they are defined in.
- Enclosing Scope: Pertains to nested functions. The enclosing scope of an inner function is the scope of the outer function.
- Global Scope: The top-level scope of a module or script. Variables defined at this level are accessible throughout the module.
3. LEGB Rule:
Python follows the LEGB rule to determine the order in which it searches for names:
- Local: Search in the local scope.
- Enclosing: Search in the enclosing scopes (nested functions).
- Global: Search in the global scope.
- Built-in: Search in the built-in namespace.
EXAMPLE:
x = 10 # Global namespace
def outer_function():
y = 20 # Enclosing namespace
def inner_function():
z = 30 # Local namespace
print(x, y, z) # Accessing variables from different namespaces
inner_function()
outer_function()
){kind=link}
0 Comments