Python模块和包

Python导入模块，Python import用法

[root@kube import]# cat demo.py 
#coding:utf-8


#导入整个模块
import sys

#使用sys 模块名作为前缀来访问模块中的成员
print(sys.argv[1])

#导入整个模块，并制定别名为s
import sys as s
print(s.argv[1])

#导入多个模块用逗号隔开
import sys,os
#导入多个模块同时制定别名
import sys as s, os as o

----------------------------------------------------
#from 模块名 import 成员名 as 别名

#导入sys 模块的argv 成员
from sys import argv
#使用导入成员的语法，直接使用成员名访问
print(argc[0])

#导入 sys 模块的argv 成员，并指定别名
from sys import argv as v
print(v[0])

#在使用 from...import 语法时，可以一次导入指定模块内的所有成员（此方式不推荐）
from sys import *



[root@kube import]# 

Python自定义模块

[root@kube import]# cat demo1.py 
#coding:utf-8

print('这是module 1')

def say_hi(user):
    print('%s 欢迎' % user)

class User:
    def __init__(self,name):
        self.name = name
    def walk(self):
        print('%s 正在路上' % self.name)
    def __repr__(self):
        return 'User[name=%s]' % self.name

[root@kube import]# cat demo2.py 
#coding:utf-8

import demo1

demo1.say_hi('jojo')

u = demo1.User('tom')

u.walk()
print(u)
[root@kube import]# py demo2.py 
这是module 1
jojo 欢迎
tom 正在路上
User[name=tom]
[root@kube import]# 

Python __name__=='__main__'作用详解

if __name__ == '__main__':

[root@kube import]# cat demo4.py 
#coding:utf-8

'''
摄氏度和华氏度的相互装换模块
'''
def c2f(cel):
    fah = cel * 1.8 + 32
    return fah

def f2c(fah):
    cel = (fah - 32) / 1.8
    return cel
def test():
    print("测试数据：0 摄氏度 = %.2f 华氏度" % c2f(0))
    print("测试数据：0 华氏度 = %.2f 摄氏度" % f2c(0))
if __name__ == '__main__':          #确定测试函数的执行条件，只有此模块单独运行时才执行
    test()
[root@kube import]# cat demo5.py 
import demo4

print("32 摄氏度 = %.2f 华氏度" % demo4.c2f(32))
print("99 华氏度 = %.2f 摄氏度" % demo4.f2c(99))
[root@kube import]# py demo5.py 
32 摄氏度 = 89.60 华氏度
99 华氏度 = 37.22 摄氏度
[root@kube import]# 

Python __all__变量用法

在默认情况下，如果使用“from 模块名 import *”这样的语句来导入模块，程序会导入该模块中所有不以下画线开头的成员（包括变量、函数和类）。但在一些场景中，我们并不希望每个成员都被暴露出来供外界使用，此时可借助于模块的 __all__ 变量，将变量的值设置成一个列表，只有该列表中的成员才会被暴露出来。

[root@kube import]# cat all_module.py 
#coding:utf-8

'''
    测试 __all__ 变量的模块
'''

def hello():
    print('hello,pthon')
def say():
    print('say hi')

def test():
    print('this is test cript')


__all__ = ['hello','say']
[root@kube import]# cat demo7.py 
#coding:utf-8

from all_module  import *
hello()
say()
test()
[root@kube import]# py demo7.py 
hello,pthon
say hi
Traceback (most recent call last):
  File "demo7.py", line 6, in <module>
    test()
NameError: name 'test' is not defined
[root@kube import]# 

从上面的输出结果可以看到，通过“from all_module import *”语句确实只能导入 __all__ 变量所列出的全部成员，没有列出的 test 就没有被导入进来。

事实上，__all__ 变量的意义在于为模块定义了一个开放的公共接口。通常来说，只有 __all__ 变量列出的成员，才是希望该模块被外界使用的成员。因此，为模块设置 __all__ 变量还是比较有用的。比如一个实际的大模块可能包含了大量其他程序不需要使用的变量、函数和类，那么通过 __all__ 变量即可把它们自动过滤掉，这还是非常酷的。

如果确实希望程序使用模块内 __all__ 列表之外的成员，有两种解决方法：

• 第一种是使用“import 模块名”来导入模块。在通过这种方式导入模块之后，总可以通过模块名前缀（如果为模块指定了别名，则可以使用模快的别名作为前缀）来调用模块内的成员。
• 第二种是使用“from 模块名 import 成员”来导入指定成员。在这种方式下，即使想导入的成员没有位于 __all__ 列表中，也依然可以导入。

[root@kube import]# cat demo7.py 
#coding:utf-8

#from all_module  import *
import all_module      #直接导入模块名，需要将模块名作为前缀进行使用，能获取到__all__ 未定义函数
all_module.hello()
all_module.say()
all_module.test()
[root@kube import]# py demo7.py 
hello,pthon
say hi
this is test cript
[root@kube import]# 

Python包

[root@kube import]# tree first_package/
first_package/
├── __init__.py
├── module1.py
└── module2.py

0 directories, 3 files
[root@kube import]# 
[root@kube import]# cd first_package/
[root@kube first_package]# cat __init__.py 
'''
包的第一个示例
'''
print('this is first package')


[root@kube first_package]# cat module1.py 
def display(n):
    print(n)
[root@kube first_package]# cat module2.py 
class Item:
    display(self):
        print('调用模块中类的方法')
[root@kube first_package]# 

Python包的导入

再次强调，包的本质就是模块，因此导入包和导入模块的语法非常类似。无论导入我们自定义的包，还是导入从他处下载的第三方包，导入方法可归结为以下 3 种。
import 包名[.模块名 [as 别名]]
from 包名 import 模块名 [as 别名]
from 包名.模块名 import 成员名 [as 别名]
用 [] 括起来的部分，是可选部分，即在使用时可以忽略。
与模块类似，包被导入之后，会在包目录下生成一个 __pycache__ 文件夹，并在该文件夹内为包生成一个 __init__.cpython-36.pyc 文件。

[root@kube import]# py demo8.py 
this is first package
jojo
[root@kube import]# cat demo8.py 
#coding:utf-8

import first_package.module1          #import   导入包，调用时必须指定前缀除非别名

first_package.module1.display('jojo')
[root@kube import]# py demo8.py 
this is first package
jojo
[root@kube import]# 

另外，从以上输出结果可以看出，当导入指定包时，程序会自动执行该包所对应文件夹下的 __init__.py 文件中的代码。需要注意的是，当使用此语法格式仅导入包名时，例如：
import first_package
first_package.module1.display(20)
直接导入包名，并不会将包中所有模块全部导入到程序中，它的作用仅仅是导入并执行包下的 __init__.py 文件，因此，运行该程序，在执行 __init__.py 文件中代码的同时，还会抛出 AttributeError 异常（访问的对象不存在）：
this is first_package
Traceback (most recent call last):
  File "C:UsersmengmaDesktopdemo.py", line 2, in <module>
    first_package.module1.display(20)
AttributeError: module 'first_package' has no attribute 'module1'

[root@kube import]# cat demo9.py 
# 导入first_package包（模块）
import first_package
print('==========')
print(first_package.__doc__)
print(type(first_package))
print(first_package)
[root@kube import]# py demo9.py 
this is first package
==========

包的第一个示例

<class 'module'>
<module 'first_package' from '/root/python/import/first_package/__init__.py'>
[root@kube import]# 

 from 包名 import 模块名 [as 别名]

[root@kube import]# cat demo10.py 
#coding:utf-8

from first_package import module1

module1.display('jojo')
[root@kube import]# py demo10.py 
this is first package
jojo
[root@kube import]# 

3) from 包名.模块名 import 成员名 [as 别名]

 from 包名.模块名 import 成员名 [as 别名]
此语法格式用于向程序中导入“包.模块”中的指定成员（变量、函数或类）。通过该方式导入的变量（函数、类），在使用时可以直接使用变量名（函数名、类名）调用，例如：
纯文本复制
from first_package.module1 import display
display(20)

另外，在使用此种语法格式加载指定包的指定模块时，可以使用 * 代替成员名，表示加载该模块下的所有成员。例如：
from first_package.module1 import *
display(20)

Python __init__.py作用详解

我们知道，导入包就等同于导入该包中的 __init__.py 文件，因此完全可以在 __init__.py 文件中直接编写实现模块功能的变量、函数和类，但实际上并推荐大家这样做，因为包的主要作用是包含多个模块。因此 __init__.py 文件的主要作用是导入该包内的其他模块。

也就是说，通过在 __init__.py 文件使用 import 语句将必要的模块导入，这样当向其他程序中导入此包时，就可以直接导入包名，也就是使用import 包名（或from 包名 import *）的形式即可。

[root@kube first_package]# cat __init__.py 
'''
包的第一个示例
'''
print('this is first package')

from . import module1
#from . import *

[root@kube import]# cat demo10.py
#coding:utf-8

import first_package         #这里直接导入  first_package   ,不用 from first_package  import module   ，__init__ 文件中已经定义了

first_package.module1.display('jojo')
[root@kube import]#

[root@kube first_package]# cd ../
[root@kube import]# py demo10.py 
this is first package
jojo
[root@kube import]# 

Python查看模块（变量、函数、类）方法

在导入模块之后，开发者往往需要了解模块包含哪些功能，比如包含哪些变量、哪些函数、哪些类等，还希望能查看模块中各成员的帮助信息，掌握这些信息才能正常地使用该模块。

为了查看模块包含什么，可以通过如下两种方式：

1. 使用 dir() 函数。
2. 使用模块本身提供的 __all__ 变量。

>>> import string
>>> dir(string)
['Formatter', 'Template', '_ChainMap', '_TemplateMetaclass', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_re', '_string', 'ascii_letters', 'ascii_lowercase', 'ascii_uppercase', 'capwords', 'digits', 'hexdigits', 'octdigits', 'printable', 'punctuation', 'whitespace']
>>> string.__all__
['ascii_letters', 'ascii_lowercase', 'ascii_uppercase', 'capwords', 'digits', 'hexdigits', 'octdigits', 'printable', 'punctuation', 'whitespace', 'Formatter', 'Template']
>>> 

很明显，该模块内有大量以下画线开头的成员，其实这些成员并不希望被其他程序使用，因此列出这些成员意义不大。

为了过滤这些以下画线开头的成员，我们可以使用如下列表推导式来列出模块中的成员：
 [e for e in dir(string) if not e.startswith('_')]

Python __file__属性：查看模块的源文件路径

>>> string.__file__
'/usr/local/lib/python3.7/string.py'
>>> 

Python第三方库（模块）下载和安装（使用pip命令）

以下命令将从Python Packaging Index安装模块的最新版本及其依赖项：

python -m pip install SomePackage               #也就是  python -m  pip 

#自动安装 pip
python  -m pip install --upgrade pip
或者

python -m ensurepip --default-pip