一.正则表达式

1.单个字符代指内容

  1. # 知识点0：直接写abc123就是本身的意思
  2. # 知识点1：`\d` 代指任意数字 
  3. # 知识点2：`\w` 代指(1)字母(2)数字(3)下划线(4)汉字，如果想剔除汉字，可以在后续函数中操作用ASCII剔除
  4. # 知识点3-1：`.`  代指除“换行符”以外的任意字符.
  5. # 知识点3-2：'\.'代表本身的.因为加了转义字符.
  6. # 知识点4：`\s` 代指任意的空白符，包括空格、制表符，如：空格、换行、转义等，相当于[\t\n\x0B\f\r]

2.[]字符集合的用法

  1. # 知识点5： []意思的理解
  2. """[abc123]里面的出现的内容，代表或的意思，就是abc123任意出现一个的意思"""
  4. # 知识点6：[a-z1-3]中'-'的意思
  5. """-在[]中代表的意思，随着形式发生变化 
  6. [a-z]:代表a-z的任意字符
  7. [1-9]:代表1-9的任意字符
  8. 但是如果没有头尾，则‘-’就是本身的意思,如:
  9. [1-]：代表1或者-
  10. """
  12. # 知识点7：[.]在[]中的意思保持不变
  13. """.本来的意思代表：除了换行符以外的任意字符，但是在[]中就是代表.本身的意思"""
  15. # 知识点8：[\d\w\s]在[]中的意思是转义后的意思
  16. """在[]中\d代表数字，\w代表···"""
  18. # 总结：除了'-'和'.'在[]中发生变化外，其余不改变
  20. # 知识点9:[&&]在[]中&&的意思是交集
  21. """[a-z&&[^a-c]]的意思是d-z"""

3.关于数量的声明

这里分为两个派系：一个是用符号+/*/?，一个是直接声明数量{1,}/{1,3}/{1}

  1. # 知识点10：符号派系声明
  2. """
  3. ?:1个或0个
  4. +:1个或更多
  5. *:0个或更多
  6. """
  8. # 知识点11：数量派系声明
  9. """
  10. {n,m}:n到m个
  11. {n,}：n个或更多
  12. {n}：n个
  13. """

4.()分组与|或

  1. # 知识点12：()会将数据进行分组，|表示或的意思
  2. """意义：分组意义在意，将几个字符组成一个整体，可以对他进行数量词修饰。
  3. 如：（one|two)?  表示连续的one或two，存在一次或不存在
  4. """
  6. # 知识点13：|或符号也可以单独使用
  7. """'java|Java|JAVA'表示任意一个"""

5.整个字符串全局匹配：^和&

  1. # 知识点14：^& 将字符串样式全局进行包裹 使用之后匹配的整个字符串，而非子串
  2. """
  3. 注意：
  4. 1.是整个字符串，不是子序列
  5. 2.只能用于匹配，不可用于替换，替换和拆分的语法不使用该字符
  6. """

6.特殊字符需要使用\进行转义

  1. # 知识点15：由于{}[]().这些正则表达式有特殊含义，所以如果要表示本身的意思，需要加\
  3. """
  4. \{\}:这个就表示正常的{}的意思
  5. \.:这个就表示正常的.的意思
  6. ···其他同理
  7. """

7.贪婪匹配与非贪婪匹配：

  1. # 知识点16：对符合条件的进行匹配，但是继续往后依然符合，如果匹配最长的就是贪婪，打住就不是贪婪匹配
  3. # 贪婪匹配：量词为正常
  4. import re
  6. text = "alexraotrootadmin"
  7. data_list = re.findall("r.+o", text) # 贪婪匹配
  8. print(data_list) # ['raotroo']
  10. # 非贪婪匹配：量词后加?
  11. import re
  13. text = "alexraotrootadmin"
  14. data_list = re.findall("r.+?o", text) # 非贪婪匹配
  15. print(data_list) # ['rao']

二.re模块功能

1.findall，获取匹配到的所有数据，得到类型为列表

  1. # 知识点1：re.findall(pattern,text) 这里会抓出来所有符合的类型，返回类型为列表
  3. import re
  5. text = "dsf130429191912015219k13042919591219521Xkk"
  6. data_list = re.findall("(\d{6})(\d{4})(\d{2})(\d{2})(\d{3})([0-9]|X)", text)
  7. print(data_list) # [('130429', '1919', '12', '01', '521', '9'), ('130429', '1959', '12', '19', '521', 'X')]
  9. # 知识点2：re.findall(pattern,text,re.ASCII)会把匹配到的汉字剔除，只匹配ASCII
  11. import re
  13. text = "楼主太牛逼了，在线想要 442662578@qq.com和xxxxx@live.com谢谢楼主，手机号也可15131255789，搞起来呀"
  14. email_list = re.findall("\w+@\w+\.\w+",text)
  15. print(email_list) # ['442662578@qq.com和xxxxx']
  18. import re
  20. text = "楼主太牛逼了，在线想要 442662578@qq.com和xxxxx@live.com谢谢楼主，手机号也可15131255789，搞起来呀"
  21. email_list = re.findall("\w+@\w+\.\w+", text, re.ASCII)
  22. print(email_list) # ['442662578@qq.com', 'xxxxx@live.com']
  24. # 知识点3：使用()分组时，会以元组的形式，对每次匹配到的整体，放在一起输出
  26. # 输出切片数据
  27. import re
  29. text = "楼主太牛逼了，在线想要 442662578@qq.com和xxxxx@live.com谢谢楼主，手机号也可15131255789，搞起来15131266666呀"
  30. data_list = re.findall("15(13)1(2\d{5})", text)
  31. print(data_list)  # [ ('13', '255789')   ]
  33. # 输出切片数据和整体数据
  34. import re
  36. text = "楼主太牛逼了，在线想要 442662578@qq.com和xxxxx@live.com谢谢楼主，手机号也可15131255789，搞起来呀"
  37. data_list = re.findall("(15131(2\d{5}))", text)
  38. print(data_list)  # [('15131255789', '255789')]

2.finditer,迭代器

  1. # 知识点4：data = re.finditer(pattern,text)
  2. """
  3. 1.data返回类型是一个迭代器，主要是防止findall数据过大
  4. 2.使用for来对data进行迭代
  5. 3.每次迭代的内容，打印数值需要.group()
  6. """
  8. import re
  10. text = "逗2B最逗3B欢乐"
  11. data = re.finditer("\dB", text)
  12. for item in data:
  13.     print(item.group())
  15. # 知识点5：finditer在pattern中加入?P<名称>+正则，输出item时加入.groupdict()可以输出为字典信息
  16. """
  17. 1.这个?P<名称>+正则：可以为正则分组信息命名
  18. 2.这个不能用在findall中，只能出现与finditer
  19. 3.在遍历输出的时候 应该为item.groupdict()
  20. 4.输出类型为字典
  21. """
  24. import re
  25. text = "dsf130429191912015219k13042919591219521Xkk"
  26. data_list = re.finditer("\d{6}(?P<year>\d{4})(?P<month>\d{2})(?P<day>\d{2})\d{3}[\d|X]", text)
  27. for item in data_list:
  28.     info_dict = item.groupdict()
  29.     print(info_dict)
  31. # {'year': '1919', 'month': '12', 'day': '01'}
  32. # {'year': '1959', 'month': '12', 'day': '19'}

3.match匹配 ：从最开始匹配，匹配成功，不再匹配，返回特殊对象，否则返回None

  1. # 知识点6：data = re.match(pattern,text)
  2. """注意：
  3. 1.data并不是匹配到的内容，而是一个match对象，如果要打印内容，可以写data.group()返回的是内容
  4. 2.match是从头开始匹配，如果开始对不上，直接就是None
  5. 3.match一旦匹配到，不再往后继续找"""
  7. # 这个是开头不对，所以是None
  8. import re
  10. text = "大小逗2B最逗3B欢乐"
  11. data = re.match("逗\dB", text)
  12. print(data) # None
  14. # 这个是匹配对的
  15. import re
  17. text = "逗2B最逗3B欢乐"
  18. data = re.match("逗\dB", text)
  19. if data:
  20.     content = data.group() # "逗2B"
  21.     print(content)

4.search匹配：从整体去寻找子序列进行匹配，成功，只返回第一个，否则None

  1. # 知识点7： data =re.search(pattern,text)
  2. """注意：
  3. 1.这里是整体匹配子序列，存在即可，不需要整体符合
  4. 2.只返回第一个后面是不管的
  5. 3.返回的也是对象，不是值，如果想调用，也是data.group()
  6. """
  8. # 这里可以看到 只显示第一个
  9. import re
  11. text = "大小逗2B最逗3B欢乐"
  12. data = re.search("逗\dB", text)
  13. if data:
  14.     print(data.group())  # "逗2B"

5.sub，替换匹配成功的位置

  1. # 知识点8：re.sub(pattern,new,string,count=0)
  3. """解释：
  4. 1.count表示最大替换数量，从左到右，默认0表示全部替换、
  5. 2.虽然replace也可以，但是这个更牛B，因为可以动态替换
  6. """
  8. # 全部替换
  9. import re
  11. text = "逗2B最逗3B欢乐"
  12. data = re.sub("\dB", "沙雕", text)
  13. print(data) # 逗沙雕最逗沙雕欢乐
  15. # 替换前一个
  16. import re
  18. text = "逗2B最逗3B欢乐"
  19. data = re.sub("\dB", "沙雕", text, 1)
  20. print(data) # 逗沙雕最逗3B欢乐

6.split，根据匹配成功的位置分割

  1. # 知识点9：re.split(pattern,string,maxsplit=0)
  3. """解释：
  4. 1.maxsplit表示最大分割数量，从左到右，默认0表示全部分割、
  5. 2.虽然split也可以，但是这个更牛B，因为可以动态指定
  6. """
  7. # 全部分割
  8. import re
  10. text = "逗2B最逗3B欢乐"
  11. data = re.split("\dB", text)
  12. print(data) # ['逗', '最逗', '欢乐']
  14. # 部分分割
  15. import re
  17. text = "逗2B最逗3B欢乐"
  18. data = re.split("\dB", text, 1)
  19. print(data) # ['逗', '最逗3B欢乐']