Python module import to implement the functions you need

Modules allow you to logically organize your Python code snippets.

Assigning related code to a module can make your code more usable and easier to understand.

Modules are also Python objects with random names Attributes used for binding or reference.

Simply put, a module is a file that stores Python code. Modules can define functions, classes and variables. Modules can also contain executable code.

Example

The Python code in a module called aname can usually be found in a file called aname.py. The following example is a simple module support.py.

def print_func( par ):

print "Hello : ", par

import statement

Want to use Python source file, just execute the import statement in another source file, the syntax is as follows:

import module1[, module2[,... moduleN]

When explained When the compiler encounters an import statement, the module will be imported if it is in the current search path.

The search path is a list of all directories that the interpreter will search first. If you want to import the module hello.py, you need to put the command at the top of the script:

#!/usr/bin/python

# Import module

import support

# Now you can call the functions contained in the module

support.print_func("Zara")

The output result of the above example:

Hello: Zara.

A module will only be imported once, no matter how many times you execute the import. This prevents imported modules from being executed over and over again.

---

From...import statement

Python's from statement allows you to import a specified part from a module into the current namespace . The syntax is as follows:

>>>from modname import name1[, name2[, ... nameN]]

For example, to import the fibonacci function of module fib, use the following statement:

>>>from fib import fibonacci

This statement will not import the entire fib module into the current namespace, it will only introduce a single fibonacci in fib into the execution The global symbol table of this declared module.

---

From…import * statement

It is also feasible to import all the contents of a module into the current namespace, just use the following statement:

> ;>>from mod_name import *

This provides an easy way to import all projects in a module. However, this statement should not be overused.

---

Locating modules

When you import a module, the Python parser searches for the module location in the following order:

• Current directory

• If it is not in the current directory, Python searches every directory under the shell variable PYTHONPATH

• .

• If neither is found, Python will check the default path. Under UNIX, the default path is generally /usr/local/lib/python/

. The module search path is stored in the sys.path variable of the system module. The variables include the current directory, PYTHONPATH and the default directory determined by the installation process.

---

PYTHONPATH variable

As an environment variable, PYTHONPATH consists of many directories installed in a list. The syntax of PYTHONPATH is the same as that of the shell variable PATH.

In Windows systems, the typical PYTHONPATH is as follows:

set PYTHONPATH=c:\python20\lib;

In UNIX systems, the typical PYTHONPATH is as follows:

set PYTHONPATH=/usr/local/lib/python

Namespace and scope

Variables are names (identifiers) that have matching objects. A namespace is a dictionary containing variable names (keys) and their corresponding objects (values). A Python

expression

can access variables in the local namespace and global namespace. If a local variable has the same name as a global variable, the local variable overrides the global variable. Each function has its own namespace. The scoping rules for class methods are the same as for regular functions.

Python will intelligently guess whether a variable is local or global, assuming that any variable assigned within a function is local.

Therefore, if you want to assign a value to a global variable in a function, you must use the global statement.

The expression of global VarName will tell Python that VarName is a global variable, so that Python will not look for this variable in the local namespace.

For example, we define a variable money in the global namespace. We then assign a value to the variable money within the function, and then Python will assume that money is a local variable. However, we did not declare a local variable money before accessing it, and the result is an UnboundLocalError. This problem can be solved by canceling the comment of the global statement.

>>>#!/usr/bin/python

>>>Money = 2000

>>>def AddMoney( ):

# If you want to correct the code, uncomment the following:

# global Money

Money = Money + 1

>>>print Money

>>>AddMoney()

>>>print Money

dir() function

# The ##dir() function is an ordered

string list, the content is the name defined in a module.

The returned list contains all modules, variables and functions defined in a module. Here is a simple example:

>>>#!/usr/bin/python

>>># Import the built-in math module

> ;>>import math

>>>content = dir(math)

>>>print content;

The above example output result ：

['doc', '

file', 'name', 'acos', 'asin', 'atan',

'atan2', 'ceil ', 'cos', 'cosh', 'degrees', 'e', ​​'exp',

'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp ', 'log',

'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh',

'sqrt', 'tan', 'tanh']

Here,

Special charactersThe string variable name points to the name of the module, and file points to the name of the imported file of the module.

---

globals() and locals() functions

Depending on where they are called, the globals() and locals() functions can be used to return names in the global and local namespaces .

If locals() is called inside a function, all names that can be accessed in the function will be returned.

If globals() is called inside a function, all global names that can be accessed in the function will be returned.

The return types of both functions are dictionaries. So the names can be extracted using the keys() function.

reload() function

When a module is imported into a script, the code in the top-level part of the module will only be executed once.

Therefore, if you want to re-execute the top-level code in the module, you can use the reload() function. This function re-imports previously imported modules. The syntax is as follows:

>>>reload(module_name)

Here, module_name should directly put the name of the module instead of a string form. For example, if you want to reload the hello module, as follows:

>>>reload(hello)

Package in Python

The package is a A hierarchical file directory structure, which defines a Python application environment consisting of modules and sub-packages, and sub-packages under sub-packages.

Consider a pots.py file in the Phone directory. This file has the following source code:

>>>#!/usr/bin/python

>>>def Pots():

print "I'm Pots Phone"

Similarly, we have two other files that hold different functions:

##Phone/Isdn.py contains the function Isdn( )
Phone/G3.py contains function G3()
Now, create file init.py in the Phone directory:

Phone/init.py
When you import Phone, in order to use all functions, you need to use explicit imports in init.py Statement, as follows:

>>>from Pots import Pots

>>>from Isdn import Isdn

>>>from G3 import G3

After you add these codes to init.py, all these classes will be available when importing the Phone package.

>>>#!/usr/bin/python

>>># Now import your Phone Package.

>>> ;import Phone

>>>Phone.Pots()

>>>Phone.Isdn()

>>>Phone .G3()

Output result of the above example:

I'm Pots Phone

I'm 3G Phone

I'm ISDN Phone

As above, for the sake of example, we only placed in each file One function, but you can actually put many functions. You can also define Python classes in these files and then build a package for these classes.

The above is the detailed content of Python module import to implement the functions you need. For more information, please follow other related articles on the PHP Chinese website!