python 基础

请从以下文件里取出所有的手机号

姓名        地区    身高    体重    电话
况咏蜜     北京    171    48    13651054608
王心颜     上海    169    46    13813234424
马纤羽     深圳    173    50    13744234523
乔亦菲     广州    172    52    15823423525
罗梦竹     北京    175    49    18623423421
刘诺涵     北京    170    48    18623423765
岳妮妮     深圳    177    54    18835324553
贺婉萱     深圳    174    52    18933434452
叶梓萱    上海    171    49     18042432324
杜姗姗    北京    167    49     13324523342

找到全部电话

f = open("联系方式",'r',encoding="utf-8")
phones = []
for line in f:
    name,city,height,weight,phone = line.split()
    if phone.startswith('1') and len(phone) == 11:
        phones.append(phone)
print(phones)

运行

['13651054608', '13813234424', '13744234523', '15823423525', '18623423421', '18623423765', '18835324553', '18933434452', '18042432324', '13324523342']

使用正则表达式

手机号是有规则的，都是数字且是11位，再严格点，就都是1开头，如果能把这样的规则写成代码，直接拿规则代码匹配文件内容不就行了？

import re
f = open("联系方式",'r',encoding="utf-8")
data = f.read()print(re.findall("1[0-9]{10}",data))

运行

['13651054608', '13813234424', '13744234523', '15823423525', '18623423421', '18623423765', '18835324553', '18933434452', '18042432324', '13324523342']

这么nb的玩法是什么？它的名字叫正则表达式

re模块

正则表达式就是字符串的匹配规则，在多数编程语言里都有相应的支持，python里对应的模块是re

常用的表达式规则

'.'     默认匹配除
之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行
'^'     匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a","
abc
eee",flags=re.MULTILINE)
'$'     匹配字符结尾， 若指定flags MULTILINE ,re.search('foo.$','foo1
foo2
',re.MULTILINE).group() 会匹配到foo1
'*'     匹配*号前的字符0次或多次， re.search('a*','aaaabac')  结果'aaaa'
'+'     匹配前一个字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb']
'?'     匹配前一个字符1次或0次 ,re.search('b?','alex').group() 匹配b 0次
'{m}'   匹配前一个字符m次 ,re.search('b{3}','alexbbbs').group()  匹配到'bbb'
'{n,m}' 匹配前一个字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb']
'|'     匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 结果'ABC'
'(...)' 分组匹配， re.search("(abc){2}a(123|45)", "abcabca456c").group() 结果为'abcabca45'


'A'    只从字符开头匹配，re.search("Aabc","alexabc") 是匹配不到的，相当于re.match('abc',"alexabc") 或^
''    匹配字符结尾，同$ 
'd'    匹配数字0-9
'D'    匹配非数字
'w'    匹配[A-Za-z0-9]
'W'    匹配非[A-Za-z0-9]
's'     匹配空白字符、	、
、
 , re.search("s+","ab	c1
3").group() 结果 '	'

'(?P<name>...)' 分组匹配 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city") 结果{'province': '3714', 'city': '81', 'birthday': '1993'}

re的匹配语法有以下几种

re.match 从头开始匹配
re.search 匹配包含
re.findall 把所有匹配到的字符放到以列表中的元素返回
re.split 以匹配到的字符当做列表分隔符
re.sub 匹配字符并替换
re.fullmatch 全部匹配

match 从头开始匹配也就是开头必须是什么匹配到就返回，返回一个对象

In [1]: import re
In [2]: s = 'abc1d3e'
In [3]: re.match("[0-9]",s) # 没有匹配到，因为不是以数字开头的
In [4]: print(re.match("[0-9]",s))
None

In [5]: re.match("[0-9]",'1dds2')  # 匹配到一个，但是只匹配一个
Out[5]: <_sre.SRE_Match object; span=(0, 1), match='1'>
In [6]: re.match("[0-9]",'12dds2')
Out[6]: <_sre.SRE_Match object; span=(0, 1), match='1'>

search 全局匹配，匹配到就返回，返回一个对象

In [8]: s = 'abc1d3e'
In [9]: re.search("[0-9]",s)
Out[9]: <_sre.SRE_Match object; span=(3, 4), match='1'>  # span是索引

搜索到才能group返回，否则报错

ret = re.search("[0-9]",s)  # 先匹配
if ret:                     # 判断要是匹配到的话，就打印
    print((ret).group())

In [19]: s
Out[19]: 'abc1d3e'
In [20]: ret = re.search("[0-9]",s)  
In [21]: ret
Out[21]: <_sre.SRE_Match object; span=(3, 4), match='1'>
In [22]: ret.group()  # 匹配到了
Out[22]: '1'
In [23]: ret = re.search("[0]",s) # 没有匹配到，后面打印就报错
In [24]: ret.group()
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-24-57f777bf89c0> in <module>()
----> 1 ret.group()

AttributeError: 'NoneType' object has no attribute 'group'

findall 全局搜索，匹配到所有，返回列表（找到的值，放在列表里，返回这个列表）

In [10]: s = 'abc1d3e'
In [11]: re.findall("[0-9]",s)
Out[11]: ['1', '3']

. 匹配

In [31]: re.search(".",'abc')
Out[31]: <_sre.SRE_Match object; span=(0, 1), match='a'>

In [32]: re.search("..",'abc')
Out[32]: <_sre.SRE_Match object; span=(0, 2), match='ab'>

^匹配，匹配开头

In [33]: re.search("^a",'abc')
Out[33]: <_sre.SRE_Match object; span=(0, 1), match='a'>

In [34]: re.search("^a",'bc')

其实就和是match等效

In [36]: re.match("ab",'abc')
Out[36]: <_sre.SRE_Match object; span=(0, 2), match='ab'>

In [37]: re.search("^ab",'abc')
Out[37]: <_sre.SRE_Match object; span=(0, 2), match='ab'>

$匹配，匹配结尾

In [37]: re.search("^ab",'abc')
Out[37]: <_sre.SRE_Match object; span=(0, 2), match='ab'>

In [38]: re.search("b$",'abc')

In [39]: re.search("b$",'ab')
Out[39]: <_sre.SRE_Match object; span=(1, 2), match='b'>

In [40]: re.search("^b$",'ab')

In [41]: re.search("^b$",'b')
Out[41]: <_sre.SRE_Match object; span=(0, 1), match='b'>

In [42]: re.search("^ab$",'b')

In [43]: re.search("^ab$",'ab')
Out[43]: <_sre.SRE_Match object; span=(0, 2), match='ab'>

* 匹配，匹配0从以上（包括0）前面那一个字符0次或者多次

In [48]: re.search("a*",'A').group()
Out[48]: ''

In [49]: re.search("a*",'a').group()
Out[49]: 'a'

In [50]: re.search("a*",'aaaa').group()
Out[50]: 'aaaa'

In [51]: re.search("a*",'aba').group()
Out[51]: 'a'

+匹配，匹配1从以上（包括1）前面那一个字符1次或者多次

In [55]: re.search("a+",'ba').group()
Out[55]: 'a'

In [56]: re.search("a+",'ba').group()
Out[56]: 'a'

In [57]: re.search("ab+",'ab').group()
Out[57]: 'ab'

In [58]: re.search("ab+",'abb').group()
Out[58]: 'abb'

In [59]: re.search("ab+",'aab').group()
Out[59]: 'ab'

In [60]: re.search("ab+",'aa').group()
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-60-f3c555bffe05> in <module>()

?匹配，匹配0或者1次前面那一个字符0或者1次

In [61]: re.search("ab?",'aa').group()
Out[61]: 'a'

In [62]: re.search("ab?",'ab').group()
Out[62]: 'ab'

In [63]: re.search("ab?",'abb').group()
Out[63]: 'ab'

{m}，{n,m}

In [64]: re.search("[0-9]{1}",'123').group()
Out[64]: '1'

In [65]: re.search("[0-9]{2}",'123').group()
Out[65]: '12'

In [66]: re.search("[0-9]{2,3}",'123').group()
Out[66]: '123'

In [67]: re.search("[0-9]{1,3}",'123').group()
Out[67]: '123'

| 或匹配到就返回

In [68]: re.search("a|b",'anc').group()
Out[68]: 'a'

In [69]: re.search("a|b",'anba').group()
Out[69]: 'a'

In [70]: re.search("a|b",'nba').group()
Out[70]: 'b'

In [71]: re.search("a|b|c",'nba').group()
Out[71]: 'b'

In [72]: re.search("a|b|c",'cnba').group()
Out[72]: 'c'

In [75]: re.search("cmz|CMZ",'cmzCMZ').group()
Out[75]: 'cmz'

In [76]: re.search("cmz|CMZ",'CMZ').group()
Out[76]: 'CMZ'

In [77]: re.search("cmz|CMZ",'cmz').group()
Out[77]: 'cmz'

In [78]: re.search("[c|C]mz",'cmz').group()
Out[78]: 'cmz'

In [79]: re.search("[c|C]mz",'Cmz').group()
Out[79]: 'Cmz'

（）分组匹配

In [83]: re.search("([a-z]+)([0-9]+)",'cmz123').groups()
Out[83]: ('cmz', '123')

带名字分组匹配

In [109]: s
Out[109]: '1307044200005250613'

In [110]: ret=re.search( '(?P<province>d{3})(?P<city>d{3})(?P<born_year>d{4})',s)

In [111]: ret.group()
Out[111]: '1307044200'

In [112]: ret.groupdict()
Out[112]: {'born_year': '4200', 'province': '130', 'city': '704'}

In [113]: ret.groupdict()['born_year']
Out[113]: '4200'

In [114]: ret.groupdict()['province']
Out[114]: '130'

In [115]: ret.groupdict()['city']
Out[115]: '704'

re.compile(pattern, flags=0)

Compile a regular expression pattern into a regular expression object, which can be used for matching using its match(), search() and other methods, described below.

The sequence

prog = re.compile(pattern)
result = prog.match(string)

is equivalent to

result = re.match(pattern, string)

but using re.compile() and saving the resulting regular expression object for reuse is more efficient when the expression will be used several times in a single program.

re.match(pattern, string, flags=0)

从起始位置开始根据模型去字符串中匹配指定内容，匹配单个

pattern 正则表达式
string 要匹配的字符串
flags 标志位，用于控制正则表达式的匹配方式

import re
obj = re.match('d+', '123uuasf')
if obj:
    print obj.group()

Flags标志符

re.I(re.IGNORECASE): 忽略大小写（括号内是完整写法，下同）
M(MULTILINE): 多行模式，改变'^'和'$'的行为
S(DOTALL): 改变'.'的行为,make the '.' special character match any character at all, including a newline; without this flag, '.' will match anything except a newline.
X(re.VERBOSE) 可以给你的表达式写注释，使其更可读，下面这2个意思一样

a = re.compile(r"""d + # the integral part
                . # the decimal point
                d * # some fractional digits""", 
                re.X)

b = re.compile(r"d+.d*")

re.search(pattern, string, flags=0)

根据模型去字符串中匹配指定内容，匹配单个

import re
obj = re.search('d+', 'u123uu888asf')
if obj:
    print obj.group()

re.findall(pattern, string, flags=0)

match and search均用于匹配单值，即：只能匹配字符串中的一个，如果想要匹配到字符串中所有符合条件的元素，则需要使用 findall。

import re
obj = re.findall('d+', 'fa123uu888asf')
print obj

re.sub(pattern, repl, string, count=0, flags=0)

用于替换匹配的字符串

In [3]: re.sub('[a-z]+','南京','leco是abc123',)
Out[3]: '南京是南京123'

In [4]: re.sub('d+','|', 'cmz22leco33loocha55',count=2)
Out[4]: 'cmz|leco|loocha55'

In [6]: re.sub('d+','|', 'cmz22leco33loocha55')
Out[6]: 'cmz|leco|loocha|

相比于str.replace功能更加强大

re.split(pattern, string, maxsplit=0, flags=0)

>>>s='9-2*5/3+7/3*99/4*2998+10*568/14'
>>>re.split('[*-/+]',s)
['9', '2', '5', '3', '7', '3', '99', '4', '2998', '10', '568', '14']

>>> re.split('[*-/+]',s,3)
['9', '2', '5', '3+7/3*99/4*2998+10*568/14']

re.fullmatch(pattern, string, flags=0)

整个字符串匹配成功就返回re object, 否则返回None

re.fullmatch('w+@w+.(com|cn|edu)',"alex@oldboyedu.cn")

In [117]: re.fullmatch('w+@w+.(com|cn|edu)',"caimz@loocha.com")
Out[117]: <_sre.SRE_Match object; span=(0, 16), match='caimz@loocha.com'>

In [118]: re.fullmatch('w+@w+.(com|cn|edu)',"caimz@loocha.com").groups()
Out[118]: ('com',)

In [125]: s
Out[125]: 'cmz22jack23rain31jinxin50' 

In [126]: re.split('d+',s)  # 按照数字分割
Out[126]: ['cmz', 'jack', 'rain', 'jinxin', '']

In [127]: re.findall('d+',s)  # 取出数字
Out[127]: ['22', '23', '31', '50']

In [129]: s = 'cmz22jack23rain31jinxin50#mac-cmz'

In [130]: re.split('d+|#|-',s)  # 多个分隔符
Out[130]: ['cmz', 'jack', 'rain', 'jinxin', '', 'mac', 'cmz']

In [132]: re.split('|',s)  # 以管道符|来分割，需要转意。加一个斜杠，做为普通的|来使用
Out[132]: ['cmz22jack23rain31jinxin50', 'mac-cmz']

In [133]: s = 'cmz22jack23rain31|jinxin50#mac-cmz'

In [134]: re.split('d+|#|-||',s)
Out[134]: ['cmz', 'jack', 'rain', '', 'jinxin', '', 'mac', 'cmz']

In [150]: s
Out[150]: 'cmz22jack23
ain31|jinxin50#mac-cmz'

In [151]: re.sub('d+','_',s) # 把数字都替换成_
Out[151]: 'cmz_jack_
ain_|jinxin_#mac-cmz'

In [152]: re.sub('d+','_',s,count=2) # 替换次数为2
Out[152]: 'cmz_jack_
ain31|jinxin50#mac-cmz'

In [154]: s='9-2*5/3+7/3*99/4*2998+10*568/14'

In [155]: re.split('[-*/+]',s)
Out[155]: ['9', '2', '5', '3', '7', '3', '99', '4', '2998', '10', '568', '14']

In [156]: re.split('[-*/+]',s,max)
max        maxsplit=  
 
In [156]: re.split('[-*/+]',s,maxsplit=2)  # 分割多少次
Out[156]: ['9', '2', '5/3+7/3*99/4*2998+10*568/14']

In [157]: re.fullmatch('cmz','cmz')  # 全部匹配到才打印，否则返回None
Out[157]: <_sre.SRE_Match object; span=(0, 3), match='cmz'>

In [158]: re.fullmatch('cmz','cmz12')

compile

In [95]: s="cmz123"

In [96]: p = re.compile('(?P<name>w{3})(?P<num>d{3})')  # 先编译好条件

In [97]: ret = re.search(p,s)

In [98]: ret.groupdict()
Out[98]: {'num': '123', 'name': 'cmz'}

In [99]: 

In [99]: ret.groupdict()['name']
Out[99]: 'cmz'

In [100]: ret.groupdict()['num']
Out[100]: '123'

In [102]: ret.groups()
Out[102]: ('cmz', '123')

In [103]: