def match(pattern, string, flags=0):
　　　　"""Try to apply the pattern at the start of the string, returning
　　　　a match object, or None if no match was found."""
　　　　return _compile(pattern, flags).match(string)

 import re
　　string = "abcdef"
　　m = re.match("abc",string)  （1）匹配"abc"，并查看返回的結(jié)果是什么
　　print(m)
　　print(m.group()) 
　　n = re.match("abcf",string)
　　print(n)      (2）字符串不在列表中查找的情況
　　l = re.match("bcd",string)  （3）字符串在列表中間查找情況
　　print(l)

 <_sre.SRE_Match object; span=(0, 3), match='abc'>  （1）abc             （2）　None             （3）
None             （4）

def fullmatch(pattern, string, flags=0):
　　　　"""Try to apply the pattern to all of the string, returning
　　　　a match object, or None if no match was found."""
　　　　return _compile(pattern, flags).fullmatch(string)

 def search(pattern, string, flags=0):
　　　　"""Scan through string looking for a match to the pattern, returning
　　　　a match object, or None if no match was found."""
　　　　return _compile(pattern, flags).search(string)
 search(pattern,string,flags)的注釋是Scan throgh string looking for a match to the pattern,returning a match object,or None if no match was found.在字符串任意一個位置查找正則表達(dá)式，如果找到了則返回match object對象，如果查找不到則返回None。

 import re
　　string = "ddafsadadfadfafdafdadfasfdafafda"
　　m = re.search("a",string)   （1）從中間開始匹配
　　print(m)
　　print(m.group())
　　n = re.search("N",string)   （2）匹配不到的情況
　　print(n)

 <_sre.SRE_Match object; span=(2, 3), match='a'>  （1）a             （2）None             （3）

def sub(pattern, repl, string, count=0, flags=0):
　　　　"""Return the string obtained by replacing the leftmost
　　　　non-overlapping occurrences of the pattern in string by the
　　　　replacement repl. repl can be either a string or a callable;
　　　　if a string, backslash escapes in it are processed. If it is
　　　　a callable, it's passed the match object and must return
　　　　a replacement string to be used."""
　　　　return _compile(pattern, flags).sub(repl, string, count)
 sub(pattern,repl,string,count=0,flags=0)查找替換，就是先查找pattern是否在字符串string中；repl是要把pattern匹配的對象，就要把正則表達(dá)式找到的字符替換為什么；count可以指定匹配個數(shù)，匹配多少個。示例如下：
 import re
　　string = "ddafsadadfadfafdafdadfasfdafafda"
　　m = re.sub("a","A",string) #不指定替換個數(shù)（1）
　　print(m)
　　n = re.sub("a","A",string,2) #指定替換個數(shù)（2）
　　print(n)
　　l = re.sub("F","B",string) #匹配不到的情況（3）
　　print(l) 

def subn(pattern, repl, string, count=0, flags=0):
　　　　"""Return a 2-tuple containing (new_string, number).
　　　　new_string is the string obtained by replacing the leftmost
　　　　non-overlapping occurrences of the pattern in the source
　　　　string by the replacement repl. number is the number of
　　　　substitutions that were made. repl can be either a string or a
　　　　callable; if a string, backslash escapes in it are processed.
　　　　If it is a callable, it's passed the match object and must
　　　　return a replacement string to be used."""
　　　　return _compile(pattern, flags).subn(repl, string, count)

 import re
　　string = "ddafsadadfadfafdafdadfasfdafafda"
　　m = re.subn("a","A",string) #全部替換的情況 （1）
　　print(m)
　　n = re.subn("a","A",string,3) #替換部分 （2）
　　print(n)
　　l = re.subn("F","A",string) #指定替換的字符串不存在 （3）
　　print(l)

 def split(pattern, string, maxsplit=0, flags=0):
　　　　"""Split the source string by the occurrences of the pattern,
　　　　returning a list containing the resulting substrings. If
　　　　capturing parentheses are used in pattern, then the text of all
　　　　groups in the pattern are also returned as part of the resulting
　　　　list. If maxsplit is nonzero, at most maxsplit splits occur,
　　　　and the remainder of the string is returned as the final element
　　　　of the list."""
　　　　return _compile(pattern, flags).split(string, maxsplit) 
 split(pattern,string,maxsplit=0,flags=0)是字符串的分割，按照某個正則要求pattern分割字符串，返回一個列表returning a list containing the resulting substrings.就是按照某種方式分割字符串，并把字符串放在一個列表中。實例如下：
 import re
　　string = "ddafsadadfadfafdafdadfasfdafafda"
　　m = re.split("a",string) #分割字符串（1）
　　print(m)
　　n = re.split("a",string,3) #指定分割次數(shù)
　　print(n)
　　l = re.split("F",string) #分割字符串不存在列表中
　　print(l)

 ['dd', 'fs', 'd', 'df', 'df', 'fd', 'fd', 'df', 'sfd', 'f', 'fd', '']  （1）
['dd', 'fs', 'd', 'dfadfafdafdadfasfdafafda']        （2）
['ddafsadadfadfafdafdadfasfdafafda']          （3）

def findall(pattern, string, flags=0):
　　　　"""Return a list of all non-overlapping matches in the string.
　　　　If one or more capturing groups are present in the pattern, return
　　　　a list of groups; this will be a list of tuples if the pattern
　　　　has more than one group.
　　　　Empty matches are included in the result."""
　　　　return _compile(pattern, flags).findall(string)
 findall(pattern,string,flags=)是返回一個列表，包含所有匹配的元素。存放在一個列表中。示例如下：
 import re
　　string = "dd12a32d46465fad1648fa1564fda127fd11ad30fa02sfd58afafda"  
　　m = re.findall("[a-z]",string)  #匹配字母，匹配所有的字母，返回一個列表（1）
　　print(m)
　　n = re.findall("[0-9]",string)  #匹配所有的數(shù)字，返回一個列表   （2）
　　print(n)
　　l = re.findall("[ABC]",string)  #匹配不到的情況      （3）
　　print(l)

 ['d', 'd', 'a', 'd', 'f', 'a', 'd', 'f', 'a', 'f', 'd', 'a', 'f', 'd', 'a', 'd', 'f', 'a', 's', 'f', 'd', 'a', 'f', 'a', 'f', 　 'd', 'a']  （1）
　　['1', '2', '3', '2', '4', '6', '4', '6', '5', '1', '6', '4', '8', '1', '5', '6', '4', '1', '2', '7', '1', '1', '3', '0', '0', 　 '2', '5', '8']  （2）
 []     （3）

def finditer(pattern, string, flags=0):
　　　　"""Return an iterator over all non-overlapping matches in the
　　　　string. For each match, the iterator returns a match object.
　　　　Empty matches are included in the result."""
　　　　return _compile(pattern, flags).finditer(string)
 finditer(pattern,string)查找模式，Return an iterator over all non-overlapping matches in the string.For each match,the iterator a match object.

 import re
　　string = "dd12a32d46465fad1648fa1564fda127fd11ad30fa02sfd58afafda"
　　m = re.finditer("[a-z]",string)
　　print(m)
　　n = re.finditer("AB",string)
　　print(n) 

<callable_iterator object at 0x7fa126441898>   （1）
　　<callable_iterator object at 0x7fa124d6b710>   （2）

 def compile(pattern, flags=0):
　　　　"Compile a regular expression pattern, returning a pattern object."
　　　　return _compile(pattern, flags)

 def purge():
　　　　"Clear the regular expression caches"
　　　　_cache.clear()
　　　　_cache_repl.clear() 

def template(pattern, flags=0):
　　　　"Compile a template pattern, returning a pattern object"
　　　　return _compile(pattern, flags|T) 

　import re
　　string = "dd12a32d46465fad1648fa1564fda127fd11ad30fa02sfd58afafda"
　　p = re.compile("[a-z]+")  #先使用compile(pattern)進(jìn)行編譯
　　m = p.match(string)   #然后進(jìn)行匹配
　　print(m.group()) 

 m = p.match("^[0-9]",'14534Abc')

 import re
　　string = "dd12a32d41648f27fd11a0sfdda"
　　#^匹配字符串的開頭，現(xiàn)在我們使用search()來匹配以數(shù)字開始的
　　m = re.search("^[0-9]",string) #匹配字符串開頭以數(shù)字開始  （1）
　　print(m)
　　n = re.search("^[a-z]+",string) #匹配字符串開頭以字母開始，如果是從開頭匹配，就與search()沒有太多的區(qū)別了 （2）
　　print(n.group())

import re
　　string = "15111252598"
　　#^匹配字符串的開頭，現(xiàn)在我們使用search()來匹配以數(shù)字開始的
　　m = re.match("^[0-9]{11}$",string)
　　print(m.group())

 import re
　　string = "1511\n1252598"
　　#點(diǎn)（·）是匹配除了換行符以外所有的字符
　　m = re.match(".",string) #點(diǎn)(·)是匹配任意字符，沒有指定個數(shù)就匹配單個  （1）
　　print(m.group())
　　n = re.match(".+",string) #.+是匹配多個任意字符，除了換行符    （2）
　　print(n.group())

 import re
　　string = "1511\n125dadfadf2598"
　　#[]匹配包含括號中的字符
　　m = re.findall("[5fd]",string) #匹配字符串中的5,f,d
　　print(m)

 import re
　　string = "1511\n125dadfadf2598"
　　#[^]匹配包含括號中的字符
　　m = re.findall("[^5fd]",string) #匹配字符串除5,f,d之外的字符
　　print(m)

 import re
　　string = "1511\n125dadfadf2598"
　　#*是匹配0個或多個的表達(dá)式
　　m = re.findall("\d*",string) #匹配0個或多個數(shù)字
　　print(m)

 import re
　　string = "1511\n125dadfadf2598"
　　#（+）是匹配1個或多個的表達(dá)式
　　m = re.findall("\d+",string) #匹配1個或多個數(shù)字
　　print(m)

 import re
　　string = "1511\n125dadfadf2598"
　　#（?）是匹配0個或1個的表達(dá)式
　　m = re.findall("\d?",string) #匹配0個或1個的表達(dá)式
　　print(m)　

 import re
　　string = "1511\n125dadfadf2598"
　　#（?）是匹配0個或1個的表達(dá)式
　　m = re.findall("\w",string) #匹配0個或1個的表達(dá)式
　　print(m)

 import re
　　string = "1511\n125dadfadf2598"
　　#\W用來匹配字符串中的非字母和數(shù)字
　　m = re.findall("\W",string) #\W用來匹配字符串中的非字母和數(shù)字
　　print(m) 

 import re
　　string = "1511\n125d\ta\rdf\fadf2598"
　　#\s是用來匹配字符串中的任意空白字符，等價于[\n\t\r\f]
　　m = re.findall("\s",string) #\s用來匹配字符串中任意空白字符
　　print(m)　

 import re
　　string = "1511\n125d\ta\rdf\fadf2598"
　　#\S是用來匹配任意非空字符
　　m = re.findall("\S",string) #\S用來匹配日任意非空字符
　　print(m)