14-Python之路---包和模块

模块的概念

模块是 Python 程序架构的一个核心概念

通常模块为一个文件，直接使用import来导入就好了。可以作为module的文件类型有".py"、".pyo"、".pyc"、".pyd"、".so"、".dll"。

每一个以扩展名 py 结尾的 Python 源代码文件都是一个 **模块 **

模块名 同样也是一个 标识符，需要符合标识符的命名规则

在模块中定义的 全局变量 、函数、类 都是提供给外界直接使用的 工具

模块 就好比是 工具包，要想使用这个工具包中的工具，就需要先 导入 这个模块

模块的两种导入方式

import 导入

import 模块名1, 模块名2

提示：在导入模块时，每个导入应该独占一行

import 模块名1
import 模块名2
  • 导入之后
    • 通过 模块名. 使用 模块提供的工具 —— 全局变量、函数、类

from ... import 导入

  • 如果希望 从某一个模块 中，导入 部分 工具，就可以使用 from ... import 的方式
  • import 模块名 是 一次性 把模块中 所有工具全部导入，并且通过 模块名/别名 访问
# 从 模块 导入 某一个工具
from 模块名1 import 工具名
  • 导入之后
    • 不需要 通过 模块名.
    • 可以直接使用 模块提供的工具 —— 全局变量、函数、类

注意

如果 两个模块，存在 同名的函数，那么 后导入模块的函数，会 覆盖掉先导入的函数

  • 开发时 import 代码应该统一写在 代码的顶部，更容易及时发现冲突
  • 一旦发现冲突，可以使用 as 关键字 给其中一个工具起一个别名

使用 as 指定模块的别名

如果模块的名字太长，可以使用 as 指定模块的名称，以方便在代码中的使用

import 模块名1 as 模块别名
from itsdangerous import TimedJSONWebSignatureSerializer as Serializer

注意：模块别名 应该符合 大驼峰命名法

变量名重复时使用 as 创建别名

from ... import *（知道）

# 从 模块 导入 所有工具
from 模块名1 import * # 这种方式不推荐使用，因为函数重名并没有任何的提示，出现问题不好排查
from requests import get
from requests.api import sessions

from itsdangerous import TimedJSONWebSignatureSerializer as Serializer

导入本地脚本

import 如果你要导入的 Python 脚本与当前脚本位于同一个目录下，只需输入 import，然后是文件名，无需扩展名 .py。

导入变量

从一个模块中导入定义好的变量

# filename: a.py

a = 1

# filename: b.py

from a import a
print(a)

导入方法

从模块中导入定义好的方法

# filename: a.py

def a():
	print(__name__)

# filename: b.py

from a import a
a()

导入对象

从模块中导入定义好的对象

# filename: a.py

class A():
	def b():
		print(__name__)

# filename: b.py

from a import A
a = A()
a.b()

案例：使用 requests 中的 get 方式的三种导入

# import requests
# from requests import *
# from requests import get
#
# response = requests.get("https://www.baidu.com")
# print(response.status_code)

import 导入的顺序(模块导入顺序)

import sys, os

# sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), 'xxx')))
print(sys.path)

变量导入顺序

locals()

globals()

使用 if __name__ == '__main__' 块

为了避免运行从其他脚本中作为模块导入的脚本中的可执行语句，将这些行包含在 if __name__ == '__main__' 块中。

每当我们运行此类脚本时，Python 实际上会为所有模块设置一个特殊的内置变量 __name__ 。当我们运行脚本时，Python 会将此模块识别为主程序，并将此模块的 __name__ 变量设为字符串 “main”。对于该脚本中导入的任何模块，这个内置 __name__ 变量会设为该模块的名称。因此，条件 if __name__ == "__main__"会检查该模块是否为主程序。

导入模块

  • import xxx
  • from xxx import xxx
  • from xxx import xxx as xx
  • from xxx.xxx import xxx
  • from . import xxx

相对导入与绝对导入

绝对导入的格式为 import A.B 或 from A import B，相对导入格式为 from .A import B 或 from ..X import Y，. 代表当前模块，.. 代表上层模块，... 代表上上层模块，依次类推。

包（Package）

通常包总是一个目录，可以使用 import 导入包，或者 from ... import 来导入包中的部分模块。包目录下为首的一个文件便是 __init__.py。然后是一些模块文件和子目录，假如子目录中也有 __init__.py 那么它就是这个包的子包了。

概念

  • 包 是一个 包含多个模块 的 特殊目录
  • 目录下有一个 特殊的文件 __init__.py
  • 包名的 命名方式 和变量名一致，小写字母 + _

好处

  • 使用 import 包名 可以一次性导入包中所有的模块

普通文件与包的区别

__init__.py

__all__ == ['a', 'b', 'c']

每一个文件都应该是可以被导入的

  • 一个 独立的 Python 文件 就是一个 模块
  • 在导入文件时，文件中 所有没有任何缩进的代码 都会被执行一遍！

实际开发场景

  • 在实际开发中，每一个模块都是独立开发的，大多都有专人负责
  • 开发人员通常会在模块下方增加一些测试代码
    • 仅在模块内使用，而被导入到其他文件中不需要执行

__name__ 属性

__name__ 属性可以做到，测试模块的代码 只在测试情况下被运行，而在被导入时不会被执行

__name__ 是 Python 的一个内置属性，记录着一个 字符串

如果是被其他文件导入的，__name__ 就是模块名

如果是当前执行的程序 __name__ 是 __main__

在很多 Python 文件中都会看到以下格式的代码：

# 导入模块
# 定义全局变量
# 定义类
# 定义函数

# 在代码的最下方
def main():
    # ...
    pass

# 根据 __name__ 判断是否执行下方代码
if __name__ == "__main__":
    main()

pip其他安装方式

pip 是 Python 包管理工具，该工具提供了对Python 包的查找、下载、安装、卸载的功能。

目前如果你在 python.org 下载最新版本的安装包，则是已经自带了该工具。

常用指令

显示版本和路径

pip --version

升级pip

pip install -U pip

指定版本安装库

pip install Django==1.7

列出已安装的包

pip list

注意事项

如果 Python2 和 Python3 同时有 pip，则使用方法如下：

Python2：

python2 -m pip install XXX

Python3:

python3 -m pip install XXX

指定下载好的文件进行安装

pip install Flask-WTF-0.10.0.tar.gz

pip install requests-master.zip

指定国内源进行安装

pip install -i https://pypi.douban.com/simple/ requests

pip国内镜像源。

阿里云 http://mirrors.aliyun.com/pypi/simple/
中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/
豆瓣 http://pypi.douban.com/simple
Python官方 https://pypi.python.org/simple/
v2ex http://pypi.v2ex.com/simple/
中国科学院 http://pypi.mirrors.opencas.cn/simple/

永久更换方法

linux修改 ~/.pip/pip.conf

mkdir ~/.pip 
vim ~/.pip/pip.conf
[global]
index-url = http://mirrors.aliyun.com/pypi/simple/
[install]
trusted-host = mirrors.aliyun.com

Windows下更换pip源为阿里源

1 打开appdata文件夹，在资源管理器的地址栏输入%appdata%后回车：

2 新建一个pip文件夹，在pip文件夹里面新建一个配置文件pip.ini：

3 在配置文件中输入如下内容后保存即可：

[global]
timeout = 6000
index-url = http://mirrors.aliyun.com/pypi/simple/
trusted-host = http://mirrors.aliyun.com/pypi/simple/

异常

程序在运行时，如果Python 解释器遇到 到一个错误，会停止程序的执行，并且提示一些错误信息，这就是 异常

程序停止执行并且提示错误信息 这个动作，我们通常称之为：抛出(raise)异常

程序开发时，很难将所有的特殊情况都处理的面面俱到，通过异常捕获可以针对突发事件做集中的处理，从而保证程序的稳定性和健壮性

捕获异常

在程序开发中，如果 对某些代码的执行不能确定是否正确，可以增加 try(尝试) 来 捕获异常

捕获异常最简单的语法格式：

try:
    尝试执行的代码
except:
    出现错误的处理

try 尝试，下方编写要尝试代码，不确定是否能够正常执行的代码

except 如果不是，下方编写尝试失败的代码

异常——整数

try:
    # 提示用户输入一个数字
    num = int(input("请输入数字："))
except:
    print("请输入正确的数字")

错误类型捕获

在程序执行时，可能会遇到不同类型的异常，并且需要针对不同类型的异常，做出不同的响应，这个时候，就需要捕获错误类型了

语法如下：

try:
    # 尝试执行的代码
    pass
except 错误类型1:
    # 针对错误类型1，对应的代码处理
    pass
except (错误类型2, 错误类型3):
    # 针对错误类型2 和 3，对应的代码处理
    pass
except Exception as result:
    print("未知错误 %s" % result)

当 Python 解释器抛出异常时，最后一行错误信息的第一个单词，就是错误类型

异常捕获演练

需求

  1. 提示用户输入一个整数
  2. 使用 8 除以用户输入的整数并且输出
try:
    num = int(input("请输入整数："))
    result = 8 / num
    print(result)
except ValueError:
    print("请输入正确的整数")
except ZeroDivisionError:
    print("除 0 错误")

捕获未知错误

在开发时，要预判到所有可能出现的错误，还是有一定难度的

如果希望程序 无论出现任何错误，都不会因为 Python 解释器 抛出异常而被终止，可以再增加一个 except

语法如下：

except Exception as result:
    print("未知错误 %s" % result)

异常捕获完整语法

在实际开发中，为了能够处理复杂的异常情况，完整的异常语法如下：

先对这个语法结构有个印象即可

try:
    # 尝试执行的代码
    pass
except 错误类型1:
    # 针对错误类型1，对应的代码处理
    pass
except 错误类型2:
    # 针对错误类型2，对应的代码处理
    pass
except (错误类型3, 错误类型4):
    # 针对错误类型3 和 4，对应的代码处理
    pass
except Exception as result:
    # 打印错误信息
    print(result)
else:
    # 没有异常才会执行的代码
    pass
finally:
    # 无论是否有异常，都会执行的代码
    print("无论是否有异常，都会执行的代码")

else 只有在没有异常时才会执行的代码

finally 无论是否有异常，都会执行的代码

之前一个演练的 完整捕获异常 的代码如下：

try:
    num = int(input("请输入整数："))
    result = 8 / num
    print(result)
except ValueError:
    print("请输入正确的整数")
except ZeroDivisionError:
    print("除 0 错误")
except Exception as e:
    print("未知错误 %s" % e)
else:
    print("正常执行")
finally:
    print("执行完成，但是不保证正确")

异常的传递

异常的传递 —— 当运行函数出现异常，会将异常传递给的调用一方

如果传递到主程序，仍然没有异常处理，程序才会被终止

提示

在开发中，可以在主函数中增加异常捕获，在主函数中调用的其他函数，只要出现异常，都会传递到主函数的 异常捕获中。这样就不需要在代码中，增加大量的 异常捕获，能够保证代码的整洁

需求

  1. 定义函数 demo1() 提示用户输入一个整数并且返回
  2. 定义函数 demo2() 调用 demo1()
  3. 在主程序中调用 demo2()
def demo1():
    return int(input("请输入一个整数："))


def demo2():
    return demo1()

try:
    print(demo2())
except ValueError:
    print("请输入正确的整数")
except Exception as result:
    print("未知错误 %s" % result)

抛出 raise 异常

在开发中，除了 代码执行出错 Python 解释器会 抛出 异常之外

还可以根据 应用程序 特有的业务需求 主动抛出异常

示例

  • 提示用户 输入密码，如果 长度少于 8，抛出 异常

注意

当前函数 只负责提示用户输入密码，如果 密码长度不正确，需要其他的函数进行额外处理

因此可以 抛出异常，由其他需要处理的函数 捕获异常

抛出异常

  • Python 中提供了一个 Exception 异常类
  • 在开发时，如果满足 特定业务需求时，希望 抛出异常，可以：
    1. 创建 一个 Exception 的 对象
    2. 使用 raise 关键字 抛出 异常对象

需求

  • 定义 input_password 函数，提示用户输入密码
  • 如果用户输入长度 < 8，抛出异常
  • 如果用户输入长度 >=8，返回输入的密码
def input_password():

    # 1. 提示用户输入密码
    pwd = input("请输入密码：")

    # 2. 判断密码长度，如果长度 >= 8，返回用户输入的密码
    if len(pwd) >= 8:
        return pwd

    # 3. 密码长度不够，需要抛出异常
    # 1> 创建异常对象 - 使用异常的错误信息字符串作为参数
    ex = Exception("密码长度不够")

    # 2> 抛出异常对象
    raise ex


try:
    user_pwd = input_password()
    print(user_pwd)
except Exception as result:
    print("发现错误：%s" % result)

def div(num1, num2):
    assert isinstance(num1, int), "值类型不正确"
    assert isinstance(num2, int), "值类型不正确"
    assert num2 != 0, "除数不能为0"
    return num1 / num2


if __name__ == '__main__':
    print(div(100, 0))
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/mark-wq/p/13491367.html