Python开发【第五篇】： 内置模块

内容概要

1. 二分查找、冒泡
2. random
3. time
4. os
5. sys
6. pickle
7. json
8. shelve
9. re

1、二分查找和冒泡排序

01. 二分查找

二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。

　　优点: 快

　　缺点: 必须是有序序列

核心思想：

掐头结尾找中间,出口:左边比右边大
目标数与中间数去比较，比中间数小则砍掉左边的一半，再去和剩下的中间数比较。以此类推。

# 非递归算法
lst = [,,,,,,,,,,,,]
n = int(input("n:"))

left =     #开头
right = len(lst) -   #结尾
while left <= right:
    mid = (left + right) // 2  # 中间
    if n > lst[mid]:   # 目标数比中间大
        left = mid + 1  # 左边索引变为中间索引 +1
    elif n < lst[mid]:  # 目标数比中间小
        right = mid - 1  # 右边索引变为中间索引 -1
    else:
        print("找到了")
        break
else:
    print("没有找到该数据")

02. 冒泡排序

#  python 数据互换

a =
b =
print(a,b)
#
a,b = b,a
print(a,b)
# 

　　它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。

lst = [, , , , ,  , , ,   ]

# 列表里面的 lst[i] 与 lst[i+]做比较
for el in lst:  # 控制循环次数
    for i in range(len(lst)-): # 列表索引,比较到最后索引的前一位
        if lst[i] > lst[i+]:  # 前面的比后面的大，就进行交换
            lst[i],lst[i+] = lst[i+],lst[i]
print(lst)

2、random 随机数

import random
#随机数函数
print(random.random()) # -1随机小数

print(random.uniform(,)) # -20之间的随机小数

#随机整数
print(random.randint(,)) #-20之间的整数

# 36选7 不能重复(使用集合)
s = set()
while len(s) < :
    s.add(random.randint(,))
print(s)

lst = ["飞驰人生", "情圣2", "疯狂外星人", "啥是佩奇"]

print(random.choice(lst))  # 随机出来一个

print(random.sample(lst,)) # 随机出来n个

random.shuffle(lst)  #随机打乱列表
print(lst)

随机生成字母

import random
import string

s = string.ascii_lowercase #所有小写字母(a-z)
#s=string.ascii_letters #所有大小写字母(a-z,A-Z)
#s=string.ascii_uppercase #所有大写字母(A-Z)
r = random.choice(s)

2、time 时间模块

在python中时间分成三种表现形式:

时间戳(timestamp). 时间戳使用的是从1970年01月01日 00点00分00秒到现在一共经过了多少秒... 使用float来表示。 中国在东八区。

# 获取当前系统时间、给机器的看的
print(time.time())
# 时间戳  1548666510.6973913

格式化时间(strftime). 这个时间可以根据我们的需要对时间进行任意的格式化.

# 格式化时间，给人的看的。字符串
print(time.strftime("%Y-%m-%d %H:%M:%S"))  # -- :: 常用格式
日期格式化的标准:
%y         两位数的年份表示（-）
%Y         四位数的年份表示（-）
%m         月份（-）
%d         月内中的一天（-）
%H         24小时制小时数（-）
%I         12小时制⼩时数（-）
%M         分钟数（=）
%S         秒（-）
%a         本地简化星期名称
%A         本地完整星期名称
%b         本地简化的月份名称
%B         本地完整的月份名称
%c         本地相应的日期表示和时间表示
%j         一年内的一天（-）
%p         本地A.M.或P.M.的等价符
%U         一年中的星期数（-）星期天为星期的开始
%w         星期（-），星期天为星期的开始
%W         ⼀年中的星期数（-）星期一为星期的开始
%x         本地相应的日期表示
%X         本地相应的时间表示
%z         当前时区的名称
%%         %号本身

结构化时间(struct_time). 这个时间主要可以把时间进行分类划分. 比如. 1970年01月01日 00点00分00秒 这个时间可以被细分为年, 月, 日.....一大堆东西.

# 结构化时间 -> python程序中的时间
print(time.localtime())
#time.struct_time(tm_year=, tm_mon=, tm_mday=, tm_hour=, tm_min=, tm_sec=, tm_wday=, tm_yday=, tm_isdst=)

时间格式之间的转化：

# 把数字转化成格式化时间

n =
# . 把时间戳转化成结构化时间
# struct_time = time.localtime(n)

# . 把结构化时间转化成格式化时间
# s = time.strftime("%Y-%m-%d %H:%M:%S",struct_time)
# print(s)

# 时间戳 -->  结构化时间  --> 格式化时间

# 把格化式时间转化为时间戳。

s = "1970-08-07"
# . 把格式化时间转化成结构化时间
struct_time = time.strptime(s,"%Y-%m-%d") # 参数1:时间字符串 参数2:格式

# . 把结构化时间转化成时间戳
n = time.mktime(struct_time)
print(n)

# 格式化时间 -> 结构化时间 -> 时间戳

时间差的计算：

# # 时间差的计算 -> 针对小时来计算
#. 获取开始和结束时间
s1 = input("开始时间(格式:yyyy-mm-dd HH:MM:SS):")
s2 = input("结束时间(格式:yyyy-mm-dd HH:MM:SS):")

# #. 把这两个时间都转化为时间戳
n1 = time.mktime(time.strptime(s1,"%Y-%m-%d %H:%M:%S"))
n2 = time.mktime(time.strptime(s2,"%Y-%m-%d %H:%M:%S"))

# . 计算时间差
diff_n = abs(n2 - n1)   #结果是秒级别的时间差

#把秒转化为分钟
ret_min = diff_n //
ret_sec = diff_n %  

# 把分钟转化为小时
ret_hour = ret_min //
ret_hour_min = ret_min %   # 计算余数，一小时多少分钟
print("过去了 %s 小时 %s 分钟 %s 秒" %(ret_hour,ret_hour_min,ret_sec))

3、sys模块

所有和python解释器相关的都在sys模块.

sys.argv         获取命令行参数List，第0个元素是程序本身路径
sys.exit(n)      退出程序，正常退出时exit(),错误退出sys.exit()
sys.version      获取Python解释程序的版本信息
sys.path         返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform     返回操作系统平台名称

4、os模块

所有和操作系统相关的内容都在os模块

目录操作

os.makedirs("a/b/c")  # 创建多层递归目录  相当于shell中mkdir dirname -p
os.removedirs("a/b/c")  # (只删除空目录)若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推

os.mkdir("a/b")    #创建单级目录；相当于shell中mkdir dirname
os.rmdir("a/b")    #删除单级空目录，若目录不为空则无法删除，报错；只删除b目录

print(os.listdir('d://'))   # 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表形式打印

文件操作

os.remove()   　　# 删除一个文件
os.remove("oldname","newname")  # 重命名文件/目录

os.stat('path/filename')  　　# 获取文件/目录属性信息
stat 结构:
st_mode: inode 保护模式
st_ino: inode 节点号。
st_dev: inode 驻留的设备。
st_nlink: inode 的链接数。
st_uid: 所有者的用户ID。
st_gid: 所有者的组ID。
st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。
st_atime: 上次访问的时间。
st_mtime: 最后一次修改的时间。
st_ctime: 由操作系统报告的"ctime"。在某些系统上（如Unix）是最新的元数据更改的时间，在其它系统上（如Windows）是创建时间。

执行shell命令

os.system("bash command")  # 运行 shell命令，直接显示
os.popen("bash command").read()  #运行shell命令，获取执行结果
print(os.getcwd())    #获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")   #改变当前脚本工作目录；相当于shell下cd

os.path

print(os.path.abspath("a"))  # 返回一个相对路径的绝对路径

将path分割成目录和文件件名，返回元祖。
print(os.path.split("E:\python-25期课上代码\day05\课上代码\今日内容大纲"))
('E:\\python-25期课上代码\\day05\\课上代码', '今日内容大纲')

# 拿到文件或者文件夹的上级目录
print(os.path.dirname("E:\python-25期课上代码\day05\课上代码\今日内容大纲"))
执行结果：
E:\python-25期课上代码\day05\课上代码

# 拿到文件或者文件夹的名字
print(os.path.basename("E:\python-25期课上代码\day05\课上代码\今日内容大纲"))
执行结果：
今日内容大纲

一些判断
print(os.path.exists("a"))    #如果path存在，返回True；如果path不存在，返回False
print(os.path.isabs("a"))     #如果path是绝对路径，返回True

print(os.path.isfile("今日内容大纲"))        #如果path是一个存在的文件，返回True。否则返回False
print(os.path.isdir("E:\python-25期课上代码\day05"))       #如果path是一个存在的目录，则返回True。否则返回False

文件路径的拼接
print(os.path.join("E:\python-25期课上代码\day05","课上代码"))
执行结果：
E:\python-25期课上代码\day05\课上代码

查看目录或文件属性

os.path.getatime(path)       #返回path所指向的文件或者目录的最后访问时间
os.path.getmtime(path)       #返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path)        #返回path的大小

特殊属性:

print(os.sep)     #输出操作系统特定的路径分隔符，   win下为"\\",Linux下为"/"
print(os.linesep)  #输出当前平台使用的行终止符，    win下为"\r\n",Linux下为"\n"
print(os.pathsep)  #输出用于分割文件路径的字符串    win下为;,Linux下为:
print(os.name)     #输出字符串指示当前使用平台。    win->'nt';  Linux->'posix'

文件复制 -> 写函数. 给两个参数. 两个文件路径. 把文件从a复制到b

def file_copy(src_file,dest_file):
    dest_dir = os.path.dirname(dest_file)  # 获取目标文件的上层目录
    if not os.path.exists(src_file):  # 判断源文件是否存在
        print(" %s 文件路径找不到" % src_file)
        return False
    elif not os.path.isdir(dest_dir): # 判断目录是否存在
        os.makedirs(dest_dir)  # 不存在则创建
    with open(src_file,mode="rb") as f1, \
        open(dest_file,mode="wb") as f2:
        for content in f1:
            f2.write(content)

file_copy("D:\胡一菲.jpg",r"F:\t\a\c.jpg")

4、序列化模块

一、什么是序列化？

在存储数据或者网络传输数据的时候. 需要对我们的对象进行处理. 把对象处理成方便存储和传输的数据格式. 这个过程叫序列化. 不同的序列化, 结果也不同. 但是目的是一样的. 都是为了存储和传输.
在python中存在三种序列化的方案：
　　1. pickle. 可以将我们python中的任意数据类型转化成bytes并写入到文件中. 同样也可以把文件中写好的bytes转换回我们python的数据. 这个过程被称为反序列化
　　2. shelve. 简单另类的一种序列化的方案. 有点类似redis持久化. 可以作为一种小型的数据库来使用
　　3. json. 将python中常用的字典, 列表转化成字符串. 是目前前后端数据交互使用频率最高的一种数据格式.

二. pickle(重点)
 pickle用起来很简单. 说白了. 就是把python对象写入到文件中的一种解决方案.但是写入到文件的是bytes. 所以这东西不是给人看的. 是给机器看的.

# 序列化  将对象序列化为字节
lst = ["大象", "胡辣汤", "馒头", "汪峰"]
bs = pickle.dumps(lst)
print(type(bs))  # bytes类型的
print(bs)

# 反序列化 将字节反序列化为我们的对象
ll = pickle.loads(bs)
print(ll)

把序列化的对象写入到文件中

lst = ["越狱","大圣归来","啥是佩琪","疯狂外星人"]

pickle.dump(lst,open("pik.dat",mode="ab"))
f = open("pik.dat",mode="rb")

while :
    try:
        obj = pickle.load(f)
        print(obj)  #数据读完会报错，EOFError: Ran out of input
    except EOFError:
        print("没数据了")
        break

 但是这样写并不够好. 因为读的时候. 并不能知道有多少对象要读. 不能一行一行的读.

那真的要写入或者读取多个内容怎么办? 很简单. 装list里. 然后读取和写入都用list

d1 = {"name":"游艇", "price":""}
d2 = {"name":"手机", "singer":""}
d3 = {"name":"电脑", "singer":""}
d4 = {"name":"鼠标", "singer":""}

# 把这些数据写入到一个列表中，然后统一把列表写入到文件中
lst = [d1,d2,d3,d4]
pickle.dump(lst,open("pik.dat",mode="wb"))

# 读取，这样写比较安全，但是效率相对较低.
lst = pickle.load(open("pik.dat",mode="rb"))
for el in lst:
    print(el)

序列化
　　dumps
　　dump -> 写入文件

反序列化
　　loads
　　load -> 读取文件

pickle序列化的内容是二进制的内容(bytes) 不是给人看的.

三. json(重点)

　　 json是我们前后端交互的枢纽. 相当于编程界的普通话. 大家沟通都用json. 为什么这样呢? 因为json的语法格式可以完美的表示出一个对象. 那什么是json: json全称javascript object notation. 翻译过来叫js对象简谱. 很复杂是吧? 来上一段我们认识的代码:

d = {
    "name":"汪峰",
    "wife":{
        "name":"章子怡",
        "外号":"国际章",
        "hello":None,
        "喜欢你":False,
        "喜欢我":True
    },
    "children":[
        {"name":"孩1"},
        {"name":"孩2"}
    ]
}

　　

　　这个不是字典么? 对的. 在python里这玩意叫字典. 但是在javascript里这东西叫json. 一模一样的. 我们发现用这样的数据结构可以完美的表示出任何对象. 并且可以完整的把对象表示出来. 只要代码格式比较好. 那可读性也是很强的. 所以大家公认用这样一种数据结构作为数据交互的格式. 那在这个鬼东西之前是什么呢? XML.....来看一段代码

<?xml version="1.0" encoding="utf-8" ?>
<wf>
    <name>汪峰</name>
    <age></age>
    <hobby>上头条</hobby>
    <wife>
        <name>⼦怡</name>
        <age></age>
        <hobbies>
            <hobby>唱歌</hobby>
            <hobby>跳舞</hobby>
            <hobby>演戏</hobby>
            </hobbies>
    </wife>

</wf>

　之前都是用这样的数据进行传输的. xml在维护和处理上是非常复杂和繁琐的.

我们的程序是在python里写的. 但是前端是在JS那边来解析json的. 所以. 我们需要把我们程序产生的字典转化成json格式的json串(字符串). 然后网络传输. 那边接收到了之后. 它爱怎么处理是它的事情.

# 把python字典转化为json格式

import json
d = {
    "name":"汪峰",
    "wife":{
        "name":"章子怡",
        "外号":"国际章",
        "hello":None,
        "喜欢你":False,
        "喜欢我":True
    },
    "children":[
        {"name":"孩1"},
        {"name":"孩2"}
    ]
}
 print(d)

 s = json.dumps(d,ensure_ascii=False)  # 默认情况下中文是不显示的. ensure_ascii=False 处理中文
 print(s)

 把json格式转化为字典

ss = '{"name": "汪峰", "wife": {"name": "章子怡", "外号": "国际章", "hello": null, "喜欢你": false, "喜欢我": true}, "children": [{"name": "孩1"}, {"name": "孩2"}]}'
print(type(ss))
obj = json.loads(ss)
print(obj)

# json也可以像pickle一样把序列化的结果写入到文件中.

json.dump 第一个参数是 对象，第二参数是 文件

dic = {"a":"女王","b":"萝莉","c":"小清新"}
f = open("test.json",mode="w",encoding="utf-8")
json.dump(dic,f,ensure_ascii=False)
f.close()

也可以写到一行

lst = ["周杰伦",None,False,]
json.dump(lst,open("jay.json",mode="w",encoding="utf-8"),ensure_ascii=False)

# 从文件中读取json

f = open("test.json",mode="r",encoding="utf-8")
dic = json.load(f)
f.close()
print(dic)

也可以写到一行

print(json.load(open("jay,json",mode="r",encoding="utf-8")))

# 可以向同一个文件写入多个json串，但是读不行。

lst = [{"a":},{"b":}]
f = open("test.json",mode="w",encoding="utf-8")
for el in lst:
    json.dump(el,f)
f.close()
#  此时文件中的内容是一行内容
# {"a": }{"b": }

　　这在读取的时候是无法正常读取的. 那如何解决呢? 两套方案. 方案一. 把所有的内容准备好统一进行写入和读取. 但这样处理, 如果数据量小还好. 数据量大的话, 就不够友好了. 方案二. 不用dump. 改用dumps和loads. 对每一行分别进行处理.

#  即使用 for 循环遍历，一行一行的写，一行一行的读

lst = [{"a":},{"b":},{"c":},{"d":"李世超"}]

# 写入
f = open("test.json",mode="w",encoding="utf-8")
for el in lst:
    s = json.dumps(el,ensure_ascii=True) + "\n"
    f.write(s)
f.close()

# 读取
f = open("test.json",mode="r",encoding="utf-8")
for line in f:
    dic = json.loads(line)
    print(dic)
f.close()

四. shalve模块
　　shelve提供python的持久化操作. 什么叫持久化操作呢? 就是把数据写到硬盘上.在操作shelve的时候非常的像操作一个字典。

import shelve
shelf = shelve.open("dump.rdb")  # 打开一个文件

# 操作shelf 就像操作字典一样
# 添加
shelf["jay"] = "周杰伦"

# 查询
print(shelf["jay"])
shelf.close()

这个东西和字典差不多. 只不过你的字典是一个文件. 接下来, 我们存储一些复杂的数据

# 存一些复杂的数据
s = shelve.open("dump.rdb")
s["jay"] = {"name":"周杰伦","age":,"hobby":"哄小孩"}
print(s["jay"])
s.close()

# 但是有坑
s = shelve.open("dump.rdb")
s["jay"]["name"] = "李世超"  # 修改字典中的数据
s.close()

s = shelve.open("dump.rdb")
print(s["jay"]["name"])  # 并没有改变
s.close()

# 解决方案

s = shelve.open("dump.rdb",writeback=True)
s["jay"]["name"] = "李世超"   # 修改字典中的数据
s.close()

s = shelve.open("dump.rdb")
print(s["jay"])     # 改变了
s.close()

writeback = True 可以动态的把我们修改的信息写入到文件中. 还可以删除数据. 就像字典一样.

s = shelve.open("dump.rdb",writeback=True)
del s["jay"]
s.close()

s = shelve.open("dump.rdb")
print(s["jay"])   # 报错了,key 被删除了
s.close()

s = shelve.open("dump.rdb",writeback=True)
s["jay"] = "周杰伦"
s["wjl"] = "王力宏"
s.close()

# 像字典一样操作
s = shelve.open("dump.rdb")
for k in s:
    print(k)

for k,v in s.items():
    print(k,v)

5、正则表达式

正则表达式是对字符串操作的一种逻辑公式. 我们一般使用正则表达式对字符串进行匹配和过滤. 使用正则的优缺点:
　　优点: 灵活, 功能性强, 逻辑性强.
　　缺点: 上手难. 一旦上手, 会爱上这个东西

工具: 各大文本编辑器一般都有正则匹配功能. 我们也可以去 http://tool.chinaz.com/regex/ 进行在线测试.

正则表达式由普通字符和元字符组成. 普通字符包含大小写字母, 数字. 在匹配普通字符的时候我们直接写就可以了. 比如"abc" 匹配的就是"abc". 我们如果用python也可以实现相同的效果. 所以普通字符没什么好说的. 重点在元字符上.

元字符: 元字符才是正则表达式的灵魂. 元字符中的内容太多了, 先看一些常用的。

1. 字符组
　　字符组很简单用 [] 括起来. 在 [] 中出现的内容会被匹配. 例如:[abc] 匹配a或b或c
　　如果字符组中的内容过多还可以使用- , 例如: [a-z] 匹配a到z之间的所有字母 [0-9]匹配所有阿拉伯数字
　　[a-zA-Z0-9] 匹配所有大小写字母和数字

2. 简单元字符
　　. 　　     匹配除换行符以外的任意字符
　　\w 　　  匹配字母或数字或下划线
　　\s 　　   匹配任意的空白符（空格、换行、制表符）
　　\d     　  匹配数字（0-9）
　　\W 　　 匹配非字母或数字或下划线 (!@#$%^%&^*)这些
　　\D 　　  匹配非数字
　　\S　　   匹配非空白符 (与小写相反)

　　\n 　　  匹配一个换行符
　　\t　　    匹配一个制表符
　　\b 　　  匹配一个单词的结尾
　　^ 　　   匹配字符串的开始
　　$ 　　   匹配字符串的结尾
　　a|b　     匹配字符a或字符b
　　() 　　   匹配括号内的表达式，也表示一个组
　　[...] 　　匹配字符组中的字符
　　[^...] 　  匹配除了字符组中字符的所有字符，取反

3. 量词
　　我们到目前匹配的所有内容都是单一文字符号. 那如何一次性匹配很多个字符呢,我们要用到量词
　　* 　　     重复零次或更多次
　　+ 　　    重复一次或更多次
　　? 　　    重复零次或一次
　　{n} 　　  重复n次
　　{n,} 　　 重复n次或更多次
　　{n,m}　   重复n到m次

4. 惰性匹配和贪婪匹配

在量词中的 *,  + , {}  都属于贪婪匹配。 就是尽可能多的匹配到结果。

str = "麻花藤昨天让英雄联盟关服了"
print(re.findall(r"麻花藤.*",str))
# 执行结果:
# ['麻花藤昨天让英雄联盟关服了']

在使用.*后面如果加了? 则是尽可能的少匹配。 表示惰性匹配

str = "麻花藤昨天让英雄联盟关服了"
print(re.findall(r"麻花藤.*?",str))
# 执行结果:
# ['麻花藤']

<.*?> 的特殊含义 找到下一个 > 为止。

str = "<div>胡辣汤<\div>"
print(re.findall(r"<.*>",str))
# 执行结果:
# ['<div>胡辣汤<\\div>']

print(re.findall(r"<.*?>",str))
# 执行结果:
# ['<div>', '<\\div>']

5. 转义

# 在正则中使用 \ 来对有特殊意义的字符转义

print(re.findall(r"\n","你好啊\n"))   # 匹配 \n
print(re.findall(r"\[\]","你好啊[]"))  # 匹配[],[]在正则中有特殊意义 要转义
# 执行结果:
# ['\n']
# ['[]']

6、re模块

re模块是python提供的一套关于处理正则表达式的模块. 核心功能有四个:

1. findall 可以通过正则匹配到字符串中的内容，返回列表，匹配不到结果返回空列表
第一个参数正则表达式的规则
第二个参数字符串

obj = re.findall(r"\d+","我在30岁，一定要赚够100w")  # 匹配数字
print(obj)
#执行结果: ['', '']

2. search 如果没有匹配到结果，返回None
如果匹配到了第一个结果就返回

ret = re.search(r"\d+\d+", "我在30岁，一定要赚够100w").group()
print(ret)
执行结果: <_sre.SRE_Match object; span=(, ), match=''>

print(ret.group())  # 必须分组拿数据
执行结果:  # 只能匹配到30

# f = open('ip.all-update','r').readlines()
# for line in f:
#     if not line == "\n": # 排除文件中的空行
#         s = line.strip()
#         ip = re.search(r"(\d+\.\d+\.\d+\.\d+)(\s)(.*)",s).group()  # group() 表示前面的括号1匹配到的内容
#         print(ip)

3. match

obj = re.mat# . matchch(r"\d+","我在30岁，一定要赚够100w")
print(obj)
执行结果: None

# match 会从字符串的开头进行匹配,匹配到结果就返回
obj = re.match(r"\d+","10 我在30岁，一定要赚够100w")
print(obj.group())
#执行结果: 

4. finditer 和 findall 一样，返回的是迭代器

it = re.finditer(r"\d+","10 我在30岁，一定要赚够100w")
print(it)
#执行结果: <callable_iterator object at 0x00000000021CF400>
for el in it:
    print(el.group())  # 依然需要分组
# 执行结果:
#
#
# 

5. 其他操作

　01. re中的分组，小括号:()

# 匹配 "哈哈哈哈"四个字
# 不加括号
print(re.findall(r"<div>哈{4}</div>","<div>哈哈哈哈</div>"))
# 执行结果: ['<div>哈哈哈哈</div>']

# 加上括号
print(re.findall(r"<div>(哈{4})</div>","<div>哈哈哈哈</div>"))
# 执行结果: ['哈哈哈哈']

取值的优先级,想要的数据括起来
it = re.finditer(r"<div>电影名: (.*?)下载链接: (.*?)</div>","<div>电影名: 羞羞的铁拳 下载链接: http://www.baidu.com</div>")
for i in it:
    print(i.group())  # 取第一个小括号匹配到的内容
    print(i.group())  # 第二个小括号匹配到的内容

# 执行结果:
羞羞的铁拳
http://www.baidu.com

# 给分组取名字 -> ?P<名字>

it = re.finditer(r"<div>电影名: (?P<name>.*?)下载链接: (?P<url>.*?)</div>","<div>电影名: 羞羞的铁拳 下载链接: http://www.baidu.com</div>")
for el in it:
    print("电影名:",el.group("name"))   # 根据分组名字取数据
    print("下载链接:",el.group("url"))

# 执行结果:
# 电影名: 羞羞的铁拳
# 下载链接: http://www.baidu.com

02. compile 预加载正则. 

obj = re.compile(r"\d+")  # 先写好正则，后面直接用
print(obj.findall("10 我在30岁，一定要赚够100w"))

#执行结果: ['', '', '']

03. split 切割

lst = re.split(r"\d+","我今年25,要在30岁赚够100W")
print(lst)
# 执行结果:  按照数字切割
# ['我今年', ',要在', '岁赚够', 'W']

# 加上小括号
lst = re.split(r"(\d+)","我今年25,要在30岁赚够100W")
print(lst)
# 执行结果: 保留了匹配的项
# ['我今年', '', ',要在', '', '岁赚够', '', 'W']

ret = re.split('[ab]', 'qberafjbcd') # 先按'a'分割得到'qber'和'fjbcd',在对'qber'和'fjbcd'分别按'b'分割
print(ret)
# 执行结果:
# ['q', 'er', 'fj', 'cd']

04. sub 替换，把字符串中的数字换成 _HHH_

ret = re.sub("\d+","_HHH_","alix123taibai45xiongmao78")
print(ret)
# 执行结果: 匹配到的数字全部换成了 _HHH_
# alix_HHH_taibai_HHH_xiongmao_HHH_

subn 显示替换的次数

ret = re.subn("\d+","_HHH_","alix123taibai45xiongmao78")
print(ret)
# 执行结果: 显示了更换的次数
# ('alix_HHH_taibai_HHH_xiongmao_HHH_', )

re练习，爬取电影天堂

#!/usr/bin/env python3
# _*_ coding:utf- _*_
from urllib.request import urlopen
import re

# . 获取网页内容
url = "https://www.dytt8.net/html/gndy/dyzz/20190213/58205.html"
content = urlopen(url).read().decode("gbk")
# print(content)

# . 写正则,匹配电影名字和下载链接
obj = re.compile(r'<div id="Zoom">.*?◎译　　名　(?P<name>.*?) <br />.*?<td.*?<a href="(?P<url>.*?)">ftp',re.S)  # re.S 让 . 可以匹配换行

# . 匹配网页内容
ret = obj.finditer(content)
for el in ret:
    print("电影名:",el.group("name"))
    print("下载链接:",el.group("url"))