python的正则表达式

1：正则表达式：

数据筛选。

2：原子

   正则表达式中基本的组成单位是原子。
   常见的类型有：普通的字符
                          非打印字符  ：\t 制表符  \n换行符
                          通用字符
                          原子表
-------------------------普通字符----------------------------------------------------
>>> import re   导入re
>>> pat="yue"  正则表达式
>>> string="http://yum.iqianyue.com"    将网址放到string中
>>> rst1=re.search(pat,string)                 re下面的search函数 ，在string中搜索pat的内容。    
>>> print(rst1)                                        打印出rst1
<_sre.SRE_Match object; span=(16, 19), match='yue'>  打印出的rst1的结果，很明显，实现了匹配‘yue’
>>> string2="abcd"                                将字符串放到string2中
>>> rst2=re.search(pat,string2)               搜索
>>> print(rst2)                                        输出结果

None                                                      结果为none

>>> pat1="abc"                                                    正则表达式
>>> aa=re.search(pat1,string2)  正则表达式：         在string2中匹配pat1
>>> print(aa)                                                         输出aa

<_sre.SRE_Match object; span=(0, 3), match='abc'>输出结果

---------------------非打印字符----------------------------------------------------------
>>> pat2="\n"
>>> string3="jsaflnjv"
>>> string3='''afkjn      三引号可以换行
fasdfdsf'''
>>> aa=re.search(pat2,string3)
>>> print(aa)
<_sre.SRE_Match object; span=(5, 6), match='\n'>  匹配出换行符号

---------------通用字符(该字符可以匹配一系列的东西)--------------------------
\w （小w） 匹配任意的字母、数字、下划线
\d  代表的十进制数
\s  匹配任意的空白字符

\W  匹配w相反的，除了字母、数字、下划线以外的任意一个字符

\b 匹配单词的开始和结束

\B匹配不是单词开始和结束的位置

实战：

>>> pat3="\w\dpython\w"
>>> string="dasddpython_"
>>> aa=re.search(pat3,string)
>>> print(aa)
None     输出结果
>>> string="sdadasd1python_"      1是十进制数，所以可以匹配出来。
>>> aa=re.search(pat3,string)
>>> print(aa)
<_sre.SRE_Match object; span=(6, 15), match='d1python_'>结果
>>> 
--------------- ----------------------------原子表------------------------------------

[jsz]中括号表示pyth与n中间， 只有1位， 可以使J或者s或者z

实战：

>>> pat="pyth[jsz]n"
>>> string="afsdfdasfascj"
>>> aa=re.search(pat,string)
>>> print(aa)
None                 输出 结果
>>> string="pythsn"
>>> aa=re.search(pat,string)
>>> print(aa)
<_sre.SRE_Match object; span=(0, 6), match='pythsn'>  输出结果
>>> string="pn"
>>> aa=re.search(pat,string)
>>> print(aa)
None      输出结果
>>> string="pythsjn"
>>> aa=re.search(pat,string)
>>> print(aa)
None    因为只可以匹配出一位，所以js为2位，匹配不到。

3：元字符

正则表达式中具有一些特殊含义的字符，比如重复N次前面的字符，下面介绍元字符：

.   表示匹配任意的字符， 能够匹配除了换行符以外的任意字符（占1个字符）
^ 匹配字符串的开始位置：     比如  "^The"：表示所有以"The"开始的字符串（"There"，"The cat"等）；

$ 匹配字符串中结束的位置 ： 比如  "of despair$"：表示所以以"of despair"结尾的字符串；

                                                       比如："^abc$"：表示开始和结尾都是"abc"的字符串——呵呵，只有"abc"自己了；

* 匹配重复0次1次或者多次前面的原子，比如“s*”可以匹配“ss”，“sss”，“s”。
？匹配重复0次或者1次前面的原子，比如“s？”可以匹配“ss”，“s”。

+ 匹配重复一次或多次前面的原子（不包括0次） ，比如“s+”可以匹配“ss”，“sss”。

                                            比如："a?b+$"：表示在字符串的末尾有零个或一个a跟着一个或几个b

{n}前面的原子恰好出现n次，  比如t{6}6个t（连在一起的） q{9}9个q连在一起。

{n,m}前面的原子至少出现了n次，至多出现了m次。s{4,7}s至少出现4次，至多出现7次。  

                                           比如："^.{3}$"：表示有任意三个字符的字符串（长度为3个字符）；      

（）提取某一个内容 ，后面的网页爬取有用到 。

|  模式选择符“或”，将第一个满足条件的内容匹配出来，比如t|s，就是t或者s。

[^m]表示匹配除了m以外的字符串

[m-n]匹配m到n区间内的数字、字母。

[m]匹配单个字符串

[m1m2......n]匹配多个字符串

例如：

"[ab]"：表示一个字符串有一个"a"或"b"（相当于"a¦b"）；
"[a-d]"：表示一个字符串包含小写的'a'到'd'中的一个（相当于"a¦b¦c¦d"或者"[abcd]"）；
"^[a-zA-Z]"：表示一个以字母开头的字符串；
"[0-9]%"：表示一个百分号前有一位的数字；

",[a-zA-Z0-9]$"：表示一个字符串以一个逗号后面跟着一个字母或数字结束。   

实战如下：

>>> pat=".python..."                                         正则表达式
>>> strin="sdadsadpythondsadasds"                字符串
>>> aa=re.search(pat,strin)                               匹配
>>> print(aa)                                                     输出
<_sre.SRE_Match object; span=(6, 16), match='dpythondsa'>    结果
>>> pat="python|php"                                    正则表达式        
>>> string="abcdphp234235python"               字符串
>>> aa=re.search(pat,string)                            匹配
>>> print(aa)                                                    输出
<_sre.SRE_Match object; span=(4, 7), match='php'>     第一个满足条件的内容匹配出来

4：模式修正符

在不改变正则表达式的情况下，通过模式修正符 改变正则表达式的含义，
从而实现一些匹配结果的调整等功能。
主要内容如下：

忽略大小写：I
多行匹配：M
本地化识别匹配：L
根据unic 字符解析我们的字符：U
让我们的.匹配换行符：S

>>> pat1="python"
>>> pat2="python"
>>> string="ksaldfjkbsvaas"
>>> string="afsdhfhhjds Pythonnfsjk"
>>> aa=re.search(pat1,string)
>>> print(aa)
None
>>> aa=re.search(pat2,string,re.I)    模式修正，忽略大小写。
>>> print(aa)
<_sre.SRE_Match object; span=(11, 17), match=' Python'>
>>> 

5：贪婪模式与懒惰模式

贪婪模式：尽可能多的去匹配（尽可能多的去覆盖）
懒惰模式：尽可能少的去匹配（更精准的定位）
pat1="p.*y"     贪婪模式       解释：. 为一个字符，*代表0个1个或者多个，所以 p与y中间的字符 是什么 不确定，数量也不确定
 
pat2="p.*?y"   懒惰模式       

实战：

>>>pat1="p.*y"     贪婪模式
>>> pat2="p.*?y"  
>>> string="abccnkjasdnpythonfasnvlncjuy"
>>> aa=re.search(pat1,string)
>>> print(aa)
<_sre.SRE_Match object; span=(11, 28), match='pythonfasnvlncjuy'>
>>> aa=re.search(pat2,string)
>>> print(aa)
<_sre.SRE_Match object; span=(11, 12), match='py'>

6：正则表达式函数

 re.match() ：从头开始匹配，如果头部不是要找的东西，则输出none.

实战：

>>>pat1="p.*y"      
>>> pat2="p.*?"
>>> string="abccnkjasdn pythonfasnvlncj"
>>> aa=re. match(pat 1,string)
>>> print(aa)
None
 >>>
 实战：演示search函数的缺点，只能搜索出一个满足条件的。
>>> pat1="p.*?y"
>>> string="asdas phdsdasb yasdjksna psdsdh y"
>>> aa= re.search(pat1,string)
>>> print(aa)

<_sre.SRE_Match object; span=(5, 14), match='phdsdasby'>

>>>

全局匹配函数  re.compile(表达式).findall(待搜索字符) ：为了避免search的缺点，能搜索出所有的符合条件的.

实战：

>>> bb=re.compile(pat1).findall(string)
>>> print(bb)
['phdsdasby', 'psdsdhy']          所有符合条件的全部提取出来。
>>> 
   re.sub()：用于替换方面（用的比较少，暂时不做介绍）
              
   re.search()：从字符串中，只能搜索出一个符合条件的，从左往右开始搜索。

实战：

>>> pat1="p.*?y"       
>>> string="asdas phdsdasb yasdjksnapsdsdhy"
>>> aa=re.search(pat1,string)
>>> print(aa)
<_sre.SRE_Match object; span=(5, 14), match='phdsdasby'>

7：常见正则实例

匹配网址（.com或者.cn的网址）：
>>> pat="[a-zA-Z]+://[^\s]*[.com|.cn]"   
>>> string='<a href="http://www.baidu.com">asdasd</a>'
>>> rst=re.compile(pat).findall(string)
>>> print(rst)
['http://www.baidu.com']         匹配的结果
>>> 

8:爬取csdn的一个课程页，并自动提取qq群：

>>> pat="<em> QQ:(.*?)</em>"         正则表达式 （根据你要爬取的csdn的网页进行编写，不懂的同学可以看看爬虫技术）
>>> import urllib.request                      
>>> date=urllib.request.urlopen("http://edu.csdn.net/huiyiCourse/detail/215").read()
>>> result=re.compile(pat).findall(str(date))        str（）是强制转换成字符串
>>> print(result)