模块 Module
什么是模块：
1、模块是一个包含有一系列数据，函数，类等组成的程序组
2、模块是一个文件，模块文件名通常以.py结尾
作用：
1、让一些相关数据，函数，类等有逻辑的组织在一起，使逻辑结构更加清晰
2、模块中的数据，函数和类等可提供给其它模块或程序使用
模块的分类：（同一个模块在不同的操作系统下可能数不同类型的模块）
1、内置模块（builtins），一般是用C语言来写的，在解析器的内部可以直接使用。模块说明中有builtins关键字
2、标准库模块，安装python时已经安装且可直接使用。
3、第三方模块（通常为开源），需要自己安装
4、用户自己完成的模块（可以作为其他人的第三方模块）
模块的导入语句
import语句
语法：import 模块名1 [as 模块新名1][,模块名2[ as 模块新名2]]，....
作用：将某模块整体导入到当前模块
用法：模块.属性名
dir（obj）函数返回模块所有属性的字符串列表
help（obj）可以查看模块相关的文档字符串
from import语句
语法： from 模块名 import 模块属性名1[as 属性新名1] [,模块属性名2[as 属性新名2]，....]
作用：将模块内的一个或多个属性导入到当前模块的作用域
说明：属性是模块内的所有全局变量
from import * 语句 （一般不用）
语法：from 模块名 import *
作用：将某模块的所有属性都导入到当前模块
dir函数：
dir（[对象]）返回一个字符串列表
作用：1、如果没有参数调用，则返回当前作用域内的所有变量的列表
2、如果给定一个对象作为参数，则返回这个对象的所有变量的列表
1）对于一个模块，返回这个模块的全部属性
2）对于一个类对象，返回这个类对象的所有变量，亲递归基类对象的所有变量
3）对于其它对象，返回所有的变量，类变量，基类变量
数学模块 math
变量:
math.e 自然对数的底e
math.pi 圆周率pi
函数：
math.ceil(x) 对x向上取整，比如x = 1.2 ，返回2
math.floor(x) 对x向下取整，比如x = 1.8 ，返回1
math.sqrt(x) 返回x的平方根
math.factorial(x) 求x的阶乘
math.log(x,[base]) 返回以base为底的x的对数，如果不给base，则以自然对数e为底
math.log10(x) 求以10为底x的对数
math.pow(x,y) 返回x**y
math.fabs(x) 返回浮点数x的绝对值，比如x = -1，返回1.0
角度degrees和弧度radians互换
math.degrees(x) 将弧度x转换为角度
math.radians(x) 将角度x转换为弧度
三角函数，下面的x都是以弧度为单位的
math.sin(x) 返回x的正弦
math.cos(x) 返回x的余弦
math.tan(x) 返回x的正切
math.asin(x) 返回x的反正弦（返回值为弧度）
math.acos(x) 返回x的反余弦（返回值为弧度）
math.atan(x) 返回x的反正切（返回值为弧度）
时间模块 time
此模块提供了时间相关的函数，且一直可用
时间简介
1、公元纪年是从公元0000年1月1日0时开始的
2、计算机元年是从1970年1月1日0时开始的，此时间为0，之后每过一秒时间+1
3、UTC时间（Coordinated Universal Time ）是从Greenwich时间开始计算的，UTC时间不会因时区问题而产生错误
4、DST阳光节约时间（Daylight Saving Time ），又称夏玲时，是一个经过日照时间修正后的时间（中国已经不用了）
时间元组
时间元组是一个9个整型元素组成的，这九个元素自前至后一次为
1、四位的年（如：1992）
2、月（1-12）
3、日（1-31）
4、时（0-23）
5、分（0-59）
6、秒（0-59）
7、星期几（0-6，周一是0）
8、元旦开始日（1-366）
9、夏令时修时间（-1，0 or 1），对中国来说是0
注：如果年份小于100，则会自动转换为加上1900后的值
变量
time.altzone 夏令时时间与UTC时间差（秒为单位），-32400秒
time.daylight 夏令时校正时间，在中国为0
time.timezone 本地区时间与UTC时间差（秒为单位），-28800秒
time.tzname 时区名字的元组，第一个名字为未经夏令时修正的时区，第二个名字为经夏令时修正后的时间（"CST","CST"）
注:CST为中国标准时间（China Standard Time UTC+8：00）
函数：
time.time() 返回从计算机元年至当前时间的秒数的浮点数（UTC时间为准）
time.sleep(secs) 让程序按给定秒数的浮点数睡眠一段时间
time.gmtime([secs]) 用给定秒数转换为用UTC表达的时间元组（默认返回当前时间元组）
time.asctime([tuple]) 将时间元组转为日期时间字符串，默认为当前时间
time.ctime([secs]) 将时间戳转发为日期时间字符串，默认是当前时间
time.mktime(tuple) 将本地日期时间元组转为新纪元秒数时间（UTC为准）
time.localtime([secs]) 将UTC秒数时间转为日期元组（以本地时间为准），默认为当前时间
注：time.mktime(time.localtime()) - time.mktime(time.gmtime()) = 28800.0 说明当时时间比UTC时间早8个小时
time.clock() 返回处理器时间，3.0版本开始已经废弃，改成time.process_time()
time.strftime(formt[,tuple]) 返回可读字符串时间，格式有参数format决定。
time.strptime()
time.tzset()
python中时间日期格式化符号
%y 表示两位数的年份（00-99）
%Y 表示四位数的年份（0000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00-59）
%S 秒数（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化月份名称
%B 本地完整月份名称
%c 本地相应的的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期日为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身
import time print(time.localtime())#time.struct_time(tm_year=2018, tm_mon=7, tm_mday=19, tm_hour=0, tm_min=44, tm_sec=5, tm_wday=3, tm_yday=200, tm_isdst=0) print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))#2018-07-19 00:44:05 print(time.strftime("%y-%m-%d %I:%M:%S",time.localtime()))#18-07-19 12:44:05 print(time.strftime("%a-%A-%b-%B-%c-%j-%p-%U-%w-%W-%x-%X-%Z-%%",time.localtime())) # Thu-Thursday-Jul-July-Thu Jul 19 00:44:05 2018-200-AM-28-4-29-07/19/18-00:44:05-?D1¨²¡À¨º¡Á?¨º¡À??-% # a A b B c j p U w W x X Z %
系统模块sys
此模块全部是运行时系统相关的信息
作用：用于获取和设置与系统相关的信息
变量
sys.path 返回模块的搜索路径，path[0]是当前脚本程序的路径，初始化时使用pythonPath环境变量的值
sys.modules 返回已加载模块的字典，字典的键为模块名，值为已加载的模块
sys.version 返回python版本信息的字符串：'3.5.4 (v3.5.4:3f56838, Aug 8 2017, 02:17:05) [MSC v.1900 64 bit (AMD64)]'
sys.version_info 返回python版本信息的命名元组：sys.version_info(major=3, minor=5, micro=4, releaselevel='final', serial=0)
sys.platform 操作系统平台的名称信息（Win32）
sys.argv 命令行参数argv[0]代表当前脚本程序的路径名，绑定用户启动程序时命令参数的列表
sys.copyright 获得python版权相关信息
sys.builtin_module_names 获得python内建模块的名称（字符串元组）
标准输入输出时会用到
sys.stdin 标准输入文件对象，多用于input（）
sys.stdout 标准输出文件对象，多用于print（）
sys.stderr 标准错误输出文件对象，用于输出错误信息
函数：
sys.exit([arg]) 退出程序，正常退出时sys.exit（0）
sys.getrecursionlimit() 得到递归嵌套层次限制（栈的深度）
sys.setrecursionlimit(n) 得到和修改递归嵌套层次限制（栈的深度），你代表递归的次数，脚本停止，则这个限制还原
自定义模块
自定义模块模块名必须符合“标识符”的命名规则（同变量名），模块有各自独立的作用域
模块化编程的优点：
1、有利于多人合作开发
2、使代码更易于维护
3、提高代码的复用率
4、有利于解决变量名冲突问题
import 语句 搜索模块的路径顺序
1、搜索程序运行时的路径（当前路径）
2、sys.path提供的路径
3、搜索内置模块
说明：sys.path是一个存储模块搜索路径的列表
1、可以把自定义的模块放在相应的路径下可以导入
2、可以把自己模块的路径添加在sys.path列表中
模块的加载过程：
1、在模块导入时，模块的所有语句会执行
2、如果一个模块已经导入，则再次导入时不会重新执行模块内的语句
模块的重新加载：
当已经被导入的模块内容被修改后，可以通过重新执行当前的程序重新加载，或者通过import imp；imp.reload(模块名)的方法重新加载
模块被导入和执行的过程
1、先搜索相关的路径找到模块（.py）
2、判断是否有此模块对应的.pyc文件，如果存在pyc文件且比.py文件新，则直接加载.pyc文件
3、否则用.py文件生成.pyc文件后再进行加载
pyc 模块的编译文件：
mymod1.py----编译(compile)------→mymod1.pyc------解释执行-----→python3
模块的属性
属性的实质是变量（是模块内的全局变量）
模块内预置的属性
__doc__属性
作用：用来绑定模块的文档字符串
模块内第一个没有赋值给任何变量的字符串为模块的文档字符串，（如果没有赋值的字符串出现在第二个语句，则文档字符串为空）
__file__属性
用来绑定模块对应的文档路径名
1、对于内建模块，不绑定路径（没有__file__属性）
2、对于其它模块，绑定路径名的字符串（相对路径：模块名.py）
__name__属性
此属性用来记录模块的自身名字
作用：1、记录模块名
2、用来判断是否为主模块（最先运行的模块）
说明：1、当此模块为主模块时，__name__绑定"__main__"
2、当此模块不是主模块时，此属性绑定模块名
模块的__all__列表（不属于模块的属性）
模块中的__all__列表是一个用来存放可导出属性的字符串列表
作用：当用from import * 语句导入时，只导入__all__列表内的属性，如果没有次列表则模块的所有属性都被导入
不会影响import 模块名 和 from 模块名 import 属性名 两个语句的导入
模块的隐藏属性：
模块中以"_"下划线（不仅仅是单下划线，多个下划线）开头的属性，在from import *语句导入时，将不被导入，通常称这些属性为隐藏属性。
如果该属性被放入__all__列表中，将会被导入
随机模块 random
作用：用于模拟或生成随机输出的模块
函数（import random as R）
R.random() 返回一个[0,1)之间的随机实数
R.randint(a,b) 返回一个 [a~b]之间的随机整数，包括a，b
R.uniform(a,b) 返回[a,b)区间内的随机实数
R.randrange([start,] stop[,step]) 返回range（start，stop，step）中的随机数
R.choice(seq) 从序列中返回随机数
R.shuffle(seq, [,random]) 随机指定序列的顺序（乱序序列），函数的第二个参数代表必须传入random模块中无参的函数目前只有random函数，可以使用 R.random代替，目前版本没有什么用
R.sample(seq,n) 从序列中选择n个随机且不重复的元素
import random L = [i for i in range(10)] L5 = random.sample(L,5) print(L) print(L5)
json&pick模块
序列化：
我们把对象（变量）从内存中变成可存储的或传输的过程称之为序列化，反过来，把变量内容从序列化后的对象重新读到内存中称为反序列化
说明：json不能讲高级的对象序列化，比如：函数、类，如果要序列化函数 或者 类时需要使用pickle模块
json中的函数：
1、dumps（）：序列化
2、loades（）：反序列化
import json dic = {'name':"xdl",'age':25} #将字典对象序列,使之变为可存储的对象 dic = json.dumps(dic) f = open('json_test','w') f.write(dic)
import json f = open('json_test','r') dic = f.read() #将读出的数据反序列化,并读入到内存中 dic = json.loads(dic) print(dic['name'])
pickle中的函数
1、dumps（）：序列化对象
2、loads（）：反序列化对象
import pickle def foo(): print('ok') #将字典对象序列,使之变为可存储的对象,是字节串，需要使用wb写入 foo = pickle.dumps(foo) f = open('json_test','wb') f.write(foo) f.close()
import pickle def foo(): print('ok') f = open('json_test','rb') data = f.read() #将读出的数据反序列化,并读入到内存中 #反序列化之前要创建一个与读取的函数名相同的函数 #否则会报错：AttributeError: Can't get attribute 'foo' on <module '__main__' from ' # /home/tarena/PycharmProjects/xdl/module/pickle_load.py'> data = pickle.loads(data) data()
logging模块（日志模块）
使用步骤：
1、获取logger实例对象，如果参数为空则返回root logger，
logger = logging.getLogger()
2、指定logger的格式
formatter = logging.Formatter('自定义格式')
3、创建具体的日志handler，并将日志格式添加到处理器上，包括文件日志和终端日志
1)文件日志：
file_handler = logging.FileHandler('文件名称.log')
file_handler.setFormatter(formatter)
2)终端日志（在终端上显示日志信息）
console_handler = logging.StreamHandler(sys.stdout)
console_handler.setFormatter(formatter)
4、设置日志级别
logger.setLevel(日志级别)
5、把日志的handler对象添加到日志对象logger中
logger.addHandler(file_handler)
logger.addHandler(console_handler)
6、写日志
7、移除日志处理器
logger.removeHandler(file_handler)
logger.removeHandler(console_handler)
import logging import sys #1、获取logger的实例,<Logger testlog (INFO)>，（INFO）是自己设置的日志级别，如果不给参数，<RootLogger root (INFO)> logger = logging.getLogger('testlog') #2、指定logger的格式 formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s') #3、创建具体的日志handler,文件日志，终端日志 #3.1、文件日志 file_handler = logging.FileHandler('testLog.log') file_handler.setFormatter(formatter) #3.2、终端日志 console_handler = logging.StreamHandler(sys.stdout) console_handler.setFormatter(formatter) #4、设置日志的级别,高于等于这个默认级别才会被显示 logger.setLevel(logging.INFO) #5、把日志的handler添加到logger实例中 logger.addHandler(file_handler) logger.addHandler(console_handler) #6、写日志 logger.error("Test Error log") logger.info("Test info log") logger.debug("Test debug log") #7、清空日志 logger.removeHandler(file_handler) logger.removeHandler(console_handler)
将日志封装成一个模块
class LogerHelper: def __init__(self,name='LogerHelper',setLevel=logging.DEBUG): self.logger = logging.getLogger(name) self.formatter = logging.Formatter("%(asctime)s %(levelname)s %(message)s") self.file_handler = logging.FileHandler(name+'.log') self.file_handler.setFormatter(self.formatter) self.console_handler = logging.StreamHandler(sys.stdout) self.console_handler.setFormatter(self.formatter) self.logger.setLevel(setLevel) self.logger.addHandler(self.file_handler) self.logger.addHandler(self.console_handler) def writeLog(self,info,level='debug'): if level == 'critial': self.logger.critical(info) elif level == 'error': self.logger.error(info) elif level == 'warn': self.logger.warn(info) elif level == 'info': self.logger.info(info) elif level == 'debug': self.logger.debug(info) def removeLog(self): self.logger.removeHandler(self.file_handler) self.logger.removeHandler(self.console_handler) if __name__ == '__main__': logger = LogerHelper() logger.writeLog("hello world",'critial') logger.writeLog("hello world",'error') logger.writeLog("hello world",'warn') logger.writeLog("hello world",'info') logger.writeLog("hello world",'debug') logger.removeLog()
包（模块包）package
包是将模块以文件夹的组织形式进行分组管理的方法（包比其它普通文件夹多一个__init__.py）
作用：将一系列模块进行分类管理，有利于防止命名冲突，可以在需要时加载一个或一部分模块而不是全部模块
__init__.py文件
常规包内必须存在的文件
__init__.py会在包加载时被自动调用
作用：1、编写此包的内容
2、在内部填写文档字符串
3、在__init__.py内可以加载此包所依赖的一些其它模块
包的导入
用三条import语句可以导入包（同模块的导入规则）
import 包名 [as 包别名]
import 包名.模块名 [as 模块新名]
import 包名.子包名.模块名
from 包名 import 模块名 [as 模块新名]
from 包名.子包名 import 模块名 [as 模块新名]
from 包名.子包名.模块名 import 属性名 [as 属性新名]
from 包名 import *
from 包名.模块名 import *
包的__init__.py内的__all__列表
作用：用来记录此包中有哪些子包或模块在用from 包 import * 语句导入时是否被导入
说明：__all__列表只对from import * 语句起作用，如果没有此列表则，都不会被导入
包的相对导入
包的相对导入是指包内模块的相互导入
语法：1、from 相对路径包或模块 import 属性或模块名
2、from 相对路径或模块 import *
相对路径：
1、.代表当前目录 如：a/b/c.py 其中.c.py代表b路径
2、..代表上一级目录
3、...代表上二级目录
4、....依次类推
注：相对导入时不能超出包的外部，如果超出包的外部会报错ValueError: attempted relative import beyond top-level package
包的加载路径：
和模块的加载路径相同
1、当前文件夹
2、sys.path给出的路径
异常 exception
什么是错误：
错误是指由于逻辑或语法等导致一个程序无法正常执行的问题
特点：有些错误是无法预知的
什么是异常：
异常是程序出错时标识的一种状态，
当异常发生时，程序不会再向下执行，而转去调用此函数的地方待处理错误并恢复为正常状态
作用：
1、通知上层调用者有错误产生需要处理
2、用作信号通知
try 语句的两种语法
try - except 语句
语法：try：
可能触发异常的语句
except 错误类型1 [as 变量1]：
异常处理语句1
except 错误类型2 [as 变量2]：
异常处理语句2
except（错误类型3，错误类型4，...）[as 变量3]：#前面必须是异常类型元组
异常处理语句3
...
except: #捕获所有错误类型
异常处理语句other
else：
未发生异常时执行的语句，(try语句嵌套的try语句出现异常并被处理，也要执行,如果没有被处理将交给外部try语句进行处理)
finally：
最终执行语句（不管有没有发生异常都会执行该语句，发生异常没有被处理同样会执行该语句）
作用：尝试捕获异常，将程序转为正常状态并继续执行
说明：1、as 子句用于绑定错误对象的变量，可以省略不写
2、except子句可以有一个或多个，但至少要有一个
3、else子句最多只能有一个，也可以省略不写
4、finally子句最多只能有一个，也可以省略不写
try-finally语句
语法：try：
可能触发异常的语句
finally：
最终语句
说明：1、finally子句不可以省略
2、一定不存在except子句
作用：通常try-finally语句来做触发异常时必须要处理的事情，无论异常是否发生，finally子句都会执行
注：try-finally语句不会改变程序的（正常/异常）状态
raise语句
作用：触发一个错误，让程序进入异常状态
语法：1、raise 异常类型 ：raise ZeroDivisionError
2、raise 异常对象：rasie ZeroDivisionError("被零除了...")
assert 语句（断言语句）
语法：assert 真值表达式，错误数据（通常是字符串）
作用：当真值表达式为False时，用错误数据创建一个AssertionError类型的错误，并进入异常状态
类似于：if 真值表达式 == False：
raise AssertionError（错误数据）
小结：
接收错误消息：try- except
做必须要处理的事情的语句：try-finally
发错误消息的语句：1、raise 语句
2、assert 语句
为什么要用异常处理处理机制：
在程序调用层数较深时，向主调用函数传递错误信息需要用return语句层层传递比较麻烦，所以用异常处理机制
异常（高级）
回顾异常相关的语句：
try-exept 用来捕获异常通知
try-finally 用来做一定要做的事情
raise 用来发生异常通知
assert 用来根据条件来发出AssertionError类型的异常通知
with语句：
语法：with 表达式1 [as 变量1]，表达式2 [as 变量2]：
语句块
作用：使用于对资源进行访问的场合，确定使用过程中不管是否发生异常，都会执行必须的‘清理’操作，并释放资源
如：文件使用后自动关闭，线程中锁的自动获取和释放等
说明：能够用于with语句进行管理的对象必须是环境管理器
'''此示例示意用try-except 和 try-finally 组合来对文件进行操作''' def read_from_file(filename="info.txt"): try: f = open(filename) try: print("正在读取文件") n = int(f.read()) print("n=",n) finally: f.close() print("文件已经关闭") except OSError: print("文件打开失败") read_from_file()
环境管理器：
1、类内有__enter__ 和 __exit__实例方法的类被称为环境管理器
2、能用with语句管理的对象必须是环境管理器
3、__enter__方法将在进入with语句时被调用，并返回由as变量管理的对象
4、__exit__方法将在离开with语句时被调用，且可以用参数来判断在离开with语句时是否有异常发生并做出相应的处理
contextlib,给我们提供了一个装饰器,只要按照它的代码协议来实现函数内容,就可以将这个函数对象变成一个上下文管理器
使用环境管理器(上下文管理器)的好处
1.提高代码的复用率
2.提高代码的优雅度
3.提高代码的可读性
import contextlib @contextlib.contextmanager def open_func(file_name): #__enter__方法 print('openfile',file_name,'in __enter__') file_handler = open(file_name,'r') #在被装饰的函数中,必须是一个生成器,而yield之前的代码相当于__enter__,之后的代码相当于__exit__ try: yield file_handler except Exception as e: print(e) finally: print('closefile',file_name,'in __exit__') file_handler.close() if __name__ == "__main__": with open_func('aa.txt') as f: print(f) 1 / 0
def read_from_file(filename="info.txt"): try: with open(filename) as f: print("正在读取文件") n = int(f.read()) print("n=",n) print("文件已经关闭") except OSError: print("文件打开失败") read_from_file()
'''此示例示意环境管理器的定义及使用''' class A: def __enter__(self): print("已经进入with语句") return self #返回的对象将由as 绑定 def __exit__(self,exc_type,exc_val,exc_tb): '''此方法会在退出with语句时自动调用 exc_type在没有异常时为None，在出现异常时为绑定异常类型 exc_val在没有异常时为None，在出现异常时绑定错误对象 exc_tb在没有异常时为None，在出现异常时绑定traceback(跟踪)''' if exc_type is None: print("正常离开with语句！") else: print("异常离开with语句！") print("异常类型是：",exc_type) print("错误对象是",exc_val) print("traceback是：",exc_tb) with A() as a: print("我是with语句内的一条语句") int(input("输入一个数：")) # 已经进入with语句 # 我是with语句内的一条语句 # 输入一个数：aa # 异常离开with语句！ # 异常类型是： <class 'ValueError'> # 错误对象是 invalid literal for int() with base 10: 'aa' # traceback是： <traceback object at 0x7f443a0e2748> # Traceback (most recent call last): # File "02_enter_exit.py", line 24, in <module> # int(input("输入一个数：")) # ValueError: invalid literal for int() with base 10: 'aa'