Python 正则表达式

1. """ 
2. 正则表达式的主要功能就是匹配字符串 
3. """  
4.   
5. import re  
6.   
7. # 基本用法  
8. ret = re.findall('world', "hello world**Worldworld")  # 查找制定字符串，以list形式返回  
9. print(ret)  
10. """ 
11. 原字符 
12. """  
13.   
14. # 1. '.' 通配符：代表任意字符，一个点一个字符  
15. ret = re.findall('w...d', "hello world")  
16. print(ret)  # ['world']  
17.   
18. ret = re.findall('w...d', "hello w\nrld")  
19. print(ret)  # [] 除了\n其他都行,当然也可以通过修改findall的第三个参数去修改成连\n都能匹配  
20.   
21. # 2. '^' 尖角符：必须从字符串的起始位置开始匹配,不考虑后续字符串中是否存在  
22. ret = re.findall('^w...d', "hello world")  
23. print(ret)  # []  
24.   
25. ret = re.findall('^w...d', "worldhello world")  
26. print(ret)  # ['world']  
27.   
28. # 3. '$' 只从最后开始匹配  
29. ret = re.findall('w...d', "hello world!!")  
30. print(ret)  # ['world']  
31.   
32. ret = re.findall('w...d$', "hello world!!")  
33. print(ret)  # []  
34.   
35. ret = re.findall('w...d$', "hello world!!world")  
36. print(ret)  # ['world']  
37.   
38. # *************************************************************  
39.   
40. # 4. '*' 重复匹配 允许*之前的一个字符重复多次  
41.   
42. ret = re.findall('hello*world', 'hellooooooworld')  
43. print(ret)  # ['hellooooooworld']  
44.   
45. ret = re.findall('hello.*world', 'hello@@sssworld')  # 如果我使用通配符'.'他就能匹配任意字符  
46. print(ret)  # ['hello@@sssworld']  
47.   
48. # 5. '+' 也是重复匹配 但是至少得有一个  
49. ret = re.findall('hello*world', 'hellworld')  
50. print(ret)  # ['hellworld']  
51.   
52. ret = re.findall('hello+world', 'hellworld')  
53. print(ret)  # []  
54. # 也就是说'+'号之前的o，在目标字符串里必须出现一次，但是'*'号允许一次也不出现  
55.   
56. # 6. '?' 还是重复匹配，但是只能是0次或者1次多了就不行  
57. ret = re.findall('hello?world', 'hellworld')  
58. print(ret)  # ['hellworld']  
59.   
60. ret = re.findall('hello?world', 'helloworld')  
61. print(ret)  # ['helloworld']  
62.   
63. ret = re.findall('hello?world', 'helloooworld')  
64. print(ret)  # []  
65.   
66. # 7. '{}' 大括号也是重复匹配，但是匹配几次自己可以设置  
67. ret = re.findall('a{5}b', 'aaaabbaaa')  # 要求a重复5次  
68. print(ret)  # []  
69.   
70. ret = re.findall('a{5}b', 'aaaaabbaaa')  
71. print(ret)  # ['aaaaab']  
72.   
73. ret = re.findall('a{1,3}b', 'ba***aab***aaab***aaaaaaaabaaa')  
74. print(ret)  # ['aab', 'aaab', 'aaab']  

1. """ 
2. 正则表达式 
3. """  
4.   
5. import re  
6.   
7. # 1. '[]' 字符集 其实就是或的关系,允许字符集内任意一个字符  
8. ret = re.findall('a[cd]x', '***adx***')  
9. print(ret)  # ['adx']  
10.   
11. ret = re.findall('a[cd]x', '***acx***')  
12. print(ret)  # ['acx']  
13.   
14. # 匹配a-z  
15. ret = re.findall('[a-z]', 'ac@@z')  
16. print(ret)  # ['a', 'c', 'z']  
17.   
18. # 取消元字符的特殊功能 '^','-','\'例外  
19. ret = re.findall('abc[.]cn', 'abc.cn')  
20. print(ret)  
21.   
22. # 取反  
23. ret = re.findall('[^abc]', 'eabcd')  
24. print(ret)  # ['e', 'd']  
25.   
26. ret = re.findall('[^4,5]', '12345')  # 取反的是[]内所有值  
27. print(ret)  # ['1', '2', '3']  
28.   
29. # 2. '\' 去除元字符特殊功能或者实现部分普通字符的特殊功能  
30. ret = re.findall('\d', 'aaa123bbb')  # 匹配所有十进制数字  
31. print(ret)  # ['1', '2', '3']  
32.   
33. ret = re.findall('\d{11}', 'aaa13411012099bbb13012033344')  
34. print(ret)  # ['13411012099', '13012033344']  
35.   
36. ret = re.findall('\D', 'aaa123bbb')  # 匹配所有非十进制数字  
37. print(ret)  # ['a', 'a', 'a', 'b', 'b', 'b']  
38.   
39. # 匹配任意空白字符 \t \n \r \f \v这些都是  
40. ret = re.findall('\saaa', ' ** \t\naaa')  
41. print(ret)  # ['\naaa']  
42.   
43. # 匹配任意非空白字符  
44. ret = re.findall('\Saaa', ' aaa** \t\naaa baaa')  
45. print(ret)  # ['baaa']  
46.   
47. # 匹配任意数字字母字符  
48. ret = re.findall('\w{3}a', 'abca,123a, a1a,1e3a')  
49. print(ret)  # ['abca', '123a', '1e3a']  
50.   
51. # 匹配任意非数字非字母字符  
52. ret = re.findall('\W', 'abc@123$a1w%1e3')  
53. print(ret)  # ['@', '$', '%']  
54.   
55. # 匹配一个特殊边界  
56. ret = re.findall('I\b', 'I am a LIST')  
57. print(ret)  # []  
58. # 怎么会没有呢 因为\b在Python里也有转义,退格符  
59. ret = re.findall(r'I\b', 'I am a LIST')  
60. print(ret)  # ['I']  
61. # 字符串之前加个r就可以防止被Python转义,正则表达式有自己的语法规则,两个\b不是一个意思哈  
62.   
63. """ 
64. ---------------------------------------------------------------------------- 
65. """  
66. # search方法 匹配出满足条件的第一个结果 返回的是一个对象  
67. ret = re.search('a.b', 'aabaac').group()  
68. print(ret)  # aab  
69.   
70. ret = re.search('aaa', "aaaaaaa")  
71. print(ret.group())  
72. # 如果没有匹配到返回的None(去除元字符意义）  
73. print(re.search('a\.b', 'aaacbaac'))  # None  
74.   
75. # 两个\是一个特殊的用法,由于在Python解释器里'\'也是有转义的意思,所以'\\\\'前两个是给Python看的,  
76. # 然而正则表达式的语法里，对于'\'也是有语法规则（去除特殊意义），那如果要用\去除\的特殊意义，也需要两个\  
77. # 加起来就变成4个了,所以以后记得不要转义的话，字符串前加r  
78. ret = re.search('\\\\', 'abcD\de').group()  
79. print(ret)  # \  
80.   
81. ret = re.search(r'\\', 'abcD\de').group()  
82. print(ret)  # \  
83.   
84. ret = re.search('\\babc', 'abcbcc').group()  
85. print(ret)  # abc  
86.   
87. """ 
88. ----------------------------------------------------------------------------- 
89. """  
90.   
91. # 4. '()'分组 和 '|'或  
92.   
93. ret = re.search('a(bc)+', 'abcbc').group()  
94. print(ret)  # abcbc  
95.   
96. # ?P<id> 这个id就是分组的名字，可以通过返回的对象，取不同的内容  
97. ret = re.search('www\.(?P<name>\w+)\.(com|cn)', 'eeewww.ThisIsATest.cnxxxxwww.ccc.com')  
98. print(ret.group('name'))  # ThisIsATest  
99.   
100. # IP地址正则匹配，不允许第一段为0,最后一段可以0-255，0代表网段，255虽然客户端不能使用，但是这个地址试有用的  
101. # 最后一段的顺序是有讲究的，越小的集合放在越前面，因为最有没有'.'作为分割了  
102. ret = re.search(  
103.     '(([1-9])|(1\d\d?)|(2[0-4]?\d)|(25[0-5]))\.'    #IP第一段 1-255  
104.     '(((1?\d?\d)|(2[0-4]?\d)|(25[0-5]))\.){2}'      #第二第三段 0-255   
105.     '((25[0-5])|(2[0-4]\d)|(1?\d?\d))',             #第四段 0-255   
106.     'ipaddr:232.2.5.253').group()  
107. print(ret)  
108.   
109. """ 
110. -------------------------------------------------------------------------------------------- 
111. """  
112. """ 
113. re常用方法 
114.  
115. 1.findall() : 返回所有结果到一个列表 
116. 2.search() : 返回一个对象，可以通过调用对象的group()方法获取返回值 
117. 3.match() : 从字符串头部开始匹配，返回一个对象，可以通过调用对象的group()方法获取返回值 
118. """  
119. # 4.split 这个举个例子  
120. # 他这个分割会先按照';'去分割--->['aaa,111', 'bbb,222']  
121. # 然后再按照','去分割每一个元素  

[python]  view plain  copy

1. # 其实我测试了一下，这个先后关系没有发现什么实际意义，通过源码的注释，我也没有发现什么，我觉得理解成 或 也没什么问题  
2. ret = re.split('[;,]', 'aaa,111;bbb,222')  
3. print(ret)  # ['aaa', '111', 'bbb', '222']  
4.   
5. # 5.sub 替换方法 第一个参数：目标字符串  第二个参数：被替换成什么字符串  第三个参数：源字符串  
6. ret = re.sub('a..', 'bbb', '**aac*abbcc')  
7. print(ret)  # **bbb*bbbcc  
8.   
9. # 6.compile 创建一个带有规则的re对象  
10. cmp = re.compile('\.com')  
11. print(cmp.search("aabbcc.com").group())  # .com  
12. print(cmp.sub('.cn', 'aabbcc.com'))  # aabbcc.cn 
13. 
    
14. 
    
15. 
    
16. 
    
17. 
    
18. 
    
19. 原文章  http://blog.csdn.net/tyrantu1989/article/details/78416440 
20. http://blog.csdn.net/tyrantu1989/article/details/78427746