py学习7——异常、模块、包

异常

"""
异常：代码在运行过程中遇到错误,给出的错误提示
异常的组成：  '异常的类型':'异常的描述信息'
"""
print("*" * 30)
num = input("请输入一个数字")
num = 10 / int(num)
# 当输入0或者不是数字的数据的时候就会产生异常

异常的捕获

"""
异常的捕获：是指在程序代码运行过程中，遇到错误，不让程序代码终止，让其继续运行，同时给使用
者一个提示信息，并记录这个错误，在后期给予改进

捕获单个异常的代码：
	try:
		可能发生异常的代码
	except 异常的类型:
		发生异常执行的代码
捕获多个异常的代码：
	try:
		可能发生异常的代码
	except (异常的类型1, 异常类型2, ...):
		发生异常执行的代码
或者：
	try:
		可能发生异常的代码
	except 异常的类型1:
		发生异常1执行的代码
	except 异常的类型2:
		发生异常2执行的代码
	......

捕获所有类型的异常：
	try:
		可能会发生异常的代码
	except:
		发生异常执行的代码
	(但是这样就不能获取异常的描述信息)
	try:
		可能会发生异常的代码
	except Exception as e:
		发生异常执行的代码
		print(e)
	(这样就可以获取异常的描述信息了)
"""
print("*" * 30)
num = input("请输入一个数字")
try:
	num = 10 / int(num)
except ZeroDivisionError:
	print('你输入有误')


print("*" * 30)
num = input("请输入一个数字")
try:
	num = 10 / int(num)
except (ZeroDivisionError, ValueError):
	print('你输入有误')


print("*" * 30)
num = input("请输入一个数字")
try:
	num = 10 / int(num)
except ZeroDivisionError:
	print('你输入有误')
except ValueError:
	print('请输入数字')
print("*" * 30)


print("*" * 30)
num = input("请输入一个数字")
try:
	num = 10 / int(num)
except Exception as e:
	print('你输入有误', e)

打印异常的信息

"""
try:
	可能发生异常的代码
except (异常的类型1, 异常类型2, ...) as 变量名:
	发生异常执行的代码
	print(变量名)
"""
print("*" * 30)
num = input("请输入一个数字")
try:
	num = 10 / int(num)
except (ZeroDivisionError, ValueError) as e:
	print('你输入有误', e)

异常的完整结构

"""
try:
	可能会发生异常的代码
except Exception as e:
	发生异常执行的代码
	print(e)
else:
	代码没有发生异常会执行
finally:
	不管有没有发生异常都会执行
"""

异常的传递

"""
是python异常处理的底层机制，是原理层面上的，不需要我们自己写代码实现，是python已经实现好的。

异常传递：当一行代码发生异常之后，会向外层将这个异常进行传递，直到被捕获或者程序报错为止。

发生的情况：
	1.try嵌套
		内层try代码中发生的异常，若果没有被捕获，将会向外层传递
	2.函数嵌套
		和try嵌套类似，它也会向外传递，找到可以捕获它的地方
"""
print("--" * 30)
num = input('请输入数字：')
try:
	try:
		a = int(num)
	except ZeroDivisionError:
		print('内层异常捕获')
	finally:
		print('内层结束')
	num = 10 / a
	print('结果：{num}')
except ValueError as e:
	print('外层异常', e)


print("--" * 30)


def fun1():
	print("-1-" * 30)
	num = input('请输入数字：')
	num = 10 / int(num)
	print(num)
	print("-2-" * 30)


def fun2():
	print("-3-" * 30)
	fun1()
	print("-4-" * 30)
	

try:
	print("-5-" * 30)
	fun2()
	print("-6-" * 30)
except Exception as e:
	print("-7-" * 30)
	print(e)


"""
输入数字0时，会产生异常
函数嵌套的输出结果：
	-5--5--5--5--5--5--5--5--5--5--5--5--5--5--5--5--5--5--5--5--5--5--5--5--5--5--5--5--5--5-
	-3--3--3--3--3--3--3--3--3--3--3--3--3--3--3--3--3--3--3--3--3--3--3--3--3--3--3--3--3--3-
	-1--1--1--1--1--1--1--1--1--1--1--1--1--1--1--1--1--1--1--1--1--1--1--1--1--1--1--1--1--1-
	请输入数字：0
	-7--7--7--7--7--7--7--7--7--7--7--7--7--7--7--7--7--7--7--7--7--7--7--7--7--7--7--7--7--7-
	division by zero
"""

抛出自定义异常

"""
程序为什么会报错？
因为不符合语法，因为python作者在代码中使用if判断，如果除数为零，就会在代码中抛出异常错误
抛出异常:
	raise 异常对象   # 当程序代码遇到raise的时候，程序就报错了

异常对象 = 异常类(参数)
抛出自定义异常：
	1.自定义异常类，继承Exception或者BaseException
	2.选择书写，定义__init__方法，定义__str__方法
	3.在合适的时机抛出异常对象即可
"""
# 定义异常类，检验密码长度是否够6位
def PasswordLengthError(Exception):
	pass


def get_password():  # 等同于系统定义函数
	password = input('请输入密码:')
	if len(password) >= 6:
		print("密码长度合格")
	else:
		# 抛出异常
		raise PasswordLengthError("密码长度不足六位")


get_password()   # 调用系统的函数

模块

import random
random.randint(a, b)   # 产生a，b之间的随机整数，包含b
import os
"""
模块就是一个python代码文件，是别人已经写好的代码文件，文件中的函数类以及变量，我们都可以使用。

使用模块的好处：直接使用别人已经实现好的功能

模块的制作：
	制作一个模块，其实就是定义一个python代码文件
	注意点：模块的名字要遵循标识符的规则(由字母、数字和下划线组成，不能以数字开头)

模块中可以定义变量、定义函数、定义类
"""
# 制作一个模块 module1.py
num = 1


def func():
	print("my_module1_func......")


class Dog(object):
	@staticmethod
	def show_info():
		print('这是一个dog类，my_module1的dog类')
	pass
	
# 想要使用模块中的内容，必须先导入模块
# 如果导入的是自己书写的模块，需要将他们放在同一个目录下，或者写详细目录
# 方法一：import 模块名
# 使用模块中的内容：模块名.功能名
import mymodule1

print(mymodule1.num)		# 使用mymodule1中的变量
mymodule1.func()			# 使用mymodule1中的函数
dog = mymodule1.Dog()		# 使用mymodule1中的类创建对象
dog.show_info()


# 方法二：from 模块名 import 功能名1, 功能名2, ......
# 使用：功能名
# 注意点：如果存在同名的方法名，则会被覆盖
from mymodule1 import func, num
func()
print(num)


# 方法三：from 模块名 import *   # 将模块中的所有功能进行导入
# 使用：功能名
# 不建议使用，因为模块中的内容可能会覆盖一些东西
from mymodule1 import *
func()
print(num)
dog = Dog()
dog.show_info()


# as 起别名，可以对模块和功能起别名
# 注意：如果使用as起别名，就不能再使用原来的名字
import mymodule1 as mm1
from mymodule1 import func as m

模块中的变量 _ all _、 _ name _

"""
__all__ 可以在每个代码文件中定义，类型是元组，列表
作用：影响 form 模块 import * 导入行为。不影响其他的导入行为
	如果没有定义__all__变量，模块中的所有功能都能被导入
	如果定义了__all__变量，只能导入变量中定义的内容
"""
__all__ = ['num', 'func', 'Dog']
num = 1


def func():
	print("my_module1_func......")


class Dog(object):
	@staticmethod
	def show_info():
		print('这是一个dog类，my_module1的dog类')
	pass


# my_calc.py文件
def add(a, b):
	print(a + b)


if __name__ = '__main__':
	add(10, 20)
	"""
	__name__变量，每个模块中都有，是系统自己定义的
		直接运行当前代码，值为__main__
		把文件作为模块导入时，运行，结果是my_calc(文件名)
	"""
	print(__name__)


# 自己定义的模块名字不要和系统中你要使用的模块名字相同
# 模块的搜索顺序：当前目录 ==> 系统目录 ⇒ 程序报错

包

"""
包：功能相近或相似的模块放在一个目录中，并在目录中定义一个__init__.py文件，这个目录就是包

包的导入：
方法一：
	import 包名.模块名 as xx

方法二：
	form 包名.模块名 import 功能名(或者 * )

方法三：(这种方法导入的是__init__.py中的内容)
	form 包名 import * 
"""