初识正则表明式,Python正则表明式

图片 4
ca88会员登录中心

何以是正则表明式

正则表明式又称规则表明式
,多数编制程序语言都帮忙选用正则表明式进行字符串操作。Python中的re模块使
Python 语言具有壹切的正则表达式成效。

正则表达式是对字符串操作的一种逻辑公式,正是用事先定义好的某些一定字符、及这几个特定字符的重组,组成多个规则字符串,这个平整字符串用来抒发对字符串的1种过滤逻辑。正则表明式是一个新鲜的字符组合,用来判别字符串是不是与其格外。

举个例证:

四条腿活得 —相配— > 牛

以A开始的三个单词 —相称—> “Andy”

正则表明式 —相称— > 字符串

正则表明式是壹种用来相配字符串的无敌的器具。它的安顿性思想是用一种描述性的言语来给字符串定义三个规则,凡是符合规则的字符串,我们就以为它匹配了。

正文主要介绍Python中re模块的常用 函数。

概述

   
正则表明式是二个非同小可的字符类别,它能帮忙你方便的检讨二个字符串是还是不是与某种形式相称。

Python 自一.伍本子起扩大了re 模块,它提供 Perl 风格的正则表明式形式。re
模块使 Python 语言具备全方位的正则表明式成效。

compile
函数根据2个形式字符串和可选的标记参数生成2个正则表明式对象。该对象具有1层层措施用李林则表明式相称和替换。

re
模块也提供了与那个艺术效果完全1致的函数,那一个函数使用二个格局字符串做为它们的首先个参数。

1>概念:正则表明式是对字符串操作的1种逻辑公式,正是用事先定义好的一部分一定字符、及那些特定字符的结缘,组成八个“规则字符串”,这几个“规则字符串”用来抒发对字符串的一种过滤逻辑。正则表明式就是记录文本规则的代码。
     所以正则表明式并不是python中有意识的法力,它是一种通用的措施。python中的正则表达式库,所做的业务是接纳正则表明式来搜索文本。要选用它,你无法不会融洽用正则表明式来叙述文本规则

Python原始字符串

正则表明式使用反斜杠字符('\')来代表极度方式或同意行使特殊字符而不调用其非常意义。那与Python在字符串文字中的一样指标的采取一样。举个例子,要合营文字反斜杠,只怕必须将'\\\\'用作正则表明式字符串,因为正则表达式必须是\\,种种反斜杠必须在平时的Python字符串文字中代表为\\

消除方案是接纳Python的原始字符串符号进行正则表明式格局,在以'r'为前缀的字符串文字中,反斜杠不以任何十分的法子管理。所以r'\n'是三个富含“\”“n”的双字符串,而“\n”是富含换行符的字眼符串。

re.match函数

re.match
尝试从字符串的序幕位置相配2个方式,假诺不是发端地方匹配成功的话,match()就回去none。

函数语法

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

函数参数表达:

参数描述

pattern:相称的正则表明式

string:要同盟的字符串。

flags:标志位,用于调整正则表明式的十一分格局,如:是还是不是区分轻重缓急写,多行相称等等。

相配成功re.match方法重临2个协作的目的,不然重临None。

咱俩能够使用group(num) 或 groups() 相称对象函数来获取相配表达式。

group(num=0):十三分的全体表明式的字符串,group()
能够一遍输入多少个组号,在这种气象下它将赶回三个分包那个组所对应值的元组。

groups():归来三个涵盖全体小组字符串的元组,从 一 到 所含的小组号。

实例 1

#!/usr/bin/python

# -*- coding: UTF-8 -*-

importreprint(re.match(‘www’,’www.runoob.com’).span())#
在开局地点相配

print(re.match(‘com’,’www.runoob.com’))# 不在开端地点匹配

二>给定1个正则表明式和另3个字符串,大家能够直达如下的指标:

正则表达式的组合

  1. 习感到常字符(字符串和数字,举个例子:abc12三)
  2. 元字符(特殊字符,举个例子:. ^ $ * + ? { } [ ] | ( ) \)

re.search方法

re.search 扫描整个字符串并回到第一个成功的匹配。

函数语法:

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

函数参数说明:

参数描述

pattern:优良的正则表达式

string:要协作的字符串。

flags:标识位,用于调节正则表明式的同盟情势,如:是还是不是区分轻重缓急写,多行相配等等。

合营成功re.search方法重回3个佳人才子的靶子,不然再次来到None。

实例 1

#!/usr/bin/python

# -*- coding: UTF-8 -*-

importreprint(re.search(‘www’,’www.runoob.com’).span())#
在起始地点相称

print(re.search(‘com’,’www.runoob.com’).span())# 不在起头地方相配

上述实例运转输出结果为:

(0, 3)

(11, 14)

  一.
加以的字符串是还是不是符合正则表明式的过滤逻辑(称作“相配”);

元字符

re.match与re.search的区别

re.match只相配字符串的发端,若是字符串开始不吻合正则表明式,则优异退步,函数再次来到None;

而re.search相称整个字符串,直到找到二个同盟。

  二.
方可由此正则表明式,从字符串中获取大家想要的特定部分。

常用元字符表

模式 描述
^ 匹配字符串的开头。
$ 匹配字符串的结尾。
. 匹配任意字符,除了换行符,当re.DOTALL标记被指定时,则可以匹配包括换行符的任意字符。
[…] 用来表示一组字符,单独列出:[amg] 匹配 ‘a’,’m’或’g’。
[^…] 不在[]中的字符:[^abc]匹配除了a,b,c之外的字符。
\w 匹配字母数字及下划线。
\W 匹配非字母数字及下划线。
\s 匹配任意空白字符,等价于 [\t\n\r\f]。
\S 匹配任意非空字符。
\d 匹配任意数字,等价于 [0-9]。
\D 匹配任意非数字。
\A 匹配字符串开始。
\Z 匹配字符串结束,如果是存在换行,只匹配到换行前的结束字符串。
\z 匹配字符串结束。
\G 匹配最后匹配完成的位置。
\b 匹配一个单词边界,也就是指单词和空格间的位置。例如, ‘er\b’ 可以匹配”never” 中的 ‘er’,但不能匹配 “verb” 中的 ‘er’。
\B 匹配非单词边界。’er\B’ 能匹配 “verb” 中的 ‘er’,但不能匹配 “never” 中的 ‘er’。
\n,\t \n: 匹配一个换行符。\t 匹配一个制表符。
* 匹配0个或多个的表达式。
+ 匹配1个或多个的表达式。
? 匹配0个或1个由前面的正则表达式定义的片段,非贪婪方式。
{n} 精确匹配n个前面表达式。
{n, m} 匹配 n 到 m 次由前面的正则表达式定义的片段,贪婪方式。
a|b 匹配a或者b。
(…) 匹配括号内的表达式,也表示一个组。

找寻和替换

Python 的 re 模块提供了re.sub用于替换字符串中的相配项。

语法:

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

参数:

pattern : 正则中的方式字符串。

repl : 替换的字符串,也可为八个函数。

string : 要被寻觅替换的原始字符串。

count : 方式相称后替换的最大次数,暗许 0 表示替换全体的同盟。

实例

#!/usr/bin/python

# -*- coding: UTF-8 -*-

importrephone=”2004-959-559 # 那是叁个国外电话号码”

# 删除字符串中的 Python注释

num=re.sub(r’#.*$’,””,phone)

print”电话号码是:”,num

# 删除非数字(-)的字符串

num=re.sub(r’\D’,””,phone)print”电话号码是 :”,num

上述实例试行结果如下:

电话号码是:  200四-95玖-559

电话号码是 :  二零零一95955玖

repl 参数是一个函数

三>正则表达式的特色是:

正则表明式修饰符—可选标识位

正则表明式能够分包部分可选标记修饰符来调节特别的格局。修饰符被钦赐为七个可选的申明。多个标记可以经过按位
or(|) 它们来钦赐。如 re.I | re.M 棉被服装置成 I 和 M 标识:

修饰符 描述信息
re.A 使\w,\W,\b,\B,\d,\D,\s和\S执行仅与ASCII匹配而不是完全的Unicode匹配。这只对Unicode模式有意义,对于字节模式将被忽略。
re.DEBUG 显示有关编译表达式的调试信息。
re.I 使匹配对大小写不敏感。
re.L 做本地化识别(locale-aware)匹配。
re.M 多行匹配,影响 ^ 和 $。
re.S 使 . 匹配包括换行在内的所有字符。
re.X 该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

标明位补充解释:

  • re.I(re.IGNORECASE)

使格外对大小写不灵活;字符类和字符串相称字母时忽略大小写。比方,钦命那个标记位后,[A-Z]也足以包容小写字母。

  • re.L(re.LOCALE)

潜移默化 “w, “W, “b, 和 “B,那取决当前的本地化设置。

locales 是 C
语言库中的一项意义,是用来为急需思虑不相同语言的编制程序提供支援的。举个例子,要是您正在管理法文文本,你想用
“w+ 来同盟文字,但 “w 只相称字符类 [A-Za-z];它并不能相配 “é” 或
“ç”。假设你的系统布局适当且本地化设置为土耳其共和国(The Republic of Turkey)语,那么内部的 C 函数将告诉程序
“é” 也理应被以为是3个假名。当在编写翻译正则表明式时行使 LOCALE
标记会赢得用那么些 C 函数来拍卖 “w
後的编译对象;那会更加慢,但也会象你指望的那样能够用 “w+ 来相配法文文本。

  • re.M(re.MULTILINE)

使用 “^” 只相配字符串的开始,而 $
则只相配字符串的终极和直接在换行(假使局地话)前的字符串结尾。当钦定本标记后,
“^” 相配字符串的上马三保字符串中每行的启幕。一样的, $
元字符匹配字符串结尾和字符串中每行的结尾(直接在各种换行以前)。

  • re.S(re.DOTALL)

使 “.” 特殊字符完全协作任何字符,包含换行;未有那一个标记, “.”
相称除了换行外的任何字符。

  • re.X(re.VERBOSE)

该标识通过给予你更加灵敏的格式以便你将正则表明式写得更易于了解。当该标识被内定期,在
RE
字符串中的空白符被忽略,除非该空白符在字符类中或在反斜杠后边;那足以让您更清晰地公司和缩进re表达式。它也得以允许你将注释写入re表达式,那些注释会被引擎忽略;注释用
“#“号 来标志,可是该符号不能够在字符串或反斜杠后边。

正则表明式修饰符 – 可选标识

正则表达式能够分包部分可选标识修饰符来调整十分的格局。修饰符被钦定为一个可选的标识。四个标记能够透过按位
OCR-V(|) 它们来钦定。如 re.I | re.M 棉被服装置成 I 和 M 标识:

修饰符描述

re.I使十三分对大小写不灵敏

re.L做本地化识别(locale-aware)相称

re.M多行相称,影响 ^ 和 $

re.S使 . 相配包涵换行在内的持有字符

re.U依附Unicode字符集深入分析字符。那个标识影响 \w, \W, \b, \B.

re.X该标记通过给予你越来越灵敏的格式以便你将正则表明式写得更易于理解。

  一.
世故、逻辑性和作用性特别的强;

正则表明式实例:

实例 描述
python 匹配 “python”。
[Pp]ython 匹配 “Python” 或 “python”。
no[bd]e 匹配 “nobe” 或 “node”。
[aeiou] 匹配中括号内的任意一个字母。
[0-9] 匹配任何数字。类似于 [0123456789]。
[a-z] 匹配任何小写字母。
[A-Z] 匹配任何大写字母。
[a-zA-Z0-9] 匹配任何字母及数字。
[^aeiou] 除了aeiou字母以外的所有字符。
[^0-9] 匹配除了数字外的字符。

正则表达式格局

形式字符串使用特殊的语法来表示叁个正则表达式:

字母和数字代表他们自个儿。三个正则表明式方式中的字母和数字相称同样的字符串。

许多假名和数字前加贰个反斜杠时会具备不相同的意义。

标点符号唯有被转义时才相称自个儿,不然它们表示特别的意思。

反斜杠自个儿要求利用反斜杠转义。

由张静则表明式日常都饱含反斜杠,所以您最棒利用原始字符串来代表它们。形式成分(如
r’/t’,等价于’//t’)相称相应的特殊字符。

以下列出了正则表明式方式语法中的特殊成分。若是您选择方式的还要提供了可选的标记参数,有些情势成分的含义会更动。

^      相称字符串的启幕

$      相称字符串的最终。

.    
  
同盟任性字符,除了换行符,当re.魔兽争夺霸权LL标志被指定时,则能够兼容包涵换行符的狂妄字符。

[…]   用来代表一组字符,单独列出:[amk] 匹配 ‘a’,’m’或’k’

[^…] 不在[]中的字符:[^abc] 相称除了a,b,c之外的字符。

re*    相称0个或三个的表明式。

re+    非常三个或三个的表达式。

re?    相配0个或一个由前边的正则表明式定义的一些,非贪婪格局

re{ n}

re{ n,}    标准相配n个后边表明式。

re{ n, m}  相配 n 到 m 次由前边的正则表明式定义的片段,贪婪格局

a| b    匹配a或b

(re)    相称括号内的表达式,也意味多个组

(?imx)   正则表达式包罗三种可选标识:i, m, 或 x
。只影响括号中的区域。

(?-imx)   正则表明式关闭 i, m, 或 x 可选标识。只影响括号中的区域。

(?: re)   看似 (…), 可是不表示1个组

(?imx: re)   在括号中使用i, m, 或 x 可选标识

(?-imx: re)   在括号中不使用i, m, 或 x 可选标记

(?#…)   注释.

(?= re)   前向自然界定符。假诺所含正则表明式,以 …
表示,在脚下岗位成功相称时成功,不然战败。但若是所含表明式已经尝试,匹配引擎根本未曾进步;方式的剩下部分还要尝试界定符的左边。

(?! re)
  
前向否定界定符。与听天由命界定符相反;当所含表达式不能够在字符串当前岗位相配时成功

(?> re)  相称的独立情势,省去回溯。

\w  相配字母数字及下划线

\W  合作非字母数字及下划线

\s   匹配大四空白字符,等价于 [\t\n\r\f].

\S   特出跋扈非空字符

\d   合作大4数字,等价于 [0-9].

\D   相配大4非数字

\A   相配字符串伊始

\Z
  
相配字符串结束,假使是存在换行,只非凡到换行前的收尾字符串。c

\z    相配字符串结束

\G   分外最后相称成功的职位。

\b   极其三个单词边界,也正是指单词和空格间的职责。比方, ‘er\b’
能够相配”never” 中的 ‘er’,但不能够匹配 “verb” 中的 ‘er’。

\B  相配非单词边界。’er\B’ 能相称 “verb” 中的 ‘er’,但无法相配”never” 中的 ‘er’。

\n, \t,   等.相配二个换行符。匹配贰个制表符。等

\1…\9  优秀第n个分组的开始和结果。

\10
  
卓越第n个分组的原委,要是它经相配。不然指的是8进制字符码的表达式。

  2.
可以飞速地用极轻便的主意实现字符串的繁杂调控。

re模块常用方法

  三.
对于刚先生接触的人的话,比较猛烈难懂。

re.match

re.match() 尝试从字符串的苗子地点相配,假设起先地点不能够相配,re.match()就返回None。

语法:

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

  • pattern:相称的正则表明式
  • string:要同盟的字符串
  • flags:标识位,用于调节正则表明式的非常格局,如:是或不是区分轻重缓急写,多行相称等。

re.match主意相称成功后回去3个协作对象,不然再次回到None。

import re

s = "life is short, you need Python."
print(re.match(r'life', s))  # 从开始位置能成功匹配到
print(re.match(r'Life', s, re.I))  # 使用re.I标志位来指定忽略大小写
print(re.match(r'life', s).span())  # .span可以获取到具体匹配的起始位置
print(re.match(r'Python', s))  # 从开始位置不能成功匹配到

输出:

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

对于相称对象能够运用group(num)和groups()来收获相称表明式。

  • group(num=0):相配的整体表达式的字符串,group()
    能够一次输入八个组号,在这种景况下它将回到三个暗含这一个组所对应值的元组。

  • groups():重临一个含有全体小组字符串的元组,从 1 到 所含的小组号。

  import re

  s = "life is short, you need Python."
  ret = re.match(r'(.*) is (.*)', s)
  print("ret.group():", ret.group())
  print("ret.group(1, 2):", ret.group(1, 2))
  print("ret.group(1):", ret.group(1))
  print("ret.group(2):", ret.group(2))
  print("ret.groups():", ret.groups())

输出:

  ret.group(): life is short, you need Python.
  ret.group(1, 2): ('life', 'short, you need Python.')
  ret.group(1): life
  ret.group(2): short, you need Python.
  ret.groups(): ('life', 'short, you need Python.')

分组命名相称:

(?P<分组的名字>正则规则) 注意:是大写的P

  import re

  s = "life is short, you need Python."
  ret = re.match(r'(?P<m1>.*) is (?P<m2>.*)', s)
  print("ret.group():", ret.group())
  print("ret.group('m1'):", ret.group('m1'))  # 支持使用组名访问匹配项
  print("ret.group('m2'):", ret.group('m2'))
  print("ret.group(1, 2):", ret.group(1, 2))
  print("ret.group(1):", ret.group(1))
  print("ret.group(2):", ret.group(2))
  print("ret.groups():", ret.groups())

输出:

  ret.group(): life is short, you need Python.
  ret.group('m1'): life
  ret.group('m2'): short, you need Python.
  ret.group(1, 2): ('life', 'short, you need Python.')
  ret.group(1): life
  ret.group(2): short, you need Python.
  ret.groups(): ('life', 'short, you need Python.')

四>字符相称(普通字符,元字符):

re.search

re.search 扫描整个字符串并回到第三个成功的相称。

语法:

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

  • pattern:相称的正则表达式。
  • string:要合作的字符串。
  • flags:标记位,用于调控正则表达式的协作方式,如:是不是区分轻重缓急写,多行相称等等。

re.search()主意匹配成功后会重临三个相称的对象,不然再次来到None。

import re

s = "life is short, you need Python."
print(re.search(r'life', s))
print(re.search(r'life', s).span())
print(re.search(r'Python', s))
print(re.search(r'Python', s).span())
print(re.search(r'xxx', s))

输出:

<_sre.SRE_Match object; span=(0, 4), match='life'>
(0, 4)
<_sre.SRE_Match object; span=(24, 30), match='Python'>
(24, 30)
None

平等能够选择group(num) 或groups() 来获取相称表明式。

import re

s = "life is short, you need Python."
ret = re.search(r'(.*) is (.*)', s)
print(ret.group())
print(ret.group(1, 2))
print(ret.group(1))
print(ret.group(2))
print(ret.groups())

输出:

life is short, you need Python.
('life', 'short, you need Python.')
life
short, you need Python.
('life', 'short, you need Python.')

re.match和re.search的区别:

re.match只相配字符串的开始,假设字符串的启幕地点不相符正则表明式,则优良战败,函数重回None;而re.search极其整个字符串,直到找到2个合营,整个字符串都找不到极其才回去None。

  普通字符:大多数数字和字母的随机集结

re.split

用极度到的目标将字符串分割成列表并赶回。

语法:

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

  • pattern:相配的正则表明式。
  • string:要同盟的字符串。
  • maxsplit:方式相称后区划的最大次数,暗许 0 表示分割全体的相称。
  • flags:标识位,用于调节正则表达式的相配格局,如:是或不是区分轻重缓急写,多行相配等等。

示例1:

import re

s = "Abc123.aBc456.abC789"
ret1 = re.split(r'\.', s)  # 用.分割字符串s
ret2 = re.split(r'\.', s, 1)  # 用.分割字符串s,只分割一次
ret3 = re.split(r'[.\d]+', s)  # 用.和数字分s
print("用.分割字符串s:", ret1)
print("用.分割字符串s,只分割一次:", ret2)
print("用.和数字分s:", ret3)

输出:

用.分割字符串s: ['Abc123', 'aBc456', 'abC789']
用.分割字符串s,只分割一次: ['Abc123', 'aBc456.abC789']
用.和数字分s: ['Abc', 'aBc', 'abC', '']

注意:

当正则相称项位于字符串的伊始或最终时,re.split()赢得列表会有空成分。

  元字符:在正则表达式中兼有卓越意义的专项使用字符

re.findall

找到字符串中全体的匹配项,以列表的方式重回。

语法:

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

  • pattern:相配的正则表明式。
  • string:要同盟的字符串。
  • flags:标识位,用于调节正则表明式的合作格局,如:是不是区分轻重缓急写,多行相称等等。

示例:

import re

s = "Abc123.aBc456.abC789"
ret = re.findall(r'\d+', s)    # 找到所有的连续数字,并以列表形式返回
print("所有的数字:", ret)

输出:

所有的数字: ['123', '456', '789']

5>元字符

re.sub

re.sub用来替换字符串中的相配项。

语法:

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

  • pattern:相称的正则表明式。
  • repl:替换的字符串,也可为二个函数。
  • string:要被搜索替换的原始字符串。
  • count:情势般配后替换的最大次数,暗中认可 0 表示替换全部的相称。
  • flags:标识位,用于调整正则表明式的相称方式,如:是还是不是区分轻重缓急写,多行相称等等。

示例1:

import re

s = "life is short, you need Python.  # 人生苦短,我用Python。"

# 删除#及后面的内容(把#及后面的字符替换成空字符串)
s1 = re.sub(r'#.*$', "", s)
print("去掉注释后:", s1)

输出:

去掉注释后: life is short, you need Python.

示例2(当repl参数是三个函数时):

import re


# 将匹配的数字乘于2
def double(matched):
    num = int(matched.group("num"))  # 注意要转成int类型
    return str(num * 2)  # 将乘以2后的结果转成str类型

s = "1 + 2 = 3"
s1 = re.sub(r'(?P<num>\d+)', double, s)  # 分组命名匹配
print("re.sub替换后:", s1)

输出:

re.sub替换后: 2 + 4 = 6

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

re.compile

将正则表明式形式编写翻译为正则表明式对象,可用于选择其match()search()主意举办相配,如下所述。

re_obj = re.compile(pattern)
ret = re_obj.match(string)

等价于:

ret = re.match(pattern, string)

^         :相称字符串的开头(从字符串开首起首相配)…………放到集合中的时候表示“非”

正则表达式演练

$         : 相配字符串的尾声(从字符串的最后开首相配)

练习一

特别手提式无线电电话机号

ret = re.match(r'(1)[3578]\d{9}', s)

*         :
相配后面的子表达式零次或频仍…………po*等价于子表达式大概是p、po、poo、pooo…….

练习二

相配邮箱

ret = re.match(r'^([a-z.0-9]{1,26})@([a-z.0-9]{1,20})(.[a-z0-9]{1,8})$', s)

+      
  :相配前边的子表明式壹遍或频仍…………po+等价于子表明式恐怕是po、poo、pooo…….

练习三

匹配IP

ret = re.match(r'^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$', s)

?       
  :相配前边的子表明式零次或三回…………po?等价于子表明式只怕是p、po

|          :将俩个特别原则进行逻辑“或”运算

\          :反斜杠后边跟元字符去除其特殊功能

        反斜杠后边跟日常字符完结特殊效果

       
引用序号所对应的字组所相配的字符串…………re.search(r”(alex)(eric)com\2″,”alexericcomeric”)

\d   :相配任性1个数字字符…………约等于[0-9]

\D    :相配大41个非数字字符………约等于[^0-9]

\s   :相配大肆贰个不可见字符,包涵空格、制表符、换页符等等…………等价于[
\t\n\r\f\v]

\S   :相配任性二个凸现字符…………等价于[^ \t\n\r\f\v]

\w    :相配任性二个字母或数字或下划线或汉字…………等价于[a-zA-Z0-9_]

\W   :相配大4一个非字母或数字或下划线或汉字…………等价于[^a-zA-Z0-9_]

\b    :相称1个单词边界,也便是指单词和空格间的岗位。

\n    :相称1个换行符

\f   :匹配叁个换页符

\r     :匹配一个回车符 

[a-z]    :相称括号中所包括的任意二个字符………-代表范围

[^a-z]  :相配任何不在钦定范围内的字符…………在那之中^表示非得意思

[]   :表示三个字符集,特殊字符在字符集中会失去其独特含义(“^” 在字符聚集是非得意思
 “-”在字符集中是至的情致  “\d”  “\w”等等还保留其固有意义)

{n}     :n是三个非负整数 ,相称整数n次

{n,}    :n是1个非负整数,至少匹配n次

{n,m} :m,n均为非负整数,m>n,最少匹配n次,最多相配m次

()    
:表示分组,利用findall相配时,只输出的组里面包车型客车原委,并结合二个新组放到列表中

    
利用search和match相称时,输出全体内容,能够用group方法抽出来各类组的剧情

a=re.findall(r"(123)(asd)\1","123asd123")
b=re.findall(r"(123)(asd)(123)","123asd123")
c=re.findall(r"(123)(asd)123","123asd123")
d=re.findall(r"(123)(asd)","123asd123")
print(a)
print(b)
print(c)
print(d)
[('123', 'asd')]
[('123', 'asd', '123')]
[('123', 'asd')]
[('123', 'asd')]

 

import re
a=re.search(r"(123)(asd)\1","123asd123").group()
b=re.search(r"(123)(asd)(123)","123asd123").group()
c=re.search(r"(123)(asd)123","123asd123").group()
d=re.search(r"(123)(asd)","123asd123").group()
print(a)
print(b)
print(c)
123asd123
123asd123
123asd123
123asd

 

图片 1

陆、flags(编译标记符): 

  re.I    使特别对大小写不灵动

  re.M   多行匹配

  re.S   使.相配包含换行在内的持有字符

  re.X   正则表明式里面能够有注释
该标记通过授予你越来越灵活的格式以便你将正则表明式写得更便于通晓

 7、re模块

python中正则表达式封装在re模块中,要想利用的话不能不调用(import  re),re模块下有常用的二种艺术:

1、match(pattern, string, flags=0):

2、search(pattern, string, flags=0):

pattern:表示非常规则

string:表示字符串

flags:表示编写翻译标记位,相称格局,用于修改进则表明式的合营格局,如:是还是不是区分轻重缓急写,多行相称等等

从开头地方上马依据模型规则去字符串中卓殊钦赐内容,只可以合营单个,假如相称成功再次来到一个match
object对象,利用group方法查看,没相称到再次来到None

match  (search)  object的方法: 壹、group()
再次回到re全部协作的字符串,能够2回输入多少个组号,对应组号相配的字符串,获得相称到的有所结果(无论是不是有组)

import re
a="hello alex asd hello"
b=re.match("(h)\w+",a).group()
print(b)

hello

二、start() 再次来到相称起来的职务
叁、end() 重返相称甘休的岗位
4、span() 重返贰个元组包涵匹配 (起初,截止) 的地点

五、groups() 获取已经格外到的结果中的分组结果放到元祖中,从group结果中领取分组结果

import re
a="hello alex asd hello"
b=re.match("(h)(e)\w+",a).groups()
print(b)

('h', 'e')

6、groupdict() (?p<name>h) 给分组中的成分七个key值组成二个字典

import re
a="hello alex asd hello"
b=re.match("(?P<n1>h)(?P<n2>e)\w+",a).groupdict()    #其中P为大写
print(b)

{'n2': 'e', 'n1': 'h'}    

 3、findall(pattern, string, flags=0):          

从初叶位置上马依照模型规则去字符串中格外内定内容,能1体佳人才子,借使合作成功以列表格局重临全数相称的字符串,没相配到再次来到None

findall相配时,假若规则中是合营集合”a()b”,则只输出()中的内容、search和match不是,若是想出口全部内容,在分组内加”?:”

图片 2

import re
a="hello alex asd hello"
b=re.findall("a(?:l)ex",a)
print(b)

['alex']

 相配规则(此处是小坑)

正则中相称规则是在此以前以往极其,二个一个找,但假设相称到剧情后,继续再以后特别的时候是从上1回匹配的末尾开端再一次相称

import re
a="1a2s3d4f5"
b=re.findall("\d\w\d",a)
print(b)

['1a2', '3d4']

 相配规则(此处tmd又是3个小坑)

正则中一旦用空(””)来同盟内容时,相配到的空内容会比其尺寸多壹个人

import re
a="12345"
b=re.findall("",a)
print(b)

['', '', '', '', '', '']            #里面6个空

 相称组中组(太tm绕了)

import re
a="asd  alex  123  alex"
b=re.findall("(a)(\w(e))(x)",a)     #先提取第一个组中a,再提取第二组中le 再提取组中组e再提取组x
print(b)

[('a', 'le', 'e', 'x'), ('a', 'le', 'e', 'x')]    #从左到右,从外到内的提取

 又三个坑来了(有多少个组提取多少个内容,看表象正是看笔者问看到多少个组”()”)

import re
a="alex"
b=re.findall("(\w)(\w)(\w)(\w)",a)  #有几个组提取几个内容
c=re.findall("(\w){4}",a)        #一个组里面的内容出现四次,默认去最后一个内容
print(b)
print(c)

[('a', 'l', 'e', 'x')]
['x']

 4、sub(pattern, repl, string, max=0):

      subn(pattern, repl, string):结果能彰显到底被替换了几回

  pattern:表示卓越规则

  repl:替换对象(用什么样替换)

  string:被替换对象

  max:替换的个数

import re
re.sub("g.t","have",'I get A,  I got B ,I gut C',2)
I have A,  I have B ,I gut C

import re
print(re.subn("g.t","have",'I get A,  I got B ,I gut C'))
('I have A,  I have B ,I have C', 3)

5、compile(strPattern[, flag]):

strPattern:将字符串情势的正则表明式编写翻译为Pattern对象

flag:是相当形式,取值能够使用按位或运算符’|’表示还要生效,比方re.I |
re.M

把壹套规则利用compile方法封装在贰个指标中,再采用对象调用方法,适用于多次杰出情况

import re
text = "JGood is a handsome boy,he is cool, clever, and so on..."
regex = re.compile(r'\w*oo\w*')
print (regex.findall(text) )  #查找所有包含'oo'的单词
['JGood', 'cool']

6、split(pattern, string, maxsplit=0, flags=0):

pattern:表示非常规则

string:表示字符串

maxsplit:表示分割的位数(用多少个规则分割)

flags:表示编译标识位,用于修考订则表明式的合营方式,如:是不是区分轻重缓急写,多行匹配等等

import re
print(re.split('\d+','one12two2three3four4'))
['one', 'two', 'three', 'four', '']

import re
print(re.split('a','1A1a2a3',flags=re.I))     #如果直接写re.I 默认把其放到第三位,不能起到作用
['1', '1', '2', '3']

用正则分割出来的列表中不带有分割部分,倘若须求把拿什么分割出来的一些显得在列表中的话就需求在表达式中参与组

import re
a="asd123asd156asd"
c=re.split("(1)(\d+)",a)
print(c)

['asd', '1', '23', 'asd', '1', '56', 'asd']

 

7、finditer(pattern, string,
flags=0):

搜寻string,重返贰个梯次访问每一个一双两好结果(Match对象)的迭代器 

import re
iterator = re.finditer(r'\d+','2g3g4g5g6g')
iterator1 = re.findall(r'\d+','2g3g4g5g6g')
print(iterator)
print(iterator1)
for match in iterator:
     print(match.group(), match.span())
<callable_iterator object at 0x0000008310911128>
['2', '3', '4', '5', '6']
2 (0, 1)
3 (2, 3)
4 (4, 5)
5 (6, 7)
6 (8, 9)

八、数量词的极度享受情势与非贪婪形式

  正则表明式平常用于在文书中探寻相配的字符串。Python里多少词暗中同意是贪心的(在个别言语里也或者是暗中认可非贪婪),总是尝试相配尽可能多的字符;非贪婪的则相反,总是尝试相称尽或者少的字符。举个例子:正则表明式”ab*”倘若用于查找”abbbc”,将找到”abbb”。而一旦运用非贪婪的数额词”ab*?”,将找到”a”。但最近后都有限定标准时,非贪婪方式失效。

玖、返斜杠的苦恼

 与半数以上编制程序语言一样,正则表明式里应用”\”作为转义字符,那就恐怕造成反斜杠搅扰。倘让你须要特别文本中的字符”\”,那么使用编程语言表示的正则表达式里将供给4个反斜杠”\\\\”:前多少个和后五个分别用于在编制程序语言里转义成反斜杠,转变来四个反斜杠后再在正则表达式里转义成1个反斜杠。Python里的原生字符串很好地消除了这一个难题,这一个例子中的正则表明式能够使用r”\\”表示。同样,相称五个数字的”\\d”能够写成r”\d”。有了原生字符串,你再也不用忧虑是否漏写了反斜杠,写出来的表明式也越来越直观。

小结:

  group是match和search的主意,findall未有group方法,要是march和search相配成功,则赶回1个”Match 
object”对象,未有相配成功则赶回贰个None,只有相配成功才有group方法,否则会报错

 图片 3

假诺前后均有限制条件,则非贪婪格局失效

import re
print(re.findall(r"a(\d+)", "a23b"))   #贪婪模式
print(re.findall(r"a(\d+?)", "a23b")) # 非贪婪模式
print(re.findall(r"a(\d+?)b","a23b"))  #前后有限定条件 非贪婪模式失效
['23']
['2']
['23']

findall相配时,借使规则中是非常群集”a()b”,则只输出()中的内容、search和match不是,就算也想输出括号外的剧情在括号前边加”?:”

import re
print(re.findall(r"a(\d+)b", "a23b"))      #获取组()中的文件
print(re.search(r"a(\d+)b", "a23b").group())
print(re.match(r"a(\d+)b", "a23b").group())
['23']
a23b
a23b

import re
a=re.findall(r"(?:123)(?:asd)123","123asd123")
print(a)
['123asd123']

match和search在极度有成团()的时候,会把括号内外的字符都输出出来,而且能够通过组号来调取分歧组中的从头到尾的经过,而findall只会经过列表输出括号内的内容

import re
print(re.search(r"m(alex)(eric)com\2m","mmalexericcomericmmm").group())      #默认group中参数为0
print(re.search(r"m(alex)(eric)com\2m","mmalexericcomericmmm").group(1))    #调取第一个组的内容
print(re.search(r"m(alex)(eric)com\2m","mmalexericcomericmmm").group(2))    #调取第二个组的内容
print(re.match(r"m(alex)(eric)com\2m","malexericcomericmmm").group())       #其中\2只是代表了第二组的内容,而没有括号
print(re.match(r"m(alex)(eric)com\2m","malexericcomericmmm").group(1))
print(re.match(r"m(alex)(eric)com\2m","malexericcomericmmm").group(2))
print(re.findall(r"m(alex)(eric)com(eric)m","malexericcomericmmm"))
malexericcomericm
alex
eric
malexericcomericm
alex
eric
[('alex', 'eric', 'eric')]

图片 4 

计算器

计量表达式:a = ” 壹 – 二 * ( (60-30
+(-40.0/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) – (-4*3)/
(16-3*2) )”

图片 5图片 6

 1 import re
 2 def f1(a):
 3     a = re.sub(" ","",a)
 4     a = a.replace('--', '+').replace('++', '+').replace('-+', '-').replace('+-', '-')
 5     if "*" in a or "/" in a:
 6         while True:
 7             b = re.split("([\-]?\d+[.]?\d*[/*][\-]?\d+[.]?\d*)",a,1)
 8             if len(b) == 3:
 9                 c = re.split("([/*])",b[1])
10                 if c[1]== "*":
11                     d = float(c[0])*float(c[2])
12                     a = b[0]+str(d)+b[2]
13                 else:
14                     d = float(c[0])/float(c[2])
15                     a = b[0]+str(d)+b[2]
16             else:
17                 e = re.findall("[\-+]?\d+\.?\d*", a)
18                 sun = 0
19                 for i in e:
20                     sun = sun + float(i)
21                 return sun
22     else:
23         e = re.findall("[\-+]?\d+\.?\d*", a)
24         sun = 0
25         for i in e:
26             sun = sun + float(i)
27         return sun
28 def f2(a):
29     a = re.sub(" ", "", a)
30     if "*" in a or "/" in a:
31         while True:
32             a = a.replace('--', '+').replace('++', '+').replace('-+', '-').replace('+-', '-')
33             b = re.split("(\d+[.]?\d*[/*][\-]?\d+[.]?\d*)", a, 1)
34             if len(b) == 3:
35                 c = re.split("([/*])", b[1])
36                 if c[1] == "*":
37                     d = float(c[0]) * float(c[2])
38                     a = b[0] + str(d) + b[2]
39                 else:
40                     d = float(c[0]) / float(c[2])
41                     a = b[0] + str(d) + b[2]
42             else:
43                 e = re.findall("[\-+]?\d+\.?\d*", a)
44                 sun = 0
45                 for i in e:
46                     sun = sun + float(i)
47                 return sun
48     else:
49         e = re.findall("[\-+]?\d+\.?\d*", a)
50         sun = 0
51         for i in e:
52             sun = sun + float(i)
53         return sun
54 while True:
55     r=re.split("\(([^()]+)\)",a,1)
56     if len(r)==3:
57         m=f1(r[1])
58         a=r[0]+str(m)+r[2]
59         print(a)
60     else:
61         r=f2(a)
62         print(r)
63         break
64 print(eval(a))

View Code

 模块的调用

import  + 模块   也等于把模块中装有成效都导入进来,然后再调用  模块.方法    

form 模块  import  方法   也就是把模块中钦定的主意拿过来用

放到模块是Python自带的功效,在利用内置模块相应的作用时,须求【起首入】再【使用】

停放模块是Python自带的法力,在选择内置模块相应的机能时,要求【发轫入】再【使用】

一、sys

用于提供对Python解释器相关的操作:

sys.argv           命令行参数List,第一个元素是程序本身路径
sys.exit(n)        退出程序,正常退出时exit(0)
sys.version        获取Python解释程序的版本信息
sys.maxint         最大的Int值
sys.path           返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称
sys.stdin          输入相关
sys.stdout         输出相关
sys.stderror       错误相关

 

二、os

用以提供系统品级的操作:

os.getcwd()                 获取当前工作目录,即当前python脚本工作的目录路径
os.chdir("dirname")         改变当前脚本工作目录;相当于shell下cd
os.curdir                   返回当前目录: ('.')
os.pardir                   获取当前目录的父目录字符串名:('..')
os.makedirs('dir1/dir2')    可生成多层递归目录
os.removedirs('dirname1')   若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推
os.mkdir('dirname')         生成单级目录;相当于shell中mkdir dirname
os.rmdir('dirname')         删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname
os.listdir('dirname')       列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印
os.remove()                 删除一个文件
os.rename("oldname","new")  重命名文件/目录
os.stat('path/filename')    获取文件/目录信息
os.sep                      操作系统特定的路径分隔符,win下为"\\",Linux下为"/"
os.linesep                  当前平台使用的行终止符,win下为"\t\n",Linux下为"\n"
os.pathsep                  用于分割文件路径的字符串
os.name                     字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")   运行shell命令,直接显示
os.environ                  获取系统环境变量
os.path.abspath(path)       返回path规范化的绝对路径
os.path.split(path)         将path分割成目录和文件名二元组返回
os.path.dirname(path)       返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path)      返回path最后的文件名。如何path以/或\结尾,那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)        如果path存在,返回True;如果path不存在,返回False
os.path.isabs(path)         如果path是绝对路径,返回True
os.path.isfile(path)        如果path是一个存在的文件,返回True。否则返回False
os.path.isdir(path)         如果path是一个存在的目录,则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回,第一个绝对路径之前的参数将被忽略
os.path.getatime(path)      返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)      返回path所指向的文件或者目录的最后修改时间

三、hashlib

用以加密相关的操作,替代了md5模块和sha模块,首要提供 SHA一, SHA22四,
SHA25陆, SHA3捌肆, SHA51二 ,MD5 算法

import hashlib

# ######## md5 ########
hash = hashlib.md5()
# help(hash.update)
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
print(hash.digest())


######## sha1 ########

hash = hashlib.sha1()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

# ######## sha256 ########

hash = hashlib.sha256()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())


# ######## sha384 ########

hash = hashlib.sha384()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

# ######## sha512 ########

hash = hashlib.sha512()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图