字符串
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

访问字典的键
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
可直接提取出标签