首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享
    首页 > Python3教程 > Python3 模块

Python3 模块的引用

import 语句

Python本身就内置了模块,只要安装完毕,这些模块就能使用

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

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

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

一个模块只会被导入一次,不管执行了多少次import。防止模块被多次导入。

使用import语句的时候,Python解释器找对应的文件的过程:

这就涉及到Python的搜索路径,搜索路径是由一系列目录名组成的,Python解释器就依次从这些目录中去寻找所引入的模块。

事实上,也能通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量

 

使用 python 标准库中模块

import sys  #引入 python 标准库中的 sys.py 模块

print('命令行参数如下:')
for i in sys.argv: #sys.argv 包含命令行参数的列表
print(i)

#包含Python 解释器自动查找所需模块的路径的列表
print('\n\nPython 程序相关路径为:', sys.path, '\n')

输出

"D:\Program Files\python\python.exe" E:/python_pro/index.py

命令行参数如下:

E:/python_pro/index.py

Python程序相关路径为: ['E:\\python_pro', 'E:\\python_pro', 'D:\\Program Files\\python\\python36.zip', 'D:\\Program Files\\python\\DLLs',

'D:\\Program Files\\python\\lib', 'D:\\Program Files\\python', 'D:\\Program Files\\python\\lib\\site-packages'] 

sys模块有一个argv变量,用list存储了命令行的所有参数。argv至少有一个元素,就是该.py文件的名称

sys.path 输出是一个列表,其中第一项是空串'',代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),

也是我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。

 

使用自定义模块

own.py文件

#!/usr/bin/env python3   # 让本文件能直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*- # 表示.py文件本身使用标准UTF-8编码

' a own module ' # 字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释;

__author__ = 'yuqingqi python' # __author__变量表示模块作者

import sys

def getinput():
args = sys.argv # sys表示指向sys模块的变量
if len(args)==1:
print('Hello, world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('all')

# 在命令行运行own模块文件时,Python解释器把一个特殊变量__name__置为__main__
# 所以,下面的if条件为真,执行模块的getinput函数
# 而如果在其他地方导入该own模块时,if判断将失败,一般用于模块的测试
if __name__=='__main__':
getinput()

index.py文件

import own  #引入自定义的模块

print('命令行参数:')
own.getinput()

输出:命令行参数:  Hello, world!

 

from…import 语句

每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。

被导入的模块的名称将被放入当前操作的模块的符号表中。

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

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

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

 

from…import* 语句

如果需要把一个模块的所有内容全都导入到当前的命名空间,使用如下声明:

from modname import *

 

__name__属性

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行

 

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

import sys

print(dir(sys))

输出:

['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames',

'_debugmallocstats', '_enablelegacywindowsfsencoding', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',

'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_wrapper',

'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace',

'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',

'set_asyncgen_hooks', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']

 

模块别名

导入模块时,还能使用别名,这样,在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,

这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你会经常看到这样的写法:

try:

    import cStringIO as StringIO

except ImportError: # 导入失败会捕获到ImportError

    import StringIO

这样就优先导入cStringIO。如果有些平台不提供cStringIO,还可以降级使用StringIO。

导入cStringIO时,用import ... as ...指定了别名StringIO,因此,后续代码引用StringIO即正常工作。

还有类似simplejson这样的库,在python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法:

try:

    import json # python >= 2.6

except ImportError:

    import simplejson as json # python <= 2.5

由于Python是动态语言,函数签名一致,接口就一样,因此,无论导入哪个模块后续代码都能正常工作。

Python3 模块的引用-Python3 模块-编程文章分享