python-模块与类库
Catalog：Click to jump to the corresponding position
目录：
=.=.=.=.=.=.=.=.=.=.=.=.=.=.=.=.=.=.=.=.=.=.=.=.=.=.=.=.=.=.=.=.=.=.=.=.=
导入模块的方式：
import module_a #导入
from module import xx #导入某个模块下的某个方法or子模块
from module.xx.xximport xx as rename #导入一个方法后重命名
from module.xx.xx import * #导入一个模块下的所有方法，不建议使用
注意︰模块一旦被调用，即相当于执行了另外一个py文件里的代码
from math import *
print(pi) #3.141592653589793
print(e) # 2.718281828459045
print(ceil(4.3)) # 5
print(floor(4.3)) # 4
print(pow(5,2)) # 25.0
print(log(e**2)) # 2.0
print(log10(100)) # 2.0
print(sqrt(25)) # 5.0
import random as rm
#随机数种子相同的情况下，打印出来的随机数就是相同的
rm.seed(1)
print(rm.random()) #0.13436424411240122
rm.seed(1)
print(rm.random()) #0.13436424411240122
import random as rm
list_case = ['a','b','c','d','e']
print(rm.random()) #0.2352760440073759
print(rm.uniform(1,10)) #6.933127996524673
print(rm.randint(1,10)) #7
print(rm.randrange(1,10,2)) #9
print(rm.choice(list_case)) #e
rm.shuffle(list_case) #直接修改的是列表本源
print(list_case) #['b', 'd', 'c', 'a', 'e']
print(rm.sample(list_case,3)) #['e', 'a', 'd']
Python中的array类似于列表list,如都可以动态增删元素，但又有所区别
list中存储的元素类型可以不一样，但array中元素类型必须完全一样。
另外，由于list中每个元素同时存储了其地址即指针(用以标记每个元素的数据类型)和实际的数据，所以，在存储及操作效率上，array又远远高于列表。
Array定义好之后和列表本质一样，只不过Array运行速度快，且Array只能存储同种类型的元素
from array import *
val = array('i',[1,3,5,7,-9,11])
print(val) #array('i', [1, 3, 5, 7, -9, 11])
for i in val:
print(i) #1、3、5、7、-9、11
参数类型：
这个模块提供各种与时间相关的函数，偏向于时间转换
时间元组：
时间日期格式化符号：
5.1 time.localtime([secs])
将一个时间戳转换为当前时区的struct_time。若secs参数未提供，则以当前时间为准。
import time
print(time.localtime())
返回结果：time.struct_time(tm_year=2020, tm_mon=9, tm_mday=24, tm_hour=9, tm_min=31, tm_sec=29, tm_wday=3, tm_yday=268, tm_isdst=0)
5.2 time.gmtime([secs])
和localtime()⽅方法类似，gmtime()方法是将一个时间戳转换为UTC时区（0时区）的struct_time
5.3 time.time()
获取当前时间戳
时间戳：从1970年1月1日 0：0到现在为止的秒数
import time
print(time.time())
可利用时间戳计算代码运行时间
import time
start_time = time.time()
time.sleep(1) #暂停一秒再运行
for i in range(1,10):
for v in range(1,i+1):
print('%d*%d=%d'%(i,v,i*v),end=" ")
print()
end_time = time.time()
running_time = end_time-start_time
print("代码运行时间：",running_time) #打印结果（代码运行时间： 1.0022175312042236）
5.4 time.mktime(t)
将⼀个struct_time转化为时间戳
import time
t=(1999,9,18,0,0,0,0,0,0) #元素可以为0，但元组的元素个数必须够9位
print(time.mktime(t))
返回结果：937584000.0
5.5 time.sleep()
线程推迟指定的时间运行,单位为秒
5.6 time.strftime(format[, t])
把一个时间元组转化为格式化的时间字符串。如果t未指定，将传⼊time.localtime()
import time
time_case = time.localtime()
# time_case = (1999,9,18,0,0,0,0,0,0)
val = time.strftime("%Y-%m-%d",time_case)
print(val)
返回结果：2020-09-24
5.7 time.strptime(string[, format])
把⼀个格式化时间字符串转化为时间元组，实际上它和strftime()是逆操作。
import time
val = time.strptime("1999-09-18 14:25:20","%Y-%m-%d %H:%M:%S")
print(val)
输出结果：time.struct_time(tm_year=1999, tm_mon=9, tm_mday=18, tm_hour=14, tm_min=25, tm_sec=20, tm_wday=5, tm_yday=261, tm_isdst=-1)
为了记住函数之间的关系，请看下图：
相⽐比于time模块，datetime模块的接口则更更直观、更更容易易调⽤用
datetime.date：表示日期的类。常⽤用的属性有year, month, day；
datetime.time：表示时间的类。常⽤用的属性有hour, minute, second, microsecond；
datetime.datetime：表示日期时间。
datetime.timedelta：表示时间间隔，即两个时间点之间的长度。
datetime.tzinfo：与时区有关的相关信息
import datetime val_1 = datetime.datetime.now() #返回当前的datetime日期类型 print(val_1)
输出结果：2020-09-24 10:16:03.573692
import datetime
val_1 = datetime.datetime.now()
print(val_1.year)
print(val_1.month)
print(val_1.day)
print(val_1.timetuple()) #将val_1返回时间元组格式
输出结果：
import datetime
val_2 = datetime.date.fromtimestamp(1500298456) #把一个时间戳转为datetime日期类型
print(val_2)
输出结果：2017-07-17
时间运算：
import datetime
print(datetime.datetime.now())
val_3 = datetime.datetime.now() + datetime.timedelta(4) #当前时间+4天(默认是天days，还可以传month、hours、minutes,weeks等)
print(val_3)
val_4 = datetime.datetime.now() + datetime.timedelta(hours=4) #当前时间+4小时
print(val_4)
时间替换:
import datetime
val_1 = datetime.datetime.now()
print(val_1)
val_2 = val_1.replace(year=1999,month=9) #返回一个新值，不会改变原数据大小
print(val_2)
Calendar模块有很广泛的方法用来处理年历和月历，例如打印某月的月历：
import calendar
cal = calendar.month(2020, 9)
print("以下输出2020年9月份的日历:")
print(cal)
快捷键 F8 step over模式 直接跳过函数体
快捷键 F7 step into 模式 执行函数体
在一个 python file 中定义函数，可以在另外一个python file 中调用，调用方法为import python file 名，然后用点调取
python file 相当于vba 中的类模块，python file中定义的函数，相当于vba 中类模块的函数/sub 体
1.lambda 函数
lambda表达式，通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用，也就是指匿名函数。
lambda所表示的匿名函数的内容应该是很简单的，如果复杂的话，干脆就重新定义一个函数了，使用lambda就有点过于执拗了。
lambda就是用来定义一个匿名函数的，如果还要给他绑定一个名字的话，就会显得有点画蛇添足，通常是直接使用lambda函数。
case = lambda a,b,c:a+b+c
print(case(5,10,15))
#最精简
print((lambda a,b,c:a+b+c)(5,10,15))
#结果都是35，重点在于显示lambda函数的传参用法
print((lambda a,b,c : a+b+c)(5,10,20))
print((lambda a,b,c=20 : a+b+c)(5,10))
print((lambda a,b,c=20 : a+b+c)(5,b=10))
print((lambda *args:sum(args))(5,10,20))
print((lambda **args:sum(args.values())) (a=5,b=10,c=20))
print((lambda x,*,y=0,z=0:x+y+z)(5,y=10,z=20))
2.map 函数
map(function, sequence) :对sequence中的item依次执行function(item)，将执行结果function(item)组成一个List返回
map(function, sequence[, sequence, ..) -> list: 入参可以是函数和列表/元组/字符串，返回值为function(item)列表
lise_case = [1,2,3,4]
result = map(lambda x:x**2,lise_case)
print(list(result)) #结果：[1, 4, 9, 16]
3.reduce 函数
用于合并
reduce(function, sequence, starting value):对sequence中的item顺序迭代调用function,如果有starting value, 还可以作为初始值调用
function接收的参数个数只能2个,先把sequence中第一一个值和第二个值当参数传给function,再把function的返回值和第三个值当参数传给function,然后只返回一个结果
reduce(function, sequence[, initial]) -> value:入参是为函数和列表/元组/字符串和初始值，返回值为数值
from functools import reduce
print(reduce(lambda x,y:x+y,range(101))) #输出结果：5050
4.filter 函数
用于过滤
filter(function, sequence):对sequence中的item依次执行function(item),将执行结果为True的item组成一个List/String/Tuple(取决于sequence的类型)
filter(function or None, sequence) -> list, tuple, or string:入参为函数和列表/元组/字符串，返回值为item列表/元组/字符串
如果想看以map、reduce、filter函数的返回结果，需要将其列表化
num = [1,2,3,4,5,6,7,8,9]
print(list(filter(lambda x:x%2 == 0,num))) #过滤奇数，保留偶数
#返回结果：[2, 4, 6, 8]
正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配
Python自1.5版本起增加了re模块，它提供Perl风格的正则表达式模式
re模块使Python语言拥有全部的正则表达式功能
1.re.match函数
re.match尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none
re.match写法：
import re
result = re.match("hello","hello world")
print(result)
#输出结果：<re.Match object; span=(0, 5), match='hello'>
re.match返回none：
import re
result = re.match("world","hello world")
print(result)
#输出结果：None
2.re.search函数
re.search扫描整个字符串并返回第一个成功的匹配
re.match与re.search的区别：
re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None
而re.search匹配整个字符串，直到找到一个匹配
import re
result_1 = re.search("hello","hello world")
print(result_1)
#输出结果：<re.Match object; span=(0, 5), match='hello'>
result_2 = re.search("world","hello world")
print(result_2)
#输出结果: <re.Match object; span=(6, 11), match='world'>
如果re.search没有找到匹配值，则返回None
3.Re的通配符
通配符在match函数和search函数中都可以使用
只不过match函数是从开始位置进行匹配，开始位置不符合就返回None
search函数是扫描整个字符串并返回第一个成功的匹配
d表数字
\d表示一个数字
\d+表示至少出现一次数字，上不封顶
\d* 表示0个或多个
\d示例：
\d+的示例：
import re
str_case = '报警电话是110'
result = re.search('\d+',str_case)
print(result)
#输出结果：<re.Match object; span=(5, 8), match='110'>
\d*示例：
4.返回通配符查找结果的索引号和查找值
1.返回索引号:
import re
str_case = '110是报警电话'
result = re.match('\d+',str_case).start()
print(result)
#输出结果：0
result_2 = re.match('\d+',str_case).end()
print(result_2)
#输出结果：3
2.返回查找值
Python模块(Module),是一个Python文件，以.py结尾，包含了Python对象定义和Python语句，模块让你能够有逻辑地组织你的Python代码段
把相关的代码分配到一个模块里能让你的代码更好用，更易懂。模块能定义函数，类和变量，模块里也能包含可执行的代码。
模块定义好后，我们可以使用import语句来引入模块，语法如下:
import module1[, module2[,.. moduleN]]
from--import语句
Python的from语句让你从模块中导入一个指定的部分到当前命名空间中的语法如下:
from modname import name1[, name2[, .. nameN]]
Python的from语句也可以让你从模块中导入模块全部的内容到当前命名空间中的语法如下：（注意，模块小了还可以用，大了不建议用，有些大的模块导入需要3分多钟）
from modname import *
导入路径：
当你导入一个模块，Python 解析器对模块位置的搜索顺序是:
1、当前目录
2、如果不在当前目录，Python 则搜索在shell变量PYTHONPATH下的每个目录。
3、如果都找不到，Python会察看默认路径。 模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。
查看模块的路径：
print(模块名.__file__) #双下划线
Dir显示模块所有的方法：
带双下划线的是系统默认的方法，后面的是自己定义的函数方法
print(dir(模块名))
模块中的IF：
导入模块时，会先把模块文件里的内容都跑一遍，模块文件里的函数如果有调用语句的话，就会被执行
所以为了防止一下问题的发生吗，往往会用到if函数做一个判断
def My_print():
print('这只是一个示例')
if __name__ == '__main__':
My_print()
__main__表示当前的打开的python文件就是定义函数的主程序
导入自定义模块的问题：
主要是自定义模块没有在同python执行文件的同级目录下的问题
文件目录截图示例：
import os print(__file__) #查看当前文件所在的路径 case = os.path.dirname(__file__) #去掉当前路径的最后一项 print(case) case_two = os.path.dirname(os.path.dirname(__file__)) #去掉当前路径的最后两项 print(case_two)
输出结果：
F:/pycharm/data/duibi/file.py
F:/pycharm/data/duibi
F:/pycharm/data
import sys print(sys.path) #返回查找模块的路径，返回的是个列表
输出结果：
#['F:\\pycharm\\data\\duibi', # 'F:\\pycharm\\data', # 'F:\\anaconda3\\python37.zip', # 'F:\\anaconda3\\DLLs', # 'F:\\anaconda3\\lib', # 'F:\\anaconda3', # 'F:\\anaconda3\\lib\\site-packages', # 'F:\\anaconda3\\lib\\site-packages\\win32', # 'F:\\anaconda3\\lib\\site-packages\\win32\\lib', # 'F:\\anaconda3\\lib\\site-packages\\Pythonwin']
module模块内部展示：
import os import sys base_path = os.path.dirname(os.path.dirname(__file__)) sys.path.append(base_path) import module as me me.sayhi()
输出结果：
从第三方库下载python模块：
因为访问外网非常麻烦，所以这里都是用国内的镜像源
1.通过pip命令安装
#清华源 pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 库名 #豆瓣 pip install -i https://pypi.douban.com/simple 库名
遇到网址拦截的时候：
pip install -i http://pypi.douban.com/simple/ 库名 --trusted-host pypi.douban.com
—trusted-host 是通过⽹网站https安全验证⽤用的
2.通过pychrm安装
文件--设置--python解释器--“+”号--输入模块名称--安装
类和对象是面向对象编程的两个核心概念，类是对一群具有相同特征或者行为的事物的一个统称，是抽象的，不能直接使用
特征被称为属性，行为被称为方法
类就相当于制造汽车时的图纸，是一个模板，是负责创建对象的
对象是由类创建出来的一个具体存在，可以直接使用
由哪一个类创建出来的对象，就拥有在哪一个类中定义的: 属性、方法
对象就相当于用图纸制造的飞机，在程序开发中，应该先有类，再有对象
创建类：
class类名:
def方法1(self,参数列表):
pass
def方法2(self,参数列表):
pass
方法的定义格式和之前学习过的函数几乎—样，区别在于第一个参数必须是self
常用类的基本特性：
下面的几种方法可以理解为VBA中的事件，当……的时候，执行……的操作
方法中的self参数：
用于给对象增加属性
在python中，要给对象设置属性，非常的容易，但是不推荐使用，因为:对象属性的封装应该封装在类的内部
在类封装的方法内部，self 就表示当前调用方法的对象自己
调用方法时，程序员不需要传递self参数
在方法内部，可以通过self.p访问对象的属性，也可以通过self.调用其他的对象方法
创建对象：
当一个类定义完成之后，要使用这个类来创建对象，语法格式如下:
对象变量=类名()
示例：
关于__str()__函数：
内部类与隐藏方法：
偶尔使用的类可以作为内部类，减轻代码工作量
不希望在对象实例中被访问的方法就是隐藏方法，通过在方法名称前加__前缀就可以实现隐藏方法
类的继承：
实现代码的重用，相同的代码不需要重复的编写
继承的传递性：C类从B类继承，B类又从A类继承那么C类就具有B类和A类的所有属性和方法
子类拥有父类以及父类的父类中封装的所有属性和方法
继承的语法：
class 类名(父类名):
pass
子类继承自父类，可以直接享受父类中已经封装好的方法，不需要再次开发
子类应该根据新的需求，封装子类特有的属性和方法
示例:
方法的重写：
当父类的方法实现不能满足子类需求时，可以对方法进行重写
覆盖父类的方法：
如果在开发中，父类的方法实现和子类的方法实现，完全不同，就可以使用覆盖的方式
class Animal:
def __init__(self):
print('这是动物类')
def eat(self):
print('动物吃食物')
class Dog(Animal):
def __init__(self):
print('这是狗狗类')
def eat(self):
print('小狗爱吃骨头')
case = Dog()
case.eat() #此时的eat就是Dog类的，子级的eat覆盖了父级的eat
#输出结果：
这是狗狗类
小狗爱吃骨头
在子类中重新编写父类的方法实现对父类方法进行扩展：
如果在开发中，子类的方法实现中包含父类的方法实现，父类原本封装的方法实现是子类方法的一部分就可以使用扩展的方式，
在子类中重写父类的方法在需要的位置使用super().父类方法来调用父类方法的执行
class Animal:
def __init__(self):
print('这是动物类')
def eat(self):
print('动物吃食物')
class Dog(Animal):
def __init__(self):
print('这是狗狗类')
def eat(self): #覆盖了父级的eat方法，但下行语句调用了父级的eat
super().eat() #调用父级的eat方法
print('小狗爱吃骨头')
case = Dog()
case.eat()
#输出结果：
这是狗狗类
动物吃食物
小狗爱吃骨头
多态：
多态可以增加代码的灵活度，以继承和重写父类方法为前提，是调用方法的技巧，不会影响到类的内部设计
多态有两种形式：
1.多态不同的子类对象调用相同的父类方法，产生不同的执行结果
class Animal:
def __init__(self):
print('这是动物类')
def eat(self):
print('动物吃食物')
class Dog(Animal):
def __init__(self):
print('这是狗狗类')
def eat(self):
print('小狗爱吃骨头')
case_1 = Dog()
case_1.eat()
case_2 = Animal()
case_2.eat()
#输出结果：
# 这是狗狗类
# 小狗爱吃骨头
# 这是动物类
# 动物吃食物
2.同一种类中，同一个方法，如果参数变得不同，会出现不同的结果
class Dog:
def __init__(self):
print('这是狗狗类')
def eat(self,x = None):
if x == None:
print('小狗爱吃骨头')
else:
print('小狗爱吃'+str(x))
case = Dog()
case.eat()
case.eat('肉肉')
#输出结果：
# 这是狗狗类
# 小狗爱吃骨头
# 小狗爱吃肉肉
