1.就其本質而言，正則表達式（regular expression）是一種小型的、高度專業化的編程語言，（在python中）它內嵌在python中，並通過re模塊實現。正則表達式模式被編譯成一系列的字節碼，然後由用c編寫的匹配引擎執行。
作用：用來模糊匹配字符串

2.字符匹配（普通字符，元字符）
普通字符：大多數字符和字母都會和自身匹配
Print(re.findall(“jiaxin”,”haszjhnjiaxinisxjhmbj”))
元字符： . ^ $ * + {} [] | () \

字符串方法回顧

# -*-coding:utf-8 -*-
__author__ = ‘xiaojiaxin‘
__file_name__ = ‘正則表達式‘

s="hello world"

# Python find() 方法檢測字符串中是否包含子字符串 str ，如果指定 beg（開始） 和 end（結束） 範圍，則檢查是否包含在指定範圍內，如果包含子字符串返回開始的索引值，否則返回-1。
print(s.find("llo"))
# 2

# print(s.index("23"))  #找不到會報錯

print(s.replace("ll","ss"))
# hesso world
print(s.split("o"))
# [‘hell‘, ‘ w‘, ‘rld‘]

#正則表達式模塊（Regular Expression 正則表達式）
 

正則表達式

import re

ret=re.findall("w\w{2}l","hello world")
print(ret)
# [‘worl‘]

#完全匹配"jiaxin",沒找到
ret1=re.findall("jiaxin","sdkjfnxkgjfkdsgfgusydxtnia")
print(ret1)
# []

ret2=re.findall("jiaxin","sdkjfnxkgjfkdsjiaxindxtnia")
print(ret2)
# [‘jiaxin‘]

元字符.

#元字符

#.通配符，代指單個任意字符,也可以匹配空格和換行符等
ret3=re.findall("j.a","sdkjfnxkgjfkdsjiaxindxtnia")
print(ret3)
# [‘jia‘]
ret4=re.findall("w.r","hello w\trld!")
print(ret4)
# [‘w\tr‘]
 

元字符^

#^  只從頭開始匹配
ret5=re.findall("^h...o","dhsfjkhello")
print(ret5)
# []
ret5=re.findall("^h...o","hhsfokhello")
print(ret5)
# [‘hhsfo‘]

元字符$

#$  只從結尾匹配
ret6=re.findall("j.a$","jiaaskdhfx js")
print(ret6)
# []
ret7=re.findall("j.a$","jiaaskdhfx jda")
print(ret7)
# [‘jda‘]

**元字符***

#* 表示重復匹配[0,+oo]  .*表示0到多次任意字符
ret8=re.findall("jia.*xin","sdjfhdxjjjiaajshjkshkxinhsfjkg")
print(ret8)
# [‘jiaajshjkshkxin‘]

ret9=re.findall("jia*","sdjfhdxjjjiaajshjkshkxinhsfjkg")
print(ret9)
# [‘jiaa‘]
 

元字符+

#+ 也表示重復匹配[1,+oo],b至少有一個
ret10=re.findall("ab+","ghfxhsgabjhf")
print(ret10)
# [‘ab‘]

元字符？

#？ [0,1]要麽0，要麽1,要麽只有一個b,要麽沒有b
ret11=re.findall("ab?","ghfxhsgabjhf")
print(ret11)
# [‘ab‘]

元字符{}

#{}規定{}前面的a重復的次數
ret12=re.findall("a{4}b?","kdfkaaaabhkfd")
print(ret12)
# [‘aaaab‘]

#{m,n}可以匹配n,n+1,n+2……m次，默認貪婪匹配，多個匹配按照最多的去匹配
ret13=re.findall("a{1,5}b?","kdfkaaabhkfd")
print(ret13)
# [‘aaab‘]
#[1.+oo)表示方法
ret14=re.findall("a{1,}b?","kdfkaaabhkfd")
print(ret14)
# [‘aaab‘]

惰性匹配

#惰性匹配
print(re.findall("abc*?","abcccccc"))
# [‘ab‘]

#結論： *  [0,+oo)
#      +   [1,+oo)
#      ?    0或1
#      {m,n}  從m或者m+1,m+2……再或者n次重復都可以

元字符[ ]

#  []叫字符集,c或者d或者e,但是不能是cde,cd,ce,de,只能是三選一
ret15=re.findall("a[c,d,e]x","acx")
print(ret15)
# [‘acx‘]

ret16=re.findall("[a-z]","acxsfw34uriyjkdhk54")
print(ret16)
# [‘a‘, ‘c‘, ‘x‘, ‘s‘, ‘f‘, ‘w‘, ‘u‘, ‘r‘, ‘i‘, ‘y‘, ‘j‘, ‘k‘, ‘d‘, ‘h‘, ‘k‘]

#[]字符集：取消元字符的特殊功能，有例外（\ ^  -）
ret17=re.findall("[a-z*]","acxsfw3*5uriyjkdhk54")
print(ret17)
# [‘a‘, ‘c‘, ‘x‘, ‘s‘, ‘f‘, ‘w‘, ‘*‘, ‘u‘, ‘r‘, ‘i‘, ‘y‘, ‘j‘, ‘k‘, ‘d‘, ‘h‘, ‘k‘]

ret18=re.findall("[a-z0-9A-Z]","acxsfw35uriyjkdhk54")
print(ret18)
# [‘a‘, ‘c‘, ‘x‘, ‘s‘, ‘f‘, ‘w‘, ‘3‘, ‘5‘, ‘u‘, ‘r‘, ‘i‘, ‘y‘, ‘j‘, ‘k‘, ‘d‘, ‘h‘, ‘k‘, ‘5‘, ‘4‘]

#^放在[]裏，表示取反
ret19=re.findall("[^a]","acxsfw35uriyjkdhk54")
print(ret19)
# [‘c‘, ‘x‘, ‘s‘, ‘f‘, ‘w‘, ‘3‘, ‘5‘, ‘u‘, ‘r‘, ‘i‘, ‘y‘, ‘j‘, ‘k‘, ‘d‘, ‘h‘, ‘k‘, ‘5‘, ‘4‘]

#a和c都要去掉
ret20=re.findall("[^a,c]","acxsfbw35uriyjkdhk54")
print(ret20)
# [‘x‘, ‘s‘, ‘f‘, ‘w‘, ‘3‘, ‘5‘, ‘u‘, ‘r‘, ‘i‘, ‘y‘, ‘j‘, ‘k‘, ‘d‘, ‘h‘, ‘k‘, ‘5‘, ‘4‘]

元字符\

#  \ 最重要的符號，功能有兩個：1.反斜杠後邊跟元字符去除特殊功能
#                              2.反斜杠後邊跟普通字符實現特殊功能

# \序號
#
# 1. 引用序號對應的子組所匹配的字符串，子組的序號從 1 開始計算
# 2. 如果序號是以 0 開頭，或者 3 個數字的長度。那麽不會被用於引用對應的子組，而是用於匹配八進制數字所表示的 ASCII 碼值對應的字符
# 舉個栗子：.+) \1 會匹配 "FishC FishC" 或 "55 55"，但不會匹配 "FishCFishC"（註意，因為子組後邊還有一個空格）
#
# \A
#
# 匹配輸入字符串的開始位置
#
# \Z
#
# 匹配輸入字符串的結束位置
#
# \b
#
# 零寬斷言，匹配一個單詞邊界，單詞被定義為 Unidcode 的字母數字或下橫線字符
# 舉個栗子：\bFishC\b 會匹配字符串 "love FishC"、FishC." 或 "(FishC)"
#
# \B
#
# 零寬斷言，匹配非單詞邊界，其實就是與 \b 相反
# 舉個栗子：py\B 會匹配字符串 "python"、"py3"  或 "py2"，但不會匹配 "py  "、"py." 或  "py!"
#
# \d
#
# 1. 對於 Unicode（str 類型）模式：匹配任何一個數字，包括 [0-9] 和其他數字字符；如果開啟了 re.ASCII 標誌，就只匹配 [0-9]
# 2. 對於 8 位（bytes 類型）模式：匹配 [0-9] 中任何一個數字
#
# \D
#
# 匹配任何非 Unicode 的數字，其實就是與 \d 相反；如果開啟了 re.ASCII 標誌，則相當於匹配 [^0-9]
#
# \s
#
# 1. 對於 Unicode（str 類型）模式：匹配 Unicode 中的空白字符（包括 [ \t\n\r\f\v] 以及其他空白字符）；如果開啟了 re.ASCII 標誌，就只匹配 [ \t\n\r\f\v]
# 2. 對於 8 位（bytes 類型）模式：匹配 ASCII 中定義的空白字符，即 [ \t\n\r\f\v]
#
# \S
#
# 匹配任何非 Unicode 中的空白字符，其實就是與 \s 相反；如果開啟了 re.ASCII 標誌，則相當於匹配 [^ \t\n\r\f\v]
#
# \w
#
# 1. 對於 Unicode（str 類型）模式：匹配任何 Unicode 的單詞字符，基本上所有語言的字符都可以匹配，當然也包括數字和下橫線；如果開啟了 re.ASCII 標誌，就只匹配 [a-zA-Z0-9_]
# 2. 對於 8 位（bytes 類型）模式：匹配 ASCII 中定義的字母數字，即 [a-zA-Z0-9_]
#
# \W
#
# 匹配任何非 Unicode 的單詞字符，其實就是與 \w 相反；如果開啟了 re.ASCII 標誌，則相當於 [^a-zA-Z0-9_]
#
# 轉義符號
#
# 正則表達式還支持大部分 Python 字符串的轉義符號：\a，\b，\f，\n，\r，\t，\u，\U，\v，\x，\# 註1：\b 通常用於匹配一個單詞邊界，只有在字符類中才表示“退格”
# 註2：\u 和 \U 只有在 Unicode 模式下才會被識別
# 註3：八進制轉義（\數字）是有限制的，如果第一個數字是 0，或者如果有 3 個八進制數字，那麽就被認為是八進制數；其他情況則被認為是子組引用；至於字符串，八進制轉義總是最多只能是 3 個數字的長度

print(re.findall("\d{11}","hdfkhdgk34980657000jhdcfbhbg0426383032"))
# [‘34980657000‘]

print(re.findall("\sabc","123 abc uirye"))
# [‘ abc‘]

print(re.findall("\wabc","123 yabc uirye"))
# [‘yabc‘]

print(re.findall("\w","123 yabc uirye"))
# [‘1‘, ‘2‘, ‘3‘, ‘y‘, ‘a‘, ‘b‘, ‘c‘, ‘u‘, ‘i‘, ‘r‘, ‘y‘, ‘e‘]

print(re.findall(r"i\b","hello,i li$ke it !"))
# [‘i‘, ‘i‘]

元字符|

# |  管道符：或

#####################################
正則表達式常用方法：

#search只找第一個匹配的，找到就不找了
#group（）用來提出分組截獲的字符串
print(re.search("ok","hdfhnkjshokjhfdkj"))
# <_sre.SRE_Match object; span=(9, 11), match=‘ok‘>
print(re.search("ok","hdfhnkjshokjhfdkj").group())
# ok

ret21=re.search("a.","agj").group()
print(ret21)

ret22=re.search("a\+","a+gj")
print(ret22.group())
# a+

ret23=re.findall(r"\\p","fha\p")
print(ret23)
# [‘\\p‘]

ret24=re.findall("\\\p","fha\p")
print(ret24)
# [‘\\p‘]

正則表達式的方法：

1. findall():所有結果都返回在一個列表裏
2. search() :返回匹配到的第一個對象（object），對象可以調用group（）返回結果
3. match() :只在字符串開始匹配時匹配，也返回匹配到的第一個對象（object），對象可以調用group（）返回結果
4. split() :
5. sub() :替換
6. compile():

split方法

#***********
#首先根據l分，再根據o分，再打印出來
ret30=re.split("[l,o]",‘hello world‘)
print(ret30)
# [‘he‘, ‘‘, ‘‘, ‘ w‘, ‘r‘, ‘d‘]

#註意""的來源
ret31=re.split("[l,h]",‘hello world‘)
print(ret31)
# [‘‘, ‘e‘, ‘‘, ‘o wor‘, ‘d‘]

ret32=re.split("[l,h]",‘hello world‘)
print(ret32)

sub方法

#替換符
ret33=re.sub("j.a","j*j","hfjhjia")
print(ret33)
# hfjhj*j

compile方法

#一次編寫規則，多次使用
rule=re.compile("\.com")
rule.findall("sdjfg.comsjdfk")
print(rule)
# re.compile(‘\\.com‘)

11.7正則表達式