判断字符串是否匹配某个规则

利用python内置的字符串函数判断是否包含一个字符串

  1. A = 'python|java'
  3. print(A.index('python')>-1)  # A.index（字符串）>-1为true则说明A中包含/存在字符串
  4. print('python' in A)

正则表达式基本操作

  1. import re
  2. # 'php为要查询项目，A为要匹配的字符串，表示A中是否匹配出符合PHP的自字符'返回一个列表形式a
  3. # 前参数可以是固定字符串如'pyyhon' 或者为 元字符如 '\d' 表示匹配的是数字，更多的元字符可以通过网络查询出
  4. result=re.findall('PHP',A) 
  6. if len(result) >0: # 注意这里是>0
  7.     print('got php')
  8. else:
  9.     print('no php')
  12. B= 'abc,acc,aba'
  13. # a[bc]c 两边的a和c和固定字符，中间的【bc】为元字符 表示匹配以a开头c结尾中间b或者c的字符
  14. # a[^bc]c ^为取反，匹配以a开头c结尾中间不是b和c的所有字符串
  15. # 如果是连续的a b c可以表示为 a-c
  16. r=re.findall('a[bc]c',B) # 结果为['abc', 'acc']
  17. print(r) #['abc', 'acc']

概括字符

概括字符，概括了一类的字符
\d 所有数字； \D 所有非数字
\w 包括了英文单词，数字，下划线＿ ； \W 非前者
\s 空白字符 如：＼t ＼n ＼r 空格 ； \S非前者

数量词

匹配符合要求字符的数量
[a-z]{3} 匹配a-z范围内三个字符
[a-z]{3,10} 匹配a-z范围长度为3到10个字符的字符串

  • 匹配0次或者无限多次
    + 匹配1次或者无限多次
    ？ 匹配0次或者1次
    这些针对的是符号之前的那个单词 ```python a=’pytho0python1pythonn2’

r=re.findall(‘python*’, a) print(r) #[‘pytho’, ‘python’, ‘pythonn’]

r=re.findall(‘python+’, a) print(r) #[python’, ‘pythonn’]

r=re.findall(‘python?’, a) print(r) #[‘pytho’, ‘python’, ‘python’]

  1. <br />
  2. <a name="96MTn"></a>
  3. ### 贪婪与非贪婪
  4. 正则表达式加上数量词{3,6} 之后默认为贪婪，意思是尽可能的找到范围内最大数量匹配的字符串<br />非贪婪指的是 找到最小匹配数量后就返回<br />具体的区别看下例
  5. ```python
  6. C='java python1234'
  7. r=re.findall('[a-z]{3,6}',C) 
  8. print('贪婪结果： '+str(r)) # 贪婪结果： ['java', 'python']
  10. ans=re.findall('[a-z]{3,6}?',C)
  11. print('非贪婪结果： '+str(ans)) # 非贪婪结果： ['jav', 'pyt', 'hon']

边界值

边界值
使用 ^:表示从头开始匹配 $:表示从最后开始匹配

  1. #判断一个数是不是四到六位数字
  2. C='10001'
  3. r=re.findall('^\d{4,6}$',C)
  4. print(r)

组

之前匹配正则表达式规则都是一个字符匹配，那么怎么达成多个字符匹配？就要使用到组
组是将正则表达式前需要匹配的若干个字符用小括号阔起来
与【】区分：
[] : 里面的内容表示或的关系
(): 里面表示且的关系

  1. D = 'javajavajavajava'
  2. r=re.findall('(java){3}[j]',D)
  3. print(r)# ['java']

匹配模式

re.findall(第三个参数)
表示匹配的时候的操作，例如 匹配时候忽略大小写
re.findall('java',D,re.I) # 匹配时候忽略单词的大小写， 如果有更多的匹配模式就使用" re.I | ... | ..."

正则替换

re.sub(正则表达式，匹配成功后需要替换成的字符串/匹配规则函数，匹配的原始字符串)
也可以使用更简单的方法:要操作的字符串.replace(操作的字符串中哪些字符串需要被替换掉，替换成的字符串)

  1. E= 'pythonGo'
  2. r=re.sub('Go','Java',E)
  3. print(r)
  5. r=E.replace('Go','Java')
  6. print(r)
  8. def convert(value):   #value为一个特殊对象，记录了匹配到的字符串的信息
  9.     matched=value.group() # 想要从这个对象中提取出匹配到的具体字符串需要调用group方法
  10.     return '!'+matched+'!'
  11. r=re.sub('Go',convert,E)
  12. print(r) #python!Go!

案例：字符串中数字如果大于等于6就替传成9 如果小于6就替传成0

  1. F='ABC3721D86'
  2. def convert(value):
  3.     if value >=6:
  4.         return ’9‘ # 注意！一定要返回字符或者字符串，不能返回别的类型
  5.     else:
  6.         return ’0‘ 
  7. r=resub('\d',convert,F)

match 和 search

match
从第一个位置开始匹配，如果有不匹配就直接返回none，如果匹配就返回一个match对象（描述匹配到的字符的位置）
match(匹配规则，匹配字符)
search
搜索字符串一旦找到匹配的就不匹配下去了，并且返回该匹配对象（同上）
search(匹配规则，匹配字符)

与findall的区别：
findall会有所有的匹配结果
match和search只要匹配到一个或者不匹配就直接返回，不会全部匹配到

分组

  1. group与search<br />    用于抓取某些字中间的信息
  1. F='life is short, i use python, i love python'
  2. r=re.search('life(.*)python(.*)python',F)
  3. print(r.group(0,1,2)) #('life is short, i use python, i love python', ' is short, i use ', ', i love ')
  4. #group(0)为完整匹配的字符串，group(1)为第一段匹配到的字符串，group(2)为第二段匹配的字符串