Python基础语法-菜鸟教程-第16章：Python3 模块

学习网址：https://www.runoob.com/python/python-basic-syntax.html
运行代码后即可生成笔记

#代码如下：

import sys
# chapter16:Python3 模块
print("\nchapter16:Python3 模块\n")
print("1.概述")
print("1)在前面的几个章节中我们脚本上是用 python 解释器来编程，如果你从 Python 解释器退出再进入，那么你定义的所有的方法和变量就都消失了。为此 Python 提供了一个办法，把这些定义存放在文件中，为一些脚本或者交互式的解释器实例使用，这个文件被称为模块。")
print("2)模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。")
print("2.import语句")
print("1)想使用 Python 源文件，只需在另一个源文件里执行 import 语句，语法如下：\n"

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

print("2)当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块 support，需要把命令放在脚本的顶端：")

print("3)一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。")

print("4)当我们使用import语句的时候，Python解释器是怎样找到对应的文件的呢:\n"
      "这就涉及到Python的搜索路径，搜索路径是由一系列目录名组成的，Python解释器就依次从这些目录中去寻找所引入的模块。\n"
      "这看起来很像环境变量，事实上，也可以通过定义环境变量的方式来确定搜索路径。\n"
      "搜索路径是在Python编译或安装的时候确定的，安装新的库应该也会修改。\n"
      "搜索路径被存储在sys模块中的path变量\n")
print("eg:")
print(">>> import sys\n"
">>> sys.path\n"
"['', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']\n"
">>> ")
print("5)可以使用模块名称来访问函数")
print("eg:")
print(">>> import fibo\n"
      ">>>fibo.fib(1000)\n"
"1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987\n"
">>> fibo.fib2(100)\n"
"[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]\n"
">>> fibo.__name__\n"
"'fibo'")
print("3.from … import 语句")
print("1)Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中，语法如下：\n"

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

print("2)eg:例如，要导入模块 fibo 的 fib 函数，使用如下语句：")
print(">>> from fibo import fib, fib2\n"
">>> fib(500)\n"
"1 1 2 3 5 8 13 21 34 55 89 144 233 377")
print("解析：这个声明不会把整个fibo模块导入到当前的命名空间中，它只会将fibo里的fib函数引入进来。")

print("4.from … import * 语句")
print("1)把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：\n"

"from modname import *")

print("5.深入模块")
print("1)模块除了方法定义，还可以包括可执行的代码。这些代码一般用来初始化这个模块。这些代码只有在第一次被导入时才会被执行。")
print("2)每个模块有各自独立的符号表，在模块内部为所有的函数当作全局符号表来使用。")
print("3)从另一个方面，当你确实知道你在做什么的话，你也可以通过 modname.itemname 这样的表示法来访问模块内的函数。")
print("4)模块是可以导入其他模块的。在一个模块（或者脚本，或者其他地方）的最前面使用 import 来导入一个模块，当然这只是一个惯例，而不是强制的。被导入的模块的名称将被放入当前操作的模块的符号表中。")
print("5)还有一种导入的方法，可以使用 import 直接把模块内（函数，变量的）名称导入到当前操作模块。这种导入的方法不会把被导入的模块的名称放在当前的字符表中（所以在这个例子里面，fibo 这个名称是没有定义的）。")
print("eg:")
print(">>> from fibo import fib, fib2\n"
">>> fib(500)\n"
"1 1 2 3 5 8 13 21 34 55 89 144 233 377")
print("6)还有一种方法，可以一次性的把模块中的所有（函数，变量）名称都导入到当前模块的字符表:")
print("eg:")
print(">>> from fibo import *\n"
">>> fib(500)\n"
"1 1 2 3 5 8 13 21 34 55 89 144 233 377")
print("解析：这将把所有的名字都导入进来，但是那些由单一下划线（_）开头的名字不在此例。大多数情况， Python程序员不使用这种方法，因为引入的其它来源的命名，很可能覆盖了已有的定义。")
print("6.__name__属性")
print("1)一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。")
print("eg:")
print("#!/usr/bin/python3\n"
"# Filename: using_name.py\n"

"if __name__ == '__main__':\n"
      "   print('程序自身在运行')\n"
      "else:\n"
      "   print('我来自另一模块')")
print("\n运行结果如下：")
print("$ python using_name.py\n"
"程序自身在运行\n"
"$ python\n"
">>> import using_name\n"
"我来自另一模块\n"
">>>")
print("说明： 每个模块都有一个__name__属性，当其值是'__main__'时，表明该模块自身在运行，否则是被引入。__name__ 与 __main__ 底下是双下划线")
print("7.dir() 函数")
print("1)内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回:")
print("eg:")
print(">>> import fibo, sys\n"
">>> dir(fibo)\n"
"['__name__', 'fib', 'fib2']\n"
">>> dir(sys)\n"  
"['__displayhook__', '__doc__', '__excepthook__', '__loader__', '__name__',\n"
" '__package__', '__stderr__', '__stdin__', '__stdout__',\n"
" '_clear_type_cache', '_current_frames', '_debugmallocstats', '_getframe',\n"
" '_home', '_mercurial', '_xoptions', 'abiflags', 'api_version', 'argv',\n"
" 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder',\n"
" 'call_tracing', 'callstats', 'copyright', 'displayhook',\n"
" 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix',\n"
" 'executable', 'exit', 'flags', 'float_info', 'float_repr_style',\n"
" 'getcheckinterval', 'getdefaultencoding', 'getdlopenflags',\n"
" 'getfilesystemencoding', 'getobjects', 'getprofile', 'getrecursionlimit',\n"
" 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettotalrefcount',\n"
" 'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',\n"
" 'intern', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path',\n"
" 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1',\n"
" 'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit',\n"
" 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout',\n"
" 'thread_info', 'version', 'version_info', 'warnoptions']")
print("2)如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称:")
print("eg:")
print(">>> a = [1, 2, 3, 4, 5]\n"
">>> import fibo\n"
">>> fib = fibo.fib\n"
">>> dir() # 得到一个当前模块中定义的属性列表\n"
"['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']\n"
">>> a = 5 # 建立一个新的变量 'a'\n"
">>> dir()\n"
"['__builtins__', '__doc__', '__name__', 'a', 'sys']\n"
">>>\n"
">>> del a # 删除变量名a\n"
">>>\n"
">>> dir()\n"
"['__builtins__', '__doc__', '__name__', 'sys']\n"
">>>")
print("8.标准模块")
print("1)Python 本身带着一些标准的模块库，在 Python 库参考文档中将会介绍到（就是后面的\"库参考文档\"）。")
print("2)有些模块直接被构建在解析器里，这些虽然不是一些语言内置的功能，但是他却能很高效的使用，甚至是系统级调用也没问题。")
print("3)这些组件会根据不同的操作系统进行不同形式的配置，比如 winreg 这个模块就只会提供给 Windows 系统。")
print("4)应该注意到这有一个特别的模块 sys ，它内置在每一个 Python 解析器中。变量 sys.ps1 和 sys.ps2 定义了主提示符和副提示符所对应的字符串:")
print("eg:")
print(">>> import sys\n"
">>> sys.ps1\n"
"'>>> '\n"
">>> sys.ps2\n"
"'... '\n"
">>> sys.ps1 = 'C> '\n"
"C> print('Runoob!')\n"
"Runoob!\n"
"C> ")
print("9.包")
print("1)包是一种管理 Python 模块命名空间的形式，采用\"点模块名称\"。")
print("2)比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B 。")
print("3)在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。")
print("4)目录只有包含一个叫做 __init__.py 的文件才会被认作是一个包，主要是为了避免一些滥俗的名字（比如叫做 string）不小心的影响搜索路径中的有效模块。")
print("5)用户可以每次只导入一个包里面的特定模块，比如:import sound.effects.echo")
print("解析：这将会导入子模块:sound.effects.echo。 他必须使用全名去访问:\n"
"sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)")
print("6)还有一种导入子模块的方法是:from sound.effects import echo")
print("解析：这同样会导入子模块: echo，并且他不需要那些冗长的前缀，所以他可以这样使用:\n"

"echo.echofilter(input, output, delay=0.7, atten=4)")
print("7)还有一种变化就是直接导入一个函数或者变量:from sound.effects.echo import echofilter")
print("解析：同样的，这种方法会导入子模块: echo，并且可以直接使用他的 echofilter() 函数:\n"

"echofilter(input, output, delay=0.7, atten=4)")
print("8)注意事项")
print("(1)注意当使用 from package import item 这种形式的时候，对应的 item 既可以是包里面的子模块（子包），或者包里面定义的其他名称，比如函数，类或者变量。")
print("(2)import 语法会首先把 item 当作一个包定义的名称，如果没找到，再试图按照一个模块去导入。如果还没找到，抛出一个 :exc:ImportError 异常。")
print("(3)反之，如果使用形如 import item.subitem.subsubitem 这种导入形式，除了最后一项，都必须是包，而最后一项则可以是模块或者是包，但是不可以是类，函数或者变量的名字。")
print("10.从一个包中导入*")
print("1)导入语句遵循如下规则：如果包定义文件 __init__.py 存在一个叫做 __all__ 的列表变量，那么在使用 from package import * 的时候就把这个列表中的所有名字作为包内容导入。")
print("2)无论是隐式的还是显式的相对导入都是从当前模块开始的。主模块的名字永远是\"__main__\"，一个Python应用程序的主模块，应当总是使用绝对路径引用。")
print("3)包还提供一个额外的属性__path__。这是一个目录列表，里面每一个包含的目录都有为这个包服务的__init__.py，你得在其他__init__.py被执行前定义哦。可以修改这个变量，用来影响包含在包里面的模块和子包。")

#代码运行结果如下：

chapter16:Python3 模块

1.概述
1)在前面的几个章节中我们脚本上是用 python 解释器来编程，如果你从 Python 解释器退出再进入，那么你定义的所有的方法和变量就都消失了。为此 Python 提供了一个办法，把这些定义存放在文件中，为一些脚本或者交互式的解释器实例使用，这个文件被称为模块。
2)模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。
2.import语句
1)想使用 Python 源文件，只需在另一个源文件里执行 import 语句，语法如下：
import module1[, module2[,… moduleN]
2)当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块 support，需要把命令放在脚本的顶端：
3)一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。
4)当我们使用import语句的时候，Python解释器是怎样找到对应的文件的呢:
这就涉及到Python的搜索路径，搜索路径是由一系列目录名组成的，Python解释器就依次从这些目录中去寻找所引入的模块。
这看起来很像环境变量，事实上，也可以通过定义环境变量的方式来确定搜索路径。
搜索路径是在Python编译或安装的时候确定的，安装新的库应该也会修改。
搜索路径被存储在sys模块中的path变量

eg:

import sys
sys.path
[’’, ‘/usr/lib/python3.4’, ‘/usr/lib/python3.4/plat-x86_64-linux-gnu’, ‘/usr/lib/python3.4/lib-dynload’, ‘/usr/local/lib/python3.4/dist-packages’, ‘/usr/lib/python3/dist-packages’]

5)可以使用模块名称来访问函数
eg:

import fibo
fibo.fib(1000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

fibo.fib2(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

fibo.name
‘fibo’
3.from … import 语句
1)Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中，语法如下：
from modname import name1[, name2[, … nameN]]
2)eg:例如，要导入模块 fibo 的 fib 函数，使用如下语句：

from fibo import fib, fib2
fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
解析：这个声明不会把整个fibo模块导入到当前的命名空间中，它只会将fibo里的fib函数引入进来。
4.from … import * 语句
1)把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：
from modname import *
5.深入模块
1)模块除了方法定义，还可以包括可执行的代码。这些代码一般用来初始化这个模块。这些代码只有在第一次被导入时才会被执行。
2)每个模块有各自独立的符号表，在模块内部为所有的函数当作全局符号表来使用。
3)从另一个方面，当你确实知道你在做什么的话，你也可以通过 modname.itemname 这样的表示法来访问模块内的函数。
4)模块是可以导入其他模块的。在一个模块（或者脚本，或者其他地方）的最前面使用 import 来导入一个模块，当然这只是一个惯例，而不是强制的。被导入的模块的名称将被放入当前操作的模块的符号表中。
5)还有一种导入的方法，可以使用 import 直接把模块内（函数，变量的）名称导入到当前操作模块。这种导入的方法不会把被导入的模块的名称放在当前的字符表中（所以在这个例子里面，fibo 这个名称是没有定义的）。
eg:

from fibo import fib, fib2
fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
6)还有一种方法，可以一次性的把模块中的所有（函数，变量）名称都导入到当前模块的字符表:
eg:

from fibo import *
fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
解析：这将把所有的名字都导入进来，但是那些由单一下划线（_）开头的名字不在此例。大多数情况， Python程序员不使用这种方法，因为引入的其它来源的命名，很可能覆盖了已有的定义。
6.__name__属性
1)一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。
eg:
#!/usr/bin/python3

Filename: using_name.py

if name == ‘main’:
print(‘程序自身在运行’)
else:
print(‘我来自另一模块’)

运行结果如下：
$ python using_name.py
程序自身在运行
$ python

import using_name
我来自另一模块

说明： 每个模块都有一个__name__属性，当其值是’main’时，表明该模块自身在运行，否则是被引入。name 与 main 底下是双下划线
7.dir() 函数
1)内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回:
eg:

import fibo, sys
dir(fibo)
[‘name’, ‘fib’, ‘fib2’]

dir(sys)
[‘displayhook’, ‘doc’, ‘excepthook’, ‘loader’, ‘name’,
‘package’, ‘stderr’, ‘stdin’, ‘stdout’,
‘_clear_type_cache’, ‘_current_frames’, ‘_debugmallocstats’, ‘_getframe’,
‘_home’, ‘_mercurial’, ‘_xoptions’, ‘abiflags’, ‘api_version’, ‘argv’,
‘base_exec_prefix’, ‘base_prefix’, ‘builtin_module_names’, ‘byteorder’,
‘call_tracing’, ‘callstats’, ‘copyright’, ‘displayhook’,
‘dont_write_bytecode’, ‘exc_info’, ‘excepthook’, ‘exec_prefix’,
‘executable’, ‘exit’, ‘flags’, ‘float_info’, ‘float_repr_style’,
‘getcheckinterval’, ‘getdefaultencoding’, ‘getdlopenflags’,
‘getfilesystemencoding’, ‘getobjects’, ‘getprofile’, ‘getrecursionlimit’,
‘getrefcount’, ‘getsizeof’, ‘getswitchinterval’, ‘gettotalrefcount’,
‘gettrace’, ‘hash_info’, ‘hexversion’, ‘implementation’, ‘int_info’,
‘intern’, ‘maxsize’, ‘maxunicode’, ‘meta_path’, ‘modules’, ‘path’,
‘path_hooks’, ‘path_importer_cache’, ‘platform’, ‘prefix’, ‘ps1’,
‘setcheckinterval’, ‘setdlopenflags’, ‘setprofile’, ‘setrecursionlimit’,
‘setswitchinterval’, ‘settrace’, ‘stderr’, ‘stdin’, ‘stdout’,
‘thread_info’, ‘version’, ‘version_info’, ‘warnoptions’]
2)如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称:
eg:

a = [1, 2, 3, 4, 5]
import fibo
fib = fibo.fib
dir() # 得到一个当前模块中定义的属性列表
[‘builtins’, ‘name’, ‘a’, ‘fib’, ‘fibo’, ‘sys’]

a = 5 # 建立一个新的变量 ‘a’
dir()
[‘builtins’, ‘doc’, ‘name’, ‘a’, ‘sys’]

del a # 删除变量名a

dir()
[‘builtins’, ‘doc’, ‘name’, ‘sys’]

8.标准模块
1)Python 本身带着一些标准的模块库，在 Python 库参考文档中将会介绍到（就是后面的"库参考文档"）。
2)有些模块直接被构建在解析器里，这些虽然不是一些语言内置的功能，但是他却能很高效的使用，甚至是系统级调用也没问题。
3)这些组件会根据不同的操作系统进行不同形式的配置，比如 winreg 这个模块就只会提供给 Windows 系统。
4)应该注意到这有一个特别的模块 sys ，它内置在每一个 Python 解析器中。变量 sys.ps1 和 sys.ps2 定义了主提示符和副提示符所对应的字符串:
eg:

import sys
sys.ps1
'>>> ’

sys.ps2
'… ’

sys.ps1 = 'C> ’
C> print(‘Runoob!’)
Runoob!
C>
9.包
1)包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。
2)比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B 。
3)在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。
4)目录只有包含一个叫做 init.py 的文件才会被认作是一个包，主要是为了避免一些滥俗的名字（比如叫做 string）不小心的影响搜索路径中的有效模块。
5)用户可以每次只导入一个包里面的特定模块，比如:import sound.effects.echo
解析：这将会导入子模块:sound.effects.echo。 他必须使用全名去访问:
sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)
6)还有一种导入子模块的方法是:from sound.effects import echo
解析：这同样会导入子模块: echo，并且他不需要那些冗长的前缀，所以他可以这样使用:
echo.echofilter(input, output, delay=0.7, atten=4)
7)还有一种变化就是直接导入一个函数或者变量:from sound.effects.echo import echofilter
解析：同样的，这种方法会导入子模块: echo，并且可以直接使用他的 echofilter() 函数:
echofilter(input, output, delay=0.7, atten=4)
8)注意事项
(1)注意当使用 from package import item 这种形式的时候，对应的 item 既可以是包里面的子模块（子包），或者包里面定义的其他名称，比如函数，类或者变量。
(2)import 语法会首先把 item 当作一个包定义的名称，如果没找到，再试图按照一个模块去导入。如果还没找到，抛出一个 :exc:ImportError 异常。
(3)反之，如果使用形如 import item.subitem.subsubitem 这种导入形式，除了最后一项，都必须是包，而最后一项则可以是模块或者是包，但是不可以是类，函数或者变量的名字。
10.从一个包中导入*
1)导入语句遵循如下规则：如果包定义文件 init.py 存在一个叫做 all 的列表变量，那么在使用 from package import * 的时候就把这个列表中的所有名字作为包内容导入。
2)无论是隐式的还是显式的相对导入都是从当前模块开始的。主模块的名字永远是"main"，一个Python应用程序的主模块，应当总是使用绝对路径引用。
3)包还提供一个额外的属性__path__。这是一个目录列表，里面每一个包含的目录都有为这个包服务的__init__.py，你得在其他__init__.py被执行前定义哦。可以修改这个变量，用来影响包含在包里面的模块和子包。