大发体育娱乐在线-大发体育娱乐官方网站-大发体育娱乐登录网址
做最好的网站

放置模块re,正则表明式4位数字

来源:http://www.dfwstonefabricators.com 作者:编程应用 人气:131 发布时间:2019-09-23
摘要:1.正则表达式,匹配字符串正则表达式是对字符串操作的一种逻辑公式.我们一般使用正则表达式对字符串镜子那个匹配和过滤,使用正则的优缺点:优点:灵活,功能性强,逻辑性强缺点:上手难

1.正则表达式,匹配字符串正则表达式是对字符串操作的一种逻辑公式.我们一般使用正则表达式对字符串镜子那个匹配和过滤,使用正则的优缺点:优点:灵活,功能性强,逻辑性强缺点:上手难.一旦上手,会爱上这个东西工具:各大文本编辑器一般都有增则匹配功能.我们也可以去:. 匹配除换行符以外的任意字符w 匹配字母数字或下划线s 匹配任意的空白符d 匹配数字n 匹配一个换行符t 匹配一个制表符b 匹配一个单词的结尾^ 匹配字符串的开始$ 匹配字符串的结尾W匹配非字母或数字或下划线D 匹配非数字S 匹配非空白符a|b 匹配字符a或字符b 匹配括号内的表达式,也表示一个组[...] 匹配字符组的字符[^...] 匹配除字符组中字符的所有字符量词:*重复零次或更多次+ 重复一次或更多次? 重复零次或一次{n}重复n次{n, }重复n次或更多次{n,m} 重复n到m次贪婪匹配和惰性匹配 贪婪匹配: .* .+ 惰性匹配: .*? 尽可能少的匹配转义: \\n => \n => n在前面添加r,原样输出分组: 使用()在python中使用正则.re <?P<name>正则> re模块是python提供的一套关于处理正则表达式的模块,核心功能有四个:findall() 查找所有,返回listfinditer() 查找返回,返回的是迭代器,search() 搜索.搜索到第一个结果返回match() 匹配.收到一个结果返回,从头开始匹配compile 编译group 获取数据re.S 干掉 .的换行# re的工作是在python中执行正则表达式import re# findresult = re.findall("d+", "baby的电话号是: 185123456789")print #['185123456789']it = re.finditer("d+", "baby123456789的电话号是: 185123456789")for el in it:print(el.group # 分组 #123456789 #185123456789search 搜索, 查找一旦匹配到结果. 直接返回, 如果匹配不到结果. 返回Noneresult = re.search("d", "宝宝的电话是111")print #<_sre.SRE_Match object; span=, match='1'>print(result.group #1匹配, 从头开始匹配. 相当于在你正则前面加了一个^result = re.match("d+", "157宝宝的电话是:")print(result.group ###157search和match的区别:search查找. 找到了结果就返回. match. 从头开始匹配.# 坑: 爬虫的一个重点# .*?result = re.finditer(r"姓名:(?P<name>.*?), 爱好:(?P<hobby>.*?),", "姓名:宝宝, 爱好:女,")for el in result:print(el.group, el.group# 正则的常用操作result = re.split("d+", "宝宝110来找你了. 你回头收拾收拾去119报道")print用正则替换s = re.sub("d+", "__sb__", "宝宝110来找你了. 你回头收拾收拾去119报道")prints = re.subn("d+", "__sb__", "宝宝110来找你了. 你回头收拾收拾去119报道") # 替换了xxx次printcode = "for i in range: print"c = compile(code, "", "exec") # 编译exec # 快速执行reg = re.compile # 编译了一段正则. 加载了一段正则lst = reg.findall("呵呵, 宝宝才不去110呢.他要去120了")printre.findall(r"d+", "呵呵, 宝宝才不去110呢.他要去120了")lst = re.findall(r"ac", "a123456c") # 把括号python中的分组变成了原来正则表达式中的分组print爬取电影天堂# 爬取电影天堂from urllib.request import urlopencontent = urlopen(" printreg = r'<div >.*?片  名(?P<name>.*?)<br />◎年  代(?P<years>.*?)<br />.*?◎上映日期(?P<date>.*?)<br />'+ '.*?◎主  演(?P<main>.*?)◎简  介.*?<td style="WORD-WRAP: break-word" bgcolor="#fdfddf"><a href="(?P<download>.*?)">'it = re.finditer(reg, content, re.S) # re.S 去掉.里面的nfor el in it:print(el.groupprint(el.groupprint(el.groupprint(el.group.replace("<br />      ", ", "))print(el.group("download"))

day4正则表达式,正则表达式4位数字

语法:

  正则表达式是处理字符串的函数,我们在Excel函数中也有很多这样的公式,因为学过一些Excel,所以看一下有什么不同的方法。

  import re       #导入re模块,处理正则表达式的模块

  p = re.compile("^[0-9]") #生成要匹配的正则对象,^代表从头开始匹配,[0-9]代表匹配0至9的任意一个数字,所以这里的意思是对传进来的字符串进行匹配,如果这个字符串的开头第一个字符是数字,就代表匹配上了

  m = p.match("12344abc")   #按上面生成的正则对象去匹配字符串,如果匹配成功,这个m就会有值,否则m为None

    pirnt(m.group())     #m.group()返回匹配上的结果,此处为1,因为匹配上的是1这个字符。

  上面的第2 和第3行也可以合并成一行来写:

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

  效果是一样的,区别在于,第一种方式是提前对要匹配的格式进行了编译(对匹配公式进行解析),这样再去匹配的时候就不用在编译匹配的格式,第2种简写是每次匹配的时候都要进行一次匹配公式的编译,所以,如果你需要从 一个5w行的文件中匹配出所有以数字开头的行,建议先把正则公式进行编译再匹配,这样速度会快点。

图片 1

字符:

    . 匹配除换行符以外的任意字符

  w 匹配字母或数字或下划线或汉字

  s 匹配任意的空白符

  d 匹配数字

  b 匹配单词的开始或结束

  ^ 匹配字符串的开始

  $ 匹配字符串的结束

次数:

  * 重复零次或更多次

  + 重复一次或更多次

  ? 重复零次或一次

  {n} 重复n次

  {n,} 重复n次或更多次

  {n,m} 重复n到m次

re模块里面的方法:

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

  def match(pattern, string, flags=0):

    # match,从起始位置开始匹配,匹配成功返回一个对象,未匹配成功返回None
    """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)

 

  match(pattern,string,flags=0)

  # pattern:正则模型

  # string:要匹配的字符串

  # falgs:匹配模式

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

  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)  

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

  def search(pattern, string, flags=0):

    # search,浏览整个字符串去匹配第一个,未匹配成功返回None
    """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)

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

  def sub(pattern, repl, string, count=0, flags=0):

    # sub,替换匹配成功的指定位置字符串
    """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是替换字符串中的元素,可以指定替换几个。

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

  # pattern:正则模型

  # repl:要替换的字符串或可执行对象

  # string:要匹配的字符串

  # count:指定匹配个数

  # flags:匹配模式

  下面实例中是将字符串中前两个数字替换为“|”,实例如下:

  >>> m = re.sub("[0-9]","|","alex1is2sb6dese8",count=2)
  >>> m
  'alex|is|sb6dese8'

  5.subn(pattern,repl,string,count=0,flags=0)

  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)

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

  def split(pattern, string, maxsplit=0, flags=0):

    # split,根据正则匹配分割字符串
    """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:正则模型

  # string:要匹配的字符串

  # maxsplit:指定分割个数

  # flags:匹配模式

  实例如下,下面的例子是以数字为分隔,把字符串进行分隔,分隔成一个列表,如下:

  >>> import re
  >>> m = re.split("[0-9]","alex1rain2jack3helen rachel8")
  >>> m
  ['alex', 'rain', 'jack', 'helen rachel', '']
  >>> m = re.split("[0-9]","alex1is2sb4heeh")
  >>> m
  ['alex', 'is', 'sb', 'heeh']

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

  def findall(pattern, string, flags=0):

    # findall,获取非重复的匹配列表;如果有一个组则以列表形式返回,且每一个匹配均是字符串;如果模型中有多个组,则以列表形式返回,且每一个匹配          是元祖;

 

# 空的匹配也会包含在结果中

    """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)是获取字符串中指定正则模型的格式,并返回一个列表,下面的例子是获取字符串中所有的数字,并返回一个列表:

  >>> m = re.findall("[0-9]","alex11rain2jack3helan rache8")
  >>> m
  ['1', '1', '2', '3', '8']                                              (1)
  >>> m = re.findall("[0-9]+","alex11rain2jack3helan rache8")
  >>> m
  ['11', '2', '3', '8']                                                   (2)

  上述代码中,(1)处如果两个数字在一起,只获取一个;在(2)处“+”是获取一个或多个。

  8.finditer(pattern,string,flags=0)

  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)

  9.compile(pattern,flags=0)

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

  10.purge()

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

  11.temlate(pattern,flags=0)

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

    12.escape(pattern)

  def escape(pattern):
    """
    Escape all the characters in pattern except ASCII letters, numbers and '_'.
    """

字符类

实例

正则式(pattern) 描述(describe)
[Pp]ython 匹配"Python"或"python"
rub[ye] 匹配"ruby"或"rube"
[aeiou] 匹配括号内任意一个字母
[0-9]  匹配任何数字。类似于[0123456789]
[a-z] 匹配任何小写字母
[A-Z] 匹配任何大写字母
[a-zA-Z0-9] 匹配任何字母及数字
[^aeiou] 匹配除了aeiou字母以外的所有字符
[^0-9] 匹配除了数字外的字符

特殊字符类

正则式(pattern) 描述(describe)
. 匹配除了"n"之外的任何单个字符。要匹配包括"n"在内的任何字符,请使用像"[.n]"的模式

d

匹配一个数字字符。等价于[0-9]
D 匹配一个非数字字符。等价于[^0-9]
s 匹配任何空白字符,包括空格,制表符,换页符。等价于[fnrtv]
S 匹配任何非空白字符。等价于[^fnrtv]
w 匹配包括下划线的任何单词字符。等价于[A-Za-z0-9_]
W 匹配任何非单词字符。等价于[^A-Za-z0-9_]

    re.match与re.search的区别:

  re.match只匹配字符串的开始,如果字符串开始不符合正则表达式,则匹配失败,函数返回None;而re.search匹配整个字符串,知道找到一个匹配。

几个常见的正则例子:

  1.匹配手机号

  phone_str = "hey my name is Jersey,and my phone number is 13651054607, please call me if you are pretty!"

  phone_str2 ``= "hey my name is alex, and my phone number is 18651054604, please call me if you are pretty!"

  m = re.search("(1)[358]d{9})",phone_str2)

  if m :

    print(m.group())

  2.匹配IPv4

  ip_addr = "inet 192.168.60.223 netmask oxfffff00 broadcast 192.168.60.255"

  m = re.search("d{1,3}.d{1,3}.d{1,3}.d{1,3}",ip_addr)

  print(m.group())

  3.分组匹配地址

  contactInfo = "Oldboy School,Beijing Changping Shahe:010-8343245"

  match = re.search(r'(w+),(w+):(S+)',contactInfo)   #分组             (方法一)

  match.group(1)

  match.group(2)

  match.group(3)

  match ``= re.search(r``'(?P<last>w+), (?P<first>w+): (?P<phone>S+)'``, contactInfo)     (方法二)

``>>> match.group('last') ``'Doe' ``>>> match.group('first') ``'John' ``>>> match.group('phone') `` '555-1212'

     4. 匹配email

   email ``= "[email protected]   http://www.oldboyedu.com"

   m ``= re.search(r``"[0-9.a-z]{0,26}@[0-9.a-z]{0,20}.[0-9a-z]{0,8}"``, email)

   print``(m.group())

    下面我们来看一个实例,定义一个正则表达式:

  import re
    #导入re模块,处理字符串的正则表达式格式
  m = re.match("abc","abcdef")
  print(m)
  m = re.match("abc","abcdef")
  print(m.group())
  m = re.match("abc","bcdef")
  print(m)

  运行结果如下:

  <_sre.SRE_Match object; span=(0, 3), match='abc'>
  abc
  None

    上面代码中,我们定义了一个正则表达式格式m,然后使用match()进行查找匹配,match()是从头开始查找,找到了就返回一个正则对象,如果查找不到则返回None.可以使用group()来查看查找到了什么内容。match()函数是从头开始

  m = re.match("[0-9]{0,10}","15d6afdgd")
  if m:
    print(m.group())

   pattern中[0-9]{0,10}是匹配数字0-9,{0,10}是匹配0到10次。

   匹配字符串中所有的数字,findall(pattern,string,flags):

     m = re.findall("[0-9]{1,10}","15d6afd2334d2dgd3")
    print(m)  

   运行结果如下:

   ['15', '6', '2334', '2', '3']

     上面代码我们匹配了字符串中的数字,返回一个列表;下面我们来匹配字符串中所有的字母:

   m = re.findall("[A-Za-z]{1,10}","15d6afd2334d2dgd3")
    print(m)

   运行如下:

   ['d', 'afd', 'd', 'dgd']

    上面代码,我们匹配了字符串中所有的字符[A-Za-z]。

   点(.)是匹配除了"n"之外的任何单个字符。要匹配包括"n"在内的任何字符,请使用像[.n].下面来看一个实例:

   m = re.findall(".","15d6afd2334d2dgd3")
    print(m)

    ['1', '5', 'd', '6', 'a', 'f', 'd', '2', '3', '3', '4', 'd', '2', 'd', 'g', 'd', '3']

  上面代码中我们使用点(.)匹配除了"n"之外任何单个字符,我们得到了单个字符的列表,因为点(.)是匹配任何单个字符。

  下面我们来使用点星(.*)来进行匹配,我们知道*是匹配任何零个或多个字符,代码如下:

  m = re.findall(".*","15d6afd2334d2dgd3")
    print(m)

  运行结果如下:

  ['15d6afd2334d2dgd3', '']

    由于点(.)是匹配的任何字符串,*星号是匹配的次数,点星(.*)的含义是匹配任何零个或多个字符串(除了"n"之外)。

  下面我们使用点加(.+)我们知道点(.)是匹配的内容,加号(+)是匹配的次数,匹配单次或多次,点加(.+)是匹配一次或多次字符串。代码如下:

  m = re.findall(".+","15d6afd2334d2dgd3")
    print(m)

  运行如下:

  ['15d6afd2334d2dgd3']

  下面我们来使用点问(.?)来看看,由于?是代表零次或者1次,看代码及运行结果:

  m = re.findall(".?","15d6afd2334d2dgd3")
    print(m)

  运行结果如下:

  ['1', '5', 'd', '6', 'a', 'f', 'd', '2', '3', '3', '4', 'd', '2', 'd', 'g', 'd', '3', '']

  问号(?)可以用在至少出现一次的情况,因为最多也就出现一次,加号(+)代表至少一次以上,星号(*)代表至少0次以上。

  ^以什么开始,$以什么结尾。

语法: 正则表达式是处理字符串的函数,我们在Excel函数中也有很多这样的公式,因为学过一些Excel,...

本文由大发体育娱乐在线发布于编程应用,转载请注明出处:放置模块re,正则表明式4位数字

关键词:

上一篇:关于逆向的一点儿小知识

下一篇:没有了

频道精选

最火资讯