# 正則表示式 —練習實踐
import re
pattrn = "abc"
str1 = "qwe"
result = re.match(pattrn,str1)
print(result) # 匹配不到，返回預設值 None
# str1為匹配的物件，match為從頭匹配，pattrn為匹配規則

str2 = "abc"
result1 = re.match(str2,pattrn)
print(result1) # <_sre.SRE_Match object; span=(0, 3), match='abc'>
print(result1.group())#  abc  列印匹配的資料

"""
1、單字元匹配
    .   匹配任意一個字元，除了 /n ,如果加上 re.
    []  匹配[] 中列舉的字元
    
    \d  匹配數字 0-9
    \D  匹配非數字
    
    \s  匹配空白，即空白，Tab，\n,\t
    \S  匹配非空白
    
    \w  匹配單詞字元，a-z,A-Z,0-9,_ 共63個字元，包括各國文字
    \W  匹配非單詞字元
    
    注： 這些字元只匹配一個字元
"""
import re
ret = re.match(r".","a")
print(ret)
print(ret.group()) # a

ret = re.match(r"..","abc")
print(ret) # <_sre.SRE_Match object; span=(0, 2), match='ab'>
print(ret.group()) # ab

# 注意： 一個 . 只能匹配一個字元。並且匹配的規則的數量一定要比 匹配字串的數量要多
ret = re.match(r"..","a")
print(ret) # None
print("1"*20)
"""
\d  匹配數字
\D  匹配非數字
"""
ret = re.match("\d","123")
print(ret) # 1

ret = re.match("\D", "abc")
print(ret) # a
print("2"*20)

"""
\s 匹配空白，eg： Tab,空字串，空格，\n,\t,\n\t.
\S 匹配非空白
"""
ret =re.match(r"\s","")
print(ret)

ret = re.match(r"\s","\n")
print(ret)

ret = re.match(r"\s","\t")
print(ret)

ret = re.match(r"\s","\n\t")
print(ret)

ret = re.match(r"\s","  ") # 匹配Tab鍵
print(ret)

ret = re.match(r"\S","abc")
print(ret)  # a
"""
列印結果
    None
    <_sre.SRE_Match object; span=(0, 1), match='\n'>
    <_sre.SRE_Match object; span=(0, 1), match='\t'>
    <_sre.SRE_Match object; span=(0, 1), match='\n'>
    <_sre.SRE_Match object; span=(0, 1), match=' '>
    <_sre.SRE_Match object; span=(0, 1), match='a'>
"""
print("3"*20)

"""
\w   匹配單詞字元，a-z，A-Z,0-9,_ 63個字串，還包含各國文字[\u4e00-\u9fa5] 表示所有的中文
\W   匹配非單詞字元
"""
ret = re.match(r"\w","abc")
print(ret)

ret = re.match(r"\w+","Ac232_")
print(ret)

ret = re.match(r"\w+","中國")
print(ret)

ret = re.match(r"\W","#")
print(ret)

ret = re.match(r"\W","￥")
print(ret)
"""
列印結果：
    <_sre.SRE_Match object; span=(0, 1), match='a'>
    <_sre.SRE_Match object; span=(0, 6), match='Ac232_'>
    <_sre.SRE_Match object; span=(0, 2), match='中國'>
    <_sre.SRE_Match object; span=(0, 1), match='#'>
    <_sre.SRE_Match object; span=(0, 1), match='￥'>
"""
print("4"*20)

# 原始字串
import re
s = "c\\b\\a"
print(s) # c\b\a

ret = re.match(r"c\\b\\a","c\\b\\a")
print(ret)

ret = re.match(r"a.","ab")
print(ret)  # 這裡面的 . 不是普通字元

ret = re.match(r"a\.b","acb")
print(ret)  # 這裡面的 . 是普通字元，沒有其他的含義

ret = re.match(r"a.b","acb")
print(ret)  # 這裡面的 . 是普通字元，沒有其他的含義

ret = re.match(r"a\.b","a.b")
print(ret)

ret = re.match(r"[a,h,j,s]","abc")
print(ret)

ret = re.match(r"\[a\]","[a]")
print(ret)
# 注 ： 加上 \ 表示反轉義，使原來的字元沒有特殊的含義。
"""
列印結果：
    c\b\a
    <_sre.SRE_Match object; span=(0, 5), match='c\\b\\a'>
    <_sre.SRE_Match object; span=(0, 2), match='ab'>
    None
    <_sre.SRE_Match object; span=(0, 3), match='acb'>
    <_sre.SRE_Match object; span=(0, 3), match='a.b'>
    <_sre.SRE_Match object; span=(0, 1), match='a'>
    <_sre.SRE_Match object; span=(0, 3), match='[a]'>
"""
print("5"*20)

"""
3、 表示數量的正則：
    *     匹配前一個字元出現0次或者多次
    +     至少出現一次
    ？    匹配前一個字元0次或者1次
    {m}   匹配前一個字元出現 m 次
    {m,n} 匹配前一個字元出現m到n次，至少m次
    {m，}  匹配前一個字元至少出現m次
"""

import re
ret = re.match(r"abc{2,4}","abccccccccc")
print(ret)

ret = re.match(r"abc{2,}","abccccccccc")
print(ret)

ret = re.match(r"abc{2}","abccccccccc")
print(ret)

ret = re.match(r"abc+","abcccccccccccc")
print(ret)

ret = re.match(r"abc*","abcc")
print(ret)

ret = re.match(r"abc*","ab")
print(ret)

"""
列印結果：
    <_sre.SRE_Match object; span=(0, 6), match='abcccc'>
    <_sre.SRE_Match object; span=(0, 11), match='abccccccccc'>
    <_sre.SRE_Match object; span=(0, 4), match='abcc'>
    <_sre.SRE_Match object; span=(0, 14), match='abcccccccccccc'>
    <_sre.SRE_Match object; span=(0, 4), match='abcc'>
    <_sre.SRE_Match object; span=(0, 2), match='ab'>
"""

print("6"*20)
"""
4 、表示邊界
    ^   匹配字串的開頭
    $   匹配字串的結尾
    \b  匹配一個單詞的邊界,
    \B  匹配非單詞邊界,
"""
import re
ret = re.search(r"world","hello world")
print(ret)

ret = re.search(r"^world","hello world")
print(ret)

ret = re.search(r"world$","hello world")
print(ret)

ret = re.search(r"who\b","who am i")
print(ret)

ret =re.search(r"who\b am","who am")
print(ret)
"""
列印結果：
    <_sre.SRE_Match object; span=(6, 11), match='world'>
    None
    <_sre.SRE_Match object; span=(6, 11), match='world'>
    <_sre.SRE_Match object; span=(0, 3), match='who'>
    <_sre.SRE_Match object; span=(0, 6), match='who am'>
"""
print("6"*20)

"""
6、 匹配分組：
    |      匹配左右兩邊任意的表示式
    (ab)   將括號
    \num   引用分組num匹配的字串
    (?P<name>)  分組起別名
    (?P=name)   引用別名為name分組匹配到的字串
"""
import re
ret = re.match(r"[1-7]?\d|100","70")  # [1-9] 表示 1-9 中任意的數字
print(ret)

ret = re.match(r"[1-9]?\d|70","7")
print(ret)

ret = re.match(r"[0-9]?\d$|100","07")
print(ret)

s="<html><h1>itcast</h1></html>"
ret = re.match(r"<(.+)><(.+)>.+</\2></\1>",s) #\num 的作用
print(ret)
print(ret.groups())   # 表示匹配到的組數  ("html","h1")
print(ret.group())    # 表示匹配的全部內容   <html><h1>itcast</h1></html>
print(ret.group(0))   # 表示匹配的全部內容   <html><h1>itcast</h1></html>
print(ret.group(1))   # 表示匹配到的第一個小括號的內容
print(ret.group(2))   # 表示匹配到的第二個小括號的內容
print("*"*20)
s="<html><h1>itcast,1</h1></html>"
ret =re.match(r"<html><h1>(.+),1</h1></html>",s)
print(ret)
print(ret.group(1))

# (?P<name>) 起別名  (?P=name) 引用別名
s = "<html><b>itcast</b></html>"
ret = re.match(r"<(?P<g1>.+)><(?P<g2>.+)>.+</(?P=g2)></(?P=g1)>",s)
print(ret)
print(ret.group())
"""
列印結果：
    <_sre.SRE_Match object; span=(0, 2), match='70'>
    <_sre.SRE_Match object; span=(0, 1), match='7'>
    <_sre.SRE_Match object; span=(0, 2), match='07'>
    <_sre.SRE_Match object; span=(0, 28), match='<html><h1>itcast</h1></html>'>
    <html><h1>itcast</h1></html>
    <html><h1>itcast</h1></html>
    html
    h1
    ********************
    <_sre.SRE_Match object; span=(0, 30), match='<html><h1>itcast,1</h1></html>'>
    itcast
    <_sre.SRE_Match object; span=(0, 26), match='<html><b>itcast</b></html>'>
    <html><b>itcast</b></html>
"""
"""
注 ： [^0-9] 表示除了 0-9之外的字元  ^ 在內部使用的時候 表示相反的意思。 
"""

"""
6、 正則表示式的函式

    re模組的高階用法：
        compile 函式 ： 用於編譯正則表示式，生成一個Pattern 物件

    格式：
        import re
        pattern = re.compile(正則表示式)

    比如說： 
        parrern =re.compile(r"\d+")
    
    Pattern 物件的一些常用方法主要有：
        match ()  :  從起始位置開始查詢，一次匹配
        search()  :  從任意位置開始查詢，一次匹配
        findall() :  全部匹配，返回一個列表
        finditer():  全部匹配，返回迭代器
        split()   :  分割字串，返回一個列表
        sub()     :  替換字串 
"""

"""
match() 函式  match(string,[start,end])
含義：
    start :  這個值可以取到  這裡面是索引為 16 的字元
    end   :  這個值取不到    這裡面是索引為 23 的字元
    跟列表的切片一樣，前閉後開 [ start, end )
"""


print("7"*20)
import  re
info = "abc"
pattern = re.compile(r"\w+")
ret = pattern.match(info)
print(ret)

info = "http://www.taobaooo.com"
pattern = re.compile(r"o+\.com")
ret = pattern.match(info,16,23)
print(ret)

print(ret.group())  # ooo.com
print(ret.span())   # (16,23)
print(ret.start())  # 16
print(ret.end())    # 23


"""
列印結果：
    77777777777777777777
    <_sre.SRE_Match object; span=(0, 3), match='abc'>
    <_sre.SRE_Match object; span=(16, 23), match='ooo.com'>
    ooo.com
    (16, 23)
    16
    23
"""

"""
search() 函式
    search(string,[start,end])
    re.I  忽略大小寫
    re.M  隻影響  ^  和  $ , 多行匹配
    當匹配到一個後，不會繼續向下面匹配
"""
print("8"*20)
pattern = re.compile(r"\d+")
ret = pattern.search("one123two456")
print(ret)

pattern = re.compile(r"[a-z]+",re.I)  # 忽略大小寫
ret = pattern.search("ABcde3456")
print(ret)

pattern = re.compile(r"a$")
ret = pattern.search("dff\na")
print(ret)

"""
列印結果：
    88888888888888888888
    <_sre.SRE_Match object; span=(3, 6), match='123'>
    <_sre.SRE_Match object; span=(0, 5), match='ABcde'>
    <_sre.SRE_Match object; span=(4, 5), match='a'>
"""

"""
findall(string[,pos[,endpos]])
    string 是匹配的字串，後面是可選引數，指定字串的起始和終點位置，預設值分別為0 和 字串的長度
    findall 以列表形式返回全部能匹配的子串，如果沒有匹配，那麼返回一個空的列表
"""
print("9"*20)
pattern = re.compile("a$",re.M)
ret = pattern.findall("a\naba")
print(ret)

pattern = re.compile("a$")
ret = pattern.findall("a\naba")
print(ret)
"""
列印結果：
    99999999999999999999
    ['a', 'a']
    ['a']
"""

"""
finditer()
    方法的行為跟 findall()的行為類似，也是搜尋整個字串
    獲得所有匹配的結果，但它返回的是一個迭代器物件。要遍歷迴圈出來
"""
print("0"*20)
pattern = re.compile(r"[a-z]+",re.I)
ret = pattern.finditer("aBc123Acd/*")
print(ret)
for i in ret :
    print(i)
    print(i.group())

"""
列印結果：
    00000000000000000000
    <callable_iterator object at 0x0000021E169BA208>
    <_sre.SRE_Match object; span=(0, 3), match='aBc'>
    aBc
    <_sre.SRE_Match object; span=(6, 9), match='Acd'>
    Acd
"""

"""
split(string[,maxsplit])
    maxsplit 用於指定最大的分割次數，不指定將符合要求的全部分割
"""
print("@"*20)
pattern = re.compile(r",")
ret = pattern.split("a,b,c,d,e")
print(ret)

ret2 = pattern.split("a,b,c,d,e",3)
# 這裡面的分割次數為3，分割次數可以無限大，還是把所有符合的都分割
print(ret2)


ret2 = pattern.split("a,b,c,d,e",30)
# 這裡面的分割次數為3，分割次數可以無限大，還是把所有符合的都分割
print(ret2)

"""
列印結果：
    @@@@@@@@@@@@@@@@@@@@
    ['a', 'b', 'c', 'd', 'e']
    ['a', 'b', 'c', 'd,e']
    ['a', 'b', 'c', 'd', 'e']
"""

"""
sub(repl,string[,count])
    這個不是從頭匹配
    其中 repl 可以是字串，也可以是一個函式：
        如果 repl 是字串，則會使用repl去替換掉，並返回替換後的字串，還可以使用id引用分組，但不能使用編號0
    
        如果 repl 是函式，這個方法應當只接受一個引數 Match物件。並且返回一個字串用於替換

        count 用於指定最多替換次數，不指定時全部替換
"""
print("&"*20)
info = "a hello 123,hello haha"
ret = re.sub(r"hello","hi",info)   # 預設全部替換
print(ret)

info = "a hello 123,hello haha"
ret = re.sub(r"hello","hi",info,1)  # 替換1個
print(ret)

info = "hello 123, hello haha "
ret = re.sub(r"(\w+) (\w+)",r"\2\1",info)
print(ret)

print("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
def add(x):
    print(x)
    print(type(x.group()))
    return str(int(x.group())+1)

ret = re.sub(r"\d+",add,"python = 996 java = 100")
print(ret)

# 改寫成匿名函式
ret = re.sub(r"\d+",lambda x : str(int(x.group())+1),"python = 10 java = 20")
print(ret)
"""
列印結果：
    &&&&&&&&&&&&&&&&&&&&
    a hi 123,hi haha
    a hi 123,hello haha
    123hello, hahahello 
    xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
    <_sre.SRE_Match object; span=(9, 12), match='996'>
    <class 'str'>
    <_sre.SRE_Match object; span=(20, 23), match='100'>
    <class 'str'>
    python = 997 java = 101
    python = 11 java = 21
"""

"""
貪婪模式 和 非貪婪模式
    貪婪模式   ： 儘可能多的匹配自己可以接受的內容
    非貪婪模式 ： 前面正則可以匹配的，後面的正則也可以匹配的，讓後面的正則來匹配
"""
print("%"*20)
info = '<img src="hahajpg"> style="display:inline"'
ret = re.findall(r'src="(.*)"',info)
print(ret)

info = '<img src="hahajpg"> style="display:inline"'
ret = re.findall(r'src="(.*?)"',info)
print(ret)

"""
列印結果：
    %%%%%%%%%%%%%%%%%%%%
    ['hahajpg"> style="display:inline']
    ['hahajpg']
"""
 

re 模組的幾個引數:

re.M      多行匹配， 影響 ^, $


re.S      . 可以匹配任何字元，包括 \n


re.A      表示匹配 Ascii 碼


re.U      都使用 unicode編碼


re.I      忽略大小寫