testst

字符串
1、a.split()
b = a.split(’,’)
按照符号分割字符串组成新的列表
a.split(str="", num=string.count(str))

参数
str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等
num – 分割次数。默认为 -1, 即分隔所有

2、a.replace()
b = a.replace(old, new[, max])

参数
old – 将被替换的子字符串
new – 新字符串，用于替换old子字符串
max – 可选字符串, 替换不超过 max 次

3、len(a)
a如果为字符串，返回字符串长度
a如果为列表，返回元素个数

4、a[:]
a[1:5]
返回第2-4个字符

5、a.capitalize()
将字符串第一个字符改为大写

6、a.casefold()
将整个字符串改为小写

7、a.isalpha()
如果字符串至少有一个字符并且其他所有字符都是字符返回True，否则False

8、a.islower()
如果字符串只包含数字则返回True，否则False

9、a.islower()
如果字符串中至少包含一个区分

10、a.isspace()
如果字符串中只包含空格则返回True，否则False

11、a.join()
a.join(sub)
以字符串为分隔符，插入到sub中所有的字符之间

12、a.lstrip()
b = a.lstrip()
去掉字符串左边的所有空格

13、a.rstrip()
b = a.rstrip()
去掉字符串右边的所有空格

14、a.partition()
a.partition(sub)
找到字符串sub把字符串分成左，sub，右三个元组

又例：
str = ‘青花瓷（live版）’
head, sep, tail = str.partition(’(’)
print(head)

15、a.split()
a.split(sep=None,maxsplit=-1)
不带参数默认以空格为分隔符切片字符串，maxsplit表示仅分隔mxsplit个字符串

16、a.swapcase()
翻转字符大小写

17、a.find()
a.find(str, beg=0, end=len(string))+21
检测字符串中是否包含子字符串str，如果指定beg（开始）和 end（结束）范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1。
后面+多少表示向后偏移多少位

18、a.format()
把字符串中{}替换为format中的字符
‘ab{}d’.format(‘c’)

abcd

19、str.rjust()
返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串
str.rjust(width[, fillchar])

参数
width
指定填充指定字符后中字符串的总长度

fillchar
填充的字符，默认为空格

列表
1、del a[index]
del 可以删除列表中的单个元素，a表示列表名称，index表示元素的索引值

2、a.append()
a.append(‘abc’)
将一个字符串添加到列表最后一个元素

3、a.extend()
a.extend([‘abc’,‘123’])
将一个列表添加到列表最后

4、a.insert()
a.insert(1,‘abc’)
将abc插入到第二位元素

5、a.remove()
a.remove(‘abc’)
将一个字符串从列表中移除

6、a.pop()
默认移除列表中最后一位元素

7、列表分片
a = [1,2,3,4]
a[1:3] = 1,2
列表分片会得到原来列表的拷贝
也可以a[:3],a[1:],a[:]

8、a.count()
a.count(‘abc’)
返回一个字符串在列表中出现的次数

9、a.index()
a.index(‘abc’,0,2)
返回一个字符串在列表中第一次出现的位置，后两个参数限制搜索范围

10、a.reverse()
将列表元素顺序倒过来

11、a.sort()
将列表元素升序排列

参数
func：指定排序的算法
key：与算法搭配的关键字
reverse：=True降序，=False升序

字典
1、创建字典
字典是另一种可变容器模型，且可存储任意类型对象
字典的每个键值key=>value对用冒号:分割，每个对之间用逗号,分割，整个字典包括在花括号{}中
a = {key1 : value1, key2 : value2 }
dict1 = { ‘abc’: 456 }

2、访问字典里的值
dict = {‘Name’: ‘Runoob’}
print (dict[‘Name’])

Runoob

3、访问字典的键
dict = {1:‘a’, 2:‘b’}
for i in dict:
print(i)

1
2

4、向字典中添加新键
a.update({1:‘a’, 2:‘b’})

5、获取字典的全部键
print(list(a.keys()))

[1,2]

6、获取字典的全部值
print(list(a.values()))

[‘a’,‘b’]

7、获取字典的全部键值对
print(list(a.items()))

[(1,‘a’),(2,‘b’)]

Python bytes 类型用来表示一个“字节串”
bytes 是 Python 3.x 新增的类型，在 Python 2.x 中是不存在的

bytes 只负责以字节序列的形式（二进制形式）来存储数据，至于这些数据到底表示什么内容（字符串、数字、图片、音频等），完全由程序的解析方式决定。如果采用合适的字符编码方式（字符集），字节串可以恢复成字符串；反之亦然，字符串也可以转换成字节串

bytes 类型的数据非常适合在互联网上传输，可以用于网络通信编程；bytes 也可以用来存储图片、音频、视频等二进制格式的文件

文件
a.write()
向文件写入一个字符串

a.writelines()
方法用于向文件中写入一序列的字符串，这一序列字符串可以是由迭代对象产生的，如一个字符串列表，换行需要制定换行符 \n

进制转换

十进制转化成二进制
使用python的内置方法bin()
dec=10
print bin(dec)

0b1010
python 中二进制以ob开头

十进制转化为八进制
dec=10
print oct(dec)

012

十进制转化16进制
dec=10
print hex(dec)

0xa

os库
提供操作系统的接口，常用的有文件系统相关和进程相关
1、os.listdir()
用于返回指定的文件夹包含的文件或文件夹的名字的列表
os.listdir(path)

参数
path – 需要列出的目录路径

如果目录名字为中文 需要转码处理
uPath = unicode(cPath,‘utf-8’)

2、os.path模块
os.path.abspath(path) 返回绝对路径
os.path.basename(path) 返回文件名
os.path.commonprefix(list) 返回list(多个路径)中，所有path共有的最长的路径
os.path.dirname(path) 返回文件路径
os.path.exists(path) 如果路径 path 存在，返回 True；如果路径 path 不存在，返回 False。
os.path.lexists 路径存在则返回True,路径损坏也返回True
os.path.expanduser(path) 把path中包含的"_"和"user"转换成用户目录
os.path.expandvars(path) 根据环境变量的值替换path中包含的"$name"和"${name}"
os.path.getatime(path) 返回最近访问时间（浮点型秒数）
os.path.getmtime(path) 返回最近文件修改时间
os.path.getctime(path) 返回文件 path 创建时间
os.path.getsize(path) 返回文件大小，如果文件不存在就返回错误
os.path.isabs(path) 判断是否为绝对路径
os.path.isfile(path) 判断路径是否为文件
os.path.isdir(path) 判断路径是否为目录
os.path.islink(path) 判断路径是否为链接
os.path.ismount(path) 判断路径是否为挂载点
os.path.join(path1[, path2[, …]]) 把目录和文件名合成一个路径
os.path.normcase(path) 转换path的大小写和斜杠
os.path.normpath(path) 规范path字符串形式
os.path.realpath(path) 返回path的真实路径
os.path.relpath(path[, start]) 从start开始计算相对路径
os.path.samefile(path1, path2) 判断目录或文件是否相同
os.path.sameopenfile(fp1, fp2) 判断fp1和fp2是否指向同一文件
os.path.samestat(stat1, stat2) 判断stat tuple stat1和stat2是否指向同一个文件
os.path.split(path) 把路径分割成 dirname 和 basename，返回一个元组
os.path.splitdrive(path) 一般用在 windows 下，返回驱动器名和路径组成的元组
os.path.splitext(path) 分割路径，返回路径名和文件扩展名的元组
os.path.splitunc(path) 把路径分割为加载点与文件
os.path.walk(path, visit, arg) 遍历path，进入每个目录都调用visit函数，visit函数必须有3个参数(arg, dirname, names)，dirname表示当前目录的目录名，names代表当前目录下的所有文件名，args则为walk的第三个参数
os.path.supports_unicode_filenames 设置是否支持unicode路径名

3、os.remove()
删除一个文件或文件夹
os.remove(path)

参数
path是文件的路径，如果这个路径是一个文件夹，则会抛出OSError的错误

4、os.system()
调用cmd命令

ping命令
ping -n 指定发送包数量

返回值
0为ping通
1未ping通

5、os.rename(Olddir, Newdir)
文件重命名

sys库
提供python解释器系统的通用配置和函数，影响着解释器的行为
1、sys.stdout.write()
sys.stdout.write()方法跟print()方法的区别是 前者打印不换行，后者换行

2、sys.stdout.flush()
立即刷新输出的内容

编码
web、文档中各类制式编码转换为中文

形似\u4e2d\u56fd\u6c5f\u82cf\u7701的转换为中文
a = ‘\u4e2d’
b = a.encode(‘utf-8’)
c = b.decode(‘utf-8’)

形似\xe4\xb8\xad\xe5\x9b\xbd的转换为中文
a = ‘\xe4’
b = a.decode(‘utf-8’)

“相当于 -> '或”

decode编码
str.decode(encoding=‘UTF-8’,errors=‘strict’)

参数
encoding – 要使用的编码，如"UTF-8"。
errors – 设置不同错误的处理方案。默认为 ‘strict’,意为编码错误引起一个UnicodeError。 其他可能得值有 ‘ignore’, ‘replace’, ‘xmlcharrefreplace’, ‘backslashreplace’ 以及通过 codecs.register_error() 注册的任何值。

UnicodeDecodeError: ‘utf8’ codec can’t decode byte 0xa1 in position 6: invalid start byte

将：
j = json.loads(line.decode(‘utf-8’))

改为：
j = json.loads(line.decode(‘ISO-8859-1’))

round() 函数
返回浮点数 x 的四舍五入值，准确的说保留值将保留到离上一位更近的一端（四舍六入），精度要求高的，不建议使用该函数。

print ("round(70.23456) : ", round(70.23456))

round(70.23456) : 70

print ("round(56.659,1) : ", round(56.659,1))

round(56.659,1) : 56.7

print ("round(80.264, 2) : ", round(80.264, 2))

round(80.264, 2) : 80.26

print ("round(100.000056, 3) : ", round(100.000056, 3))

round(100.000056, 3) : 100.0

print ("round(-100.000056, 3) : ", round(-100.000056, 3))

round(-100.000056, 3) : -100.0

random库
1、random.random()
返回随机生成的一个实数，它在[0,1)范围内

2、random.randint()
产生x到y的一个整数型随机数
random.randint(x,y)

3、random.sample()
实现从序列或集合seq中随机选取k个独立的的元素
random.sample(seq, k)

参数：
seq：元组、列表或字符串
k：选取元素个数

time库
1、time.time()
用于获取当前时间戳
时间戳单位最适于做日期运算。但是1970年之前的日期就无法以此表示了。太遥远的日期也不行，UNIX和Windows只支持到2038年

2、time.localtime()
获取当前年月日时分秒时间

3、time.asctime()
获取格式化的时间

4、time.strftime(format[, t])
格式化日期

格式化成2016-03-20 11:45:39形式

print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))

格式化成Sat Mar 28 22:24:24 2016形式

print(time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()))

python中时间日期格式化符号：
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-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 当前时区的名称
%% %号本身

5、time.sleep(secs)
推迟调用线程的运行，secs指秒数

不会耗内存，也不会给计算机的运行造成压力，sleep()函数会主动通知操作系统，自己进入休眠模式，在指定的时间内不用调度自己

6、time.perf_counter()
获取程序执行时间

start = time.perf_counter()

代码块

end = time.perf_counter()
print(‘Running time: %s Seconds’ % (end - start))

7、time.mktime()
将格式化时间转换为时间戳
t = ‘2021-09-13 21:45:42’
timeArray = time.strptime(t, ‘%Y-%m-%d %H:%M:%S’)
timeStamp = int(time.mktime(timeArray))
print(timeStamp)

1631540742

8、将时间戳转换为格式化时间
now = int(time.time())
timeArray = time.localtime(now)
otherStyleTime = time.strftime("%Y-%m-%d %H:%M:%S", timeArray)
或
print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(int(time.time()))))

datetime库
1、datetime.datetime.strptime()
str类型的日期转换为时间戳
a = ‘2013-10-10 23:40:00’
b = datetime.datetime.strptime(a, “%Y-%m-%d %H:%M:%S”)

2、datetime.datetime.strftime()
时间戳转换为指定格式的日期
timeStamp = 1381419600
dateArray = datetime.datetime.utcfromtimestamp(timeStamp)
otherStyleTime = dateArray.strftime("%Y-%m-%d %H:%M:%S")

3、获取当前格式化时间
today = datetime.date.today()
print(today, today.year, today.month, today.day)
或
today = str(datetime.datetime.now().strftime(’%Y-%m-%d %H:%M:%S’))

4、获取当前时间戳
today = datetime.datetime.now().timestamp()

5、获取昨天日期
def get_yesterday():
now_time = datetime.datetime.now()
yesterday = (now_time + datetime.timedelta(days=-1)).strftime("%Y-%m-%d")
return yesterday

print(get_yesterday())

calendar库
1、calendar.month()
获取某月日历
calendar.month(2016, 1)

2、calendar.calendar()
返回一个多行字符串格式的year年年历，3个月一行，间隔距离为c。 每日宽度间隔为w字符。每行长度为21* W+18+2* C。l是每星期行数
calendar.calendar(year,w=2,l=1,c=6)

3、calendar.firstweekday( )
返回当前每周起始日期的设置。默认情况下，首次载入 calendar 模块时返回 0，即星期一

4、calendar.isleap()
是闰年返回 True，否则为 False
calendar.isleap(year)

import calendar
print(calendar.isleap(2000))
True

print(calendar.isleap(1900))
False

5、calendar.leapdays()
返回在Y1，Y2两年之间的闰年总数
calendar.leapdays(y1,y2)

6、calendar.month()
返回一个多行字符串格式的year年month月日历，两行标题，一周一行。每日宽度间隔为w字符。每行的长度为7* w+6。l是每星期的行数
calendar.month(year,month,w=2,l=1)

7、calendar.monthcalendar()
返回一个整数的单层嵌套列表。每个子列表装载代表一个星期的整数。Year年month月外的日期都设为0;范围内的日子都由该月第几日表示，从1开始
calendar.monthcalendar(year,month)

8、calendar.monthrange()
返回两个整数。第一个是该月的星期几的日期码，第二个是该月的日期码。日从0（星期一）到6（星期日）;月从1到12
calendar.monthrange(year,month)

9、calendar.prcal(year,w=2,l=1,c=6)
相当于 print calendar.calendar(year,w=2,l=1,c=6)

10、calendar.prmonth(year,month,w=2,l=1)
相当于 print calendar.month(year,month,w=2,l=1)

11、calendar.setfirstweekday()
设置每周的起始日期码。0（星期一）到6（星期日）
calendar.setfirstweekday(weekday)

12、calendar.timegm()
和time.gmtime相反：接受一个时间元组形式，返回该时刻的时间戳（1970纪元后经过的浮点秒数）
calendar.timegm(tupletime)

13、calendar.weekday()
返回给定日期的日期码。0（星期一）到6（星期日）。月份为 1（一月） 到 12（12月）
calendar.weekday(year,month,day)

运行python程序不显示cmd的方法
运行python程序的时候会在背景显示一个cmd
方法1:pythonw xxx.py
方法2:将.py改成.pyw (这个其实就是使用脚本解析程序pythonw.exe)

全局变量global
count = 0
def a():
global count
count += 1
for i in range(5):
a()
print(count)

5

断言assert
用于判断一个表达式，在表达式条件为false的时候触发异常。断言可以在条件不满足程序运行的情况下直接返回错误，而不必等待程序运行后出现崩溃的情况。

assert True
条件为true正常执行

assert False

Traceback (most recent call last):
File “C:/Users/把爱送到家/Desktop/py/test - 副本 - 副本.py”, line 1, in
assert False
AssertionError

urllib库

urllib是python内置的HTTP请求库，无需安装即可使用，它包含了4个模块：
request：它是最基本的http请求模块，用来模拟发送请求
error：异常处理模块，如果出现错误可以捕获这些异常
parse：一个工具模块，提供了许多URL处理方法，如：拆分、解析、合并等
robotparser：主要用来识别网站的robots.txt文件，然后判断哪些网站可以爬

urllib.request模块

1、urllib.request.urlopen()
urllib.request.urlopen(url,data=None,[timeout,],cafile=None,capath=None,cadefault=False,context=None)
请求站点获得一个HTTP对象，获取一个GET请求

url参数

a = urllib.request.urlopen(‘http://www.baidu.com’)
上述是通过请求百度的get请求获得百度，下面使用urllib的post请求

data参数

data = bytes(urllib.parse.urlencode({‘word’: ‘hello’}), encoding=‘utf8’)
这里就用到urllib.parse，通过bytes(urllib.parse.urlencode())可以将post数据进行转换放到urllib.request.urlopen的data参数中，这样就完成了一次post请求

所以如果我们添加data参数的时候就是以post请求方式请求，如果没有data参数就是get请求方式

timeout参数

在某些网络情况不好或者服务器端异常的情况会出现请求慢的情况，或者请求异常，所以这个时候我们需要给请求设置一个超时时间，而不是让程序一直在等待结果
urllib.request.urlopen(‘http://httpbin.org/get’, timeout=1)

2、a.read().decode()
读取并解析已urlopen的网址，返回网页源代码

参数
decode(‘UTF-8’)
默认为utf-8编码

3、a.status()
返回网页响应状态码，如404,200,504

4、a.getheaders()
返回网页响应头信息，与6一样

5、urllib.request.Requset()
urllib.request.Request(url,data=None,headers={},origin_req_host=None,unverifiable=False,method=None)
请求访问回传网站表单信息

参数
url：请求的URL，必须传递的参数，其他都是可选参数
data：上传的数据，必须传bytes字节流类型的数据，如果它是字典，可以先用urllib.parse模块里的urlencode()编码
headers：它是一个字典，传递的是请求头数据，可以通过它构造请求头，也可以通过调用请求实例的方法add_header()来添加
origin_req_host：指请求方的host名称或者IP地址
unverifiable：表示这个请求是否是无法验证的，默认为False，如我们请求一张图片如果没有权限获取图片那它的值就是true
method：是一个字符串，用来指示请求使用的方法，如：GET,POST,PUT等

6、a.info()
返回网页的响应头信息，与4一样

7、rulllib.request.ProxyHandler()
很多网站都会检测某一段时间某个IP的访问次数，如果同一个IP访问过于频繁，那么该网站就会禁止来自该IP的访问，针对这种情况，可以使用代理服务器，每隔一段时间换一个马甲
urllib.request.ProxyHandler({“http”: “211.141.111.114:61395”})

8、urllib.request.HTTPCookieProcessor()
cookie中保存中我们常见的登录信息，有时候爬取网站需要携带cookie信息访问,这里用到了http.cookijar，用于获取cookie以及存储cookie
同时cookie可以写入到文件中保存，有两种方式http.cookiejar.MozillaCookieJar和http.cookiejar.LWPCookieJar()

urllib.parse模块

1、urllib.parse.urlparse(）
urllib.parse.urlparse(urlstring,scheme=’’,allow_fragments=True)

参数
urlstring：待解析的URL，字符串
scheme：它是默认的协议，如http或者https，URL如果不带http协议，可以通过scheme来指定，如果URL中制定了http协议则URL中生效
allow_fragments：是否忽略fragment即锚点，如果设置为False，fragment部分会被忽略，反之不忽略

2、urllib.parse.urlunparse()
与urlparse()相反，通过列表或者元祖的形式接受一个可迭代的对象，实现URL构造

3、urllib.parse.urlsplit()
与urlparse()方法类似，它会返回5个部分，把params合并到path中

4、urllib.parse.urlunsplit()
与urlunparse()类似，它也是将链接的各部分组合完整的链接的方法，传入的参数也是可迭代的对象，如列表元祖等，唯一的区别是长度必须是5个，它省略了params

5、urllib.parse.urljoin()
通过将基本URL（base）与另一个URL(url)组合起来构建完整URL，它会使用基本URL组件，协议(schemm)、域名(netloc)、路径(path)、来提供给URL中缺失的部分进行补充，最后返回结果
base_url提供了三项内容scheme,netloc,path，如果这3项在新的链接中不存在就给予补充，如果新的链接存在就使用新的链接部分，而base_url中的params,query和fragment是不起作用的。通过urljoin()方法可以实现链接的解析、拼接和生成

6、urllib.parse.urlencode()
urlencode()在构造GET请求参数时很有用，它可以将字典转化为GET请求参数

7、urllib.parse.parse_qs()
parse_qs()与urlencode()正好相反，它是用来反序列化的，如将GET参数转换回字典格式

8、urllib.parse.parse_qsl()
它将参数转换为元祖组成的列表

9、urllib.parse.quote()
把url中的中文转码成url形式
该方法可以将内容转换为URL编码的格式，如参数中带有中文时，有时会导致乱码的问题，此时用这个方法将中文字符转化为URL编码

10、urllib.parse.unquote()
与urllib.parse.quote()相反，他用来进行URL解码

urllib.Robots模块
利用urllib的robotparser模块，我们可以实现网站Robots协议的分析

1、Robots协议
Robots协议也称为爬虫协议、机器人协议，它的全名叫做网络爬虫排除标准(Robots Exclusion Protocol)，用来告诉爬虫和搜索引擎哪些网页可以抓取，哪些不可以抓取，它通常是一个robots.txt的文本文件，一般放在网站的根目录下。
当搜索爬虫访问一个站点时，它首先会检查这个站点根目录下是否存在robots.txt文件，如果存在，搜索爬虫会根据其中定义的爬去范围来爬取，如果没有找到，搜索爬虫会访问所有可直接访问的页面

我们来看下robots.txt的样例：
User-agent: *
Disallow: /
Allow: /public/

它实现了对所有搜索爬虫只允许爬取public目录的功能，将上述内容保存为robots.txt文件放在网站根目录下，和网站的入口文件（index.html）放在一起
User-agent描述了搜索爬虫的名称，将其设置为*则代表协议对任何爬虫有效，如设置为Baiduspider则代表规则对百度爬虫有效，如果有多条则对多个爬虫受到限制，但至少需要指定一条
一些常见的搜索爬虫名称：
BaiduSpider　　百度爬虫 www.baidu.com
Googlebot　　Google爬虫 www.google.com
360Spider　　360爬虫 www.so.com
YodaoBot　　有道爬虫 www.youdao.com
ia_archiver　　Alexa爬虫 www.alexa.cn
Scooter　　altavista爬虫 www.altavista.com
Disallow指定了不允许抓取的目录，如上例中设置的/则代表不允许抓取所有的页面
Allow一般和Disallow一起使用，用来排除单独的某些限制，如上例中设置为/public/则表示所有页面不允许抓取，但可以抓取public目录
设置示例：
#禁止所有爬虫
User-agent: *
Disallow: /

#允许所有爬虫访问任何目录,另外把文件留空也可以
User-agent: *
Disallow:

#禁止所有爬虫访问某那些目录
User-agent: *
Disallow: /home/
Disallow: /tmp/

#只允许某一个爬虫访问
User-agent: BaiduSpider
Disallow:
User-agent: *
Disallow: /

2、robotparser模块
rebotparser模块用来解析robots.txt，该模块提供了一个类RobotFileParser，它可以根据某网站的robots.txt文件来判断一个抓取爬虫时都有权限来抓取这个网页
urllib.robotparser.RobotFileParser(url=’’)

robotparser类常用的方法：
set_url()：用来设置robots.txt文件的连接，如果在创建RobotFileParser对象是传入了连接，就不需要在使用这个方法设置了
read()：读取reobts.txt文件并进行分析，它不会返回任何内容，但执行那个了读取和分析操作
parse()：用来解析robots.txt文件，传入的参数是robots.txt某些行的内容，并安装语法规则来分析内容
can_fetch()：该方法传入两个参数，第一个是User-agent，第二个是要抓取的URL，返回的内容是该搜索引擎是否可以抓取这个url,结果为True或False
mtime()：返回上次抓取和分析robots.txt的时间
modified()：将当前时间设置为上次抓取和分析robots.txt的时间

正则表达式

1、search()方法
re.search(r’abc’,‘123abc456’)

在字符串中找到该组字符

re.search(r’.’,‘123’)

在字符串中找到第一个字符返回

re.search(r’\d’,‘abc123’)

在字符串中找到数字

创建字符类，匹配字符类中任何一个字符都算匹配
re.search(r’[abc],‘123abc’)

re.search(r’[a-z]’,‘123abc’)

创建a-z所有字母字符串

re.search(r’a{3}bc’,‘123aaabc’)

大括号表示前面的字符要重复匹配多少次

re.search(r’a{3,5}bc’,‘123aaaabc’)

大括号表示前面的字符要重复匹配多少次，并给定范围

正则表达式基本语法
两个特殊的符号’^‘和’${}^{\prime }。他们的作用是分别指出一个字符串的开始和结束。例子如下：{"}^{A}bc"：表示所有以"Abc"开始的字符串"Abc$"：表示所以以"Abc"结尾的字符串
“^Abc$"：表示开始和结尾都是"Abc"的字符串（找自己）"Abc"：表示任何包含"Abc"的字符串。"Abc\ast "：表示一个字符串有一个A后面跟着零个或若干个c"Abc+"：表示一个字符串有一个A后面跟着至少一个c或者更多；"Abc?"：表示一个字符串有一个A后面跟着零个或者一个c；"a?b+$”：表示在字符串的末尾有零个或一个a跟着一个或几个b。

你也可以使用范围，用大括号括起，用以表示重复次数的范围
“ab{2}”：表示一个字符串有一个a跟着2个b（“abb”）
“ab{2,}”：表示一个字符串有一个a跟着至少2个b
“ab{3,5}”：表示一个字符串有一个a跟着3到5个b

请注意，你必须指定范围的下限（如："{0,2}“而不是”{,2}"）。还有，你可能注意到了，’*’，’+‘和’?'相当于"{0,}"，"{1,}“和”{0,1}"

还有一个’|’，表示“或”操作：
“hi|hello”：表示一个字符串里有"hi"或者"hello"
“(b|cd)ef”：表示"bef"或"cdef"
“(a|b)*c”：表示一串"a"“b"混合的字符串后面跟一个"c”

'.'可以替代任何字符：

“a.[0-9]”：表示一个字符串有一个"a"后面跟着一个任意字符和一个数字
“^.{3}$”：表示有任意三个字符的字符串（长度为3个字符）

方括号表示某些字符允许在一个字符串中的某一特定位置出现：
“[ab]”：表示一个字符串有一个"a"或"b"（相当于"a|b"）；
“[a-d]”：表示一个字符串包含小写的’a’到’d’中的一个（相当于"a|b|c|d"或者"[abcd]"）
“¹”：表示一个以字母开头的字符串
“[0-9]%”：表示一个百分号前有一位的数字
“,[a-zA-Z0-9]$”：表示一个字符串以一个逗号后面跟着一个字母或数字结束

\d 匹配数字，即0-9
\d+匹配任意数量数字
\D 匹配非数字，即不是数字
\s 匹配空白，即 空格，tab键
\S 匹配非空白
\w 匹配非特殊字符，即a-z、A-Z、0-9、、汉字
\W 匹配特殊字符，即非字母、非数字、非汉字、非

你也可以在方括号里用’^{‘表示不希望出现的字符，’}'应在方括号里的第一位（如："%[^a-zA-Z]%"表示两个百分号中不应该出现字母）

为了逐字表达，你必须在"^.$()|*+?{"这些字符前加上转移字符’’。

请注意在方括号中，不需要转义字符

匹配两个字符串A与B中间的字符串包含A与B：
表达式:A.*?B（“.“表示任意字符，“？”表示匹配0个或多个）
示例:Awww.apizl.comB
结果:Awww.apizl.comB

匹配两个字符串A与B中间的字符串包含A但是不包含B：
表达式:A.*?(?=B)
示例:Awww.apizl.comB
结果:Awww.apizl.com

匹配两个字符串A与B中间的字符串不包含A但是包含B：
表达式:(?<=A).*?B
示例:Awww.apizl.comB
结果:www.apizl.comB

匹配两个字符串A与B中间的字符串且不包含A与B：
表达式:(?<=A).*?(?=B)
示例:Awww.apizl.comB
结果:www.apizl.com

(?:pattern) 非捕获匹配，匹配pattern但不获取匹配结果，不进行存储供以后使用
(?=pattern) 非捕获匹配，正向肯定预查，在任何匹配pattern的字符串开始处匹配查找字符串，不进行存储供以后使用
(?!pattern) 非捕获匹配,正向否定预查，在任何不匹配pattern的字符串开始处匹配查找字符串，不进行存储供以后使用
(?<=pattern) 非捕获匹配，反向肯定预查，与正向肯定预查类似，但是方向相反
(?

2、findall()方法
re.findall()
找到字符串中所有匹配的内容，返回一个列表

3、compile()方法
如果需要重复地使用某个正则表达式，可以先将该正则表达式编译成模式对象，使用re.compile()方法来编译

a = re.compile(r’a’)
a.search(‘aaa’)

4、group()方法
例：a = re.search(r’a’,‘abc’)
b = a.group()
print(b)
a
返回a中查找到的字符

a.start()
开始位置
a.end()
结束位置
a.span()
范围

bs4 - BeautifulSoup

bs = BeautifulSoup(a,‘html.parser’)
打开读取html文件

参数a为html内容

1、bs.title
读取title标签行

2、bs.title.name
读取title标签名title

3、bs.title.string
读取title标签内容

4、bs.title.parent.name
读取title父标签名

5、bs.a
读取a标签行

6、从文档中找到所有标签的链接
for link in bs.find_all(‘a’):
print(link.get(‘href’))

http://example.com/elsie
http://example.com/lacie
http://example.com/tillie

7、bs.p
读取p标签行

8.bs.head
读取head标签行

9、ba.a.attrs
读取a标签所有属性值

10、bs.head.contents
获取Tag所有子节点，返回list

11、bs.find_all()
读取该标签所有匹配的行，返回一个列表

参数
limit
如bs.find_all(‘a’,limit=3)
查找a标签3次

如bs.find_all(‘a’)，bs.find_all(id=‘cl’)
bs.find_all(text=‘贴吧’)
查找’贴吧’文本

12、bs.find_all(re.compile())
读取包含该字符的标签

bs.find_all(text=re.compile(’\d’))
应用正则表达式来查找包含特定文本的内容

13、bs.find()
找到第一个符合条件的标签行，返回一个字符串
bs.find(‘title’)

14、从文档中获取所有文字内容
print(bs.get_text())

15、tag的属性的操作方法
例：
print(tag[‘class’])

u’boldest’

16、可以嵌套使用
如bs.head.title
bs.find(“head”).find(“title”)

17、css选择器
bs.select(‘title’)
通过标签查找
bs.select(’.mnav’)
通过类名查找
bs.select(’#u1’)
通过id查找
bs.select(‘a[class=‘bri’]’)
通过属性查找
bs.select(’‘head>title)
通过子标签查找
bs.select(’.mnav~.bri’)
通过兄弟标签查找

lxml库

XPath常用规则
表达式 描述
nodename 选取此节点的所有子节点
/ 从当前节点选取直接子节点
// 从当前节点选取子孙节点
. 选取当前节点
… 选取当前节点的父节点
@ 选取属性

•   通配符，选择所有元素节点与元素名
  

@* 选取所有属性
[@attrib] 选取具有给定属性的所有元素
[@attrib=‘value’] 选取给定属性具有给定值的所有元素
[tag] 选取所有具有指定元素的直接子节点
[tag=‘text’] 选取所有具有指定元素并且文本内容是text节点

from lxml import etree
若网页源代码 = a

1、etree.HTML()
初始化生成一个XPath解析对象
b = etree.HTML(a)

2、etree.tostring()
解析对象输出代码，网页源代码
result = etree.tostring(b,encoding=‘utf-8’)

3、etree.parse()
打开html文件导入
指定解析器HTMLParser会根据文件修复HTML文件中缺失的如声明信息
b = etree.parse(‘a.html’,etree.HTMLParser())
result = etree.tostring(b)

4、b.xpath()
获取xpath
c = b.xpath(’//li[@class=“item-1”]’)

5、按序选择
获取所有li节点下a节点的内容
result=html.xpath(’//li[contains(@class,“aaa”)]/a/text()’)

获取第一个
result1=html.xpath(’//li[1][contains(@class,“aaa”)]/a/text()’)

获取最后一个
result2=html.xpath(’//li[last()][contains(@class,“aaa”)]/a/text()’)

获取第一个
result3=html.xpath(’//li[position()>2 and position()<4][contains(@class,“aaa”)]/a/text()’)

获取倒数第三个
result4=html.xpath(’//li[last()-2][contains(@class,“aaa”)]/a/text()’)

6、文本获取
获取a节点下的内容
b.xpath(’//li[@class=“item-1”]/a/text()’)

7、消除xpath返回带文本的列表中的转义字符’\r\n\t\t\r\n\t\t\t’
b = etree.HTML(a)
c = b.xpath(’//*[@id=“body”]/div/div/div/div/div/h4/text()’)
c = [x.strip() for x in c]
print©

8、属性获取
获取a的href属性
b.xpath(’//li/a/@href’)

requests
Requests: 让 HTTP 服务人类
Requests 唯一的一个非转基因的 Python HTTP 库，人类可以安全享用

1、requests.get()
a=requests.get(url,params,headers)

获取某个网页

参数
params
如果你是手工构建 URL，那么数据会以键/值对的形式置于 URL 中，跟在一个问号的后面，使用 params 关键字参数，以一个字符串字典来提供这些参数

rear = {‘key1’: ‘value1’, ‘key2’: ‘value2’}
a=requests.get(“http://httpbin.org/get”, params=rear)
http://httpbin.org/get?key2=value2&key1=value1

还可以将一个列表作为值传入：
rear={‘key1’: ‘value1’, ‘key2’: [‘value2’, ‘value3’]}
a=requests.get(‘http://httpbin.org/get’, params=rear)
http://httpbin.org/get?key1=value1&key2=value2&key2=value3

headers
添加网页请求头

2、requests.post()
a=requests.post(‘http://httpbin.org/post’, data = {‘key’:‘value’})
发送一个 HTTP POST请求

3、requests.put()
a=requests.put(‘http://httpbin.org/put’, data = {‘key’:‘value’})
发送一个 HTTP PUT请求

4、requests.delete()
a=requests.delete(‘http://httpbin.org/delete’)
发送一个 HTTP DELETE请求

5、requests.head()
requests.head(‘http://httpbin.org/get’)
发送一个 HTTP HEAD请求

6、requests.options()
a=requests.options(‘http://httpbin.org/get’)
发送一个 HTTP OPTIONS请求

7、a.url
打印URL来查看URL

8、a.text
读取服务器响应的内容，html内容

9、a.content
对于非文本请求，如图片，可以字节形式访问响应主体

10、a.json()
内置的JSON解码器

11、a.cookies[’’]
访问响应Cookie
a.cookies[‘example_cookie_name’]

12、a.headers
返回网页响应头

13、requests.session()
在某些网站或app抓取时，有时强制登陆，有的是不登陆返回的数据就是假的或者说是不完整的数据，需要用到保持会话的功能，可以只登陆一次，然后保持这种状态去做其他或更多的请求
session = requests.session()
a = session.post(url,headers=req_header,data=form_data)
或者
session.headers = head

14、requests.session()
在session中手动设置cookie
cookie = {“aaa”}
a = requests.session()
requests.utils.add_dict_to_cookiejar(a.cookies,{“PHPSESSID”:“hp43”})
a.get(“http://127.0.0.1:80”,cookies = cookie)

15、requests.request(method,url,**kwargs）
构造一个请求，支撑以下个方法的基础方法

参数

method：请求方式，对应get/put/post等七种
拟获取页面的url链接
控制访问参数，共13个
method：请求方式

r = requests.request(‘GET’,url,**kwargs)
r = requests.request(‘POST’, url, **kwargs)
r = requests.request(‘PUT’, url, **kwargs)
r = requests.request(‘delete’, url, **kwargs)

**kwargs：控制访问参数，为可选项

1. params : 字典或字节序列，作为参数增加到url中
2. data : 字典、字节序列或文件对象，作为Request的内容
3. json : JSON格式的数据，作为Request的内容
4. headers : 字典，HTTP定制头
5. cookies : 字典或CookieJar，Request中的auth : 元组支持HTTP认证功能
6. files : 字典类型，传输文件
7. timeout : 设定超时时间，秒为单位
8. proxies: 字典类型，设定访问代理服务器，可以增加登录认证
9. allow_redirects : True/False，默认为True，重定向开关
10. stream : True/False，默认为True，获取内容立即下载开关
11. verify : True/False，默认为True，认证SSL证书开关
12. cert : 本地SSL证书
13. auth : 元组，支持HTTP认证功能

16、设置代理ip
proxy = {“http”:“http://218.21.230.156:808”}
a = requests.post(url, proxies=proxy)

python爬虫之请求头报错：ValueError: Invalid header name b’:authority’

无法解析请求头，这是hppt2的请求，作为RFC 描述，Http 请求头不能以分号开头，安装hyper进行解析，因为hyper认识这样的请求头

from hyper.contrib import HTTP20Adapter
sessions=requests.session()
sessions.mount(‘https://pubmed.ncbi.nlm.nih.gov’, HTTP20Adapter())
res=sessions.get(url,headers=headers)

HTTPSConnectionPool(host=‘xxxxx‘, port=443)错误解决办法
http连接太多没有关闭导致的。
经过一番查询，发现该错误是因为如下：
http的连接数超过最大限制，默认的情况下连接是Keep-alive的，所以这就导致了服务器保持了太多连接而不能再新建连接。

1、ip被封
2、程序请求速度过快

response = requests.get(url, headers=headers, stream=True, verify=False)

requests默认是keep-alive的，可能没有释放，加参数 headers={‘Connection’:‘close’}

提示警告InsecureRequestWarning
在语句前加上以下代码即可不会被报错：
requests.packages.urllib3.disable_warnings()

html字符转义
import html
html.unescape(‘字符’)

json库
字典和json都是树形结构，本身具有很强的相似性

1. json.dumps()
   字典到JSON转化
   jsoninfo = json.dumps(dict)
   输出str类型

参数
separators！！！！！！！
作用是去掉‘，’ ‘：’后面的空格，在传输数据的过程中，越精简越好，冗余的东西全部去掉
json.dumps(dict,separators=(’,’,’:’))

2.json.loads()
JSON到字典转化
dictinfo = json.loads(json_str)
输出dict类型

hashlib库
MD5加密

1. md5是不可逆的，不能解密
2. 所有语言生成的md5串都是一样的
3. 不论字符串多长，生成的md5是等长的
4. 彩虹表：存的所有常用的加密后的密码对应的md5
5. 解密查询，只能解密常用字符：https://www.cmd5.com/

s=‘123456’
变成bytes类型才能加密
m = hashlib.md5(s.encode()) #长度是32

m = hashlib.sha3_224(s.encode()) #长度是224

m = hashlib.sha3_256(s.encode()) #长度是256

m = hashlib.sha3_512(s.encode()) #长度是512

返回md5
m.hexdigest()

uuid库
UUID（Universally Unique Identifier）是通用唯一识别码，在许多领域用作标识，比如我们常用的数据库也可以用它来作为主键，原理上它是可以对任何东西进行唯一的编码

1、uuid1()
这个是根据当前的时间戳和MAC地址生成的，最后的12个字符408d5c985711对应的就是MAC地址，因为是MAC地址，那么唯一性应该不用说了。但是生成后暴露了MAC地址这就很不好了
uuid.uuid1()

bf1dfacf-67d8-11e8-9a23-408d5c985711

2、uuid3()
里面的namespace和具体的字符串都是我们指定的，然后呢···应该是通过MD5生成的，这个我们也很少用到，莫名其妙的感觉
uuid.uuid3(uuid.NAMESPACE_DNS, ‘yuanlin’)

ddb366f5-d4bc-3a20-ac68-e13c0560058f

3、uuid4()
这是基于随机数的uuid，既然是随机就有可能真的遇到相同的，但这就像中奖似的，几率超小，因为是随机而且使用还方便，所以使用这个的还是比较多的
uuid.uuid4()

144d622b-e83a-40ea-8ca1-66af8a86261c

4、uuid5()
这个看起来和uuid3()貌似并没有什么不同，写法一样，也是由用户来指定namespace和字符串，不过这里用的散列并不是MD5，而是SHA1
uuid.uuid5(uuid.NAMESPACE_DNS, ‘yuanlin’)

4a47c18d-037a-5df6-9e12-20b643c334d3

selenium库
selenium是一个自动化测试工具，支持Firefox，Chrome等众多浏览器，在爬虫中的应用主要是用来解决JS渲染的问题。

selenium.webdriver模块

1、selenium.webdriver.Chrome()
创建一个谷歌浏览器对象，操控浏览器

参数
chromedriver插件所在位置
a = selenium.webdriver.Chrome(r’d:\chromedriver.exe’)

2、a.get()
打开一个网址

参数
a.get(‘http://www.baidu.com’)

3、查找元素
-------------单个
根据id选择元素，返回该元素对应的webelement，该对象用于后面操作
通过该webelement对象可以对页面元素进行操作
（1）a.find_element_by_id()
（2）a.find_element_by_name()
（3）a.find_element_by_xpath()
（4）a.find_element_by_link_text()
（5）a.find_element_by_partial_link_text()
（6）a.find_element_by_tag_name()
（7）a.find_element_by_class_name()
b = a.find_element_by_class_name(‘a’)
找到class = 'a’的标签的第一个元素
没有符合条件抛出异常
（8）a.find_element_by_css_selector()
参数
元素的id号
b = a.find_element_by_id(‘kw’)

-------------多个
（1）a.find_elements_by_name
（2）a.find_elements_by_id
（3）a.find_elements_by_xpath
（4）a.find_elements_by_link_text
（5）a.find_elements_by_partial_link_text
（6）a.find_elements_by_tag_name
（7）a.find_elements_by_class_name
b = a.find_elements_by_class_name(‘a’)
找到所有class = 'a’的标签元素
返回是一个列表，包含所有a的信息
没有符合条件返回空列表
（8）a.find_elements_by_css_selector

4、b.send_keys()
输入字符串到该输入框中
b.send_keys(‘123’)

5、b.click()
对该元素进行点击
b = a.find_element_by_id(‘su’)
b.click()

6、a.page_source
获取页面源代码

7、a.title
获取当前页面title

8、a.current_url
获取当前页面url

9、a.close()
关闭当前页面

10、取出上面b中内容
for i in b:
print(i.text)
.text打印出文本内容

11、*当进入某一网站搜索时，查找元素可能会error出错NoSuchElementException，原因是代码执行的速度比搜索引擎服务器响应的速度快，服务器没来得及返回搜索结果
用time.sleep()延迟提交或者

a.implicitly_wait(1)
后续所有的find_element或find_elements方法都会采取每隔1秒查找一次的策略

12、b.get_attribute()
b = a.find_element_by_tag_name(‘a’)
c = b.get_attribute(‘class’)
获取a标签内class的value

c.tag_name()
获取标签名字

c.click()
点击该标签

get_attribute只接受str，用find_elements要一个个for出来

要获取整个标签元素对应的HTML全部文本内容
可以使用b.get_attribute(‘outerHTML’)

只获取标签元素内部的HTML全部文本内容
可以使用element.get_attribute(‘innerHTML’)
剥离了标签行内容

对于input输入框的元素，要获取里面的输入文本可以使用
element.get_attribute(‘value’)

element.get_attribute(‘textContent’)
获取两个标签之间的内容

移动浏览器观看展示
driver.set_window_size(width=500, height=500, windowHandle=“current”)
driver.set_window_position(x=1000, y=100, windowHandle=‘current’)

13、a.switch_to.frame()
如果网页有iframe捣乱，用此方法可以先触发再进入该标签内操作
进入js渲染子界面
b = a.switch_to.frame(0)

14、a.maximize_window()
最大化浏览器

15、a.minimize_window()
最小化浏览器

16、a.set_window_size(1024, 768)
设置窗口大小

17、获取浏览器窗口左上角坐标的坐标
x = a.get_window_position().get(‘x’)
y = a.get_window_position().get(‘y’)

18、a.set_window_position(0, 0)
将窗口移动到所选位置

19、a.refresh()
刷新页面

20、a.back()
后退

21、a.forward()
向前

22、a.fullscreen_window()
填充整个屏幕，类似按F11键

23、save_screenshot(’./image.png’)和get_screenshot_as_file()
用于捕获当前浏览上下文的屏幕截图

24、用于为当前浏览上下文捕获元素的屏幕截图
ele = driver.find_element(By.CSS_SELECTOR, ‘h1’)
ele.screenshot(’./image.png’)

25、a.clear()
清空文本框中的值

26、a.current_window_handle
获取当前页面的句柄

27、a.window_handles
获取所有窗口句柄

28、切换句柄
a.switch_to.window(handles_index[0])

29、设置user-agent
options = selenium.webdriver.ChromeOptions()
options.add_argument(‘user-agent=ywy’)
a = selenium.webdriver.Chrome(options=options)

在这里设置和在后面head里设置完全不一样！！！
这里是打开网页之前判定

30、a.find_element_by_xpath().text
可直接提取出标签中所有text文本

31、设置代理ip
PROXY = “125.108.118.226:9000”
chrome_options = selenium.webdriver.ChromeOptions()
chrome_options.add_argument(’–proxy-server={0}’.format(PROXY))
a = selenium.webdriver.Chrome(options=options)

32、a.implicitly_wait()
隐形等待，设置了一个最长等待时间，如果在规定时间内网页加载完成，则执行下一步，否则一直等到时间截止，然后执行下一步
a.implicitly_wait(15)

Selenium下Chrome配置

例：
chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument(’–headless’)
driver = webdriver.Chrome(chrome_options=chrome_options)

chrome_options.add_argument(’–headless’)
无头模式

chrome_options.add_argument(’–disable-gpu’)
禁用GPU加速

chrome_options.add_argument(’–start-maximized’)
浏览器最大化

chrome_options.add_argument(’–window-size=1280x1024’)
设置浏览器分辨率（窗口大小）

chrome_options.add_argument(‘log-level=3’)
#info(default) = 0
#warning = 1
#LOG_ERROR = 2
#LOG_FATAL = 3

chrome_options.add_argument(’–user-agent=""’)
设置请求头的User-Agent

driver.add_cookie(cookie_dict=cookies)
设置cookie

chrome_options.add_argument(’–disable-infobars’)
禁用浏览器正在被自动化程序控制的提示

chrome_options.add_argument(’–incognito’)
隐身模式（无痕模式）

chrome_options.add_argument(’–hide-scrollbars’)
隐藏滚动条, 应对一些特殊页面

chrome_options.add_argument(’–disable-javascript’)
禁用javascript

chrome_options.add_argument(’–blink-settings=imagesEnabled=false’)
不加载图片, 提升速度

chrome_options.add_argument(’–ignore-certificate-errors’)
禁用扩展插件并实现窗口最大化
chrome_options.add_argument(’–disable-software-rasterizer’)
chrome_options.add_argument(’–disable-extensions’)

selenium规避被检测识别
from selenium.webdriver import Chrome
from selenium.webdriver import ChromeOptions
option = ChromeOptions()
option.add_experimental_option(‘excludeSwitches’, [‘enable-automation’])
a = selenium.webdriver.Chrome(options=option)

更多设置（非常多）
https://peter.sh/experiments/chromium-command-line-switches/

from selenium.webdriver.common.action_chains import ActionChains模块

1、click()
单击鼠标左键
ActionChains(a).click(on_element=None)

2、click_and_hold()
点击鼠标左键，不松开
ActionChains(a).click_and_hold(on_element=None)

3、context_click()
点击鼠标右键
ActionChains(a).context_click(on_element=None)

4、double_click()
双击鼠标左键
ActionChains(a).double_click(on_element=None)

5、drag_and_drop()
拖拽到某个元素然后松开
ActionChains(a).drag_and_drop(source, target)

6、drag_and_drop_by_offset()
拖拽到某个坐标然后松开
ActionChains(a).drag_and_drop_by_offset(source, xoffset, yoffset)

7、move_by_offset()
鼠标从当前位置移动到某个坐标
ActionChains(a).move_by_offset(xoffset, yoffset)

8、move_to_element()
鼠标移动到某个元素
ActionChains(a).move_to_element(to_element)

9、move_to_element_with_offset()
移动到距某个元素（左上角坐标）多少距离的位置
ActionChains(a).move_to_element_with_offset(to_element, xoffset, yoffset)

10、perform()
执行链中的所有动作
ActionChains(a).perform()

11、release()
在某个元素位置松开鼠标左键
ActionChains(a).release(on_element=None)

12、send_keys()
发送某个键到当前焦点的元素
ActionChains(a).send_keys(*keys_to_send)

13、send_keys_to_element()
发送某个键到指定元素
ActionChains(a).send_keys_to_element(element, *keys_to_send)

from selenium.webdriver.common.keys import Keys模块

1、key_down(value, element=None)
按下某个键盘上的键

2、key_up(value, element=None)
松开某个键

3、Keys.BACK_SPACE
相当于backspace
a.find_element_by_id(“kw”).send_keys(Keys.BACK_SPACE)

4、Keys.SPACE
输入空格，方法同上

5、Keys.CONTROL, ‘a’
按下Ctrl和a
driver.find_element_by_id(“kw”).send_keys(Keys.CONTROL, ‘a’)

还有其他按键
send_keys(Keys.TAB) 制表键(Tab)
send_keys(Keys.ESCAPE) 回退键（Esc）
send_keys(NUMPAD) 数字键1
send_keys(NUMPAD9) 数字键9
send_keys(Keys.F1) 键盘 F1
send_keys(Keys.F12) 键盘 F12
send_keys(Keys.PAGE_UP) Page Up（翻页键上）
send_keys(Keys.PageDown) PageDown（相当于滑动下拉框到底部）
send_keys(Keys.LEFT) 方向键左（Left）
send_keys(Keys.UP) 方向键上（Up）
send_keys(Keys.RIGHT) 方向键右（Right）
send_keys(Keys.DOWN) 方向键下（Down）
send_keys(Keys.ARROW_DOWN) 键盘向下箭头
send_keys(Keys.BACK_SPACE) 回退键（BackSpace）
send_keys(Keys.ENTER) 回车键（Enter）
send_keys(Keys.SHIFT) 大小写转换键（Shift）
send_keys(Keys.CONTROL) Control键（Ctrl）
send_keys(Keys.ALT) ALT键（Alt）
send_keys(Keys.SPACE) 空格键（Space）
send_keys(Keys.END) 行尾键（End）
send_keys(Keys.HOME) 行首键（Home）
send_keys(Keys.INSERT) 插入键（Insert）
send_keys(DELETE) 删除键（Delete）
Keys.ENTER 回车键
Keys.RETURN 换行键

提供了两个方法，key_down与key_up，模拟按下键盘的某个键子，与松开某个键子，接收的参数是按键的Keys与elementObj。可以与send_keys连用（例：全选、复制、剪切、粘贴）
ActionChains(driver).key_down(Keys.CONTROL,dom).send_keys(‘a’).send_keys(‘c’).key_up(Keys.CONTROL).key_down(Keys.CONTROL,dom1).send_keys(‘v’).key_up(Keys.CONTROL).perform()

execute_script()方法
1、window.scrollTo()
用于设置浏览器窗口滚动条的水平位置和垂直位置，第一个参数表示水平左边距，第二个参数表示垂直上边距
js = “window.scrollTo(100,450);”
a.execute_script(js)

2、a.set_window_size()
设置浏览器分辨率为：500×500
a.set_window_size(500,500)

3、浏览器后退和前进
a.back()：后退
a.forward()：前进

4、JS增删改查操作元素的属性
#新增属性
a.execute_script(“arguments[0].%s=arguments[1]” % attributeName, elementObj, value)

#修改属性
driver.execute_script(“arguments[0].setAttribute(arguments[1],arguments[2])”, elementObj, attributeName, value)

例如百度
search_button = driver.find_element_by_id(“su”)
#arguments[0]对应的是第一个参数，可以理解为python里的%s传参，与之类似
a.execute_script(“arguments[0].value = ‘你猜一下’;”, search_button)

#获取属性
elementObj.get_attribute(attributeName)

#删除属性
driver.execute_script(“arguments[0].removeAttribute(arguments[1])”,elementObj, attributeName)

elementObj为
修改元素的标签

attributeName为
修改的元素名

value为
修改的元素值

更改div的文本内容 ↓div的class name ↓div的inner
js = “document.getElementsByClassName(“editor”)[0].innerHTML=“亲亲”;”
a.execute_script(js)

5、滚到页面底部
a.execute_script(“window.scrollTo(0, document.body.scrollHeight);”)

6、打开新的标签页
js = “window.open(‘http://www.sogou.com’)”
a.execute_script(js)

pyppeteer库
https://blog.csdn.net/freeking101/article/details/93331204

pyppeteer.launcher模块
配合asyncio使用
1、创建浏览器对象
w, h = 500, 300
a = await pyppeteer.launcher.launch(headless=False, args=[’–disable-infobars’, f’–window-size={w},{h}’], autoClose=True)

接受字典形式的关键字配置

语法 值 描述
ignorehttpserrrors bool 忽略https错误，默认false
headless bool 是否可见
viewport dict 界面大小viewport={‘width’: 1280, ‘height’: 800}
args list[str] 附加参数（标志）过程
userDataDir str 用户数据目录的路径
devtools bool 打卡面板，效果同headless
log level （int str）打印日志的日志级别。默认与根记录器
autoClose bool 自动关闭浏览器的时候删除tmp文件

args=[’–disable-infobars’] 关闭 受控制提示
args=[’–window-size=1366,768’] 设置浏览器界面大小

2、page = await a.newPage()
创建一个页面对象， 页面操作在该对象上执行

3、await page.setViewport({‘width’: 1280, ‘height’: 1880})
设置页面显示大小

4、设置useragent
await page.setUserAgent(‘Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99’
‘.100.4844.0 Safari/537.36’)

5、await page.goto(‘https://www.baidu.com’, options={‘timeout’: 10000})
页面跳转

参数
timeout
超时时间10000毫秒

6、await page.screenshot({‘path’: ‘example.png’})
截图保存

7、await a.close()
关闭浏览器

8、无痕模式
b = await a.createIncogniteBrowserContext() # 无痕模式浏览器
page = await b.newPage()

9、断开浏览器，断开后可以通过connect连接
await a.disconnect()

10、设置缓存目录
a = await pyppeteer.launcher.launch(userDataDir=’./userdata’)
比如淘宝登陆一次后，设置目录后下次打开淘宝会处于登陆状态，很方便

11、获取所有html内容
page.content()

12、获取页面内容
content = await page.evaluate(‘document.body.textContent’, force_expr=True)

13、获取元素内部内容
选择器
element = await page.querySelector(‘body’)

xpath
Page.xpath(’/html/body’)

content = await page.evaluate(’(element) => element.textContent’, element)

14、滚动到页面底部
await page.evaluate(‘window.scrollBy(0, document.body.scrollHeight)’)

15、获取页面cookie
page.cookies()

16、在网页上执行js 脚本
dimensions = await page.evaluate(pageFunction=’’’() => {
return {
width: document.documentElement.clientWidth, // 页面宽度
height: document.documentElement.clientHeight, // 页面高度
deviceScaleFactor: window.devicePixelRatio, //像素比1.0000000149011612
}
}’’’, force_expr=False)
print(dimensions)

17、获取当前页标题
page.title()

18、

aiohttp库
https://docs.aiohttp.org/en/stable/

1、客户端快速入门
import aiohttp
import asyncio

async def main():
async with aiohttp.ClientSession() as session:
async with session.get(‘http://httpbin.org/get’) as resp:
print(resp.status)
print(await resp.text())

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

现在，我们有一个ClientSession被调用session的ClientResponse对象和一个名为resp的对象。我们可以从响应中获取所需的所有信息。ClientSession.get()协程的必需参数是HTTP URL（str或类：yarl.URL实例）

2、其他HTTP方法也可用
session.post(‘http://httpbin.org/post’, data=b’data’)
session.put(‘http://httpbin.org/put’, data=b’data’)
session.delete(‘http://httpbin.org/delete’)
session.head(‘http://httpbin.org/get’)
session.options(‘http://httpbin.org/get’)
session.patch(‘http://httpbin.org/patch’, data=b’data’)

3、会话上下文管理器的使用不是强制性的，但在这种情况下应调用方法
session = aiohttp.ClientSession()
async with session.get(’…’):
# …
await session.close()

4、如果您想将key1=value1和传递 key2=value2给httpbin.org/get
params = {‘key1’: ‘value1’, ‘key2’: ‘value2’}
async with session.get(‘http://httpbin.org/get’,
params=params) as resp:
expect = ‘http://httpbin.org/get?key1=value1&key2=value2’
assert str(resp.url) == expect

您可以通过打印URL来查看URL是否已正确编码

用于发送具有相同密钥的多个值的数据MultiDict；该库还支持嵌套列表（）替代。{‘key’: [‘value1’, ‘value2’]}

也可以传递2个项目元组的列表作为参数
params = [(‘key’, ‘value1’), (‘key’, ‘value2’)]
async with session.get(‘http://httpbin.org/get’,
params=params) as r:
expect = ‘http://httpbin.org/get?key=value2&key=value1’
assert str(r.url) == expect

您也可以将str内容作为参数传递，但要注意–内容不是由库编码的
async with session.get(‘http://httpbin.org/get’,
params=‘key=value+1’) as r:
assert str(r.url) == ‘http://httpbin.org/get?key=value+1’

aiohttp在发送请求之前在内部执行URL规范化，规范化通过IDNA编解码器编码主机部分，并将 重新引用应用于路径和查询部分
例如URL(‘http://example.com/путь/%30?a=%31’)转换为 URL(‘http://example.com/%D0%BF%D1%83%D1%82%D1%8C/0?a=1’)

如果服务器接受精确的表示并且不重新引用URL本身，则有时不希望进行规范化，要禁用规范化，请使用encoded=True参数进行URL构建：
await session.get(
URL(‘http://example.com/%30’, encoded=True))

传递参数将覆盖encoded=True，切勿同时使用这两个选项

5、我们可以读取服务器响应的内容及其状态代码
async with session.get(‘https://api.github.com/events’) as resp:
print(resp.status)
print(await resp.text())

aiohttp自动解码来自服务器的内容，您可以为该text()方法指定自定义编码
await resp.text(encoding=‘windows-1251’)

6、二进制响应内容
对于非文本请求，您还可以字节形式访问响应主体
print(await resp.read())

7、所有的会话的请求方法，如request()， ClientSession.get()，ClientSesssion.post()等接受 JSON参数

async with aiohttp.ClientSession() as session:
async with session.post(url, json={‘test’: ‘object’})

8、流响应内容
虽然方法read()， json()并且text()都非常方便，您应该谨慎使用它们。所有这些方法将整个响应加载到内存中
with open(filename, ‘wb’) as fd:
while True:
chunk = await resp.content.read(chunk_size)
if not chunk:
break
fd.write(chunk)

9、流式上传
with open(‘massive-body’, ‘rb’) as f:
await session.post(‘http://httpbin.org/post’, data=f)

10、自定义请求头
可以为所有会话请求设置默认头部
headers={“Authorization”: “Basic bG9naW46cGFzcw==”}
async with aiohttp.ClientSession(headers=headers) as session:
async with session.get(“http://httpbin.org/headers”) as r:
json_body = await r.json()

11、自定义cookie
url = ‘http://httpbin.org/cookies’
cookies = {‘cookies_are’: ‘working’}
async with ClientSession(cookies=cookies) as session:
async with session.get(url) as resp:
assert await resp.json() == {
“cookies”: {“cookies_are”: “working”}}

12、查看服务器的响应头
res.headers
以及访问一个value获得其key值
print(res.headers.get(‘Bdqid’))

0xf0db1b0a0004c716

所有标头都是UTF-8从二进制数据转换而来，在大多数情况下，这可以正常工作，但如果服务器使用非标准编码，则有时需要未转换的数据，可以使用以下方法来检索
resp.raw_headers

13、aiohttp.ClientSession()
用于创建客户端会话和发出请求的类

aiohttp.ClientSession(*, connector=None, loop=None, cookies=None, headers=None, skip_auto_headers=None, auth=None, json_serialize=json.dumps, version=aiohttp.HttpVersion11, cookie_jar=None, read_timeout=None, conn_timeout=None, timeout=sentinel, raise_for_status=False, connector_owner=True, auto_decompress=True, read_bufsize=2 ** 16, requote_redirect_url=False, trust_env=False, trace_configs=None)

参数

cookies(dict)
与请求一起发送的cookies（可选）
headers
与每个请求一起发送的HTTP标头（可选）
timeout
一种ClientTimeout设置结构，默认情况下总超时为300秒（5分钟）
read_timeout(float)
请求操作超时，read_timeout对所有请求操作（请求，重定向，响应，数据消耗）累积。默认情况下，读取超时为5 * 60秒，使用None或0禁用超时检查
conn_timeout(float)
建立连接超时（可选），值0或None表示没有超时

14、request()
在鼓励ClientSession使用的同时，我们还提供了用于发出HTTP请求的简单协程
request(method, url, *, params=None, data=None, json=None, cookies=None, headers=None, skip_auto_headers=None, auth=None, allow_redirects=True, max_redirects=10, compress=None, chunked=None, expect100=False, raise_for_status=None, read_until_eof=True, read_bufsize=None, proxy=None, proxy_auth=None, timeout=sentinel, ssl=None, verify_ssl=None, fingerprint=None, ssl_context=None, proxy_headers=None)

async def fetch():
async with aiohttp.request(‘GET’,
‘http://python.org/’) as resp:
assert resp.status == 200
print(await resp.text())

request(‘get’, ‘http://httpbin.org/get’)
等同于
async with aiohttp.ClientSession() as session:
async with session.get(‘http://httpbin.org/get’) as resp:

参数

method(str)
HTTP方法
url
请求URL，str或URL
params
映射，可将键/值对或字符串的元组作为新请求的查询字符串中的参数进行迭代（可选）
data
要在请求正文中发送的数据。这可以是一个FormData对象，也可以是任何可以传递到的 对象 FormData，例如字典，字节或类似文件的对象（可选）
json
任何与json兼容的python对象（可选），json和data参数不能同时使用
cookie(dict)
发送的HTTP cookie请求（可选）发送请求时，将合并全局会话cookie和显式设置的cookie
headers(dict)
与请求一起发送的HTTP标头（可选）

pychrome库

在cmd中打开chrome加参数
“C:\Program Files (x86)\Google\Chrome\Application\chrome.exe” --remote-debugging-port=9222

1、创建一个浏览器实例
browser = pychrome.Browser(url=“http://127.0.0.1:9222”)

2、新建一个选项卡
tab = browser.new_tab()

3、开始接收消息
tab.start()

4、调用Network方法
tab.Network.enable()

5、打开指定网页并设置超时时间
tab.Page.navigate(url=“https://www.baidu.com”, _timeout=5)

6、等待页面加载
tab.wait(5)

7、停止处理事件, 停止从chrome接收消息
tab.stop()

8、关闭选项卡
browser.close_tab(tab)

9、在百度搜索框输入selenium
tab.Runtime.evaluate(expression=‘document.getElementById(“kw”).value=“selenium”’)

10、点击“百度一下”按钮
tab.Runtime.evaluate(expression=‘document.getElementById(“su”).click()’)

11、列出所有选项卡
tabs = browser.list_tab()

xlwt库
1、book = xlwt.Workbook()
创建一个excel
book = xlwt.Workbook(encoding=‘utf-8’)

2、sheet = book.add_sheet(‘sheet1’)
创一个sheet
sheet = book.add_sheet(‘sheet1’,cell_overwrite_ok=True)

参数
cell_overwrite_ok=True
该sheet单元格可覆盖

3、sheet.write()
在A1单元格内输入hello
sheet.write(0,0,‘hello’)

4、book.save()
保存excel
book.save(‘1.xls’)

5、xlwt.Alignment()
设置单元格的对齐方式
al = xlwt.Alignment()
al.horz = 0x02 #设置水平居中
al.vert = 0x01 #设置垂直居中
style.alignment = al
sheet.write(0, 0, ‘文本居中’, style)

VERT_TOP = 0x00 上端对齐
VERT_CENTER = 0x01 居中对齐（垂直方向上）
VERT_BOTTOM = 0x02 低端对齐
HORZ_LEFT = 0x01 左端对齐
HORZ_CENTER = 0x02 居中对齐（水平方向上）
HORZ_RIGHT = 0x03 右端对齐

6、xlwt.Font()
设置单元格的字体
style = xlwt.XFStyle() #初始化样式
font = xlwt.Font() #为样式创建字体
font.name = ‘Times New Roman’
font.bold = True #黑体
font.underline = True #下划线
font.italic = True #斜体字
style.font = font #设定样式
worksheet.write(1, 0, ‘Formatted value’, style) # 带样式的写入

7、worksheet.col().width
设置单元格宽度
worksheet.col(0).width = 3333

8、xlwt.Formula()
添加超链接
worksheet.write(0, 0, xlwt.Formula(‘HYPERLINK(“http://www.google.com”;“Google”)’))

9、xlwt.Alignment.HORZ_CENTER
对齐方式
alignment.horz = xlwt.Alignment.HORZ_CENTER #May be: HORZ_GENERAL, HORZ_LEFT, HORZ_CENTER, HORZ_RIGHT, HORZ_FILLED, HORZ_JUSTIFIED, HORZ_CENTER_ACROSS_SEL, HORZ_DISTRIBUTED
alignment.vert = xlwt.Alignment.VERT_CENTER #May be: VERT_TOP, VERT_CENTER, VERT_BOTTOM, VERT_JUSTIFIED, VERT_DISTRIBUTED

10、xlwt.Borders.DASHED
添加边框
borders = xlwt.Borders()
borders.left = xlwt.Borders.DASHED
DASHED虚线
NO_LINE没有
THIN实线

May be: NO_LINE, THIN, MEDIUM, DASHED, DOTTED, THICK, DOUBLE, HAIR, MEDIUM_DASHED, THIN_DASH_DOTTED, MEDIUM_DASH_DOTTED, THIN_DASH_DOT_DOTTED, MEDIUM_DASH_DOT_DOTTED, SLANTED_MEDIUM_DASH_DOTTED, or 0x00 through 0x0D.

borders.right = xlwt.Borders.DASHED
borders.top = xlwt.Borders.DASHED
borders.bottom = xlwt.Borders.DASHED
borders.left_colour = 0x40
borders.right_colour = 0x40
borders.top_colour = 0x40
borders.bottom_colour = 0x40
style = xlwt.XFStyle()
style.borders = borders

11、xlwt.Pattern()
设置背景颜色
pattern = xlwt.Pattern()
pattern.pattern = xlwt.Pattern.SOLID_PATTERN #May be: NO_PATTERN, SOLID_PATTERN, or 0x00 through 0x12
pattern.pattern_fore_colour = 5 #May be: 8 through 63. 0 = Black, 1 = White, 2 = Red, 3 = Green, 4 = Blue, 5 = Yellow, 6 = Magenta, 7 = Cyan, 16 = Maroon, 17 = Dark Green, 18 = Dark Blue, 19 = Dark Yellow , almost brown), 20 = Dark Magenta, 21 = Teal, 22 = Light Gray, 23 = Dark Gray, the list goes on…
style = xlwt.XFStyle()
style.pattern = pattern

12、style.num_format_str
输入一个日期到单元格
import datetime
style = xlwt.XFStyle()
style.num_format_str = ‘M/D/YY’ #Other options: D-MMM-YY, D-MMM, MMM-YY, h:mm, h:mm:ss, h:mm, h:mm:ss, M/D/YY h:mm, mm:ss, [h]:mm:ss, mm:ss.0

13、xlwt.Formula()
向单元格添加一个公式
worksheet.write(1, 0, xlwt.Formula(‘A1*B1’)) #Should output “10” (A1[5] * A2[2])
worksheet.write(1, 1, xlwt.Formula(‘SUM(A1,B1)’)) #Should output “7” (A1[5] + A2[2])

14、write_merge()
合并列和行
worksheet.write_merge(0, 0, 0, 3, ‘First Merge’) #Merges row 0’s columns 0 through 3.
font = xlwt.Font()
font.bold = True
style = xlwt.XFStyle()
style.font = font
worksheet.write_merge(1, 2, 0, 3, ‘Second Merge’, style) #Merges row 1 through 2’s columns 0 through 3.

15、worksheet.write_merge()
往单元格内写入数据，合并单元格
worksheet.write(m_row, m_col, u’内容’, body_style())
合并单元格，前四个参数分别是起止的行列位置
worksheet.write_merge(1, 2, m_col, m_col+3, u’还好’, body_style())

xlrd库
1、xlrd.open_workbook()
打开文件
a = xlrd.open_workbook(‘file/demo.xlsx’)

2、a.sheet_names()
返回工作表所有sheet名

3、a.sheet_by_name()
通过文件名获得工作表，获取工作表
b = a.sheet_by_name(‘工作表1’)

4、获取行数和列数
b.nrows
b.ncols

5、获取整行的值 和整列的值，返回的结果为数组
整行值：b.row_values(start,end)
整列值：b.col_values(start,end)

参数
start 为从第几个开始打印
end为打印到那个位置结束，默认为none

6、b.cell().value或b.cell_value(rowx,colx)
获取某个单元格的值，例如获取B3单元格值
b.cell(2,1).value
b.cell_value(rowx,colx)

xlutils库
使用xlutils将xlrd读取的对象转为xlwt可操作对象

from xlutils.copy import copy
1、利用xlrd，打开想要更改的excel文件
book = xlrd.open_workbook(‘xxx.xlsx’)

2、将操作文件对象拷贝，变成可写的workbook对象
nb = copy(book)

3、获得第一个sheet的对象
sheet = nb.get_sheet(0)

4、写入数据
sheet.write(1, 0, ‘a’)
sheet.write(1, 1, ‘b’)
sheet.write(1, 2, ‘c’)
sheet.write(1, 3, ‘d’)

5、另存为excel文件
nb.save(‘xxx.xlsx’)

openpyxl库
1、openpyxl.load_workbook()
打开excel文件,获取工作簿对象
a = openpyxl.load_workbook(‘1.xlsx’)

2、从工作薄中获取一个表单(sheet)对象
b = a.get_sheet_by_name(‘1’)

3、获取整行整列
b.rows
b.columns

4、打印出整行整列值
b.iter_cols(min_col=None,max_col=None,min_row=None,max_row=None,values_only=False)
可以在iter_cols内加入参数（value_only=True),即可获得第一列数据

5、为一个单元格赋值
b.cell(1,1,‘123’)
从1开始，不是从0开始

6、保存
b.save(‘1.xlsx’)

7、创建表
①实例化
wb = openpyxl.Workbook()
②激活
ws = wb.active

8、储存数据
方式①
ws[‘A1’] = 42
方式②
ws.append([1, 2, 3])

xlsxwriter库

1、Workbook(filename[,options])
创建一个XlsxWriter的Workbook对象。Workbook代表整个电子表格文件，并且存储在磁盘上
book = xlsxwriter.Workbook(‘1.xls’)

2、add_worksheet([sheetname])
用于添加一个新的工作表，sheetname为工作表名称
sheet = book.add_worksheet(‘1’)

3、add_format([properties])
用于在工作表中创建一个新的格式对象来格式化单元格
bold = book.add_format({‘bold’: True})
等价的语句如下：
bold = book.add_format()
bold.set_bold()

4、add_chart(options)
用于在工作表中创建一个图表对象

例如设置一个线条行的图表对象
chart = book.add_chart({‘type’: ‘line’})

5、close()
作用是关闭工作表文件
book.close()

6、write(row, col, *args)
将普通数据写入单元格中
sheet.write(‘A1’, ‘123’)

write.string()：写入字符串类型数据
wirte_number()：写入数字型数据
write_blank()：写入空类型数据
write_formula()：写入公式型数据
write_datetime()：写入日期型数据
wirte_boolean()：写入逻辑型数据
write_url()：写入超链接型数据

还可调用excel的公式表达式
sheet.write(row, 0, ‘Total’)
sheet.write(row, 1, ‘=SUM(B1:B4)’)

7、sheet.set_row(row, height, cell_format, options)
用于设定行单元格的属性
sheet.write(‘A1’, ‘hello’)
bold = book.add_format({‘bold’: True})

设定A1行高40，加粗
sheet.set_row(0, 40, bold)

隐藏第二行
sheet.set_row(1, None, None, {‘hidden’: True})

8、sheet.set_column(first_col, last_col, width, cell_format, options)
用于设置一列或多列单元格的属性
sheet.write(‘A1’, ‘hello’)
sheet.write(‘B1’, ‘world’)
bold = book.add_format({‘bold’: True})

设定列A到B单元格宽度10像素，加粗
sheet.set_column(0, 1, 10, bold)

设置C到D单元格宽度20像素
sheet.set_column(‘C:D’, 20)

隐藏E到G单元格
sheet.set_column(‘E:G’, None, None, {‘hidden’: 1})

9、sheet.insert_image(row, col, image[, options])
用于插入图片到指定的单元格，支持PNG，JPEG，BMP等多种格式

在B5单元格插入python-logo.png图片，超链接为http://python.org
sheet.insert_image(‘B5’, ‘img/python-logo.png’, {‘url’: ‘http://python.org’})

接受字典形式的可选参数来定位和缩放图片

offset的值是以像素为单位的：
sheet.insert_image(‘B2’, ‘python.png’, {‘x_offset’: 15, ‘y_offset’: 10})
offset的值可以大于基础单元格的宽度与高度。如果想将两个及以上的图片相对于同一单元格对齐，这有时会很有用

x_scale和y_scale参数可以用于水平及垂直的缩放图片：
sheet.insert_image(‘B3’, ‘python.png’, {‘x_scale’: 0.5, ‘y_scale’: 0.5})

image_data参数用于在io.BytesIO中添加内存中的字节流：
sheet.insert_image(‘B5’, ‘python.png’, {‘image_data’: image_data})

10、add_chart({type, ‘图表类型’})
实图表组件，支持包括面积、条形图、柱状图、折线图、散点图等
创建一个column（柱形）图表
chart = workbook.add_chart({type, ‘column’})

area：面积样式的图表
bar：条形图
column：柱状图
line：线条样式的图表
pie：饼形图
scatter：散点图
stock：股票样式的图表
radar：雷达样式的图表

在A7单元格插入图表
sheet.insert_chart(‘A7’, chart)

11、chart.add_series(options)
用于添加一个数据系列的图表
chart.add_series({
‘categories’: ‘=Sheet1!$A$1:$A$5^{\prime }{,}^{\prime }value{s}^{\prime }{:}^{\prime }=Sheet1!$B$1:$B$5’,
‘line’: {‘color’: ‘red’},
})
categories：设置图表类别标签范围；
values：设置图表数据范围；
line：设置图表线条属性，包括宽度、颜色等；

12、set_x_axis(options)
设置图表X轴选项
chart.set_x_axis({
‘name’: ‘x name’,
‘name_font’: {‘size’: 14, ‘bold’: True}
‘num_font’: {‘italic’: True}
})
name：设置x轴名称；
name_font：设置x轴字体；
num_font：设置x轴数字字体属性；

13、set_size(options)
用于设置图表大小
chart.set_size({‘width’: 720, ‘height’: 576})
width：设置宽度；
height：设置高度；

14、set_title(options)
设置图表标题
chart.set_title({‘name’: ‘test’})

15、set_style(style_id)
用于设置图表样式
chart.set_style(37)

style_id为不同数字代表不同样式

16、set_table(options)
设置x轴为数据表格式
chart.set_table()

csv库
python自带了csv模块提供用户对csv文件进行读写操作

1、写入csv文件的表头
headers = [‘class’, ‘name’, ‘sex’, ‘height’, ‘year’]
with open(‘test.csv’, ‘w’)as f:
f_csv = csv.writer(f)
f_csv.writerow(headers)（写入一行）

2、每一行的内容写入到csv文件中
rows = [
[1,‘xiaoming’,‘male’,168,23],
[1,‘xiaohong’,‘female’,162,22],
[2,‘xiaozhang’,‘female’,163,21],
[2,‘xiaoli’,‘male’,158,21]
with open(‘test.csv’,‘w’)as f:
f_csv = csv.writer(f)
f_csv.writerows(rows)（写入多行）

3、写入字典序列的数据
headers = [‘class’,‘name’,‘sex’,‘height’,‘year’]
rows = [
{‘class’:1,‘name’:‘xiaoming’,‘sex’:‘male’,‘height’:168,‘year’:23},
{‘class’:1,‘name’:‘xiaohong’,‘sex’:‘female’,‘height’:162,‘year’:22},
{‘class’:2,‘name’:‘xiaozhang’,‘sex’:‘female’,‘height’:163,‘year’:21},
{‘class’:2,‘name’:‘xiaoli’,‘sex’:‘male’,‘height’:158,‘year’:21},
]
with open(‘test2.csv’,‘w’,newline=’’)as f:
f_csv = csv.DictWriter(f,headers)
f_csv.writeheader()
f_csv.writerows(rows)

4、csv文件读取
with open(‘test.csv’)as f:
f_csv = csv.reader(f)
for row in f_csv:
print(row)

pandas库
1、首先导入pandas库，一般都会用到numpy库
import numpy
import pandas

PIL库

PIL.Image模块

1、PIL.Image.open()
读取一张图片
a = PIL.Image.open(’/home/Picture/test.jpg’)

2、a.show()
显示一张图片

3、a.save()
保存图片
a.save(“save.gif”, “GIF”) #保存图像为gif格式

RGBA保存为jpg，丢弃透明图层
captcha = a.convert(‘RGB’)
captcha.save(‘code.jpg’)

4、PIL.Image.new()
创建新图片
PIL.Image.new(mode,size,color)
newImg = PIL.Image.new(“RGBA”,(640,480),(0,255,0))

5、PIL.Image.blend()
两张图片相加
PIL.Image.blend(img1,img2,alpha=1) # 这里alpha表示img1和img2的比例参数

6、a.point()
点操作
a.point(function) #,这个function接受一个参数，且对图片中的每一个点执行这个函数
out=a.point(lambdai:i*1.5)#对每个点进行50%的加强

7、查看图像信息：
a.format,a.size,a.mode

8、图片裁剪：

设置要裁剪的区域

box = (100, 100, 500, 500)

此时region是一个新的图像对象

region = a.crop(box)

参数
box
剪裁左上角的x，y坐标和右下角的x，y坐标

9、a.paste()
图像黏贴（合并）
a.paste(region,box)#粘贴box大小的region到原先的图片对象中

10、通道分离
r,g,b=a.split()#分割成三个通道，此时r,g,b分别为三个图像对象

11、PIL.Image.merge()
通道合并
a=PIL.Image.merge(“RGB”,(b,g,r))#将b,r两个通道进行翻转

12、a.resize()
改变图像的大小

resize成128*128像素大小

out = a.resize((128, 128))

13、a.rotate()
out=a.rotate(45)#逆时针旋转45度

有更方便的：
region = a.transpose(PIL.Image.ROTATE_180）

14、a.transpose()
图像转换
out = a.transpose(PIL.Image.FLIP_LEFT_RIGHT)
#左右对换

out = a.transpose(PIL.Image.FLIP_TOP_BOTTOM)
#上下对换

15、a.convert()
图像类型转换
im=a.convert(“RGBA”)

16、a.getpixel()
获取某个像素位置的值
a.getpixel((4,4))

17、a.putpixel()
写某个像素位置的值
a.putpixel((4,4),(255,0,0))

18、a.mode
图像所使用像素格式

modes 描述
1 1位像素，黑和白，存成8位的像素
L 8位像素，黑白
P 8位像素，使用调色板映射到任何其他模式
RGB 3× 8位像素，真彩
RGBA 4×8位像素，真彩+透明通道
CMYK 4×8位像素，颜色隔离
YCbCr 3×8位像素，彩色视频格式
I 32位整型像素
F 32位浮点型像素

19、加载图片传递给tkinter.Label
po = PIL.Image.open(‘1.jpg’)
photo = PIL.ImageTk.PhotoImage(po)
label = tkinter.Label(tk, text=‘photo’, image=photo)

PIL.ImageGrab模块

1、PIL.ImageGrab.grabclipboard()
获取剪贴板文件

2、PIL.ImageGrab.grab()
抓取当前屏幕快照，返回一个模式为“RGB”的图像，参数边界框用于限制只拷贝当前屏幕的一部分区域
在Unix / Linux上运行！！
PIL.ImageGrab.grab((300, 100, 1400, 600))

Windows平台的正确代码
PIL.ImageGrab.grab(bbox=(x, y, w, h))

PIL.ImageEnhance模块
该类专门用于图像的增强处理,不仅可以增强(或减弱)图像的亮度、对比度、色度,还可以用于增强图像的锐度

1、亮度增强
a = PIL.ImageEnhance.Brightness(image)
brightness = 1.5
b = a.enhance(brightness)
b.show()

2、色度增强
a = PIL.ImageEnhance.Color(image)
color = 1.5
b = a.enhance(color)
b.show()

3、对比度增强
a = PIL.ImageEnhance.Contrast(image)
contrast = 1.5
b = a.enhance(contrast)
b.show()

4、锐度增强
a = PIL.ImageEnhance.Sharpness(image)
sharpness = 3.0
b = a.enhance(sharpness)
b.show()

针对视频处理
可用OpenCV、imageio、ffmpeg、MoviePy库

OpenCV库
http://www.woshicver.com/
https://docs.opencv.org/4.3.0/d6/d00/tutorial_py_root.html

import cv2

1、读取图像
img = cv2.imread(‘1.jpg\1.png’，0)

第二个参数指定了读取图像的方式
cv2.IMREAD_COLOR
加载彩色图像。任何图像的透明度都会被忽视。它是默认标志

cv2.IMREAD_GRAYSCAL
以灰度模式加载图像

cv2.IMREAD_UNCHANGE
加载图像，包括alpha通道

除了这三个标志，你可以分别简单地传递整数1、0或-1

2、显示图像
imagewindow = cv2.imshow(‘image’, img)

参数1
窗口标题

参数2
图像对象

3、cv2.waitKey(0)
k = cv2.waitKey()
是一个键盘绑定函数。其参数是以毫秒为单位的时间。该函数等待任何键盘事件指定的毫秒。如果您在这段时间内按下任何键，程序将继续运行。如果0被传递，它将无限期地等待一次敲击键

k为输入的键值

if cv2.waitKey(1) == ord(‘q’):
break
判断此时键入’q’键退出循环

！！！
提示！不写上面这行代码图像显示不出来…
！！！

4、销毁创建的所有窗口
cv2.destroyAllWindows()

5、销毁任何特定的窗口
cv2.destroyWindow(imagewindow)

6、cv2.namedWindow()
创建一个空窗口，然后再将图像加载到该窗口
cv2.namedWindow(‘image’，cv2.WINDOW_NORMAL)

参数1
窗口标题

参数2
默认情况下，该标志为cv2.WINDOW_AUTOSIZE，如果将标志指定为cv2.WINDOW_NORMAL，则可以调整窗口大小
当图像尺寸过大以及向窗口添加跟踪栏时，这将很有帮助

7、保存图像
cv2.imwrite(‘messigray.png’，img)

参数1
文件名

参数2
要保存的图像

8、打开视频文件
cap = cv2.VideoCapture(‘12.mp4’)

9、cap.isOpened()
检查cap是否已初始化捕获

10、cap.read()
ret, frame = cap.read()

第一个参数ret的值为True或False，代表有没有读到图片

第二个参数是frame，是当前截取一帧的图片

11、释放捕获器
cap.release()

12、获取视频宽度
width = cap.get(3)

13、获取视频高度
height = cap.get(4)

14、获取视频FPS
fps = cap.get(cv2.CAP_PROP_FPS)
或
total_frames = cap.get(5)

15、获取视频总帧数
total_frames = cap.get(cv2.CAP_PROP_FRAME_COUNT)
或
total_frames = cap.get(7)

16、视频文件的当前位置（以毫秒为单位）或视频捕获时间戳
location = cap.get(cv2.CAP_PROP_POS_MSEC)

17、下一个要解码/捕获的帧的基于 0 的索引
cap.get(cv2.CAP_PROP_POS_FRAMES)

18、fourcc指定编码器

19、保存视频
VideoWriter(filename, fourcc, fps, frameSize[, isColor])

参数
filename
保存的文件路径

fourcc
指定编码器，常用的有DIVX、XVID、MJPG、X264、WMV1、WMV2
DIVX最适配，XVID、MJPG也可以转换，MJPG储存大小最大

fps
要保存的视频的帧率

frameSize
要保存的文件的画面尺寸

isColor
指示是黑白画面还是彩色的画面

fourcc = cv2.VideoWriter_fourcc(*‘DIVX’)
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
fps = int(cap.get(cv2.CAP_PROP_FPS))

out = cv2.VideoWriter(‘xx.avi’, fourcc, fps, (width, height))
while 1:

写入处理后的图片

out.write(frame)

out.release()

20、绘图功能
创建一个图像，默认是黑色
mg = numpy.zeros((300, 300, 3))

21、轨迹栏

22、访问图片像素值
image = cv2.imread(‘1.jpg’)
访问行100，列100的像素值
px = image[100,100]
print(px)

仅访问蓝色像素
blue = img[100,100,0]
print(blue)

仅访问绿色像素
green = img[100,100,1]
print(green)

仅访问红色像素
red = img[100,100,2]
print(red)

警告！！！
利用cv2访问每个像素值并对其进行修改将非常缓慢
建议全部使用Numpy快速数组计算
仅访问蓝色像素
blue = img.item(100,100,0)
print(blue)

仅访问绿色像素
green = img.item(100,100,1)
print(green)

仅访问红色像素
red = img.item(100,100,2)
print(red)

23、更改图片像素值
cv2：img[100,100] = [255,255,255]
numpy：
img.itemset((100,100,2),255)
img.itemset((100,100,1),255)
img.itemset((100,100,0),255)

24、访问图像形状
img.shape
返回行，列和通道数的元组（如果图像是彩色的）

如果img分辨率是1920x1080
row, col, a = img.shape
row = 1080, col = 1920

如果图像是灰度的，则返回的元组仅包含行数和列数，因此这是检查加载的图像是灰度还是彩色的好方法

25、访问像素总数
img.size
行x列x通道数

26、访问图像数据类型
img.dtype

img.dtype在调试时非常重要，因为OpenCV-Python代码中的大量错误是由无效的数据类型引起的

27、拆分图像通道
b, g, r = cv2.split(img)

显示单通道图片
cv2.imshow(‘blue’, b)

28、合并图像通道
img = cv2.merge((b, g, r))

29、图像加法
x = numpy.uint8([250])

y = numpy.uint8([10])
print( cv2.add(x, y) )

250+10 = 260 => 255

[[255]]

print(x + y)

250+10 = 260 % 256 = 4

[4]

OpenCV加法和Numpy加法之间有区别。OpenCV加法是饱和运算，而Numpy加法是模运算

img1 = cv2.imread(‘1.jpg’)
img2 = cv2.imread(‘2.jpg’)
img = img1 + img2
cv2.imshow(‘1’, img)
cv2.waitKey(0)

30、图像融合
这也是图像加法，但是对图像赋予不同的权重，以使其具有融合或透明的感觉

dst = cv2.addWeighted(img1, 0.7, img2, 0.3, 0)
第一幅图像的权重为0.7，第二幅图像的权重为0.3，γ被视为零

31、改变颜色空间
image = cv2.cvtColor(img, flag)

flag决定转换的类型
BGR→灰度转换
cv2.COLOR_BGR2GRAY

BGR→HSV转换
cv2.COLOR_BGR2HSV

32、对象追踪

33、缩放
res = cv2.resize(img, None, fx=0.5, fy=0.5, interpolation=cv2.INTER_LINEAR)
缩小至img的四分之一
res = cv2.resize(img, None, fx=2, fy=2, interpolation=cv2.INTER_LINEAR)
放大至img的四分之一

34、平移
偏移为(100, 50)
row, col = img.shape
m = numpy.float32([[1, 0, 100], [0, 1, 50]])
res = cv2.warpAffine(img, m, (col, row))

将偏移量放入numpy.float32类型的Numpy数组中，并将其传递给cv2.warpAffine函数

35、旋转
相对于中心旋转90度而没有任何缩放比例
m = cv2.getRotationMatrix2D(((col - 1) / 2.0, (row - 1) / 2.0), 90, 1)
res = cv2.warpAffine(img, m, (col, row))

36、仿射变换
在仿射变换中，原始图像中的所有平行线在输出图像中仍将平行。为了找到变换矩阵，我们需要输入图像中的三个点及其在输出图像中的对应位置

img = cv2.imread(‘1.jpg’)
rows, cols, ch = img.shape
pts1 = numpy.float32([[50, 50], [200, 50], [50, 200]])
pts2 = numpy.float32([[10, 100], [200, 50], [100, 250]])
M = cv2.getAffineTransform(pts1, pts2)
dst = cv2.warpAffine(img, M, (cols, rows))
matplotlib.pyplot.subplot(121), matplotlib.pyplot.imshow(img), matplotlib.pyplot.title(‘Input’)
matplotlib.pyplot.subplot(122), matplotlib.pyplot.imshow(dst), matplotlib.pyplot.title(‘Output’)
matplotlib.pyplot.show()

37、透视变换

38、简单阈值
对于每个像素，应用相同的阈值。如果像素值小于阈值，则将其设置为0，否则将其设置为最大值。函数cv2.threshold用于应用阈值。第一个参数是源图像，它应该是灰度图像。第二个参数是阈值，用于对像素值进行分类。第三个参数是分配给超过阈值的像素值的最大值。OpenCV提供了不同类型的阈值，这由函数的第四个参数给出。通过使用cv2.THRESH_BINARY类型。所有简单的阈值类型为：

cv.THRESH_BINARY
cv.THRESH_BINARY_INV
cv.THRESH_TRUNC
cv.THRESH_TOZERO
cv.THRESH_TOZERO_INV

img = cv2.imread(‘1.jpg’)
ret, thresh1 = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY)
ret, thresh2 = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY_INV)
ret, thresh3 = cv2.threshold(img, 127, 255, cv2.THRESH_TRUNC)
ret, thresh4 = cv2.threshold(img, 127, 255, cv2.THRESH_TOZERO)
ret, thresh5 = cv2.threshold(img, 127, 255, cv2.THRESH_TOZERO_INV)
titles = [‘Original Image’, ‘BINARY’, ‘BINARY_INV’, ‘TRUNC’, ‘TOZERO’, ‘TOZERO_INV’]
images = [img, thresh1, thresh2, thresh3, thresh4, thresh5]
for i in range(6):
matplotlib.pyplot.subplot(2, 3, i + 1), matplotlib.pyplot.imshow(images[i], ‘gray’)
matplotlib.pyplot.title(titles[i])
matplotlib.pyplot.xticks([]), matplotlib.pyplot.yticks([])
matplotlib.pyplot.show()

39、自适应阈值
除上述参数外，方法cv.adaptiveThreshold还包含三个输入参数：
该adaptiveMethod决定阈值是如何计算的：
cv2.ADAPTIVE_THRESH_MEAN_C::阈值是邻近区域的平均值减去常数C。 cv2.ADAPTIVE_THRESH_GAUSSIAN_C:阈值是邻域值的高斯加权总和减去常数C。

该BLOCKSIZE确定附近区域的大小，C是从邻域像素的平均或加权总和中减去的一个常数

40、Otsu的二值化
Otsu的方法避免了必须选择一个值并自动确定它的情况

img = cv2.imread(‘1.jpg’, 0)

全局阈值

ret1, th1 = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY)

Otsu阈值

ret2, th2 = cv2.threshold(img, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

高斯滤波后再采用Otsu阈值

blur = cv2.GaussianBlur(img, (5, 5), 0)
ret3, th3 = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

绘制所有图像及其直方图

images = [img, 0, th1,
img, 0, th2,
blur, 0, th3]
titles = [‘Original Noisy Image’, ‘Histogram’, ‘Global Thresholding (v=127)’,
‘Original Noisy Image’, ‘Histogram’, “Otsu’s Thresholding”,
‘Gaussian filtered Image’, ‘Histogram’, “Otsu’s Thresholding”]
for i in range(3):
matplotlib.pyplot.subplot(3, 3, i * 3 + 1), matplotlib.pyplot.imshow(images[i * 3], ‘gray’)
matplotlib.pyplot.title(titles[i * 3]), matplotlib.pyplot.xticks([]), matplotlib.pyplot.yticks([])
matplotlib.pyplot.subplot(3, 3, i * 3 + 2), matplotlib.pyplot.hist(images[i * 3].ravel(), 256)
matplotlib.pyplot.title(titles[i * 3 + 1]), matplotlib.pyplot.xticks([]), matplotlib.pyplot.yticks([])
matplotlib.pyplot.subplot(3, 3, i * 3 + 3), matplotlib.pyplot.imshow(images[i * 3 + 2], ‘gray’)
matplotlib.pyplot.title(titles[i * 3 + 2]), matplotlib.pyplot.xticks([]), matplotlib.pyplot.yticks([])
matplotlib.pyplot.show()

41、图像平滑2D卷积（图像过滤）图像模糊（图像平滑）

<1>平均
这是通过将图像与归一化框滤镜进行卷积来完成的。它仅获取内核区域下所有像素的平均值，并替换中心元素

示例演示其内核大小为5x5：
img = cv2.imread(‘1.jpg’)
blur = cv2.blur(img, (5, 5))
matplotlib.pyplot.subplot(121), matplotlib.pyplot.imshow(img), matplotlib.pyplot.title(‘Original’)
matplotlib.pyplot.xticks([]), matplotlib.pyplot.yticks([])
matplotlib.pyplot.subplot(122), matplotlib.pyplot.imshow(blur), matplotlib.pyplot.title(‘Blurred’)
matplotlib.pyplot.xticks([]), matplotlib.pyplot.yticks([])
matplotlib.pyplot.show()

通过增加cv2.blur中的内核大小，如(10, 10)，来增加模糊

<2>高斯模糊
我们应指定内核的宽度和高度，该宽度和高度应为正数和奇数。高斯模糊对于从图像中去除高斯噪声非常有效
blur = cv2.GaussianBlur(img, (15, 15), 0)

<3>中位模糊
提取内核区域下所有像素的中值，并将中心元素替换为该中值。这对于消除图像中的椒盐噪声非常有效

blur = cv2.medianBlur(img, 15)

<4>双边滤波
在去除噪声的同时保持边缘清晰锐利非常有效。但是，与其他过滤器相比，该操作速度较慢

blur = cv2.bilateralFilter(img, 19, 75, 75)

42、形态学转换

<1>侵蚀
侵蚀前景物体的边界(尽量使前景保持白色)，内核滑动通过图像(在2D卷积中)，原始图像中的一个像素(无论是1还是0)只有当内核下的所有像素都是1时才被认为是1，否则它就会被侵蚀(变成0)。根据内核的大小，边界附近的所有像素都会被丢弃。因此，前景物体的厚度或大小减小，或只是图像中的白色区域减小。它有助于去除小的白色噪声(正如我们在颜色空间章节中看到的)，分离两个连接的对象等

kernel = numpy.ones((5, 5), numpy.uint8)
erosion = cv2.erode(blur, kernel, iterations=1)

<2>扩张
它与侵蚀正好相反。如果内核下的至少一个像素为“ 1”，则像素元素为“ 1”。因此，它会增加图像中的白色区域或增加前景对象的大小。通常，在消除噪音的情况下，腐蚀后会膨胀。因为腐蚀会消除白噪声，但也会缩小物体。因此，我们对其进行了扩展。由于噪音消失了，它们不会回来，但是我们的目标区域增加了。在连接对象的损坏部分时也很有用

kernel = numpy.ones((5, 5), numpy.uint8)
dilation = cv2.dilate(img, kernel, iterations=1)

<3>开运算
开放只是侵蚀然后扩张的另一个名称，它对于消除噪音很有用

opening = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel)

<4>闭运算
闭运算与开运算相反，先扩张然后再侵蚀。在关闭前景对象内部的小孔或对象上的小黑点时很有用

closing = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)

<5>形态学梯度
这是图像扩张和侵蚀之间的区别，结果将看起来像对象的轮廓

gradient = cv2.morphologyEx(img, cv2.MORPH_GRADIENT, kernel)

<6>顶帽
它是输入图像和图像开运算之差

tophat = cv2.morphologyEx(img, cv2.MORPH_TOPHAT, kernel)

43、图像梯度

<1>Sobel 和 Scharr 算子
Sobel算子是高斯平滑加微分运算的联合运算，因此它更抗噪声。逆可以指定要采用的导数方向，垂直或水平（分别通过参数yorder和xorder）。逆还可以通过参数ksize指定内核的大

<2>Laplacian 算子
它计算了给出的图像的拉普拉斯图,它是每一阶导数通过Sobel算子计算

下面的代码显示了单个图表中的所有算子
img = cv2.imread(‘1.jpg’, 0)
laplacian = cv2.Laplacian(img, cv2.CV_64F)
sobelx = cv2.Sobel(img, cv2.CV_64F, 1, 0, ksize=5)
sobely = cv2.Sobel(img, cv2.CV_64F, 0, 1, ksize=5)
matplotlib.pyplot.subplot(2, 2, 1), matplotlib.pyplot.imshow(img, cmap=‘gray’)
matplotlib.pyplot.title(‘Original’), matplotlib.pyplot.xticks([]), matplotlib.pyplot.yticks([])
matplotlib.pyplot.subplot(2, 2, 2), matplotlib.pyplot.imshow(laplacian, cmap=‘gray’)
matplotlib.pyplot.title(‘Laplacian’), matplotlib.pyplot.xticks([]), matplotlib.pyplot.yticks([])
matplotlib.pyplot.subplot(2, 2, 3), matplotlib.pyplot.imshow(sobelx, cmap=‘gray’)
matplotlib.pyplot.title(‘Sobel X’), matplotlib.pyplot.xticks([]), matplotlib.pyplot.yticks([])
matplotlib.pyplot.subplot(2, 2, 4), matplotlib.pyplot.imshow(sobely, cmap=‘gray’)
matplotlib.pyplot.title(‘Sobel Y’), matplotlib.pyplot.xticks([]), matplotlib.pyplot.yticks([])
matplotlib.pyplot.show()

44、Canny边缘检测
OpenCV将以上所有内容放在单个函数cv2.Canny()中。我们将看到如何使用它。第一个参数是我们的输入图像。第二个和第三个参数分别是我们的minVal和maxVal。第三个参数是perture_size。它是用于查找图像渐变的Sobel内核的大小。默认情况下为3。最后一个参数是L2gradient，它指定用于查找梯度幅度的方程式。如果为True，则使用上面提到的更精确的公式，默认情况下，它为False

img = cv2.imread(‘1.jpg’, 0)
edges = cv2.Canny(img, 100, 200)
matplotlib.pyplot.subplot(121), matplotlib.pyplot.imshow(img, cmap=‘gray’)
matplotlib.pyplot.title(‘Original Image’), matplotlib.pyplot.xticks([]), matplotlib.pyplot.yticks([])
matplotlib.pyplot.subplot(122), matplotlib.pyplot.imshow(edges, cmap=‘gray’)
matplotlib.pyplot.title(‘Edge Image’), matplotlib.pyplot.xticks([]), matplotlib.pyplot.yticks([])
matplotlib.pyplot.show()

45、图像金字塔
使用金字塔进行图像融合
金字塔的一种应用是图像融合。例如，在图像拼接中，您需要将两个图像堆叠在一起，但是由于图像之间的不连续性，可能看起来不太好。在这种情况下，使用金字塔混合图像可以无缝混合，而不会在图像中保留大量数据

46、绘制轮廓
轮廓可以简单地解释为连接具有相同颜色或强度的所有连续点（沿边界）的曲线。轮廓是用于形状分析以及对象检测和识别的有用工具

im = cv2.imread(‘12.jpg’)
imgray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(imgray, 127, 255, 0)
contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
ss = cv2.drawContours(im, contours, -1, (0, 255, 0), 3)
cv2.imshow(‘1’, ss)
cv2.waitKey(0)

47、轮廓特征
<1>特征矩
img = cv2.imread(‘1.jpg’,0)
ret, thresh = cv2.threshold(img, 127, 255, 0)
contours, hierarchy = cv2.findContours(thresh, 1, 2)
cnt = contours[0]
M = cv.moments(cnt)
print(M)

质心由关系给出
cx = int(M[‘m10’]/M[‘m00’])
cy = int(M[‘m01’]/M[‘m00’])

<2>轮廓面积
从矩M[‘m00’]中给出

<3>轮廓周长
perimeter = cv2.arcLength(cnt, True)

<4>轮廓近似
它是Douglas-Peucker算法的实现
epsilon = 0.1 * cv2.arcLength(cnt, True)
approx = cv2.approxPolyDP(cnt, epsilon, True)

<5>轮廓凸包
hull = cv.convexHull(cnt)

<6>检查凸度
k = cv2.isContourConvex(cnt)

<7>边界矩形直角矩形
令(x，y)为矩形的左上角坐标，而(w，h)为矩形的宽度和高度
x, y, w, h = cv2.boundingRect(cnt)
a = cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)

<8>边界矩形旋转矩形
rect = cv2.minAreaRect(cnt)
box = cv2.boxPoints(rect)
box = numpy.int0(box)
a = cv2.drawContours(im, [box], 0, (0, 0, 255), 2)

<9>最小闭合圈
(x, y), radius = cv2.minEnclosingCircle(cnt)
center = (int(x), int(y))
radius = int(radius)
a = cv2.circle(im, center, radius, (0, 255, 0), 2)

<10>拟合一个椭圆
ellipse = cv2.fitEllipse(cnt)
a = cv2.ellipse(im, ellipse, (0, 255, 0), 2)

<11>拟合直线
rows, cols = im.shape[:2]
[vx, vy, x, y] = cv2.fitLine(cnt, cv2.DIST_L2, 0, 0.01, 0.01)
lefty = int((-x * vy / vx) + y)
righty = int(((cols - x) * vy / vx) + y)
a = cv2.line(im, (cols-1, righty), (0, lefty), (0, 255, 0), 2)

48、轮廓属性
<1>长宽比
它是对象边界矩形的宽度与高度的比值
x, y, w, h = cv2.boundingRect(cnt)
aspect_ratio = float(w) / h

<2>范围
范围是轮廓区域与边界矩形区域的比值
area = cv2.contourArea(cnt)
x, y, w, h = cv2.boundingRect(cnt)
rect_area = w * h
extent = float(area) / rect_area

<3>坚实度
坚实度是等高线面积与其凸包面积之比
area = cv2.contourArea(cnt)
hull = cv2.convexHull(cnt)
hull_area = cv2.contourArea(hull)
solidity = float(area) / hull_area

<4>等效直径
等效直径是面积与轮廓面积相同的圆的直径
area = cv2.contourArea(cnt)
equi_diameter = numpy.sqrt(4 * area / numpy.pi)

<5>取向
取向是物体指向的角度。以下方法还给出了主轴和副轴的长度
(x, y), (MA, ma), angle = cv2.fitEllipse(cnt)

<6>掩码和像素点
在某些情况下，我们可能需要构成该对象的所有点
imgray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
mask = numpy.zeros(imgray.shape, numpy.uint8)
cv2.drawContours(mask, [cnt], 0, 255, -1)
pixelpoints = numpy.transpose(numpy.nonzero(mask))

<7>最大值，最小值和它们的位置
我们可以使用掩码图像找到这些参数
imgray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
mask = numpy.zeros(imgray.shape, numpy.uint8)
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(imgray, mask=mask)

<8>平均颜色或平均强度
imgray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
mask = numpy.zeros(imgray.shape, numpy.uint8)
mean_val = cv2.mean(im, mask=mask)

<9>极端点
极点是指对象的最顶部，最底部，最右侧和最左侧的点
leftmost = tuple(cnt[cnt[:, :, 0].argmin()][0])
rightmost = tuple(cnt[cnt[:, :, 0].argmax()][0])
topmost = tuple(cnt[cnt[:, :, 1].argmin()][0])
bottommost = tuple(cnt[cnt[:, :, 1].argmax()][0])

49、轮廓：更多属性
<1>凸性缺陷

<2>点多边形测试

<3>形状匹配

fake_useragent库
现在的网站一般都有反爬虫措施，最常见的是检查浏览器的头部信息，所以对头部信息进行伪装的操作可以说是很必要的，为此可以引入fake_useragent库

1、UserAgent()
能够获得浏览器种类信息的实例
a = UserAgent()

2、a.random
随机获得头部信息
headers = {‘User-Agent’:a.random}

协程
协程不是计算机提供的，是程序员人为创造的

asyncio 异步 I/O
asyncio是用来编写并发代码的库
https://docs.python.org/zh-cn/3/library/asyncio-task.html
https://asyncio.readthedocs.io/en/latest/index.html

1、asyncio.run()
运行一个协程

2、asyncio.create_task(coro, *, name=None)
用来并发运行作为asyncio任务的多个协程

将 coro协程打包为一个Task排入日程准备执行，返回Task对象
name不为None，它将使用Task.set_name()来设为任务的名称

3、asyncio.sleep(delay, result=None, *, loop=None)
阻塞delay指定的秒数

如果指定了result，则当协程完成时将其返回给调用者
sleep()总是会挂起当前任务，以允许其他任务运行

4、asyncio.shield(aw, *, loop=None)
保护一个可等待对象防止其被取消

5、asyncio.wait_for(aw, timeout, *, loop=None)
等待aw可等待对象完成，指定timeout秒数后超时

# Sleep for one hour
await asyncio.sleep(3600)
print('yay!')

async def main():
# Wait for at most 1 second
try:
await asyncio.wait_for(eternity(), timeout=1.0)
except asyncio.TimeoutError:
print(‘timeout!’)

asyncio.run(main())

6、asyncio.wait(aws, *, loop=None, timeout=None, return_when=ALL_COMPLETED)
简单等待，如指定timeout(float或int类型) 则它将被用于控制返回之前等待的最长秒数
请注意此函数不会引发asyncio.TimeoutError

7、asyncio.to_thread(func, /, *args, **kwargs)
在不同的线程中异步地运行函数func
通过改用asyncio.to_thread()，我们可以在不同的线程中运行它从而不会阻塞事件循环

由于GIL的存在，asyncio.to_thread() 通常只能被用来将IO密集型函数变为非阻塞的。 但是，对于会释放GIL的扩展模块或无此限制的替代性Python实现来说，asyncio.to_thread()也可被用于CPU密集型函数

8、asyncio.run_coroutine_threadsafe(coro, loop)
向指定事件循环提交一个协程，线程安全

9、asyncio.current_task(loop=None)
返回当前运行的Task实例，如果没有正在运行的任务则返回None

10、asyncio.Task(coro, *, loop=None, name=None)
一个与Future类似的对象，可运行Python协程，非线程安全

11、asyncio.ensure_future()
安排协程的执行，用future包装它，返回一个task

12、asyncio.gather(*coros_or_futures, loop=None, return_exceptions=False)
将多个协程或future，集成为一个future，所有的future必须在一个事件循环中。如果所有的future都成功完成了，则按照输入顺序（而不是返回顺序）返回所有result

tkinter库（8.6）

import tkinter
from tkinter import ttk

1、a = tkinter.TK()
实例化tkinter对象

2、a.geometry()
a.geometry(“350x200”)
设置窗口大小，会把窗口设置成350个像素宽，200个像素高

3、窗口最大化
a.state(“zoomed”)

4、设置窗口图标
window.iconbitmap(“icon.ico”)

5、a.title()
显示标签
a.title(‘first window’)

6、tkinter.Frame()/ttk.Frame
tab = tkinter.Frame(width=1920, height=1080, bg="#FFFFFF").pack()

7、tkinter.Label()/ttk.Label()
创建一个标签组件
b = ttk.Label(a, text=‘第一个窗口程序!’).grid()

参数
text
文本标签

justify
表示文字左右对齐，如tkinter.LEFT,tkinter.RIGHT

image
显示图片

compound
图片与字体叠加形式，如tkinter.CENTER

font
设置字体，字号，如
font=(‘黑体’, 20)

fg
设置前景色

relief
边框样式，可选值为：flat(默认),sunken,raised,groove,ridge

borderwidth
边框的宽度，单位是像素

设置新的组件参数
b.configure()

更改文本内容
b[‘text’] = ‘New’

8、.grid()
Grid(网格)布局管理器会将控件放置到一个二维的表格里。主控件被分割成一系列的行和列，表格中的每个单元(cell)都可以放置一个控件
label.grid(column=0, row=0)

参数
column
设置网格列数

row
设置网格行数

9、ttk.Button()
创建一个按钮组件
tkinter.Butten(a, text=“ok”, command, bg=“orange”, fg=“red”, image, width=20, height=5).grid()
ttk不支持bg和fg

参数
text
设置按钮文字

command
触发事件
调用函数时，切不可加（），只写函数名！！！！！！！！

调用函数传递参数
command=lambda: function(a, b, c)
若要传入变化量
command=lambda m=变化量i: function(m))

fg
设置按钮的前景色（文字颜色）

bg
设置按钮的背景色

image
设置按钮图片
img = tkinter.PhotoImage(file=‘1.gif’)
ttk.Button(a, image=img).grid()

relief
浮雕样式
relief=tkinter.FLAT（平坦的）
relief=tkinter.RAISED（突起）
relief=tkinter.SUNKEN（凹陷）
relief=tkinter.GROOVE（凹槽）
relief=tkinter.RIDGE（脊状）

justify
文字左右居中对齐
justify=tkinter.LEFT
justify=tkinter.CENTER
justify=tkinter.RIGHT

wraplength
换行宽度

10、ttk.Entry()
创建一个输入文本框组件
msg = ttk.Entry(a, width=10, state, show=’*’).grid()

参数
width
设置长度，10个字符长

state
设置禁用小组件state=‘disabled’

show
设置文本框中显示的字符，如果是*，则表示文本框为密码框

输出内容
msg.get()

background
设置 Entry 的背景颜色

bg
background一样

borderwidth
设置 Entry 的边框宽度

bd
borderwidth一样

cursor
指定当鼠标在 Entry 上飘过的时候的鼠标样式

exportselection
指定选中的文本是否可以被复制到剪贴板
默认值是 True，可以修改为 False 表示不允许复制文本

font
指定 Entry 中文本的字体

foreground
设置 Entry 的文本颜色

fg
foreground一样

highlightbackground
指定当 Entry 没有获得焦点的时候高亮边框的颜色

highlightcolor
指定当 Entry 获得焦点的时候高亮边框的颜色

highlightthickness
指定高亮边框的宽度

insertbackground
指定输入光标的颜色

insertborderwidth
指定输入光标的边框宽度，如果被设置为非 0 值，光标样式会被设置为 RAISED
将insertwidth设置大一点才能看到效果

insertofftime
该选项控制光标的闪烁频率（灭），单位是毫秒

insertontime
该选项控制光标的闪烁频率（亮），单位是毫秒

insertwidth
指定光标的宽度

invalidcommand
指定当输入框输入的内容“非法”时调用的函数
也就是指定当 validateCommand 选项指定的函数返回 False 时的函数

invcmd
invalidcommand一样

justify
定义如何对齐输入框中的文本，使用 “left”，“right” 或 “center”

relief
指定边框样式，默认值是 “sunken”，其他可以选择的值是 “flat”，“raised”，“groove” 和 “ridge”

selectbackground
指定输入框的文本被选中时的背景颜色

selectborderwidth
指定输入框的文本被选中时的边框宽度（选中边框）

selectforeground
指定输入框的文本被选中时的字体颜色

state
可以设置的状态：“normal”，“disabled” 或 “readonly”（注意，它跟 “disabled” 相似，但它支持选中和拷贝，只是不能修改，而 “disabled” 是完全禁止），如果此选项设置为 “disabled” 或 “readonly”，那么调用 insert() 和 delete() 方法都会被忽略

takefocus
指定使用 Tab 键可以将焦点移动到输入框中，默认是开启的，可以将该选项设置为 False 避免焦点在此输入框中

textvariable
指定一个与输入框的内容相关联的 Tkinter 变量（通常是 StringVar），当输入框的内容发生改变时，该变量的值也会相应发生改变
addr = tkinter.StringVar(value=‘123’)
ent0 = tkinter.Entry(tk, width=40, relief=‘groove’, textvariable=addr)

validate
该选项设置是否启用内容验证

validatecommand
该选项指定一个验证函数，用于验证输入框内容是否合法，验证函数需要返回 True 或 False 表示验证结果，该选项只有当 validate 的值非 “none” 时才有效

vcmd
validatecommand一样

xscrollcommand
与 scrollbar（滚动条）组件相关联

11、tkinter.Text()
创建一个文本框组件
txt = tkinter.Text(a, width=35, height=5, font=(‘黑体’, 14))

输出
txt.get(0.0, tkinter.END)

插入内容
插入光标当前位置
txt.insert(‘insert’, ‘abc’)
插入到最后
txt.insert(‘end’, ‘abc’)

12、ttk.Combobox()
创建一个组合框组件
combo = ttk.Combobox(a, values=(1, 2, 3, 4, 5, “text”))

参数
values
设置组合框选项

输出
combo.get()
获取组合框被选中的选项

如果不希望可以输入值
state=‘readonly’

13、combo.current()
传递期望被选中选项的索引，设置被选中的选项

combo.current(1)
默认选中第二项

14、创建一个复选框组件
用BooleanVar变量用来设置复选框的状态
chk_state = tkinter.BooleanVar()

设置初始状态是选中（True）还是不选中（False）
chk_state.set(False)

chk = ttk.Checkbutton(a, text=“choose”, var=chk_state, command)
chk.grid(column=0, row=0)

参数
text
选项显示名称

var
添加该选项

command
触发事件

设置多个复选框：
chk_state1 = tkinter.BooleanVar()
chk_state1.set(False)
chk1 = ttk.Checkbutton(a, text=“1”, var=chk_state1)
chk1.grid(column=0, row=0)

chk_state2 = tkinter.BooleanVar()
chk_state2.set(False)
chk2 = ttk.Checkbutton(a, text=“2”, var=chk_state2)
chk2.grid(column=0, row=1)

chk_state3 = tkinter.BooleanVar()
chk_state3.set(False)
chk3 = ttk.Checkbutton(a, text=“3”, var=chk_state3)
chk3.grid(column=0, row=2)
注意grid设置，不要重叠

15、tkinter.Radiobutton()
创建一个单选框组件
selected = tkinter.IntVar()/selected = tkinter.StringVar()
rad1 = tkinter.Radiobutton(a, text=“1”, value=1, variable=selected)
rad1.grid(column=0, row=0)

创建多个单选框组件
rad1 = tkinter.Radiobutton(a, text=“1”, variable=selected, value=1)
rad1.grid(column=0, row=0)
rad2 = tkinter.Radiobutton(a, text=“2”, variable=selected, value=2)
rad2.grid(column=1, row=0)
rad3 = tkinter.Radiobutton(a, text=“3”, variable=selected, value=3)
rad3.grid(column=2, row=0)

如果按钮（选项）比较多
option_name = [(‘陈泡泡’, 1), (‘老万’, 2), (‘老杨’, 3), (‘扣总’, 4)]
selected = tkinter.IntVar()
for option_nam, i1 in option_name:
rad = tkinter.Radiobutton(a, text=option_nam, variable=selected, value=option_nam)
rad.grid(column=0, row=i1 - 0)

默认选中1
v.set(1)
默认选中2
v.set(2)
默认都不选中
v.set(0)

参数
text
选项内容

value
需要给每个单选框设置不同的值，否则会不起作用

variable
利用selected关联每个单选框value，用get()输出触发事件时该组件的value
def cc():
print(selected.get())

16、创建一个MessageBox小部件
tkinter.messagebox.showinfo(“msgtt”, “well”)

参数
第一个参数
消息框title内容

第二个参数
消息内容

警告
tkinter.messagebox.showwarning()
错误
tkinter.messagebox.showerror()
是否
msg = tkinter.messagebox.askquestion()
print(msg)

yse/no
tkinter.messagebox.askyesno()
是否取消
tkinter.messagebox.askyesnocancel()
确定取消
tkinter.messagebox.askokcancel()
重试取消
tkinter.messagebox.askretrycancel()

17、添加一个SpinBox数字小部件
spin = tkinter.Spinbox(a, from_=0, to=100, width=5)
或
spin = tkinter.Spinbox(a, values=(1, 3, 5), width=5)
spin.grid(column=0, row=0)

参数
from_
限制最小数字（含）

to
限制最大数字（含）

width
文本框宽度

values
指定可选数字

18、添加进度栏小部件并设置样式
设置黑底进度条
style = ttk.Style()
style.theme_use(‘default’)
style.configure(‘black.Horizontal.TProgressbar’, background=‘black’)

添加进度栏
bar = ttk.Progressbar(a, length=200, maximum=120, value=0, style=‘black.Horizontal.TProgressbar’)
bar.grid(column=0, row=0)

style = ttk.Style()
框架具有style配置选项，这对于所有主题小部件都是通用的，可以控制其外观或行为的许多其他方面

参数
length
进度条长度（像素）

maximum
进度值最大数

value
进度数

进度条动画
def running():
for i in range(10):
bar[‘value’] = i * 10 + 10
a.update()
time.sleep(0.5)
running()
在单独函数内跑（因为time），改变value增加进度，使用updata更新组件

19、添加文件对话框（文件和目录选择器）
from tkinter import filedialog
返回单文件路径
file_window = filedialog.askopenfilename()

返回多文件路径
file_window = filedialog.askopenfilenames()

返回目录路径
file_window = filedialog.askdirectory()

返回指定文件类型扩展名
加参数
filetypes = ((“Text files”,".txt"),(“all files”,".*"))

指定文件对话框的初始目录
加参数
initialdir= path.dirname(file)

输出路径
print(file_window)

20、添加菜单栏
menu = tkinter.Menu(a)
menu.add_command(label=‘File’)
a.config(menu=menu)

add_cascade()函数在任何菜单下添加菜单项

menu = tkinter.Menu(a)
submenu = tkinter.Menu(menu, tearoff=0)
submenu.add_command(label=“打开”)
submenu.add_command(label=“保存”)
submenu.add_command(label=“关闭”)
menu.add_cascade(label=“文件”, menu=submenu)
submenu = tkinter.Menu(menu, tearoff=0)
submenu.add_command(label=“复制”)
submenu.add_command(label=“粘贴”)
submenu.add_separator()
submenu.add_command(label=“剪切”)
menu.add_cascade(label=“编辑”, menu=submenu)
a.config(menu=menu)

tearoff参数
禁用子菜单最上面的虚线

new_item.add_separator()
添加一条子菜单分割线

21、添加笔记本小部件（选项卡控件）
将小部件添加到笔记本
可以使用相同的方式添加许多选项卡，创建选项卡后，可以通过将父属性分配给所需的选项卡来将小部件放置在这些选项卡中

tab_control = ttk.Notebook(a)
tab1 = ttk.Frame(tab_control)
tab2 = ttk.Frame(tab_control)
tab3 = ttk.Frame(tab_control)
tab4 = ttk.Frame(tab_control)
tab5 = ttk.Frame(tab_control)
tab_control.add(tab1, text=‘1’)
tab_control.add(tab2, text=‘2’)
tab_control.add(tab3, text=‘3’)
tab_control.add(tab4, text=‘4’)
tab_control.add(tab5, text=‘5’)
lbl1 = ttk.Label(tab1, text=‘label1’)
lbl1.grid(column=0, row=0)
lbl2 = ttk.Label(tab2, text=‘label2’)
lbl2.grid(column=0, row=0)
lbl2 = ttk.Label(tab3, text=‘label3’)
lbl2.grid(column=0, row=0)
lbl2 = ttk.Label(tab4, text=‘label4’)
lbl2.grid(column=0, row=0)
lbl2 = ttk.Label(tab5, text=‘label5’)
lbl2.grid(column=0, row=0)
tab_control.pack(expand=1, fill=‘both’)

22、a.mainloop()
窗口主事件循环

23、tkinter.PhotoImage()
显示图片（仅支持gif）
tkinter.PhotoImage(file=‘1.gif’)

24、b.pack()
适合于少量的组件排序，所以在使用上是相当简单
用于自动调节窗口的尺寸与位置
或手动调节
b.pack(side,padx,pady)

参数
side
定义控件放置的位置，TOP（靠上对齐）、BOTTOM（靠下对齐）、LEFT（靠左对齐）或RIGHT（靠右对齐）
side=tkinter.LEFT,side=tkinter.RIGHT
将组件放置最左居中，将组件放置最右居中

padx,pady
此选项定义控件之间的距离，单位是像素，也可以是其它测量单位，如厘米、英寸等

fill
决定如何填满空间，可以是X、Y、BOTH或NONE，此选项必须在expand等于1才有作用。当fill等于X时，窗体会占满整个窗口X方向剩余的空间；当fill等于Y时，窗体会占满整个窗口Y方向剩余的空间；当fill等于BOTH时，窗体会占满整个窗口剩余的空间；当fill等于NONE时，窗体维持不变

ipadx,ipady
此选项与fill选项共同使用，以定义窗体内的控件与窗体边界之间的距离。此选项的单位是像素，也可以是其他测量单位，如厘米、英寸等

25、b.place()
用于调节窗口的尺寸与位置（像素）
b.place(x=10, y=10, anchor=‘nw’)

参数
x
横坐标位置

y
纵坐标位置

anchor
对齐方向，上北下南左西右东

26、添加滚动条小部件
sb = tkinter.Scrollbar(a)
sb.pack(side=tkinter.RIGHT, fill=tkinter.Y)

参数
background (bg)
设置背景颜色

borderwidth (bd)
指定边框宽度，通常是 2 像素

cursor
指定当鼠标在上方飘过的时候的鼠标样式

orient
指定绘制 “horizontal”（垂直滚动条）还是 “vertical”（水平滚动条）

highlightbackground
指定当滚动条没有获得焦点的时候高亮边框的颜色

highlightcolor
指定当滚动条获得焦点的时候高亮边框的颜色

jump
指定当用户拖拽滚动条时的行为

relief
指定边框样式, 默认值是 “sunken”

command
当滚动条更新时回调的函数
通常的是指定对应组件的 xview() 或 yview() 方法

takefocus
指定该组件是否接受输入焦点（用户可以通过 tab 键将焦点转移上来）, 默认值是 True

width
设置滚动条的宽度, 默认值是 16 像素

27、添加分割线小部件
ss = ttk.Style()
ss.configure(‘red.TSeparator’, background=’#CCFFFF’)
ttk.Separator(tk, orient=‘horizontal’, style=‘red.TSeparator’).place(y=30, width=1920, height=5)

设置颜色为#CCFFFF，距上边框30像素，线宽度5像素，长度1920像素

28、 添加画布
canv = tkinter.Canvas(a, width=224, height=1038, bg="#FFFFFF").place(x=0, y=0, anchor=‘nw’)

如果给这个canvas设置一个背景色，容器外部设置另外一个背景色，可以看得到canvas四周有一条白色的边框。在我们做窗口布置时，显得不太完美，改进方法为
highlightthickness=0

29、添加表格
tree = ttk.Treeview(tk, show=“headings”, height=2400)

定义列
tree[“columns”] = (“姓名”, “年龄”, “身高”, “体重”)

设置列宽度和对齐方式
tree.column(“姓名”, width=100, anchor=‘center’)
tree.column(“年龄”, width=100, anchor=‘center’)

设置显示的表头名
tree.heading(“姓名”, text=“x姓名”)
tree.heading(“年龄”, text=“x年龄”)

给第0行添加数据，索引值可重复
tree.insert("", 0, text=“line1”, values=(“卡恩”, “18”, “180”, “65”))
tree.insert("", 1, text=“line2”, values=(“范冰冰”, “38”, “170”, “55”))

Treeview组件与垂直滚动条结合
scrollBar.config(command=tree.yview)

定义并绑定Treeview组件的鼠标单击事件
def treeviewClick(event):
pass
tree.bind(’’, treeviewClick)

设置行高
s = ttk.Style()
s.configure(‘Treeview’, rowheight=40)

获取行id值
x = tree.get_children()

删除某行
tree.delete(x[0])

30、添加子窗口
top = tkinter.Toplevel()
top.grab_set()

top.mainloop()

设置窗口名称
top.title(“窗口名称”)

设置窗口大小
top.geometry(“400x300”)

31、事件处理
a.bind(‘sequence’, func, add)

参数
func
表示所绑定的事件处理函数

add
表示可选参数，为空字符或者"+"

className
表示所绑定的类

sequence
表示所绑定的事件，必须是以尖括号“<>”包围的字符串

鼠标事件
= = =
表示按下鼠标左键
= 按下鼠标中键
= 按下鼠标右键
= 释放鼠标左键
释放鼠标中键
释放鼠标右键
= 按住鼠标左键并移动
按住鼠标中键并移动
按住鼠标右键并移动
= 双击鼠标左键
双击鼠标中键
双击鼠标右键
鼠标指针进入某一组件区域
鼠标指针离开某一组件区域
鼠标滑轮滚动动作

键盘事件
回车
Break键
BackSpace键
Tab键
Shift键
左shift按键响应
右shift按键响应
Alt键
Control键
Pause键
Caps_Lock键
Escapel键
PageUp键
PageDown键
End键
Home键
左箭头
上箭头
右箭头
下箭头
Print Screen键
Insert键
Delete键
F1键
. .
. .
F12键
Num_Lock键
Scroll_Lock键
任意键
按下A键
按下a键

Shift+Up
Alt+Up
Ctrl+Up
Ctrl+shift+a
Alt+A
Control+A
Shift+A
快速按两下A
CapsLock+A

Event
widget 事件被触发的控件
x, y 鼠标距离窗体左上角的位置（坐标）
x_root, x_y 鼠标距离屏幕左上角的位置（坐标）
char 键盘事件对应的字符代码
keysym 键盘事件对应的字符串
keycode 键盘事件对应的按键码
num 鼠标事件对应的按键码
width, height 控件的新大小
type 事件类型

常用的窗口事件
：当控件由不可用转为可用时触发。
：当控件大小改变时触发。
：当控件由可用转为不可用时触发。
：当控件被销毁时触发。
：当控件从被遮挡状态中暴露出来时触发。
：当控件获得焦点时触发。
：当控件失去焦点时触发。
：当控件由隐藏状态变为显示状态时触发。
：当窗体的属性被删除或改变时触发。
：当控件由显示状态变为隐藏状态时触发。
：当控件变为可视状态时触发。

def calculate(event):
tkinter.Label(a, background=‘blue’, width=50).grid(column=0, row=0)
print({event.char})
a.bind(’’, calculate)

若bind传入多个参数
def calculate(b):
print(b)
a.bind(’’, lambda event: calculate(a))

31、窗口置顶
a.wm_attributes(’-topmost’, 1)
可以用于某些程序的消息提示，能够弹出到桌面显示

32、隐藏/显示控件
button.pack_forget()
button.pack

33、销毁控件
button.destroy()

34、退出程序
a.quit()

35、窗口透明度
a.attributes(’-alpha’, 0.85)

chet = tkinter.Tk()
chet.geometry(‘800x200+1800+0’)
chet.overrideredirect(True) # 删除标题栏
chet.attributes(’-transparentcolor’, ‘white’) # 使白色为透明色
tkinter.Text(chet, bg=‘white’).place(x=0, y=30, width=800, height=200)

chet_m = tkinter.Tk()

窗口透明度

chet_m.attributes(’-alpha’, 0.9)

位置要对其顶层窗口的缺口位置

chet_m.geometry(‘800x200+1800+0’)
chet_m.overrideredirect(True)

chet.mainloop()

pyautogui库

1、pyautogui.position()
获取鼠标当前坐标

2、pyautogui.click()
单击

pyautogui.click(x=100, y=200)
pyautogui.click(clicks=2)

pyautogui.click(button=‘right’)
右击

3、pyautogui.doubleClick()
双击

4、移动坐标位置
绝对移动
pyautogui.moveTo()

pyautogui.moveTo(x,y,time)
time为移动秒数，默认为0.1

相对移动
pyautogui.moveRel(x,y)

5、拖拽鼠标
绝对移动
pyautogui.dragTo(x,y,time,button=‘left’,duration=0.25)

相对移动
pyautogui.dragRel(x,y,time, button=‘right’,duration=0.25)

参数
duration
表示持续时间，即当前点到达下一个点所需花费的时间

6、pyautogui.press()
调用键盘操作
pyautogui.press(keys, presses=1, interval=0.0, logScreenshot=None, _pause:bool=True)

参数
presses
连续输入几个
interval
间隔时长

回车
pyautogui.press(‘enter’)
空格
pyautogui.press(‘space’)
CTRL
pyautogui.press(‘ctrl’)

键名 对应输入值
回车 enter
ECS键 esc
左右SHIFT键 shiftleft/shiftright
左右ALT键 altleft/altright
左右CTRL键 ctrlleft/ctrlright
BACKSPACE/DELETE键 backspace/delete
PAGE UP和PAGE DOWN键 pageup/pagedown
HOME和END键 home/end
箭头键 up/down/left/right
F1-F12键 f1/f2/f3/f4…
声音控制键 volumemute/volumedown/volumeup
CAPS LOCK键 capslock
NUM LOCK键 numlock
SCROLLLOCK键 scrolllock
INS或INSERT键 insert
PRTSC或PRINT SCREEN键 printscreen
win键 winleft/winright
Mac os x command键 command

7、pyautogui.hotkey()
连续快捷键操作
pyautogui.hotkey(‘ctrl’,‘c’)
pyautogui.hotkey(‘ctrl’,‘shift’,‘t’)

8、键盘长按和松开
pyautogui.keyDown(‘L’)
pyautogui.keyDown(‘shift’)
pyautogui.keyUp(‘L’)
pyautogui.keyUp(‘shift’)

9、pyautogui.PAUSE
每隔几秒执行一个操作指令
pyautogui.PAUSE=1

10、pyautogui.write()
控制键盘输入内容
pyautogui.write(‘123’,interval=0.3)

参数interval是每个字符之间的停顿间隔，以秒为单位

11、鼠标按下和抬起
pyautogui.mouseDown()
pyautogui.mouseUp()

12、截屏功能
可以直接截屏，当变量使用
im1 = pyautogui.screenshot()

也可以截屏，保存在当前文件夹
im2 = pyautogui.screenshot(‘my_screenshot.png’)

im = pyautogui.screenshot(region=(0,0, 300, 400))

13、测量截屏大小
pyautogui.locateOnScreen(‘calc7key.png’)

14、确定截屏中心点x,y
pyautogui.center(button7location)

15、确定某点的颜色
im = pyautogui.screenshot()
im.getpixel((100, 200))

pywin32库
主要作用是方便python开发者快速调用windowsAPI的一个模块

win32api模块
1、win32api.GetCursorPos()
获取鼠标当前的位置坐标，返回一个(x,y)的元组

2、win32api.SetCursorPos()
将鼠标移动到坐标处
win32api.SetCursorPos((200,200))

3、win32api.mouse_event()
操作鼠标进行点击

win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN, 100, 100, 0, 0)
在该坐标按下鼠标左键
win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP, 100, 100, 0, 0)
在该坐标释放鼠标左键
win32api.mouse_event(win32con.MOUSEEVENTF_RIGHTTDOWN, 100, 100, 0, 0)
在该坐标按下鼠标右键
win32api.mouse_event(win32con.MOUSEEVENTF_RIGHTUP, 100, 100, 0, 0)
在该坐标释放鼠标右键

4、win32api.mouse_event()
模拟鼠标中轴滑动，-1代表页面向下，1代表向上
win32api.mouse_event(win32con.MOUSEEVENTF_WHEEL,0,0,-1)

5、模拟键盘按键
按回车
win32api.keybd_event(VK_CODE[‘enter’],0,0,0)
释放
win32api.keybd_event(VK_CODE[‘enter’],0,win32con.KEYEVENTF_KEYUP,0)

VK_CODE = {
‘backspace’:0x08,
‘tab’:0x09,
‘clear’:0x0C,
‘enter’:0x0D,
‘shift’:0x10,
‘ctrl’:0x11,
‘alt’:0x12,
‘pause’:0x13,
‘caps_lock’:0x14,
‘esc’:0x1B,
‘spacebar’:0x20,
‘page_up’:0x21,
‘page_down’:0x22,
‘end’:0x23,
‘home’:0x24,
‘left_arrow’:0x25,
‘up_arrow’:0x26,
‘right_arrow’:0x27,
‘down_arrow’:0x28,
‘select’:0x29,
‘print’:0x2A,
‘execute’:0x2B,
‘print_screen’:0x2C,
‘ins’:0x2D,
‘del’:0x2E,
‘help’:0x2F,
‘0’:0x30,
‘1’:0x31,
‘2’:0x32,
‘3’:0x33,
‘4’:0x34,
‘5’:0x35,
‘6’:0x36,
‘7’:0x37,
‘8’:0x38,
‘9’:0x39,
‘a’:0x41,
‘b’:0x42,
‘c’:0x43,
‘d’:0x44,
‘e’:0x45,
‘f’:0x46,
‘g’:0x47,
‘h’:0x48,
‘i’:0x49,
‘j’:0x4A,
‘k’:0x4B,
‘l’:0x4C,
‘m’:0x4D,
‘n’:0x4E,
‘o’:0x4F,
‘p’:0x50,
‘q’:0x51,
‘r’:0x52,
‘s’:0x53,
‘t’:0x54,
‘u’:0x55,
‘v’:0x56,
‘w’:0x57,
‘x’:0x58,
‘y’:0x59,
‘z’:0x5A,
‘numpad_0’:0x60,
‘numpad_1’:0x61,
‘numpad_2’:0x62,
‘numpad_3’:0x63,
‘numpad_4’:0x64,
‘numpad_5’:0x65,
‘numpad_6’:0x66,
‘numpad_7’:0x67,
‘numpad_8’:0x68,
‘numpad_9’:0x69,
‘multiply_key’:0x6A,
‘add_key’:0x6B,
‘separator_key’:0x6C,
‘subtract_key’:0x6D,
‘decimal_key’:0x6E,
‘divide_key’:0x6F,
‘F1’:0x70,
‘F2’:0x71,
‘F3’:0x72,
‘F4’:0x73,
‘F5’:0x74,
‘F6’:0x75,
‘F7’:0x76,
‘F8’:0x77,
‘F9’:0x78,
‘F10’:0x79,
‘F11’:0x7A,
‘F12’:0x7B,
‘F13’:0x7C,
‘F14’:0x7D,
‘F15’:0x7E,
‘F16’:0x7F,
‘F17’:0x80,
‘F18’:0x81,
‘F19’:0x82,
‘F20’:0x83,
‘F21’:0x84,
‘F22’:0x85,
‘F23’:0x86,
‘F24’:0x87,
‘num_lock’:0x90,
‘scroll_lock’:0x91,
‘left_shift’:0xA0,
'right_shift ‘:0xA1,
‘left_control’:0xA2,
‘right_control’:0xA3,
‘left_menu’:0xA4,
‘right_menu’:0xA5,
‘browser_back’:0xA6,
‘browser_forward’:0xA7,
‘browser_refresh’:0xA8,
‘browser_stop’:0xA9,
‘browser_search’:0xAA,
‘browser_favorites’:0xAB,
‘browser_start_and_home’:0xAC,
‘volume_mute’:0xAD,
‘volume_Down’:0xAE,
‘volume_up’:0xAF,
‘next_track’:0xB0,
‘previous_track’:0xB1,
‘stop_media’:0xB2,
‘play/pause_media’:0xB3,
‘start_mail’:0xB4,
‘select_media’:0xB5,
‘start_application_1’:0xB6,
‘start_application_2’:0xB7,
‘attn_key’:0xF6,
‘crsel_key’:0xF7,
‘exsel_key’:0xF8,
‘play_key’:0xFA,
‘zoom_key’:0xFB,
‘clear_key’:0xFE,
‘+’:0xBB,
‘,’:0xBC,
‘-’:0xBD,
‘.’:0xBE,
‘/’:0xBF,
‘`’:0xC0,
‘;’:0xBA,
‘[’:0xDB,
‘\’:0xDC,
‘]’:0xDD,
"’":0xDE}

win32gui模块
1、win32gui.FindWindow()
获取窗口句柄

a = win32gui.FindWindow(None, ‘League of Legends’)
获取英雄联盟窗口句柄

2、win32gui.GetClassName()
获取窗口classname
b = win32gui.GetClassName(a)

3、win32gui.GetWindowText()
获取窗口标题
b = win32gui.GetWindowText(a)

4、win32gui.GetWindowRect()
获取窗口坐标
b = win32gui.GetWindowRect(a)

5、win32gui.SetWindowPos()
调整窗口大小
win32gui.SetWindowPos(a, win32con.HWND_TOPMOST, x1,y1,x2,y2,win32con.SWP_SHOWWINDOW)

获取剪贴板信息
import win32clipboard as w
import win32con

def get_text():
w.OpenClipboard()
d = w.GetClipboardData(win32con.CF_TEXT)
w.CloseClipboard()
return d.decode(‘utf-8’, ‘ignore’)

print(get_text())

tqdm库
Tqdm 是一个快速，可扩展的Python进度条，可以在 Python 长循环中添加一个进度提示信息，用户只需要封装任意的迭代器 tqdm(iterator)

1、简单的demo
import time
from tqdm import tqdm

for i in tqdm(range(100)):
time.sleep(0.01)

2、对于任意list的使用

pyperclip库
用于跨平台的剪切板访问读写工具库

1、pyperclip.copy()
用于将文字复制进剪切板
pyperclip.copy(“this is a test”)

2、pyperclip.paste()
用于将文字从剪切板复制出来

matplotlib库

matplotlib.pyplot模块
1、设置字体
默认字体无法显示中文，需要给个中文ttf
zt = matplotlib.font_manager.FontProperties(fname=“matplotlib.ttf”)
matplotlib.pyplot.title(“珠宝账号销量”, fontproperties=zt)

或

matplotlib.pyplot.rcParams[‘font.sans-serif’] = [‘SimHei’]

2、加载图片
matplotlib.pyplot.imshow(image, cmap=‘gray’)

参数1
图像数据、cv2对象

cmap
将标量数据映射到色彩图

3、显示图表
matplotlib.pyplot.show()

4、设置图形大小
matplotlib.pyplot.figure(figsize=(20,8),dpi=80)

5、隐藏 x 轴和 y 轴上的刻度值
matplotlib.pyplot.xticks([]), matplotlib.pyplot.yticks([])

错误/警告
RuntimeWarning: Glyph 35813 missing from current font

解决办法：
matplotlib.pyplot.rcParams[‘font.sans-serif’] = [‘SimHei’]
matplotlib.pyplot.rcParams[‘axes.unicode_minus’] = False

折线图
1、设置x轴，y轴数据
x = [‘10:10’, ‘10:15’]
y = [1717, 1720]

2、显示图例
显示label的值
plt.legend(prop=)

3、添加标题
matplotlib.pyplot.title(‘form’, fontproperties=)

参数
prop
设置图例字体

4、设置横坐标说明
matplotlib.pyplot.xlabel(‘time’, fontproperties=)

5、设置纵坐标说明
matplotlib.pyplot.ylabel(‘count’, fontproperties=)

6、设置纵坐标刻度
matplotlib.pyplot.yticks([1,2,3,4,5])

7、显示网格
matplotlib.pyplot.grid(True)

8、显示节点数据
t = [‘12.26’, ‘12.27’, ‘12.28’, ‘12.29’, ‘12.30’, ‘12.31’, ‘1.1’, ‘1.2’, ‘1.3’, ‘1.4’, ‘1.5’, ‘1.6’]
yx = [1717, 1717, 1716, 1717, 1719, 1719, 1720, 1722, 1723, 1725, 1730, 1731]
plt.plot(t, yx)
for a, b in zip(t, yx):
plt.text(a, b, b, ha=‘center’, va=‘bottom’, fontsize=10)

9、生成图表
matplotlib.pyplot.plot(x, y, color=, label=)

饼图
1、生成图表
matplotlib.pyplot.pie(x, explode=None, labels=None, colors=None, autopct=None,
pctdistance=0.6, shadow=False, labeldistance=1.1, startangle=None,
radius=None, counterclock=True, wedgeprops=None, textprops=None,
center=(0, 0), frame=False, rotatelabels=False, hold=None, data=None)

参数

x :(每一块)的比例，如果sum(x) > 1会使用sum(x)归一化；
labels :(每一块)饼图外侧显示的说明文字；
explode :(每一块)离开中心距离；
startangle :起始绘制角度,默认图是从x轴正方向逆时针画起,如设定=90则从y轴正方向画起；
shadow :在饼图下面画一个阴影。默认值：False，即不画阴影；
labeldistance :label标记的绘制位置,相对于半径的比例，默认值为1.1, 如<1则绘制在饼图内侧；
autopct :控制饼图内百分比设置,可以使用format字符串或者format function
'%1.1f’指小数点前后位数(没有用空格补齐)；
pctdistance :类似于labeldistance,指定autopct的位置刻度,默认值为0.6；
radius :控制饼图半径，默认值为1；
counterclock ：指定指针方向；布尔值，可选参数，默认为：True，即逆时针。将值改为False即可改为顺时针。
wedgeprops ：字典类型，可选参数，默认值：None。参数字典传递给wedge对象用来画一个饼图。例如：wedgeprops={‘linewidth’:3}设置wedge线宽为3。
textprops ：设置标签（labels）和比例文字的格式；字典类型，可选参数，默认值为：None。传递给text对象的字典参数。
center ：浮点类型的列表，可选参数，默认值：(0,0)。图标中心位置。
frame ：布尔类型，可选参数，默认值：False。如果是true，绘制带有表的轴框架。
rotatelabels ：布尔类型，可选参数，默认为：False。如果为True，旋转每个label到指定的角度。

2、使饼图长宽相等（圆形）
matplotlib.pyplot.axis(‘equal’)

fontTools库

from fontTool.ttLib import TTFont模块

1、TTFont()
打开字体文件
font = TTFont(“字体文件.woff”)
font = TTFont(“字体文件.ttf”)

2、font.saveXML()
将字体文件保存为可读的xml文件
font.saveXML(‘font.xml’)

3、font[‘cmap’].getBestCmap()
找字体的映射关系，字体的映射关系在cmap中体现
font_map = font[‘cmap’].getBestCmap()
print(font_map)

pyinstall库
运行命令符中输入
pyinstaller -F xxxx.py
等待即可

---

1. a-zA-Z ↩︎