【美高梅开户网址】正则表明式应用,re模块和正则表明式

正则表明式平日不常用,平日都以用的时候,暂时抱佛脚,查文书档案,然后就是被各个坑之后,才会日渐熟悉。

re模块

os模块是与操作系统交互的三个接口

 

在线正则表明式测试:

讲正题以前大家先来看2个例证:

 

正则表达式

  首先,大家引进了正则表明式的学识。所谓正则表明式,正是对字符串操作的一种逻辑公式,便是用事先定义好的片段特定字符、及那么些特定字符的3结合,组成2个“规则字符串”,那么些“规则字符串”用来表述对字符串的壹种过滤逻辑。

  正则表明式自身和python未有啥样关系,就是相称字符串内容的一种规则。那里给了3个十分好用的在线测试工具

  聊起正则,就只和字符串相关了。着眼于正则的时候,输入的每一个字都以三个字符串。要是在1个岗位的二个值,不会出现什么样变化,那么是不须要规则的,直接就足以合营上。在随后大家越来越多要思念的是在同2个地方上得以出现的字符的范围。

  字符组 : 形式为——[字符组]

  在同三个地方恐怕出现的各样字符组成了贰个字符组,在正则表明式中用[
]意味着字符分为很多类,比如数字、字母、标点等等。假若你以后供给多少个职位”只可以出现1个数字”,那么那一个位置上的字符只好是0、一、二…玖那11个数之一。能够用[0123456789]发挥,也能够用[0-9],后者只好从小指到大,即不得以用[9-0]的形式。

字符组
待匹配字符
匹配
结果
说明
[0123456789]
8
True
在一个字符组里枚举合法的所有字符,字符组里的任意一个字符
和"待匹配字符"相同都视为可以匹配
[0123456789]
a
False
由于字符组中没有"a"字符,所以不能匹配
 

[0-9]
 

7
True
[0-9]和[0123456789]是一个意思
 

[a-z]
 

s
 

True
 

同样的如果要匹配所有的小写字母,直接用[a-z]就可以表示
 

[A-Z]
 

B
 

True
 

[A-Z]就表示所有的大写字母
 

[0-9][a-f][A-F]
 

e
 

True
 

可以匹配数字,大小写形式的a~f,用来验证十六进制字符

 

以下是正则表达式中的全体字符及其用法:

元字符
 

匹配内容
匹配除换行符以外的任意字符
\w 匹配字母或数字或下划线或汉字
\s 匹配任意的空白符
\d 匹配数字
\n 匹配一个换行符
\t 匹配一个制表符
\b 匹配一个单词的结尾
^ 匹配字符串的开始
$ 匹配字符串的结
\W
匹配非字母或数字或下划线或汉字,即除\w能匹配的类型以外的所有类型
\D
匹配非数字,即除\d能匹配的类型以外的所有类型
\S
匹配非空白符,即除\s能匹配的类型以外的所有类型
a|b
匹配字符a或字符b
()
匹配括号内的表达式,也表示一个组
[…]
匹配字符组中的字符
[^…]
匹配除了字符组中字符的所有字符,即与[]相反
量词
用法说明
* 重复零次或更多次
+ 重复一次或更多次
? 重复零次或一次
{n} 重复n次
{n,} 重复n次或更多次
{n,m} 重复n到m次

. ^
$的用法简介

正则 待匹配字符 匹配
结果
说明
海. 海燕海东西海娇

海燕

海东

海娇

  匹配所有"海."的字符
^海. 海燕海东西海娇 海燕 只从开头匹配"海."
  海.$   海燕海东西海娇 海娇 只匹配结尾的"海.$"

 

* +
? { }的用法简介

正则 待匹配字符 匹配
结果
说明
李.? 李杰和李莲英和李二棍子

李杰
李莲
李二

 

?表示重复零次或一次,即只匹配"李"后面一个任意字符,贪婪匹配

 

李.* 李杰和李莲英和李二棍子 李杰和李莲英和李二棍子
*表示重复零次或多次,即匹配"李"后面0或多个任意字符,贪婪匹配
李.+ 李杰和李莲英和李二棍子 李杰和李莲英和李二棍子
+表示重复一次或多次,即只匹配"李"后面1个或多个任意字符,贪婪匹配
李.{1,2} 李杰和李莲英和李二棍子

李杰和
李莲英
李二棍

{1,2}匹配1到2次任意字符,贪婪匹配

 注意:前面的*,+,?等都是贪心相称,也正是尽大概相称,前面加?号使其变为惰性相称

正则 待匹配字符 匹配
结果
说明
李.*? 李杰和李莲英和李二棍子 李杰
李莲
李二
惰性匹配

 

字符集[][^]的用法简介

正则 待匹配字符 匹配
结果
说明
李[杰莲英二棍子]* 李杰和李莲英和李二棍子

李杰
李莲英
李二棍子

 

表示匹配"李"字后面[杰莲英二棍子]的字符任意次

 

李[^和]* 李杰和李莲英和李二棍子

李杰
李莲英
李二棍子

表示匹配一个不是"和"的字符任意次
[\d] 456bdha3

4
5
6
3

表示匹配任意一个数字,匹配到4个结果
[\d]+ 456bdha3

456
3

表示匹配任意个数字,匹配到2个结果

 

分组
()与 或 |[^]的用法简介

 身份证号码是二个长短为一五或十八个字符的字符串,借使是一三人则全体由数字组合,第四位无法为0;若是是二12位,则前二10个人1体是数字,倒数一位恐怕是数字或x,上面大家尝试用正则来代表:

正则 待匹配字符 匹配
结果
说明
^[1-9]\d{13,16}[0-9x]$ 110101198001017032

110101198001017032

   表示可以匹配一个正确的身份证号
^[1-9]\d{13,16}[0-9x]$ 1101011980010170

1101011980010170

表示也可以匹配这串数字,但这并不是一个正确的身份证号码,它是一个16位的数字
^[1-9]\d{14}(\d{2}[0-9x])?$ 1101011980010170

False

现在不会匹配错误的身份证号了
()表示分组,将\d{2}[0-9x]分成一组,就可以整体约束他们出现的次数为0-1次
^([1-9]\d{16}[0-9x]|[1-9]\d{14})$ 110105199812067023

110105199812067023

表示先匹配[1-9]\d{16}[0-9x]如果没有匹配上就匹配[1-9]\d{14}

 

转义符
\的用法简介

在正则表明式中,有成都百货上千有例外意义的是元字符,比如\d和\s等,若是要在正则中非凡符合规律的”\d”而不是”数字”就必要对”\”实行转义,变成’\\’。

在python中,无论是正则表达式,照旧待相称的始末,都以以字符串的情势出现的,在字符串中\也有非凡的意义,自个儿还需求转义。所以假使合作3回”\d”,字符串中要写成’\\d’,那么正则里即将写成”\\\\d”,那样就太难为了。这一年大家就用到了r’\d’这些概念,此时的正则是r’\\d’就足以了。

正则 待匹配字符 匹配
结果
说明
\d \d  False
因为在正则表达式中\是有特殊意义的字符,所以要匹配\d本身,用表达式\d无法匹配
\\d \d  True
转义\之后变成\\,即可匹配
"\\\\d" ‘\\d’  True
如果在python中,字符串中的'\'也需要转义,所以每一个字符串'\'又需要转义一次
r’\\d’ r’\d’  True
在字符串之前加r,让整个字符串不转义

 

在线JSON格式化:

那是京东的登记页面,打开页面大家就看到那几个供给输入个人新闻的唤起。
设若大家随便的在手提式有线电话机号码那①栏输入一个1111111111一,它会唤醒大家格式有误。
本条职能是怎么落到实处的啊?
假使今后你用python写壹段代码,类似:

美高梅开户网址 1

贪得无厌相配

贪心相称:在满意匹配时,相称尽只怕长的字符串,暗许景况下,采用贪婪相配

正则 待匹配字符 匹配
结果
说明
<.*>

<script>…<script>

<script>…<script>
默认为贪婪匹配模式,会匹配尽量长的字符串
<.*?> r’\d’  

<script>
<script>

加上?为将贪婪匹配模式转为非贪婪匹配模式,会匹配尽量短的字符串

注:在背后加上?后即转为非贪婪相称形式,全部相称长度都取最短

附:非贪婪情势的2个用法——  .*?x
    正是取后面任意长度的字符,直到三个x油不过生

 

 

正则表达式手册:

phone_number = input('please input your phone number : ')
'''
os.getcwd() 获取当前工作目录,即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录;相当于shell下cd
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名:('..')
os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推
os.mkdir('dirname')    生成单级目录;相当于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname
os.listdir('dirname')    列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息
os.sep    输出操作系统特定的路径分隔符,win下为"\\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符,win下为"\t\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  运行shell命令,直接显示
os.popen("bash command)  运行shell命令,获取执行结果
os.environ  获取系统环境变量

os.path

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所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小
'''

re模块下的常用方法

import re

ret = re.findall('a', 'eva egon yuan')  # 返回所有满足匹配条件的结果,放在列表里
print(ret) #结果 : ['a', 'a']

ret = re.search('a', 'eva egon yuan').group()
print(ret) #结果 : 'a'
# 函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以
# 通过调用group()方法得到匹配的字符串,如果字符串没有匹配,则返回None。

ret = re.match('a', 'abc').group()  # 同search,不过仅在字符串开始处进行匹配,如果开始没有匹配到就报错
print(ret)
#结果 : 'a'

ret = re.split('[ab]', 'abcd')  # 先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割
print(ret)  # ['', '', 'cd']

ret = re.sub('\d', 'H', 'eva3egon4yuan4', 1)#将数字替换成'H',参数1表示只替换1个
print(ret) #evaHegon4yuan4

ret = re.subn('\d', 'H', 'eva3egon4yuan4')#将数字替换成'H',返回元组(替换的结果,替换了多少次)
print(ret)#('evaHegonHyuanH', 3)

obj = re.compile('\d{3}')  #将正则表达式编译成为一个 正则表达式对象,规则要匹配的是3个数字
ret = obj.search('abc123eeee') #正则表达式对象调用search,参数为待匹配的字符串
print(ret.group())  #结果 : 123

import re
ret = re.finditer('\d', 'ds3sy4784a')   #finditer返回一个存放匹配结果的迭代器
print(ret)  # <callable_iterator object at 0x10195f940>
print(next(ret).group())  #查看第一个结果即3
print(next(ret).group())  #查看第二个结果即4
print([i.group() for i in ret])  #查看剩余的结果,以列表的形式打印,即['7', '8', '4']

 

专注:findall和split的预先级查询:

#1 findall的优先级查询:
import re

ret = re.findall('www.(sogo|baidu).com', 'www.baidu.com')
print(ret)  # ['baidu']     这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可

ret = re.findall('www.(?:sogo|baidu).com', 'www.baidu.com')
print(ret)  # ['www.baidu.com']





#2 split的优先级查询
ret=re.split("\d+","eva3egon4yuan")
print(ret) #结果 : ['eva', 'egon', 'yuan']

ret=re.split("(\d+)","eva3egon4yuan")
print(ret) #结果 : ['eva', '3', 'egon', '4', 'yuan']

#在匹配部分加上()之后所切出的结果是不同的,
#没有()的没有保留所匹配的项,但是有()的却能够保留了匹配的项,
#这个在某些需要保留匹配部分的使用过程是非常重要的。

 

 

上面举多少个练习的栗子,要求领会,为了变得更牛逼出去更加好的装逼最佳依然控制:

先来看下代码和平运动效啊

你怎么判断那几个phone_number是法定的啊?

美高梅开户网址 2

1、匹配标签

美高梅开户网址 3美高梅开户网址 4

import re


ret = re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>")
#还可以在分组中利用?<name>的形式给分组起名字
#获取的匹配结果可以直接用group('名字')拿到对应的值
print(ret.group('tag_name'))  #结果 :h1
print(ret.group())  #结果 :<h1>hello</h1>

ret = re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>")
#如果不给组起名字,也可以用\序号来找到对应的组,表示要找的内容和前面的组内容一致
#获取的匹配结果可以直接用group(序号)拿到对应的值
print(ret.group(1))
print(ret.group())  #结果 :<h1>hello</h1>

View Code

 string msg, rex;
            Match m;
            msg = "昨日总能耗0度。 (长沙市口腔医院)星期一【紫衡技术】";
            rex = @".*(昨日总?能耗)([0-9]{1,}[.]?[0-9]*)*度。 \((.*)\)(.{3}).*";
            m = Regex.Match(msg, rex);
            Console.WriteLine("0:" + m.Success);
            WriteGroupInfo(m);

            //1
            msg = @"上周总能耗28401.4度。 (沙井街道办)星期一【紫衡技术】";
             rex = @".*(上周总?能耗)([0-9]{1,}[.][0-9]*)*度。 \((.*)\)(.{3}).*";
            //昨日总能耗2582.1度。【长沙市天心区人民法院】2018 - 07 - 08【紫衡技术】
             m = Regex.Match(msg, rex);
            var r = m.Success;
            Console.WriteLine("1:"+r);
            WriteGroupInfo(m);

            //2
            rex = @".*(昨日总?能耗)([0-9]{1,}[.]?[0-9]*)*度。\【(.*)\】(\d{4}-\d{2}-\d{2}).*";
            msg= "昨日总能耗209.9度。【长沙市天心区人民检察院】2018-07-08【紫衡技术】";
            Match m1 = Regex.Match(msg, rex);
            Console.WriteLine("2:"+m1.Success);
            WriteGroupInfo(m1);

            //3
            rex = @".*(上周总?能耗)([0-9]{1,}[.]?[0-9]*)*度。 \((.*)\)(.{3}).*";
            msg = "上周总能耗10922.4度。 (深圳市地方税务局第二稽查局)星期一【紫衡技术】";
            m1 = Regex.Match(msg, rex);
            Console.WriteLine("3:"+m1.Success);
            WriteGroupInfo(m1);

            //4
            rex = @".*(上月总?能耗)([0-9]{1,}[.]?[0-9]*)*度。 \((.*)\)(.{8}).*";
            msg = "上月总能耗49276.9度。 (深圳市地方税务局第二稽查局)2018年06月【紫衡技术】";
            m1 = Regex.Match(msg, rex);
            Console.WriteLine("4:"+m1.Success);
            WriteGroupInfo(m1);

            //5
            rex = @".*(建筑名称)\:(.*),在(\d{4}-\d{2}-\d{2}).{3}([0-9]{1,}[.][0-9]*)*度。";
            msg = "建筑名称:长沙市天心区人民法院,在2018-07-08日用电2582.1度。";
            m1 = Regex.Match(msg, rex);
            Console.WriteLine("5:"+m1.Success);
            WriteGroupInfo(m1);

            //6
            rex = @"(今日能耗)\:([0-9]{1,}[.]?[0-9]*)";
            msg = "今日能耗:300【紫衡技术】";
            m1 = Regex.Match(msg, rex);
            Console.WriteLine("6:" + m1.Success);
            WriteGroupInfo(m1);

            //^【([^】]+)】异常(.+?)服务(【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)
            //*(服务【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*.+
            rex = @"^【([^】]+)】异常(.+?)服务(【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*
                 (服务【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*.+";
            msg = "【公司WNC服务监控台】异常 - 服务【Secom.Emx.SmsServer.Service】未找到或者未安装!【紫衡技术】";
            m1 = Regex.Match(msg, rex);
            Console.WriteLine("7:" + m1.Success);
            WriteGroupInfo(m1);
            Console.ReadKey();
        }

        private static void WriteGroupInfo(Match m)
        {
            var g = m.Groups;
            if (g.Count > 0)
            {
                for (var i = 0; i < g.Count; i++)
                {
                    Console.WriteLine(i+":"+g[i].Value);
                }
            }
        }
根据手机号码一共11位并且是只以13、14、15、18开头的数字这些特点,我们用python写了如下代码: 

 

二、相称整数

美高梅开户网址 5美高梅开户网址 6

import re

ret=re.findall(r"\d+","1-2*(60+(-40.35/5)-(-4*3))")
print(ret) #['1', '2', '60', '40', '35', '5', '4', '3']

ret=re.findall(r"-?\d+\.\d*|(-?\d+)","1-2*(60+(-40.35/5)-(-4*3))")
print(ret) #['1', '-2', '60', '', '5', '-4', '3']

ret.remove("")
print(ret) #['1', '-2', '60', '5', '-4', '3']

ret=re.findall(r'(-?\d+\.\d*)|-?\d+','1-2*(60+(-40.35/5)-(-4*3))')
print(ret)#['', '', '', '-40.35', '', '', '']

ret=re.findall(r'-?\d+\.\d*|-?\d+','1-2*(60+(-40.35/5)-(-4*3))')
print(ret)#['1', '-2', '60', '-40.35', '5', '-4', '3']

View Code

运维结果:

美高梅开户网址 7美高梅开户网址 8

 

3、数字相称

美高梅开户网址 9美高梅开户网址 10

1、 匹配一段文本中的每行的邮箱
      http://blog.csdn.net/make164492212/article/details/51656638

2、 匹配一段文本中的每行的时间字符串,比如:‘1990-07-12’;

   分别取出1年的12个月(^(0?[1-9]|1[0-2])$)、
   一个月的31天:^((0?[1-9])|((1|2)[0-9])|30|31)$

3、 匹配qq号。(腾讯QQ号从10000开始)  [1,9][0,9]{4,}

4、 匹配一个浮点数。       ^(-?\d+)(\.\d+)?$   或者  -?\d+\.?\d*

5、 匹配汉字。             ^[\u4e00-\u9fa5]{0,}$ 

6、 匹配出所有整数

View Code

美高梅开户网址 11

while True:
    phone_number = input('please input your phone number : ')
    if len(phone_number) == 11 \
            and phone_number.isdigit()\
            and (phone_number.startswith('13') \
            or phone_number.startswith('14') \
            or phone_number.startswith('15') \
            or phone_number.startswith('18')):
        print('是合法的手机号码')
    else:
        print('不是合法的手机号码')

 

4、爬虫练习

美高梅开户网址 12美高梅开户网址 13

import requests

import re
import json

def getPage(url):

    response=requests.get(url)
    return response.text

def parsePage(s):

    com=re.compile('<div class="item">.*?<div class="pic">.*?<em .*?>(?P<id>\d+).*?(?P<title>.*?)'
                   '.*?(?P<rating_num>.*?).*?(?P<comment_num>.*?)评价',re.S)

    ret=com.finditer(s)
    for i in ret:
        yield {
            "id":i.group("id"),
            "title":i.group("title"),
            "rating_num":i.group("rating_num"),
            "comment_num":i.group("comment_num"),
        }

def main(num):

    url='https://movie.douban.com/top250?start=%s&filter='%num
    response_html=getPage(url)
    ret=parsePage(response_html)
    print(ret)
    f=open("move_info7","a",encoding="utf8")

    for obj in ret:
        print(obj)
        data=json.dumps(obj,ensure_ascii=False)
        f.write(data+"\n")

if __name__ == '__main__':
    count=0
    for i in range(10):
        main(count)
        count+=25

View Code

 

至杨佳则的学问近年来就到那边,上面要说关于模块的学识

 


 

亟需注意的地方,待相称文字中的空格以及全角和半角字符要小心区分。

看清手机号码是否合法1

专注:os.stat(‘path/filename’)  获取文件/目录音信 的布局表明

what’s the 是模块

  2个模块正是3个带有了python定义和表明的公文,文件名就是模块名字加上.py的后缀。

但骨子里import加载的模块分为四个通用项目: 

  1采用python编写的代码(.py文件)

  二已被编译为共享库或DLL的C或C++扩大

  3 包好一组模块的包

  四行使C编写并链接到python解释器的嵌入模块

何以要运用模块?

 
 固然您退出python解释器然后重新进入,那么你之前定义的函数恐怕变量都将遗失,由此大家普通将顺序写到文件中以便永久保存下去,须求时就因而python
test.py模式去实践,此时test.py被叫做脚本script。

   
随着程序的前行,作用进一步多,为了方便管理,我们日常将次第分成3个个的公文,那样做程序的布局更清楚,方便管理。那时我们不光可以把这么些文件作为脚本去执行,还足以把她们当作模块来导入到别的的模块中,完结了效益的重复利用。

  模块的导入应该在程序的胚胎地方。格式为import +模块名

 

 

  首先大家学了re模块,re模块与正则表明式荣辱与共,关于re模块的采纳,在上文正则表明式中就有谈到,即findallsearchmatch的利用办法,那里不做赘述。

  然后大家来看望关于collection模块

储存正则表明式字符串,不可能储存到Json文件中,特殊字符会出现转义,存XML中一向不这几个题材。通过结构sql语句存款和储蓄到mysql中的时候,反斜杠\将会被一向吃掉,所以插入之前要先进行转义。

这是你的写法,现在我要展示一下我的写法:

美高梅开户网址 14美高梅开户网址 15

collection模块

  在放权数据类型(dict、list、set、tuple)的底蕴上,collections模块还提供了多少个附加的数据类型:Counter、deque、defaultdict、namedtuple和OrderedDict等

    一.namedtuple:
生成能够动用名字来做客成分内容的tuple

    贰.deque:
双端队列,能够连忙的从此外1侧追加和推出对象

    3.Counter:
计数器,首要用来计数

    4.OrderedDict:
有序字典

    5.defaultdict:
带有暗中同意值的字典

上面我们来详细介绍一下那伍种数据类型:

namedtuple:最首要用在坐标上意味着,如代表3个点照旧3个圆

from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
p.x
p.y


#表示圆
#namedtuple('名称', [属性list]):
Circle = namedtuple('Circle', ['x', 'y', 'r'])

 

deque:

  因为list是线性存款和储蓄,数据量大的时候,插入和删除作用十分低。deque是为着急速落到实处插入和删除操作的双向列表,适合用来队列和栈:

from collections import deque
q = deque(['a', 'b', 'c'])
q.append('x')
q.appendleft('y')
print(q)#['y', 'a', 'b', 'c', 'x']

注:deque除了落成list的append()和pop()“外,还协理appendleft()和popleft(),那样就足以13分急忙地往底部添加或删除成分。

 

OrderedDict:应用dict时,Key是冬辰的。在对dict做迭代时,我们不或者鲜明Key的相继。假使要保险Key的相继,能够用OrderedDict

from collections import OrderedDict
d = dict([('a', 1), ('b', 2), ('c', 3)])# dict的Key是无序的
print(d)#{'a': 1, 'c': 3, 'b': 2}

od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])# OrderedDict的Key是有序的
print(od)#OrderedDict([('a', 1), ('b', 2), ('c', 3)])

注:“OrderedDict的Key会依照插入的顺序排列,不是服从Key本人排序

 

defaultdict:使用“dict时,借使引用的Key不存在,就会抛出KeyError。假若愿意key不设有时,重临三个暗中同意值,就能够用defaultdict

from collections import defaultdict
dd=defaultdict(lambda :'N/A')#即key不存在时返回设置的默认值
dd['k1']='abc'
print(dd['k1'])#abc
print(dd['k2])#N/A

拿defaultdict举个小栗子:

美高梅开户网址 16美高梅开户网址 17

#有如下值集合 [11,22,33,44,55,66,77,88,99,90...],将所有大于 66 的值保存至字典的第一个key中,将小于 66 的值保存至第二个key的值中。
#即: {'k1': 大于66 , 'k2': 小于66}

#利用字典的解决方式:
l= [11, 22, 33,44,55,66,77,88,99,90]
my_dict = {}
for value in  l:
    if value>66:
        if my_dict.has_key('k1'):
            my_dict['k1'].append(value)
        else:
            my_dict['k1'] = [value]
    else:
        if my_dict.has_key('k2'):
            my_dict['k2'].append(value)
        else:
            my_dict['k2'] = [value]



#利用defaultdict的解决方法:
from collections import defaultdict

l= [11, 22, 33,44,55,66,77,88,99,90]

my_dict = defaultdict(list)

for value in l:
    if value>66:
        my_dict['k1'].append(value)
    else:
        my_dict['k2'].append(value)

View Code

 

【美高梅开户网址】正则表明式应用,re模块和正则表明式。Counter:Counter类的目标是用来跟踪值出现的次数。它是三个严节的容器类型,以字典的键值对情势储存,其兰月素作为key,其计数作为value。计数值能够是即兴的Interger(包括0和负数)。

c = Counter('abcdeabcdabcaba')
print c
#Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})

 

 var _TemplateReg = v.Value.TemplateReg.Replace("\\", "\\\\");

美高梅开户网址 18美高梅开户网址 19

美高梅开户网址 20

光阴模块

  在Python中,平日有那三种艺术来表示时间:时间戳(timestamp)、元组(struct_time)、格式化的年华字符串(Format
String) 

  (一)时间戳(timestamp)
:经常来说,时间戳表示的是从壹玖7零年六月2六日00:00:00开始按秒计算的偏移量。大家运营“type(time.time())”,重回的是float类型。

  (2)格式化的年华字符串(Format
String):表现方式为 ‘1997-1二-0陆’,下文子禽详细介绍

  (3)元组(struct_time)
:struct_time元组共有8个成分共七个成分:(年,月,日,时,分,秒,一年中第几周,一年中第几天和是或不是是夏令时)

注:时间戳是电脑能够识其他时间;时间字符串是人可以看懂的流年;元组则是用来操作时间的

索引(Index) 属性(Attribute) 值(Values)
0 tm_year(年) 比如2011
1 tm_mon(月) 1 – 12
2 tm_mday(日) 1 – 31
3 tm_hour(时) 0 – 23
4 tm_min(分) 0 – 59
5 tm_sec(秒) 0 – 61
6 tm_wday(weekday) 0 – 6(0表示周日)
7 tm_yday(一年中的第几天) 1 – 366
8 tm_isdst(是否是夏令时) 默认为-1
import time
#时间戳
print(time.time())#1502179789.9325476
#时间字符串,%都有对应的意思
print(time.strftime('%Y-%m-%d %X'))#2017-08-08 16:09:49
#时间元祖
print(time.localtime())#time.struct_time(tm_year=2017, tm_mon=8, tm_mday=8, tm_hour=16, tm_min=9, tm_sec=49, tm_wday=1, tm_yday=220, tm_isdst=0)

至于于大运字符串中的格式化符号,具体如下:

美高梅开户网址 21美高梅开户网址 22

%y 两位数的年份表示(00-99)
%Y 四位数的年份表示(000-9999)
%m 月份(01-12)
%d 月内中的一天(0-31)
%H 24小时制小时数(0-23)
%I 12小时制小时数(01-12)
%M 分钟数(00=59)
%S 秒(00-59)
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天(001-366)
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数(00-53)星期天为星期的开始
%w 星期(0-6),星期天为星期的开始
%W 一年中的星期数(00-53)星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身

python中时间日期格式化符号:

View Code

 

二种格式之间的转移格局如下图:

美高梅开户网址 23

具体方法如下:

#时间戳转化为结构化时间(元祖)-->time.gmtime()  time.localtime()
print(time.gmtime())#UTC时间,即格林尼治时间,与英国伦敦当地时间一致
print(time.localtime())#当地时间。例如我们现在在北京执行这个方法:与UTC时间相差8小时,UTC时间+8小时 = 北京时间
#如果括号内有参数,则输出的是参数所代表的时间
print(time.gmtime(1500000000))#time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=2, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)
print(time.localtime(1500000000))#time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)

#结构化时间(元祖)转化为时间戳-->time.mktime(结构化的时间)
print(time.mktime(time.localtime()))#1502180872.0

#结构化时间(元祖)转换为字符串时间(格式化)-->time.strftime("格式定义","结构化时间")  结构化时间参数若不传,则现实当前时间
print(time.strftime('%Y-%m-%d %X'))#2017-08-08 16:30:16
print(time.strftime("%Y-%m-%d %X",time.localtime(1500000000)))#2017-07-14 10:40:00

#字符串时间(格式化)转化为结构化时间(元祖)-->time.strptime(时间字符串,字符串对应格式)
print(time.strptime("2017-03-16","%Y-%m-%d"))#time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1)
print(time.strptime("07/24/2017","%m/%d/%Y"))#time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=205, tm_isdst=-1)

 

其余还有1种专门的转移方式,如下图:

美高梅开户网址 24

具体方法如下:

#结构化时间(元祖)转化为%a %b %d %H:%M:%S %Y串-->time.asctime(结构化时间),如果不传参数,直接返回当前时间的格式化串
print(time.asctime())#Tue Aug  8 16:47:55 2017
print(time.asctime(time.localtime(1500000000)))#Tue Aug  8 16:47:55 2017

#%a %d %d %H:%M:%S %Y串转化为结构化时间-->time.ctime(时间戳),如果不传参数,直接返回当前时间的格式化串
print(time.ctime())#Tue Aug  8 16:49:54 2017
print(time.ctime(1500000000))#Fri Jul 14 10:40:00 2017

 

在C#中\\表示\,\\\\就表示\\。

import re
phone_number = input('please input your phone number : ')
if re.match('^(13|14|15|18)[0-9]{9}$',phone_number):
        print('是合法的手机号码')
else:
        print('不是合法的手机号码')
stat 结构:

st_mode: inode 保护模式
st_ino: inode 节点号。
st_dev: inode 驻留的设备。
st_nlink: inode 的链接数。
st_uid: 所有者的用户ID。
st_gid: 所有者的组ID。
st_size: 普通文件以字节为单位的大小;包含等待某些特殊文件的数据。
st_atime: 上次访问的时间。
st_mtime: 最后一次修改的时间。
st_ctime: 由操作系统报告的"ctime"。在某些系统上(如Unix)是最新的元数据更改的时间,在其它系统上(如Windows)是创建时间(详细信息参见平台的文档)。

random模块

  random模块的效应便是任意,可任意生成整数、小数、字母,首要的运用措施是生成验证码。

import random
print(random.random())#随机生成0-1之间的小数
print(random.uniform(1,3))#随机生成1-3之间的小数
#
# 生成四个随机整数:
l = []
l.append(str(random.randint(0,9)))
l.append(str(random.randint(0,9)))
l.append(str(random.randint(0,9)))
l.append(str(random.randint(0,9)))
print(''.join(l))#随机四个数,如4041
print(l)#随机四个数组成的列表,如['4', '0', '4', '1']

print(random.randint(1000,9999))#随机生成1000-9999之间的整数,也可以视为给了四个随机整数的一种方法
print(random.randrange(1,7,2))#也可以使用步距

ret = random.choice([1,2,'b',4,'a',6])
print(ret)#随机从列表的元素中取出一个
ret = random.sample([1,2,'b',4,'a',6],3)
print(ret)#随机从列表的元素中取出三个

l = list(range(100))
random.shuffle(l)#随机打乱l中的顺序,
print(l)

random模块的三个要害应用场景是生成验证码,下边举2个板栗:

美高梅开户网址 25美高梅开户网址 26

#写一个验证码,首先要有数字,其次要有字母,一共4位,可以重复
new_num_l = list(map(str,range(10)))  #['0','1'...'9']
# alph_l = []   #用来存字母
# for i in range(65,91):#查询ascii码得到英文字母A-Z对应的数字为65-90
#     alph = chr(i)
#     alph_l.append(alph)   #['A'..'Z']
alph_l = [chr(i) for i in range(65,91)]  #列表推导式
new_num_l.extend(alph_l)
Alph_l = [chr(i) for i in range(97,124)]
new_num_l.extend(Alph_l)
# ret_l = []   #存生成的随机数字或字母
# for i in range(4):
#     ret_l.append(random.choice(new_num_l))
ret_l = [random.choice(new_num_l) for i in range(4)]
#ret_l中有4个元素
# ret = random.sample(new_num_l,4)
print(''.join(ret_l))



#高级方法:
def myrandom():
    new_num_l = list(map(str,range(10)))
    alph_l = [chr(i) for i in range(65,91)]  #列表推导式
    Alph_l = [chr(i) for i in range(97,124)]
    new_num_l.extend(alph_l)
    new_num_l.extend(Alph_l)
    ret_l = [random.choice(new_num_l) for i in range(4)]
    return ''.join(ret_l)
print(myrandom())

View Code

 

事先在四个全局变量中储存了好多数码,今后自笔者要求将其储存到数据库中。原来的代码如下:

判断手提式有线电话机号码是或不是合法二

美高梅开户网址 27

os模块

 os模块是与操作系统交互的三个接口

美高梅开户网址 28美高梅开户网址 29

os.getcwd() 获取当前工作目录,即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录;相当于shell下cd
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名:('..')
os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推
os.mkdir('dirname')    生成单级目录;相当于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname
os.listdir('dirname')    列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息
os.sep    输出操作系统特定的路径分隔符,win下为"\\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符,win下为"\t\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
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所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小

有着有关os模块的章程

在Linux和Mac平台上,该函数会原样返回path,在windows平台上会将路径中所有字符转换为小写,并将所有斜杠转换为饭斜杠。
>>> os.path.normcase('c:/windows\\system32\\')   
'c:\\windows\\system32\\'   


规范化路径,如..和/
>>> os.path.normpath('c://windows\\System32\\../Temp/')   
'c:\\windows\\Temp'   

>>> a='/Users/jieli/test1/\\\a1/\\\\aa.py/../..'
>>> print(os.path.normpath(a))
/Users/jieli/test1

os路径处理
#方式一:推荐使用
import os
#具体应用
import os,sys
possible_topdir = os.path.normpath(os.path.join(
    os.path.abspath(__file__),
    os.pardir, #上一级
    os.pardir,
    os.pardir
))
sys.path.insert(0,possible_topdir)


#方式二:不推荐使用
os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

 

 

 

美高梅开户网址 30美高梅开户网址 31

对待上边包车型地铁三种写法,此时此刻,作者要问您你喜爱哪一种办法呀?你一定照旧会说第二种,为啥吧?因为第2种不用学呀!
唯独借使明天有3个文件,笔者让您从全方位文件里相配出全部的手提式有线电话机号码。你用python给本人写个试试?
但是学了今日的技术之后,分分钟帮你化解!

stat 结构

sys模块

sys模块是与python解释器交互的叁个接口

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

 

        /// <summary>
        /// 短信模板
        /// </summary>
        #region old code
        Dictionary<string, SmsTemplate> templates = new Dictionary<string, SmsTemplate> {
            // 能耗日报模板  
            {
                "能耗提醒",
                new SmsTemplate {
                    TemplateCode = "SMS_139242133",
                    TemplateReg = @"测试短信通知",
                    TemplateParam =  new { name=string.Empty, date=string.Empty, energy=string.Empty },
                    SignName = "紫衡技术"
                }
            },
            {
                "测试",
                new SmsTemplate {
                    TemplateCode = "SMS_119091381",
                    TemplateReg = @"测试短信通知",
                    TemplateParam =  new { name=string.Empty, date=string.Empty, energy=string.Empty },
                    SignName = "紫衡技术"
                }
            },
            {
                "能耗",
                new SmsTemplate {
                    TemplateCode = "SMS_119076277",
                    TemplateReg = @"^[^(上周)|(上月)]*(能耗)值*[::]*([\d.]+).*\(([^)]+)\)(\d{4}-\d{2}-\d{2}).*$",
                    TemplateParam =  new { name=string.Empty, date=string.Empty, energy=string.Empty },
                    SignName = "能耗报告"
                }
            },
            {
                "能耗Extend",
                new SmsTemplate
                {
                    TemplateCode = "SMS_128880488",
                    TemplateReg = @"^[^(上周)|(上月)]*(能耗)值*[::]*([\d.]+).*\(([^)]+)\)(\d{4}-\d{2}-\d{2}).*$",
                    TemplateParam =  new { name=string.Empty, date=string.Empty, energy=string.Empty, extend=string.Empty},
                    SignName = "能耗报告"
                }
            },
            {
                "昨日能耗",
                new SmsTemplate {
                    TemplateCode = "SMS_139242142",
                    TemplateReg = @".*(昨日总?能耗)([0-9]{1,}[.]?[0-9]*)*度。 \((.*)\)(.{3}).*",//昨日总能耗16677.6度。 (天心区鑫远白天鹅酒店)星期一【紫衡技术】
                    TemplateParam =  new { name=string.Empty, date=string.Empty, energy=string.Empty },
                    SignName = "能耗报告"
                }
            },
             {
                "昨日能耗1",
                new SmsTemplate {
                    TemplateCode = "SMS_139242142",
                    TemplateReg = @".*(昨日总?能耗)([0-9]{1,}[.]?[0-9]*)*度。\【(.*)\】(\d{4}-\d{2}-\d{2}).*",//昨日总能耗209.9度。【长沙市天心区人民检察院】2018-07-08【紫衡技术】
                    TemplateParam =  new { name=string.Empty, date=string.Empty, energy=string.Empty },
                    SignName = "能耗报告"
                }
            },
            {
                "上周能耗",
                new SmsTemplate {
                    TemplateCode = "SMS_119081757",
                    TemplateReg = @".*(上周总?能耗)值*[::]*([\d.]+).*\(([^)]+)\)(\d{4}-\d{2}-\d{2}).*",
                    TemplateParam =  new { name=string.Empty, date=string.Empty, energy=string.Empty },
                    SignName = "能耗报告"
                }
            },
            {
                "上月能耗",
                new SmsTemplate {
                    TemplateCode = "SMS_119086386",
                    TemplateReg = @".*(上月总?能耗)值*[::]*([\d.]+).*\(([^)]+)\)(\d{4}-\d{2}-\d{2}).*",
                    TemplateParam =  new { name=string.Empty, date=string.Empty, energy=string.Empty },
                    SignName = "能耗报告"
                }
            },
            {
                "定额",
                new SmsTemplate {
                    TemplateCode = "SMS_119076277",
                    TemplateReg = @".*(定额)值*[::]*([\d.]+).*\(([^)]+)\)(\d{4}-\d{2}-\d{2}).*",
                    TemplateParam =  new { name=string.Empty, date=string.Empty, energy=string.Empty },
                    SignName = "能耗报告"
                }
            },
            {
                "基准",
                new SmsTemplate {
                    TemplateCode = "SMS_119076277",
                    TemplateReg = @".*(基准)值*[::]*([\d.]+).*\(([^)]+)\)(\d{4}-\d{2}-\d{2}).*",
                    TemplateParam =  new { name=string.Empty, date=string.Empty, energy=string.Empty },
                    SignName = "能耗报告"
                }
            },
            {
                "节能量",
                new SmsTemplate {
                    TemplateCode = "SMS_119076277",
                    TemplateReg = @".*(节能量)值*[::]*([\d.]+).*\(([^)]+)\)(\d{4}-\d{2}-\d{2}).*",
                    TemplateParam =  new { name=string.Empty, date=string.Empty, energy=string.Empty },
                    SignName = "能耗报告"
                }
            },
            {
                "优化",
                new SmsTemplate {
                    TemplateCode = "SMS_119076277",
                    TemplateReg = @".*(优化)值*[::]*([\d.]+).*\(([^)]+)\)(\d{4}-\d{2}-\d{2}).*",
                    TemplateParam =  new { name=string.Empty, date=string.Empty, energy=string.Empty },
                    SignName = "能耗报告"
                }
            },
            // 报警日报模板
            {
                "报警",
                new SmsTemplate {
                    TemplateCode = "SMS_119076278",
                    TemplateReg = @"(建筑\[)*(.+?)([\],,])*产生以下报警:(.+)(【紫衡技术】)",
                    TemplateParam =  new { name=string.Empty, date=string.Empty, alarm=string.Empty },
                    SignName = "能管系统报警"
                }
            },
            // 运维工单模板
            {
                "运维通知",
                new SmsTemplate {
                    TemplateCode = "SMS_119091206",
                    TemplateReg = "您有一条新的(.+)工单需处理【工单号[::]([^】]+).+",
                    TemplateParam =  new { type=string.Empty, code=string.Empty },
                    SignName = "运维系统"
                }
            },
            {
                "运维抢单",
                new SmsTemplate {
                    TemplateCode = "SMS_119076276",
                    TemplateReg = "您有一条新的(.+)工单(提示)*【工单号[::]([^】]+).+",
                    TemplateParam =  new { type=string.Empty, code=string.Empty },
                    SignName = "运维系统"
                }
            },
            {
                "运维派单",
                new SmsTemplate {
                    TemplateCode = "SMS_119076273",
                    TemplateReg =  "您有新的(.+)工单无人[抢|接]单【工单号[::]([^】]+).+",
                    TemplateParam =  new { type=string.Empty, code=string.Empty },
                    SignName = "运维系统"
                }
            },
            {
                "库存不足",
                new SmsTemplate {
                    TemplateCode = "SMS_119091203",
                    TemplateReg =  ".+【([^】]+)】.+库存已不足.+",
                    TemplateParam =  new { type=string.Empty, code=string.Empty },
                    SignName = "运维系统"
                }
            },
            {
                "维修签到",
                new SmsTemplate {
                    TemplateCode = "SMS_119076712",
                    TemplateReg =  ".*您有(.*)未签到【工单号:([^】]+)】.+",
                    TemplateParam =  new { type=string.Empty, code=string.Empty },
                    SignName = "运维系统"
                }
            }

            ,
            {
                "报警抢单",
                new SmsTemplate {
                    TemplateCode = "SMS_119091869",
                    TemplateReg =  "您有(.*)报警.*无人[抢|接]单【工单号[::]([^】]+).+",
                    TemplateParam =  new { type=string.Empty, code=string.Empty },
                    SignName = "运维系统"
                }
            }
            ,
            {
                "广医派工",
                new SmsTemplate {
                    TemplateCode = "SMS_135795374",
                    TemplateReg =  "您有新的(.+)工单(.+)需处理,详情请打开“智慧机电运维系统APP”查看。",
                    TemplateParam =  new { type=string.Empty, code=string.Empty },
                    SignName = "运维系统"
                }
            }
            ,
            {
                "报警签到",
                new SmsTemplate {
                    TemplateCode = "SMS_119081998",
                    TemplateReg =  "您有(.*)报警事件未现场签到【工单号[::]([^】]+).+",
                    TemplateParam =  new { type=string.Empty, code=string.Empty },
                    SignName = "运维系统"
                }
            },
            {
                "未处理完崔单",
                new SmsTemplate {
                    TemplateCode = "SMS_119076997",
                    TemplateReg =  "您有(.*)处理尚未完成【工单号[::]([^】]+).+",
                    TemplateParam =  new { type=string.Empty, code=string.Empty },
                    SignName = "运维系统"
                }
            },
            {
                "运维崔单",
                new SmsTemplate {
                    TemplateCode = "SMS_119087014",
                    TemplateReg =  "您有一条(.+)催单提示【工单号[::]([^】]+).+",
                    TemplateParam =  new { type=string.Empty, code=string.Empty },
                    SignName = "运维系统"
                }
            },
            {
                "运维工单事件",
                new SmsTemplate {
                    TemplateCode = "SMS_119091936",
                    TemplateReg =  "您有新的工单事件【工单号[::]([^】]+).+",
                    TemplateParam =  new { type=string.Empty, code=string.Empty },
                    SignName = "运维系统"
                }
            },
            {
                "MAN服务未找到异常",
                new SmsTemplate {
                    TemplateCode = "SMS_120120306",
                    TemplateReg =  "^【([^】]+)】异常(.+?)服务(【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*.+",
                    TemplateParam =  new { type=string.Empty, code=string.Empty },
                    SignName = "能管365"
                }
            }

        };
        #endregion

明天我们要读书python里的re模块和正则表明式,学会了那几个就足以帮大家化解刚刚的疑问。正则表达式不仅在python领域,在任何编制程序届都占据首要的地位。

 

系列化模块

将原先的字典、列表等内容转换到1个字符串的长河就叫做序列化

 

字符串str——通过反连串化——数据结构

 

数据结构——通过种类化——字符串str

 

美高梅开户网址 32美高梅开户网址 33

比如,我们在python代码中计算的一个数据需要给另外一段程序使用,那我们怎么给?
现在我们能想到的方法就是存在文件里,然后另一个python程序再从文件里读出来。
但是我们都知道,对于文件来说是没有字典这个概念的,所以我们只能将数据转换成字典放到文件中。
你一定会问,将字典转换成一个字符串很简单,就是str(dic)就可以办到了,为什么我们还要学习序列化模块呢?
没错序列化的过程就是从dic 变成str(dic)的过程。现在你可以通过str(dic),将一个名为dic的字典转换成一个字符串,
但是你要怎么把一个字符串转换成字典呢?
聪明的你肯定想到了eval(),如果我们将一个字符串类型的字典str_dic传给eval,就会得到一个返回的字典类型了。
eval()函数十分强大,但是eval是做什么的?e官方demo解释为:将字符串str当成有效的表达式来求值并返回计算结果。
BUT!强大的函数有代价。安全性是其最大的缺点。
想象一下,如果我们从文件中读出的不是一个数据结构,而是一句"删除文件"类似的破坏性语句,那么后果实在不堪设设想。
而使用eval就要担这个风险。
所以,我们并不推荐用eval方法来进行反序列化操作(将str转换成python中的数据结构)

注意事项

连串化的指标

一、以某种存款和储蓄格局使自定义对象持久化;

二、将对象从1个地点传递到另二个地点。

3、使程序更具维护性。

Json模块是种类化模块的一种,提供了八个职能:dumps、dump、loads、load,上边是有血有肉效能:

美高梅开户网址 34美高梅开户网址 35

#dumps和loads的用法
import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic)  #序列化:将一个字典转换成一个字符串
print(type(str_dic),str_dic)  #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
#注意,json转换完的字符串类型的字典中的字符串是由""表示的

dic2 = json.loads(str_dic)  #反序列化:将一个字符串格式的字典转换成一个字典
#注意,要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
print(type(dic2),dic2)  #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}


list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
str_dic = json.dumps(list_dic) #也可以处理嵌套的数据类型 
print(type(str_dic),str_dic) #<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
list_dic2 = json.loads(str_dic)
print(type(list_dic2),list_dic2) #<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]



#dump和load的用法
import json
f = open('json_file','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f)  #dump方法接收一个文件句柄,直接将字典转换成json字符串写入文件
f.close()

f = open('json_file')
dic2 = json.load(f)  #load方法接收一个文件句柄,直接将文件中的json字符串转换成数据结构返回
f.close()
print(type(dic2),dic2)

View Code

 

pickle模块也是类别化的一种,它与json极其相似,甚至说比json还要厉害。

    json是用于字符串 和
python数据类型间实行更换,pickle是用来python特有的类型 和
python的数据类型间展开转移

    pickle模块提供了多个效用:dumps、dump(体系化,存)、loads(反连串化,读)、load
 (不仅能够类别化字典,列表…        
能够把python中四意的数据类型类别化

注:那里大家要证美素佳儿(Friso)下,json是壹种具有的语言都能够分辨的数据结构。假使我们将2个字典大概列表种类化成了一个json存在文件里,那么java代码可能js代码也足以拿来用。不过如若大家用pickle进行种类化,其余语言就无法读懂那是哪些了。所以,假若你种类化的始末是列表或然字典,相当推荐应用json模块。但假如出于某种原因你只可以连串化别的的数据类型,而将来还会用python对那几个数目开始展览反类别化的话,那么就能够利用pickle。

那边对pickle模块的用法进行求证:

import pickle
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = pickle.dumps(dic)
print(str_dic)  #一串二进制内容

dic2 = pickle.loads(str_dic)
print(dic2)    #字典

import time
struct_time  = time.localtime(1000000000)
print(struct_time)
f = open('pickle_file','wb')
pickle.dump(struct_time,f)
f.close()

f = open('pickle_file','rb')
struct_time2 = pickle.load(f)
print(struct_time.tm_year)

 

View Code

美高梅开户网址 36美高梅开户网址 37

回去顶部

shelve模块

shelve也是python提必要大家的体系化学工业具,比pickle用起来更简Bellamy(Karicare)些。shelve只提要求大家三个open方法,是用key来访问的,使用起来和字典类似。

import shelve
f = shelve.open('shelve_file')
f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'}  #直接对文件句柄操作,就可以存入数据
f.close()

import shelve
f1 = shelve.open('shelve_file')
existing = f1['key']  #取出数据的时候也只需要直接用key获取即可,但是如果key不存在会报错
f1.close()
print(existing)

其一模块有个限制,它不支持八个应用同目前间往同七个DB举行写操作。所以当大家明白咱们的施用假如只进行读操作,大家得以让shelve通过只读格局打开DB

import shelve
f = shelve.open('shelve_file', flag='r')
existing = f['key']
f.close()
print(existing)

鉴于shelve在默许情况下是不会记录待持久化对象的其他修改的,所以大家在shelve.open()时候必要修改暗中同意参数,不然对象的修改不会保留。

import shelve
f1 = shelve.open('shelve_file')
print(f1['key'])
f1['key']['new_value'] = 'this was not here before'
f1.close()

f2 = shelve.open('shelve_file', writeback=True)
print(f2['key'])
f2['key']['new_value'] = 'this was not here before'
f2.close()

writeback格局有可取也不符合规律。优点是压缩了我们失误的可能率,并且让对象的持久化对用户越来越的透明了;但那种格局并不是持有的图景下都亟待,首先,使用writeback以往,shelf在open()的时候会增多额外的内部存款和储蓄器消耗,并且当DB在close()的时候会将缓存中的每四个对象都写入到DB,那也会带来额外的等待时间。因为shelve未有办法知道缓存中怎么着对象修改了,哪些对象未有改动,由此有所的靶子都会被写入。

 

 

自身想直接通过代码来机关将其搬迁到mysql数据库中去。

不管以后你是不是去做python开发,只要你是一个程序员就应该了解正则表达式的基本使用。如果未来你要在爬虫领域发展,你就更应该好好学习这方面的知识。
但是你要知道,re模块本质上和正则表达式没有一毛钱的关系。re模块和正则表达式的关系 类似于 time模块和时间的关系
你没有学习python之前,也不知道有一个time模块,但是你已经认识时间了 12:30就表示中午十二点半(这个时间可好,一般这会儿就该下课了)。
时间有自己的格式,年月日时分秒,12个月,365天......已经成为了一种规则。你也早就牢记于心了。time模块只不过是python提供给我们的可以方便我们操作时间的一个工具而已

sys模块

 hashlib模块

  hashlib模块的功用是提供了广泛的摘要算法,如MD5,SHA1,SHA25陆,SHA51二等等

  那么,什么是摘要算法呢?摘要算法正是能够把自由长度的数目转换为确定地点长度的字符串(常常用16进制的字符串表示)。摘要算法便是通过摘要函数f()对随意长度的多少data总结出稳定长度的摘要digest,目标是为着发现原来数据是还是不是被人篡改过,也足以用来加密文书。

  摘要算法之所以能建议数据是或不是被篡改过,就是因为摘要函数是1个单向函数,总括f(data)很简单,但由此digest反推data却很是困难。而且,对原本数据做一个bit的修改,都会招致计算出的摘要完全两样。

此地以大规模的摘要算法MD五为例,总计出3个字符串的MD5值:

import hashlib

obj = hashlib.md5()
obj.update('what is your name?')
print md5.hexdigest()

计算结果如下:
d26a53750bc40b38b65a520292f69306


#如果数据量很大,可以分块多次调用update(),最后计算的结果是一样的:
obj= hashlib.md5()
obj.update('hello,my name is jack')
obj.update('what is your name')
obj.update('nice to meet you')
obj.update('goodbye')
print md5.hexdigest()
#其结果与将所有的话合成一句话后调用摘要算法的结果完全一样

 

MD5是最普遍的摘要算法,速度高速,生成结果是定位的12捌bit字节,经常用3个三十个人的1陆进制字符串表示。另①种常见的摘要算法是SHA一,调用SHA一和调用MD5全然类似:

import hashlib

sha1 = hashlib.sha1()
sha1.update('you motherfuker ')
sha1.update('oh shit,get out of here!')
print sha1.hexdigest()

 

摘要算法的一大应用正是将文件举行加密。

  任何允许用户登录的网址都会存款和储蓄用户登录的用户名和口令。怎么样存款和储蓄用户名和口令呢?方法是存到数据库表中。若是以公开保存用户口令,假设数据库走漏,全体用户的口令就落入黑客的手里。此外,网址运营人士是能够访问数据库的,也正是能获得到全体用户的口令。正确的保留口令的艺术是不存款和储蓄用户的掌握口令,而是存款和储蓄用户口令的摘要,比如MD5。

  可是只要您的口令设置的过分简单比如‘1贰三’,‘abc’之类的,攻击者能够兑现算出那几个值的摘要,然后来开始展览比对,壹旦有用户的口令简单到被黑客猜中了,就会收到攻击。所以那正是怎么都推荐大家将密码设置的相持复杂的案由,诸如12三、88捌、破壳日之类的尽量制止。

  当然啦,为了掩护那个脑回路简单的用户的平安,网址的程序员在编码时也会对思考到这一个难点并使用相应的艺术。一般是通过对原始口令加八个复杂字符串来达成,俗称“加盐”

import hashlib

sha1 = hashlib.sha1(‘i am the salt’)#在初始位置加个东西,每个人的口令都会加上这一串,从而起到复杂化的作用,俗称‘加盐’
sha1.update('you motherfuker ')
sha1.update('oh shit,get out of here!')
print sha1.hexdigest()

  经过加盐处理的MD伍口令,只要‘盐’不被黑客知道,尽管用户输入不难口令,就很难通过MD5反推明文口令。

  然则假使有七个用户都利用了千篇一律的大致口令比如12345陆,在数据库中,将积存两条相同的MD伍值,那申明那八个用户的口令是一律的。有未有方法让动用同一口令的用户存款和储蓄分歧的MD5呢?假如1旦用户无法修改登录名,就足以因此把登录名作为Salt的一片段来测算MD5,从而完结平等口令的用户也蕴藏分化的MD伍。

 注:摘要算法不是加密算法,不可能用来加密(因为不能透过摘要反推明文),只可以用于防篡改,可是它的单向总括性情决定了足以在不存款和储蓄明文口令的状态下验证用户口令。

 

        /// <summary>
        /// 初始化数据,将原来代码中的模板配置生成并加载到数据库中
        /// </summary>
        /// <param name="templates"></param>
        /// <returns></returns>
        public int InitData(Dictionary<string, SmsTemplate> templates)
        {
            StringBuilder sb = new StringBuilder();
            sb.Append("INSERT INTO smstemplate VALUES");
            foreach(var v in templates)
            {
                var _TemplateReg = v.Value.TemplateReg.Replace("\\", "\\\\");
                sb.AppendFormat(@"('{0}','{1}','{2}','{3}','{4}'),",v.Key,v.Value.TemplateCode, _TemplateReg, JsonConvert.SerializeObject(v.Value.TemplateParam),v.Value.SignName);
            }
            string sql= sb.ToString().TrimEnd(',');
            var cmd = db.GetSqlStringCommand(sql);
            return db.ExecuteNonQuery(cmd);
        }
        /// <summary>
        /// 从数据库中加载模板配置列表
        /// </summary>
        /// <returns>模板配置列表</returns>
        public Dictionary<string, SmsTemplate> GetSmsTemplate()
        {
            Dictionary<string, SmsTemplate> dic = new Dictionary<string, SmsTemplate>();
            var sql = "SELECT `Key`,`TemplateCode`,`TemplateReg`,`TemplateParam`,`SignName` FROM smstemplate";
            try
            {
                var cmd = db.GetSqlStringCommand(sql);
                SmsTemplate item;
                string key;
                using (var reader = db.ExecuteReader(cmd))
                {
                    while (reader.Read())
                    {
                        key = reader.GetString(0);
                        item = new SmsTemplate();
                        item.TemplateCode = reader.GetString(1);
                        item.TemplateReg = reader.GetString(2);
                        item.TemplateParam = (JObject)JsonConvert.DeserializeObject(reader.GetString(3));
                        item.SignName = reader.GetString(4);
                        dic.Add(key, item);
                    }
                }
            }
            catch(Exception ex)
            {
                throw new Exception(ex.Message);
            }

            return dic;
        }

构造完成后的sql脚本:

正则表明式和re模块

sys模块是与python解释器交互的3个接口

configparser模块

该模块适用于配置文件的格式与windows
ini文件类似,能够蕴含三个或多个节(section),各个节能够有多少个参数(键=值)。

来看一个众多软件的常见文书档案格式如下:

[DEFAULT]
ServerAliveInterval = 45
Compression = yes
CompressionLevel = 9
ForwardX11 = yes

[bitbucket.org]
User = hg

[topsecret.server.com]
Port = 50022
ForwardX11 = no

接下去我们用python生成3个这么的文书档案

import configparser

config = configparser.ConfigParser()

config["DEFAULT"] = {'ServerAliveInterval': '45',
                      'Compression': 'yes',
                     'CompressionLevel': '9',
                     'ForwardX11':'yes'
                     }

config['bitbucket.org'] = {'User':'hg'}

config['topsecret.server.com'] = {'Host Port':'50022','ForwardX11':'no'}

with open('example.ini', 'w') as configfile:

   config.write(configfile)

查找文件

import configparser

config = configparser.ConfigParser()

#---------------------------查找文件内容,基于字典的形式

print(config.sections())        #  []

config.read('example.ini')

print(config.sections())        #   ['bitbucket.org', 'topsecret.server.com']

print('bytebong.com' in config) # False
print('bitbucket.org' in config) # True


print(config['bitbucket.org']["user"])  # hg

print(config['DEFAULT']['Compression']) #yes

print(config['topsecret.server.com']['ForwardX11'])  #no


print(config['bitbucket.org'])          #<Section: bitbucket.org>

for key in config['bitbucket.org']:     # 注意,有default会默认default的键
    print(key)

print(config.options('bitbucket.org'))  # 同for循环,找到'bitbucket.org'下所有键

print(config.items('bitbucket.org'))    #找到'bitbucket.org'下所有键值对

print(config.get('bitbucket.org','compression')) # yes       get方法Section下的key对应的value

增加和删除改操作

import configparser

config = configparser.ConfigParser()

config.read('example.ini')

config.add_section('yuan')



config.remove_section('bitbucket.org')
config.remove_option('topsecret.server.com',"forwardx11")


config.set('topsecret.server.com','k1','11111')
config.set('yuan','k2','22222')

config.write(open('new2.ini', "w"))

 

美高梅开户网址 38美高梅开户网址 39

正则表明式

一说规则本人早已知晓您很晕了,今后就让大家先来看有个别实际上的行使。在线测试工具 

首先你要知道的是,谈到正则,就只和字符串相关了。在我给你提供的工具中,你输入的每一个字都是一个字符串。
其次,如果在一个位置的一个值,不会出现什么变化,那么是不需要规则的。
  比如你要用"1"去匹配"1",或者用"2"去匹配"2",直接就可以匹配上。这连python的字符串操作都可以轻松做到。
那么在之后我们更多要考虑的是在同一个位置上可以出现的字符的范围。

字符组 : [字符组]
在同一个位置可能出现的各种字符组成了一个字符组,在正则表达式中用[]表示
字符分为很多类,比如数字、字母、标点等等。
假如你现在要求一个位置"只能出现一个数字",那么这个位置上的字符只能是0、1、2...9这10个数之一。
正则
待匹配字符
匹配
结果
说明
[0123456789]
8
True
在一个字符组里枚举合法的所有字符,字符组里的任意一个字符
和"待匹配字符"相同都视为可以匹配
[0123456789]
a
False
由于字符组中没有"a"字符,所以不能匹配
 

[0-9]
 

7
True
也可以用-表示范围,[0-9]就和[0123456789]是一个意思
 

[a-z]
 

s
 

True
 

同样的如果要匹配所有的小写字母,直接用[a-z]就可以表示
 

[A-Z]
 

B
 

True
 

[A-Z]就表示所有的大写字母
 

[0-9][a-f][A-F]
 

e
 

True
 

可以匹配数字,大小写形式的a~f,用来验证十六进制字符
 
sys.argv           命令行参数List,第一个元素是程序本身路径
sys.exit(n)        退出程序,正常退出时exit(0),错误退出sys.exit(1)
sys.version        获取Python解释程序的版本信息
sys.path           返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称
INSERT INTO smstemplate
VALUES
    (
        '能耗提醒',
        'SMS_139242133',
        '测试短信通知',
        '{"name":"","date":"","energy":""}',
        '紫衡技术'
    ),
    (
        '测试',
        'SMS_119091381',
        '测试短信通知',
        '{"name":"","date":"","energy":""}',
        '紫衡技术'
    ),
    (
        '能耗',
        'SMS_119076277',
        '^[^(上周)|(上月)]*(能耗)值*[::]*([\\d.]+).*\\(([^)]+)\\)(\\d{4}-\\d{2}-\\d{2}).*$',
        '{"name":"","date":"","energy":""}',
        '能耗报告'
    ),
    (
        '能耗Extend',
        'SMS_128880488',
        '^[^(上周)|(上月)]*(能耗)值*[::]*([\\d.]+).*\\(([^)]+)\\)(\\d{4}-\\d{2}-\\d{2}).*$',
        '{"name":"","date":"","energy":"","extend":""}',
        '能耗报告'
    ),
    (
        '昨日能耗',
        'SMS_139242142',
        '.*(昨日总?能耗)([0-9]{1,}[.]?[0-9]*)*度。 \\((.*)\\)(.{3}).*',
        '{"name":"","date":"","energy":""}',
        '能耗报告'
    ),
    (
        '昨日能耗1',
        'SMS_139242142',
        '.*(昨日总?能耗)([0-9]{1,}[.]?[0-9]*)*度。\\【(.*)\\】(\\d{4}-\\d{2}-\\d{2}).*',
        '{"name":"","date":"","energy":""}',
        '能耗报告'
    ),
    (
        '上周能耗',
        'SMS_119081757',
        '.*(上周总?能耗)值*[::]*([\\d.]+).*\\(([^)]+)\\)(\\d{4}-\\d{2}-\\d{2}).*',
        '{"name":"","date":"","energy":""}',
        '能耗报告'
    ),
    (
        '上月能耗',
        'SMS_119086386',
        '.*(上月总?能耗)值*[::]*([\\d.]+).*\\(([^)]+)\\)(\\d{4}-\\d{2}-\\d{2}).*',
        '{"name":"","date":"","energy":""}',
        '能耗报告'
    ),
    (
        '定额',
        'SMS_119076277',
        '.*(定额)值*[::]*([\\d.]+).*\\(([^)]+)\\)(\\d{4}-\\d{2}-\\d{2}).*',
        '{"name":"","date":"","energy":""}',
        '能耗报告'
    ),
    (
        '基准',
        'SMS_119076277',
        '.*(基准)值*[::]*([\\d.]+).*\\(([^)]+)\\)(\\d{4}-\\d{2}-\\d{2}).*',
        '{"name":"","date":"","energy":""}',
        '能耗报告'
    ),
    (
        '节能量',
        'SMS_119076277',
        '.*(节能量)值*[::]*([\\d.]+).*\\(([^)]+)\\)(\\d{4}-\\d{2}-\\d{2}).*',
        '{"name":"","date":"","energy":""}',
        '能耗报告'
    ),
    (
        '优化',
        'SMS_119076277',
        '.*(优化)值*[::]*([\\d.]+).*\\(([^)]+)\\)(\\d{4}-\\d{2}-\\d{2}).*',
        '{"name":"","date":"","energy":""}',
        '能耗报告'
    ),
    (
        '报警',
        'SMS_119076278',
        '(建筑\\[)*(.+?)([\\],,])*产生以下报警:(.+)(【紫衡技术】)',
        '{"name":"","date":"","alarm":""}',
        '能管系统报警'
    ),
    (
        '运维通知',
        'SMS_119091206',
        '您有一条新的(.+)工单需处理【工单号[::]([^】]+).+',
        '{"type":"","code":""}',
        '运维系统'
    ),
    (
        '运维抢单',
        'SMS_119076276',
        '您有一条新的(.+)工单(提示)*【工单号[::]([^】]+).+',
        '{"type":"","code":""}',
        '运维系统'
    ),
    (
        '运维派单',
        'SMS_119076273',
        '您有新的(.+)工单无人[抢|接]单【工单号[::]([^】]+).+',
        '{"type":"","code":""}',
        '运维系统'
    ),
    (
        '库存不足',
        'SMS_119091203',
        '.+【([^】]+)】.+库存已不足.+',
        '{"type":"","code":""}',
        '运维系统'
    ),
    (
        '维修签到',
        'SMS_119076712',
        '.*您有(.*)未签到【工单号:([^】]+)】.+',
        '{"type":"","code":""}',
        '运维系统'
    ),
    (
        '报警抢单',
        'SMS_119091869',
        '您有(.*)报警.*无人[抢|接]单【工单号[::]([^】]+).+',
        '{"type":"","code":""}',
        '运维系统'
    ),
    (
        '广医派工',
        'SMS_135795374',
        '您有新的(.+)工单(.+)需处理,详情请打开“智慧机电运维系统APP”查看。',
        '{"type":"","code":""}',
        '运维系统'
    ),
    (
        '报警签到',
        'SMS_119081998',
        '您有(.*)报警事件未现场签到【工单号[::]([^】]+).+',
        '{"type":"","code":""}',
        '运维系统'
    ),
    (
        '未处理完崔单',
        'SMS_119076997',
        '您有(.*)处理尚未完成【工单号[::]([^】]+).+',
        '{"type":"","code":""}',
        '运维系统'
    ),
    (
        '运维崔单',
        'SMS_119087014',
        '您有一条(.+)催单提示【工单号[::]([^】]+).+',
        '{"type":"","code":""}',
        '运维系统'
    ),
    (
        '运维工单事件',
        'SMS_119091936',
        '您有新的工单事件【工单号[::]([^】]+).+',
        '{"type":"","code":""}',
        '运维系统'
    ),
    (
        'MAN服务未找到异常',
        'SMS_120120306',
        '^【([^】]+)】异常(.+?)服务(【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*(服务【([^】]+)】未找到或者未安装!)*.+',
        '{"type":"","code":""}',
        '能管365'
    )

字符:

 

元字符
 

匹配内容
匹配除换行符以外的任意字符
\w 匹配字母或数字或下划线
\s 匹配任意的空白符
\d 匹配数字
\n 匹配一个换行符
\t 匹配一个制表符
\b 匹配一个单词的结尾
^ 匹配字符串的开始
$ 匹配字符串的结尾
\W
匹配非字母或数字或下划线
\D
匹配非数字
\S
匹配非空白符
a|b
匹配字符a或字符b
()
匹配括号内的表达式,也表示一个组
[…]
匹配字符组中的字符
[^…]
匹配除了字符组中字符的所有字符

 

美高梅开户网址 40美高梅开户网址 41

View Code

量词:

量词
用法说明
* 重复零次或更多次
+ 重复一次或更多次
? 重复零次或一次
{n} 重复n次
{n,} 重复n次或更多次
{n,m} 重复n到m次

 

import sys
try:
    sys.exit(1)
except SystemExit as e:
    print(e)
JsonConvert.SerializeObject(v.Value.TemplateParam),把原来的对象进行序列化。
之前一直用的在线正则表达式匹配http://tool.oschina.net/regex/,不过发现不方便,于是我自己写了一个小工具。

源码下载:https://github.com/zouyujie/RegexTool
吐槽:阿里云的短信平台,短信模板中的单个变量长度不超过20个字符,而且还不支持组合变量,变量之间要用文字或者字符隔开,这样一来,假设我有需要发出去的变量文字是超过20个字符的,就不得不拆开,中间还要用字符或者汉字拆开,那么这样的话,客户收到的短信岂不是很奇葩,活生生的一些连续的描述文字被拆开了。
记录以备忘。

. ^ $

正则 待匹配字符 匹配
结果
说明
海. 海燕海娇海东 海燕海娇海东   匹配所有"海."的字符
^海. 海燕海娇海东 海燕 只从开头匹配"海."
  海.$   海燕海娇海东 海东 只匹配结尾的"海.$"

 

万分处理和status

* + ? { }

正则 待匹配字符 匹配
结果
说明
李.? 李杰和李莲英和李二棍子

李杰
李莲
李二

 

?表示重复零次或一次,即只匹配"李"后面一个任意字符

 

李.* 李杰和李莲英和李二棍子 李杰和李莲英和李二棍子
*表示重复零次或多次,即匹配"李"后面0或多个任意字符
李.+ 李杰和李莲英和李二棍子 李杰和李莲英和李二棍子
+表示重复一次或多次,即只匹配"李"后面1个或多个任意字符
李.{1,2} 李杰和李莲英和李二棍子

李杰和
李莲英
李二棍

{1,2}匹配1到2次任意字符

 注意:前面的*,+,?等都以贪心相称,也正是不择手段相称,后边加?号使其变为惰性相配

正则 待匹配字符 匹配
结果
说明
李.*? 李杰和李莲英和李二棍子

惰性匹配

 

 

字符集[][^]

正则 待匹配字符 匹配
结果
说明
李[杰莲英二棍子]* 李杰和李莲英和李二棍子

李杰
李莲英
李二棍子

 

表示匹配"李"字后面[杰莲英二棍子]的字符任意次

 

李[^和]* 李杰和李莲英和李二棍子

李杰
李莲英
李二棍子

表示匹配一个不是"和"的字符任意次
[\d] 456bdha3

4
5
6
3

表示匹配任意一个数字,匹配到4个结果
[\d]+ 456bdha3

456
3

表示匹配任意个数字,匹配到2个结果

 

回来顶部

分组 ()与 或 |[^]

 身份证编号是一个长短为一5或1玖个字符的字符串,固然是16人则整个️数字组合,第3位不可能为0;假若是二十一人,则前壹七位一体是数字,倒数一位或许是数字或x,下边大家品尝用正则来表示:

正则 待匹配字符 匹配
结果
说明
^[1-9]\d{13,16}[0-9x]$ 110101198001017032

110101198001017032

   表示可以匹配一个正确的身份证号
^[1-9]\d{13,16}[0-9x]$ 1101011980010170

1101011980010170

表示也可以匹配这串数字,但这并不是一个正确的身份证号码,它是一个16位的数字
^[1-9]\d{14}(\d{2}[0-9x])?$ 1101011980010170

False

现在不会匹配错误的身份证号了
()表示分组,将\d{2}[0-9x]分成一组,就可以整体约束他们出现的次数为0-1次
^([1-9]\d{16}[0-9x]|[1-9]\d{14})$ 110105199812067023

110105199812067023

表示先匹配[1-9]\d{16}[0-9x]如果没有匹配上就匹配[1-9]\d{14}

 

系列化模块

转义符 \

美高梅开户网址 ,在正则表明式中,有成都百货上千有特有含义的是元字符,比如\d和\s等,尽管要在正则中相称平常的”\d”而不是”数字”就须求对”\”进行转义,变成’\\’。

在python中,无论是正则表明式,照旧待相称的情节,都是以字符串的花样出现的,在字符串中\也有特有的含义,本人还亟需转义。所以假若合营一回”\d”,字符串中要写成’\\d’,那么正则里即将写成”\\\\d”,那样就太费事了。这一年我们就用到了r’\d’这么些定义,此时的正则是r’\\d’就能够了。

正则 待匹配字符 匹配
结果
说明
\d \d  False
因为在正则表达式中\是有特殊意义的字符,所以要匹配\d本身,用表达式\d无法匹配
\\d \d  True
转义\之后变成\\,即可匹配
"\\\\d" ‘\\d’  True
如果在python中,字符串中的'\'也需要转义,所以每一个字符串'\'又需要转义一次
r’\\d’ r’\d’  True
在字符串之前加r,让整个字符串不转义

 

 

野心勃勃相称

贪心不足相配:在满足相称时,相配尽可能长的字符串,默许景况下,选用贪婪相配

正则 待匹配字符 匹配
结果
说明
<.*>

<script>…<script>

<script>…<script>
默认为贪婪匹配模式,会匹配尽量长的字符串
<.*?> r’\d’  

<script>
<script>

加上?为将贪婪匹配模式转为非贪婪匹配模式,会匹配尽量短的字符串

什么样叫种类化——将本来的字典、列表等内容转换到三个字符串的经过就称为序列化

多少个常用的非贪婪匹配Pattern

*? 重复任意次,但尽可能少重复
+? 重复1次或更多次,但尽可能少重复
?? 重复0次或1次,但尽可能少重复
{n,m}? 重复n到m次,但尽可能少重复
{n,}? 重复n次以上,但尽可能少重复

美高梅开户网址 42美高梅开户网址 43

.*?的用法

美高梅开户网址 44

. 是任意字符
* 是取 0 至 无限长度
? 是非贪婪模式。
何在一起就是 取尽量少的任意字符,一般不会这么单独写,他大多用在:
.*?x

就是取前面任意长度的字符,直到一个x出现

美高梅开户网址 45

美高梅开户网址 46

re模块下的常用方法

 

美高梅开户网址 47

import re

ret = re.findall('a', 'eva egon yuan')  # 返回所有满足匹配条件的结果,放在列表里
print(ret) #结果 : ['a', 'a']

ret = re.search('a', 'eva egon yuan').group()
print(ret) #结果 : 'a'
# 函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以
# 通过调用group()方法得到匹配的字符串,如果字符串没有匹配,则返回None。

ret = re.match('a', 'abc').group()  # 同search,不过尽在字符串开始处进行匹配
print(ret)
#结果 : 'a'

ret = re.split('[ab]', 'abcd')  # 先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割
print(ret)  # ['', '', 'cd']

ret = re.sub('\d', 'H', 'eva3egon4yuan4', 1)#将数字替换成'H',参数1表示只替换1个
print(ret) #evaHegon4yuan4

ret = re.subn('\d', 'H', 'eva3egon4yuan4')#将数字替换成'H',返回元组(替换的结果,替换了多少次)
print(ret)

obj = re.compile('\d{3}')  #将正则表达式编译成为一个 正则表达式对象,规则要匹配的是3个数字
ret = obj.search('abc123eeee') #正则表达式对象调用search,参数为待匹配的字符串
print(ret.group())  #结果 : 123

import re
ret = re.finditer('\d', 'ds3sy4784a')   #finditer返回一个存放匹配结果的迭代器
print(ret)  # <callable_iterator object at 0x10195f940>
print(next(ret).group())  #查看第一个结果
print(next(ret).group())  #查看第二个结果
print([i.group() for i in ret])  #查看剩余的左右结果

美高梅开户网址 48

 

比如,我们在python代码中计算的一个数据需要给另外一段程序使用,那我们怎么给?
现在我们能想到的方法就是存在文件里,然后另一个python程序再从文件里读出来。
但是我们都知道,对于文件来说是没有字典这个概念的,所以我们只能将数据转换成字典放到文件中。
你一定会问,将字典转换成一个字符串很简单,就是str(dic)就可以办到了,为什么我们还要学习序列化模块呢?
没错序列化的过程就是从dic 变成str(dic)的过程。现在你可以通过str(dic),将一个名为dic的字典转换成一个字符串,
但是你要怎么把一个字符串转换成字典呢?
聪明的你肯定想到了eval(),如果我们将一个字符串类型的字典str_dic传给eval,就会得到一个返回的字典类型了。
eval()函数十分强大,但是eval是做什么的?e官方demo解释为:将字符串str当成有效的表达式来求值并返回计算结果。
BUT!强大的函数有代价。安全性是其最大的缺点。
想象一下,如果我们从文件中读出的不是一个数据结构,而是一句"删除文件"类似的破坏性语句,那么后果实在不堪设设想。
而使用eval就要担这个风险。
所以,我们并不推荐用eval方法来进行反序列化操作(将str转换成python中的数据结构)

【python】正则表明式-group和group的界别

正则表明式中,group()用来建议分组截获的字符串,()用来分组

1
2
3
4
5
6
7
8
 
import re
= "123abc456"
print re.search("([0-9]*)([a-z]*)([0-9]*)",a).group()   #123abc456
print re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(0)  #123abc456
print re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(1)  #123
print re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(2)  #abc
print re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(3)  #456
print re.search("([0-9]*)([a-z]*)([0-9]*)",a).groups()  #('123', 'abc', '456')

  上边正则表明式中的3组括号把相称结果分成三组

  •  group() 同group(0)就是匹配正则表明式全部结果
  •  group(一) 列出第一个括号相称部分,group(二)
    列出第3个括号相配部分,group(三) 列出第七个括号般配部分。
  • groups()是把全部相称出来的分组参日元组中
 1
2
3
4
5
 
import re
= "123abc456"
print re.search("[0-9]*[a-z]*[0-9]*",a).group()   #123abc456
print re.search("[0-9]*[a-z]*[0-9]*",a).group(0)  #123abc456
print re.search("[0-9]*[a-z]*[0-9]*",a).groups()  #()

 当然正则表明式中尚无括号分组,group(一)和groups肯定不对了。

 

注意:

美高梅开户网址 49

一 findall的先行级查询:

美高梅开户网址 50

import re

ret = re.findall('www.(baidu|oldboy).com', 'www.oldboy.com')
print(ret)  # ['oldboy']     这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可

ret = re.findall('www.(?:baidu|oldboy).com', 'www.oldboy.com')
print(ret)  # ['www.oldboy.com']

美高梅开户网址 51

 

干什么要有种类化模块

2 split的先期级查询

美高梅开户网址 52

ret=re.split("\d+","eva3egon4yuan")
print(ret) #结果 : ['eva', 'egon', 'yuan']

ret=re.split("(\d+)","eva3egon4yuan")
print(ret) #结果 : ['eva', '3', 'egon', '4', 'yuan']

#在匹配部分加上()之后所切出的结果是不同的,
#没有()的没有保留所匹配的项,但是有()的却能够保留了匹配的项,
#这个在某些需要保留匹配部分的使用过程是非常重要的。

美高梅开户网址 53

 

连串化的指标

练习

一、以某种存款和储蓄情势使自定义对象持久化;

一、相配标签

美高梅开户网址 54美高梅开户网址 55

import re


ret = re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>")
#还可以在分组中利用?<name>的形式给分组起名字
#获取的匹配结果可以直接用group('名字')拿到对应的值
print(ret.group('tag_name'))  #结果 :h1
print(ret.group())  #结果 :<h1>hello</h1>

ret = re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>")
#如果不给组起名字,也可以用\序号来找到对应的组,表示要找的内容和前面的组内容一致
#获取的匹配结果可以直接用group(序号)拿到对应的值
print(ret.group(1))
print(ret.group())  #结果 :<h1>hello</h1>

View Code

 

二、将目的从二个地点传递到另3个地方。

二、相称整数

美高梅开户网址 56美高梅开户网址 57

import re

ret=re.findall(r"\d+","1-2*(60+(-40.35/5)-(-4*3))")
print(ret) #['1', '2', '60', '40', '35', '5', '4', '3']
ret=re.findall(r"-?\d+\.\d*|(-?\d+)","1-2*(60+(-40.35/5)-(-4*3))")
print(ret) #['1', '-2', '60', '', '5', '-4', '3']
ret.remove("")
print(ret) #['1', '-2', '60', '5', '-4', '3']

View Code

 

3、使程序更具维护性。

三、数字相配

美高梅开户网址 58美高梅开户网址 59

1、 匹配一段文本中的每行的邮箱
      http://blog.csdn.net/make164492212/article/details/51656638

2、 匹配一段文本中的每行的时间字符串,比如:‘1990-07-12’;

   分别取出1年的12个月(^(0?[1-9]|1[0-2])$)、
   一个月的31天:^((0?[1-9])|((1|2)[0-9])|30|31)$

3、 匹配qq号。(腾讯QQ号从10000开始)  [1,9][0,9]{4,}

4、 匹配一个浮点数。       ^(-?\d+)(\.\d+)?$   或者  -?\d+\.?\d*

5、 匹配汉字。             ^[\u4e00-\u9fa5]{0,}$ 

6、 匹配出所有整数

View Code

 

美高梅开户网址 60

四、爬虫练习

美高梅开户网址 61美高梅开户网址 62

import requests

import re
import json

def getPage(url):

    response=requests.get(url)
    return response.text

def parsePage(s):

    com=re.compile('<div class="item">.*?<div class="pic">.*?<em .*?>(?P<id>\d+).*?(?P<title>.*?)'
                   '.*?(?P<rating_num>.*?).*?(?P<comment_num>.*?)评价',re.S)

    ret=com.finditer(s)
    for i in ret:
        yield {
            "id":i.group("id"),
            "title":i.group("title"),
            "rating_num":i.group("rating_num"),
            "comment_num":i.group("comment_num"),
        }

def main(num):

    url='https://movie.douban.com/top250?start=%s&filter='%num
    response_html=getPage(url)
    ret=parsePage(response_html)
    print(ret)
    f=open("move_info7","a",encoding="utf8")

    for obj in ret:
        print(obj)
        data=json.dumps(obj,ensure_ascii=False)
        f.write(data+"\n")

if __name__ == '__main__':
    count=0
    for i in range(10):
        main(count)
        count+=25

View Code

 

 

json

Json模块提供了多少个效能:dumps、dump、loads、load

美高梅开户网址 63美高梅开户网址 64

美高梅开户网址 65

import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic)  #序列化:将一个字典转换成一个字符串
print(type(str_dic),str_dic)  #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
#注意,json转换完的字符串类型的字典中的字符串是由""表示的

dic2 = json.loads(str_dic)  #反序列化:将一个字符串格式的字典转换成一个字典
#注意,要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
print(type(dic2),dic2)  #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}


list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
str_dic = json.dumps(list_dic) #也可以处理嵌套的数据类型 
print(type(str_dic),str_dic) #<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
list_dic2 = json.loads(str_dic)
print(type(list_dic2),list_dic2) #<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]

美高梅开户网址 66

loads和dumps

美高梅开户网址 67美高梅开户网址 68

美高梅开户网址 69

import json
f = open('json_file','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f)  #dump方法接收一个文件句柄,直接将字典转换成json字符串写入文件
f.close()

f = open('json_file')
dic2 = json.load(f)  #load方法接收一个文件句柄,直接将文件中的json字符串转换成数据结构返回
f.close()
print(type(dic2),dic2)

美高梅开户网址 70

load和dump

美高梅开户网址 71美高梅开户网址 72

美高梅开户网址 73

import json
f = open('file','w')
json.dump({'国籍':'中国'},f)
ret = json.dumps({'国籍':'中国'})
f.write(ret+'\n')
json.dump({'国籍':'美国'},f,ensure_ascii=False)
ret = json.dumps({'国籍':'美国'},ensure_ascii=False)
f.write(ret+'\n')
f.close()

美高梅开户网址 74

ensure_ascii关键字参数

 

pickle

 

json & pickle 模块

 

用来系列化的五个模块

 

  • json,用于字符串 和 python数据类型间开始展览转换
  • pickle,用于python特有的类型 和 python的数据类型间实行转换

 

pickle模块提供了五个职能:dumps、dump(种类化,存)、loads(反体系化,读)、load
 (不仅能够连串化字典,列表…能够把python中随心所欲的数据类型种类化

 

美高梅开户网址 75美高梅开户网址 76

美高梅开户网址 77

import pickle
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = pickle.dumps(dic)
print(str_dic)  #一串二进制内容

dic2 = pickle.loads(str_dic)
print(dic2)    #字典

import time
struct_time  = time.localtime(1000000000)
print(struct_time)
f = open('pickle_file','wb')
pickle.dump(struct_time,f)
f.close()

f = open('pickle_file','rb')
struct_time2 = pickle.load(f)
print(struct_time2.tm_year)

美高梅开户网址 78

pickle

 

那会儿机智的您又要说了,既然pickle如此强大,为何还要学json呢?
此间大家要证实一下,json是一种具有的语言都得以识其余数据结构。
比方大家将二个字典或然种类化成了3个json存在文件里,那么java代码恐怕js代码也能够拿来用。
而是就算我们用pickle实行系列化,其余语言就无法读懂这是何许了~
因此,假设你体系化的剧情是列表或然字典,大家那几个推荐您接纳json模块
但若是由于某种原因你不得不体系化其余的数据类型,如今后你还会用python对这一个数目开始展览反种类化的话,那么就能够利用pickle

shelve

shelve也是python提供给我们的体系化学工业具,比pickle用起来更简便壹些。
shelve只提供给大家1个open方法,是用key来访问的,使用起来和字典类似。

美高梅开户网址 79美高梅开户网址 80

美高梅开户网址 81

import shelve
f = shelve.open('shelve_file')
f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'}  #直接对文件句柄操作,就可以存入数据
f.close()

import shelve
f1 = shelve.open('shelve_file')
existing = f1['key']  #取出数据的时候也只需要直接用key获取即可,但是如果key不存在会报错
f1.close()
print(existing)

美高梅开户网址 82

shelve

其一模块有个限制,它不帮忙多个使用同近年来间往同多少个DB进行写操作。所以当我们精晓大家的选用要是只举办读操作,我们能够让shelve通过只读形式打开DB

美高梅开户网址 83美高梅开户网址 84

import shelve
f = shelve.open('shelve_file', flag='r')
existing = f['key']
f.close()
print(existing)

shelve只读

鉴于shelve在默许情形下是不会记录待持久化对象的别的修改的,所以大家在shelve.open()时候须求修改私下认可参数,不然对象的修改不会保留。

美高梅开户网址 85美高梅开户网址 86

美高梅开户网址 87

import shelve
f1 = shelve.open('shelve_file')
print(f1['key'])
f1['key']['new_value'] = 'this was not here before'
f1.close()

f2 = shelve.open('shelve_file', writeback=True)
print(f2['key'])
f2['key']['new_value'] = 'this was not here before'
f2.close()

美高梅开户网址 88

设置writeback

writeback情势有帮助和益处也有弱点。优点是削减了我们失误的可能率,并且让对象的持久化对用户越来越的晶莹了;但这种办法并不是具有的情景下都急需,首先,使用writeback今后,shelf在open()的时候会增多额外的内部存款和储蓄器消耗,并且当DB在close()的时候会将缓存中的每二个指标都写入到DB,那也会推动杰出的等候时间。因为shelve未有艺术知道缓存中如何对象修改了,哪些对象未有改动,因而具有的对象都会被写入。

 

归来顶部

re模块

讲正题在此以前我们先来看3个事例:

那是京东的挂号页面,打开页面大家就观看那些须求输入个人音信的晋升。
比方大家随便的在手提式有线电话机号码那一栏输入八个1111111111一,它会提示大家格式有误。
其1功用是怎么落实的呢?
借使以往你用python写一段代码,类似:

phone_number = input('please input your phone number : ')

你怎么判断那么些phone_number是官方的吗?

根据手机号码一共11位并且是只以13、14、15、18开头的数字这些特点,我们用python写了如下代码:

美高梅开户网址 89美高梅开户网址 90

美高梅开户网址 91

while True:
    phone_number = input('please input your phone number : ')
    if len(phone_number) == 11 \
            and phone_number.isdigit()\
            and (phone_number.startswith('13') \
            or phone_number.startswith('14') \
            or phone_number.startswith('15') \
            or phone_number.startswith('18')):
        print('是合法的手机号码')
    else:
        print('不是合法的手机号码')

美高梅开户网址 92

认清手提式有线电话机号码是还是不是合法一

这是你的写法,现在我要展示一下我的写法:

美高梅开户网址 93美高梅开户网址 94

import re
phone_number = input('please input your phone number : ')
if re.match('^(13|14|15|18)[0-9]{9}$',phone_number):
        print('是合法的手机号码')
else:
        print('不是合法的手机号码')

判断手提式有线电话机号码是不是合法二

相比较上边的三种写法,此时此刻,小编要问你你喜爱哪一种办法呀?你肯定依然会说第叁种,为啥吗?因为第2种不用学呀!
不过即便今后有三个文本,笔者让您从总体文件里相称出全体的手提式有线话机号码。你用python给本身写个试试?
只是学了前些天的技术之后,分分钟帮你化解!

前几天大家要读书python里的re模块和正则表明式,学会了那个就足以帮大家化解刚刚的疑团。正则表明式不仅在python领域,在全部编制程序届都占据主要的地方。

美高梅开户网址 95美高梅开户网址 96

美高梅开户网址 97

不管以后你是不是去做python开发,只要你是一个程序员就应该了解正则表达式的基本使用。如果未来你要在爬虫领域发展,你就更应该好好学习这方面的知识。
但是你要知道,re模块本质上和正则表达式没有一毛钱的关系。re模块和正则表达式的关系 类似于 time模块和时间的关系
你没有学习python之前,也不知道有一个time模块,但是你已经认识时间了 12:30就表示中午十二点半(这个时间可好,一般这会儿就该下课了)。
时间有自己的格式,年月日时分秒,12个月,365天......已经成为了一种规则。你也早就牢记于心了。time模块只不过是python提供给我们的可以方便我们操作时间的一个工具而已

美高梅开户网址 98

正则表明式和re模块

正则表达式本人也和python未有怎么关系,便是匹配字符串内容的一种规则

官方定义:正则表达式是对字符串操作的一种逻辑公式,就是用事先定义好的一些特定字符、及这些特定字符的组合,组成一个“规则字符串”,这个“规则字符串”用来表达对字符串的一种过滤逻辑。

正则表明式

一说规则自身早已知道您很晕了,以往就让大家先来看1些实际上的利用。在线测试工具 

首先你要知道的是,谈到正则,就只和字符串相关了。在我给你提供的工具中,你输入的每一个字都是一个字符串。
其次,如果在一个位置的一个值,不会出现什么变化,那么是不需要规则的。
  比如你要用"1"去匹配"1",或者用"2"去匹配"2",直接就可以匹配上。这连python的字符串操作都可以轻松做到。
那么在之后我们更多要考虑的是在同一个位置上可以出现的字符的范围。

美高梅开户网址 99美高梅开户网址 100

字符组 : [字符组]
在同一个位置可能出现的各种字符组成了一个字符组,在正则表达式中用[]表示
字符分为很多类,比如数字、字母、标点等等。
假如你现在要求一个位置"只能出现一个数字",那么这个位置上的字符只能是0、1、2...9这10个数之一。

字符组

正则
待匹配字符
匹配
结果
说明
[0123456789]
8
True
在一个字符组里枚举合法的所有字符,字符组里的任意一个字符
和"待匹配字符"相同都视为可以匹配
[0123456789]
a
False
由于字符组中没有"a"字符,所以不能匹配
 

[0-9]
 

7
True
也可以用-表示范围,[0-9]就和[0123456789]是一个意思
 

[a-z]
 

s
 

True
 

同样的如果要匹配所有的小写字母,直接用[a-z]就可以表示
 

[A-Z]
 

B
 

True
 

[A-Z]就表示所有的大写字母
 

[0-9a-fA-F]
 

e
 

True
 

可以匹配数字,大小写形式的a~f,用来验证十六进制字符

字符:

 

元字符
 

匹配内容
匹配除换行符以外的任意字符
\w 匹配字母或数字或下划线
\s 匹配任意的空白符
\d 匹配数字
\n 匹配一个换行符
\t 匹配一个制表符
\b 匹配一个单词的结尾
^ 匹配字符串的开始
$ 匹配字符串的结尾
\W
匹配非字母或数字或下划线
\D
匹配非数字
\S
匹配非空白符
a|b
匹配字符a或字符b
()
匹配括号内的表达式,也表示一个组
[…]
匹配字符组中的字符
[^…]
匹配除了字符组中字符的所有字符

 

量词:

量词
用法说明
* 重复零次或更多次
+ 重复一次或更多次
? 重复零次或一次
{n} 重复n次
{n,} 重复n次或更多次
{n,m} 重复n到m次

 

. ^ $

正则 待匹配字符 匹配
结果
说明
海. 海燕海娇海东 海燕海娇海东   匹配所有"海."的字符
^海. 海燕海娇海东 海燕 只从开头匹配"海."
  海.$   海燕海娇海东 海东 只匹配结尾的"海.$"

 

* + ? { }

正则 待匹配字符 匹配
结果
说明
李.? 李杰和李莲英和李二棍子

李杰
李莲
李二

 

?表示重复零次或一次,即只匹配"李"后面一个任意字符

 

李.* 李杰和李莲英和李二棍子 李杰和李莲英和李二棍子
*表示重复零次或多次,即匹配"李"后面0或多个任意字符
李.+ 李杰和李莲英和李二棍子 李杰和李莲英和李二棍子
+表示重复一次或多次,即只匹配"李"后面1个或多个任意字符
李.{1,2} 李杰和李莲英和李二棍子

李杰和
李莲英
李二棍

{1,2}匹配1到2次任意字符

 注意:前面的*,+,?等都以名缰利锁相配,相当于不择手段相称,前边加?号使其成为惰性相配

正则 待匹配字符 匹配
结果
说明
李.*? 李杰和李莲英和李二棍子

惰性匹配

 

字符集[][^]

正则 待匹配字符 匹配
结果
说明
李[杰莲英二棍子]* 李杰和李莲英和李二棍子

李杰
李莲英
李二棍子

 

表示匹配"李"字后面[杰莲英二棍子]的字符任意次

 

李[^和]* 李杰和李莲英和李二棍子

李杰
李莲英
李二棍子

表示匹配一个不是"和"的字符任意次
[\d] 456bdha3

4
5
6
3

表示匹配任意一个数字,匹配到4个结果
[\d]+ 456bdha3

456
3

表示匹配任意个数字,匹配到2个结果

 

分组 ()与 或 |[^]

 身份证编号是2个尺寸为一五或二十个字符的字符串,若是是十九个人则全体️数字组成,第二人不能为0;假如是二12个人,则前15位一体是数字,最后一位或者是数字或x,下边大家尝试用正则来代表:

正则 待匹配字符 匹配
结果
说明
^[1-9]\d{13,16}[0-9x]$ 110101198001017032

110101198001017032

   表示可以匹配一个正确的身份证号
^[1-9]\d{13,16}[0-9x]$ 1101011980010170

1101011980010170

表示也可以匹配这串数字,但这并不是一个正确的身份证号码,它是一个16位的数字
^[1-9]\d{14}(\d{2}[0-9x])?$ 1101011980010170

False

现在不会匹配错误的身份证号了
()表示分组,将\d{2}[0-9x]分成一组,就可以整体约束他们出现的次数为0-1次
^([1-9]\d{16}[0-9x]|[1-9]\d{14})$ 110105199812067023

110105199812067023

表示先匹配[1-9]\d{16}[0-9x]如果没有匹配上就匹配[1-9]\d{14}

 

转义符 \

在正则表明式中,有诸多有万分含义的是元字符,比如\d和\s等,假使要在正则中相称符合规律的”\d”而不是”数字”就要求对”\”举行转义,变成’\\’。

在python中,无论是正则表明式,还是待相配的始末,都以以字符串的款型现身的,在字符串中\也有异样的意义,本身还要求转义。所以尽管同盟贰回”\d”,字符串中要写成’\\d’,那么正则里即将写成”\\\\d”,那样就太难为了。那一年大家就用到了r’\d’这么些定义,此时的正则是r’\\d’就能够了。

正则 待匹配字符 匹配
结果
说明
\d \d  False
因为在正则表达式中\是有特殊意义的字符,所以要匹配\d本身,用表达式\d无法匹配
\\d \d  True
转义\之后变成\\,即可匹配
"\\\\d" ‘\\d’  True
如果在python中,字符串中的'\'也需要转义,所以每一个字符串'\'又需要转义一次
r’\\d’ r’\d’  True
在字符串之前加r,让整个字符串不转义

 

贪欲相配

贪得无厌匹配:在满足相称时,相配尽可能长的字符串,私下认可景况下,选取贪婪相称

正则 待匹配字符 匹配
结果
说明
<.*>

<script>…<script>

<script>…<script>
默认为贪婪匹配模式,会匹配尽量长的字符串
<.*?> r’\d’  

<script>
<script>

加上?为将贪婪匹配模式转为非贪婪匹配模式,会匹配尽量短的字符串
几个常用的非贪婪匹配Pattern

*? 重复任意次,但尽可能少重复
+? 重复1次或更多次,但尽可能少重复
?? 重复0次或1次,但尽可能少重复
{n,m}? 重复n到m次,但尽可能少重复
{n,}? 重复n次以上,但尽可能少重复

.*?的用法

美高梅开户网址 101

. 是任意字符
* 是取 0 至 无限长度
? 是非贪婪模式。
何在一起就是 取尽量少的任意字符,一般不会这么单独写,他大多用在:
.*?x

就是取前面任意长度的字符,直到一个x出现

美高梅开户网址 102

re模块下的常用方法

 

美高梅开户网址 103

import re

ret = re.findall('a', 'eva egon yuan')  # 返回所有满足匹配条件的结果,放在列表里
print(ret) #结果 : ['a', 'a']

ret = re.search('a', 'eva egon yuan').group()
print(ret) #结果 : 'a'
# 函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以
# 通过调用group()方法得到匹配的字符串,如果字符串没有匹配,则返回None。

ret = re.match('a', 'abc').group()  # 同search,不过尽在字符串开始处进行匹配
print(ret)
#结果 : 'a'

ret = re.split('[ab]', 'abcd')  # 先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割
print(ret)  # ['', '', 'cd']

ret = re.sub('\d', 'H', 'eva3egon4yuan4', 1)#将数字替换成'H',参数1表示只替换1个
print(ret) #evaHegon4yuan4

ret = re.subn('\d', 'H', 'eva3egon4yuan4')#将数字替换成'H',返回元组(替换的结果,替换了多少次)
print(ret)

obj = re.compile('\d{3}')  #将正则表达式编译成为一个 正则表达式对象,规则要匹配的是3个数字
ret = obj.search('abc123eeee') #正则表达式对象调用search,参数为待匹配的字符串
print(ret.group())  #结果 : 123

import re
ret = re.finditer('\d', 'ds3sy4784a')   #finditer返回一个存放匹配结果的迭代器
print(ret)  # <callable_iterator object at 0x10195f940>
print(next(ret).group())  #查看第一个结果
print(next(ret).group())  #查看第二个结果
print([i.group() for i in ret])  #查看剩余的左右结果

美高梅开户网址 104

注意:

一 findall的事先级查询:

美高梅开户网址 105

import re

ret = re.findall('www.(baidu|oldboy).com', 'www.oldboy.com')
print(ret)  # ['oldboy']     这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可

ret = re.findall('www.(?:baidu|oldboy).com', 'www.oldboy.com')
print(ret)  # ['www.oldboy.com']

美高梅开户网址 106

 

二 split的预先级查询

美高梅开户网址 107

ret=re.split("\d+","eva3egon4yuan")
print(ret) #结果 : ['eva', 'egon', 'yuan']

ret=re.split("(\d+)","eva3egon4yuan")
print(ret) #结果 : ['eva', '3', 'egon', '4', 'yuan']

#在匹配部分加上()之后所切出的结果是不同的,
#没有()的没有保留所匹配的项,但是有()的却能够保留了匹配的项,
#这个在某些需要保留匹配部分的使用过程是非常重要的。

美高梅开户网址 108

 

 

练习

1、相称标签

美高梅开户网址 109美高梅开户网址 110

美高梅开户网址 111

import re


ret = re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>")
#还可以在分组中利用?<name>的形式给分组起名字
#获取的匹配结果可以直接用group('名字')拿到对应的值
print(ret.group('tag_name'))  #结果 :h1
print(ret.group())  #结果 :<h1>hello</h1>

ret = re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>")
#如果不给组起名字,也可以用\序号来找到对应的组,表示要找的内容和前面的组内容一致
#获取的匹配结果可以直接用group(序号)拿到对应的值
print(ret.group(1))
print(ret.group())  #结果 :<h1>hello</h1>

美高梅开户网址 112

View Code

 

贰、相配整数

美高梅开户网址 113美高梅开户网址 114

美高梅开户网址 115

import re

ret=re.findall(r"\d+","1-2*(60+(-40.35/5)-(-4*3))")
print(ret) #['1', '2', '60', '40', '35', '5', '4', '3']
ret=re.findall(r"-?\d+\.\d*|(-?\d+)","1-2*(60+(-40.35/5)-(-4*3))")
print(ret) #['1', '-2', '60', '', '5', '-4', '3']
ret.remove("")
print(ret) #['1', '-2', '60', '5', '-4', '3']

美高梅开户网址 116

View Code

 

三、数字相配

美高梅开户网址 117美高梅开户网址 118

美高梅开户网址 119

1、 匹配一段文本中的每行的邮箱
      http://blog.csdn.net/make164492212/article/details/51656638

2、 匹配一段文本中的每行的时间字符串,比如:‘1990-07-12’;

   分别取出1年的12个月(^(0?[1-9]|1[0-2])$)、
   一个月的31天:^((0?[1-9])|((1|2)[0-9])|30|31)$

3、 匹配qq号。(腾讯QQ号从10000开始)  [1,9][0,9]{4,}

4、 匹配一个浮点数。       ^(-?\d+)(\.\d+)?$   或者  -?\d+\.?\d*

5、 匹配汉字。             ^[\u4e00-\u9fa5]{0,}$ 

6、 匹配出所有整数

美高梅开户网址 120

View Code

 

4、爬虫演练

美高梅开户网址 121美高梅开户网址 122

美高梅开户网址 123

import requests

import re
import json

def getPage(url):

    response=requests.get(url)
    return response.text

def parsePage(s):

    com=re.compile('<div class="item">.*?<div class="pic">.*?<em .*?>(?P<id>\d+).*?(?P<title>.*?)'
                   '.*?(?P<rating_num>.*?).*?(?P<comment_num>.*?)评价',re.S)

    ret=com.finditer(s)
    for i in ret:
        yield {
            "id":i.group("id"),
            "title":i.group("title"),
            "rating_num":i.group("rating_num"),
            "comment_num":i.group("comment_num"),
        }

def main(num):

    url='https://movie.douban.com/top250?start=%s&filter='%num
    response_html=getPage(url)
    ret=parsePage(response_html)
    print(ret)
    f=open("move_info7","a",encoding="utf8")

    for obj in ret:
        print(obj)
        data=json.dumps(obj,ensure_ascii=False)
        f.write(data+"\n")

if __name__ == '__main__':
    count=0
    for i in range(10):
        main(count)
        count+=25

美高梅开户网址 124

View Code

美高梅开户网址 125美高梅开户网址 126

美高梅开户网址 127

import re
import json
from urllib.request import urlopen

def getPage(url):
    response = urlopen(url)
    return response.read().decode('utf-8')

def parsePage(s):
    com = re.compile(
        '<div class="item">.*?<div class="pic">.*?<em .*?>(?P<id>\d+).*?(?P<title>.*?)'
        '.*?(?P<rating_num>.*?).*?(?P<comment_num>.*?)评价', re.S)

    ret = com.finditer(s)
    for i in ret:
        yield {
            "id": i.group("id"),
            "title": i.group("title"),
            "rating_num": i.group("rating_num"),
            "comment_num": i.group("comment_num"),
        }


def main(num):
    url = 'https://movie.douban.com/top250?start=%s&filter=' % num
    response_html = getPage(url)
    ret = parsePage(response_html)
    print(ret)
    f = open("move_info7", "a", encoding="utf8")

    for obj in ret:
        print(obj)
        data = str(obj)
        f.write(data + "\n")

count = 0
for i in range(10):
    main(count)
    count += 25

美高梅开户网址 128

简化版

美高梅开户网址 129美高梅开户网址 130

美高梅开户网址 131

flags有很多可选值:

re.I(IGNORECASE)忽略大小写,括号内是完整的写法
re.M(MULTILINE)多行模式,改变^和$的行为
re.S(DOTALL)点可以匹配任意字符,包括换行符
re.L(LOCALE)做本地化识别的匹配,表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境,不推荐使用
re.U(UNICODE) 使用\w \W \s \S \d \D使用取决于unicode定义的字符属性。在python3中默认使用该flag
re.X(VERBOSE)冗长模式,该模式下pattern字符串可以是多行的,忽略空白字符,并可以添加注释

美高梅开户网址 132

flags

 

作业

实现能计算类似 
1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )等类似公式的计算器程序

 

在线测试工具 

发表评论

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

网站地图xml地图