python学习之正则表达式,StringIO模块,异常处理,搭建测试环境

python正则表达式

　　引入一个强大的匹配功能来匹配字符串

import re
正则表达式的表示类型
raw string类型(原生字符串类型)　　r'sa\\/sad/asd'用r转为raw string类型
字符串类型,string类型,所以当正则表达式中出现<转义符>建议使用raw string
正则表达式方法
import re#导入模块

test = "oihAdoiahsd213ihf(*TY(&GHW"

match　　从一个字符串的开始位置起匹配正则,返回match对象
print(re.match('a', test))  # 从开始位置开始匹配,如果开头没有则无----返回None
print(re.match('o', test))  # 返回<_sre.SRE_Match object; span=(0, 1), match='o'>
print(re.match('o', test).group())  # 可以加.group返回o,如果匹配不成功会报错

search　　在一个字符串中搜索匹配正则的第一个位置,返回match对象,贪婪匹配方式
re.search(pattern,string,flags=0)
flags:表示正则使用时的控制标记,对应下方控制参数

print(re.search('a','asuidho'))  # search方法可以搜索整个字符串,搜索第一个匹配的结果    返回一个对象,如果没有匹配返回None
print(re.search('a', asui dho).group())  # 如果要取具体内容可以加.group返回a


findall　　搜索字符串,以列表类型返回全部能匹配的字符串
print(re.findall('o', test))  # 搜索整个字符串,返回一个list    搜索到一个返回一个['o', 'o'],如果没有找到返回空

res = (re.finditer('\d','sadsad112'))#把匹配到的结果放到迭代器中,
print(next(res).group())#使用next或者for循环来取出结果

sub　　在一个字符串中替换所有匹配正则的子串,返回替换后的字符串
re.sub(pattern,repl,string,count,count=0,flags=0)
string表示待匹配字符串
count表示匹配最大替换次数
print(re.sub('213', 'SSS', test, 1))  # 正则替换,参数一为原想要替换的字符串,参数二为正则规则,参数三为原字符串,返回oihAdoiahsdSSSihf(*TY(&GHW,匹配不到返回原来字符串,参数四填数字,如果不填就是全部替换,如果填2表示匹配成功后替换的次数
print(re.subn('213','SSS',test, 1))　　#返回返回值和替换的次数

split　　按照正则匹配结果进行分割,返回列表类型
re.split(pattern,string,maxsplit=0,flags=0)
maxsplit表示最大分割数,剩余部分作为最后一个元素 输出
print(re.split('o',test))  # 分割字段,参数一为想要分割的分割点,分割后该元素会为空,参数二为原字符串,返回一个list['', 'ihAd', 'iahsd213ihf(*TY(&GHW'],如果匹配不到返回原来字符串　　'[o,2]'如果这样分割顺序是先按o分割,之后取到分割后的两字段再按2进行分割

import re
spec = 'jdaklsdj ,dkslajddasd;dsalkdjasd'
res = re.split(r'[,;]',spec)
print(res)#['jdaklsdj ', 'dkslajddasd', 'dsalkdjasd']

finditer　　搜索字符串,返回一个匹配结果的迭代类型,每个迭代元素是match对象
for m in re.finditer(r'[1-9]\d{5}','TIT100081 TSU100084'):
　　if m:
　　　　print(m.group(0))
>>100081
>>100084
#迭代的匹配每一次匹配到的结果并单独输出
compile
# 如果要多次使用同一规则来进行匹配的话，可以使用 re.compile 函数来将规则预编译，使用编译过返回的 Regular Expression Object 或叫做 Pattern 对象来进行查找。
s = '111,222,aaa,bbb,ccc333,444ddd'  # 需要正则的字符串
rule = r'\b\d+\b'  # 正则规则
A = re.compile(rule)　　#把rule规则储存在A对象中
print(A)  # 返回re.compile('\\b\\d+\\b')
res = A.findall(s)　　#A对象只要输入指定需要匹配的内容,当多次调用时达到最大效果
print(res)  # 返回['111', '222']

控制参数
# 正则表达式可以包含一些可选择的修饰符来控制匹配模式
　　re.I    使匹配对大小写不敏感
　　re.L    做本地化识别（locale-aware）匹配
　　re.M    多行匹配，影响 ^ 和 $
　　re.S    使 . 匹配包括换行在内的所有字符
　　re.U    根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
　　re.X    该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。
print(re.search(r'[a-z)]+', test).group())  # 匹配多个a-z中的值,返回oih,但是看到大写不进行匹配了
print(re.search(r'[a-z)]+', test, re.I).group())  # 在最后加入参数,返回oihAdoiahsd

正则判断举例
if re.match(r'[0-9]', test):
    print('m')  # 我们可以用正则做判断是否符合我们的要求
else:
    print("匹配失败了")


特殊字符
#特殊意义
#^ / | \ -
# ^  在字符集[]中表示取反
print(re.findall('[^4,2]', '213444422222'))#取除了4和2的其他字符,注4和2是一组 ['1', '3']

# \ 反斜杠后边跟元字符是去除特殊功能    如\\,\/
print(re.search('s\.','swdass.').group())#\.表示让.没有意义,所以匹配后面的s.

print(re.findall('\\\\d2324','as\d2324'))#在python解释器中也对\有特殊的意义,所以转到正则需要4个\  返回['\\d2324']

#   但是反斜杠后面跟普通字符是可以实现特殊功能   如\w,\d
print(re.findall('\d{11}','sadjslajdk12222222212111'))#匹配11个数字,从最前面

# - 杠   在字符集中-有特殊的意义
print(re.findall('[a-zA-Z0-9]','s-aA9'))#['s', 'a', 'A', '9']

#  | 管道符  管道符表示或的意思
print(re.search('(ss)|2', 'ssadfaasd2').group())#意思是ss匹配或者2都能匹配成功    返回ss


元字符
　　^    #尖角号,匹配字符串的开头
　　$    #匹配字符串的末尾。
　　.    #通配符,匹配任意字符，除了换行符，,一个点只能代指一个字符,当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
　　* 　 #重复匹配,0到无穷
　　+　　 #最少有1个
　　?　　 #0-1个

　 {} 　　#大括号,满足{}中的内容
　　　　re{ n}
　　　　re{ n,}    #精确匹配n个前面表达式。
　　　　re{ n, m}    #匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式

   []    #中括号
　　　　a  = 'asdlajoivh23421ds'
　　　　print(re.findall('a[s2]d', a))#[]表示字符集,[]中匹配2或者s    返回asd
　　　　[...]    #用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'
　　　　[^...]    #不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。

　 () 　　#小括号表示一个整体,内部只能用|操作符
　　　　print(re.search('(sad)+', 'sadfaasd').group())
　　　　(re)    #G匹配括号内的表达式，也表示一个组
　　　　(?imx)    #正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
　　　　(?-imx)    #正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
　　　　(?: re)    #类似 (...), 但是不表示一个组
　　　　?imx: re)    #在括号中使用i, m, 或 x 可选标志
　　　　(?-imx: re)    #在括号中不使用i, m, 或 x 可选标志
　　　　(?#...)    #注释.
　　　　(?= re)    #前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
　　　　(?! re)    #前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功
　　　　(?> re)    #匹配的独立模式，省去回溯。
　　　　
　　最小匹配扩展
　　　　*? #前一个字符0次或无限次扩展,最小匹配
　　　　+? #前一个字符1次或无限次扩展,最小匹配
　　　　?? #前一个字符0次或1次扩展,最小匹配
　　　　{m,n}? 扩展前一个字符m至n次(含n),最小匹配
　　　　
　　字符集特殊字符
　　　　\w    #匹配字母数字下划线
　　　　\W    #匹配非字母数字
　　　　\s    #匹配任意空白字符，等价于 [\t\n\r\f].
　　　　\S    #匹配任意非空字符
　　　　\d    #匹配任意数字，等价于 [0-9].
　　　　\D    #匹配任意非数字
　　　　\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个分组的子表达式，如果它经匹配。否则指的是八进制字符码的表达式。
　　　　[\u4e00-\u9fa5]#匹配中文字符

分组

#元字符分组()
print(re.findall('(wf)*','wfcwfc'))#使用()分组中的内容为一组,后面加元字符是组满足条件  返回['wf', 'wf']

#实现路径分组     ?P固定格式+<内容>
res = re.search('(?P<username>\d{4})/(?P<password>\w{3})','http://das123q_9911/wqe.html')
print(res.group())#9911/wqe
print(res.group('username'))#9911
print(res.group('password'))#wqe

print(re.findall('www.\w+.com','www.baidu.com'))#返回['www.baidu.com']
print(re.findall('www.(\w+).com','www.baidu.com'))#当按照组分后,只去取分组中的内容,返回['baidu']
print(re.findall('www.(?:\w+).com','www.baidu.com'))#?:表示取消组的权限,返回['www.baidu.com']

 

 　　StringIO模块

# io.stringio当遇到修改频繁的字符串可以用它
# 只要已开始定义一个对象,那它的方法用就可以了,修改时它不会生成新的对象，当频繁使用性能比较好
from io import StringIO

s = 'rainbol is not a superman'
res = StringIO(s)  # 实例化
# res.seek(0)#默认位置就是0
res.write('rainbol is a superman')
res.seek(0)
print(res.read())

 

搭建测试环境

　　部署文档

　　　　1.安装依赖软件

　　　　　　java(jdk,tomcat,redis,mysql)

　　　　　　python py3,py2,pip install xx

　　　　2.导入基础数据

　　　　　　建表(初始化的数据)

　　　　3.获取代码,打包

　　　　　　java,c编译

　　　　　　python不需要

　　　　4.修改配置文件

　　　　5.启动,重启服务

 

参数控制argv

　　linux命令后面加入了参数,如ls -a 表示显示当前目录所有文件,在python也可以在后面添加参数,在终端中输入python xxxx.py -aaa bbb -ccc ddd后面参数不会执行,需要在xxxx.py用argv来控制

import sys
print(sys.argv)#直接打印输出是[文件的绝对路径]
res = sys.argv

　　在终端输入python xxxx.py -aaa bbb -ccc ddd,打印如下,返回了一个list

　　我们可以针对这个list来做条件判断

 

 python异常处理　　在写代码时候会有很多报错信息,这都是异常,我们怎么捕捉异常呢呢

　　1.捕捉指定异常

try:#尝试写s = 100/0
    s = 100/0
except ZeroDivisionError as e:#捕捉ZeroDivisionError(整数不能为0)的错误信息并由e获取
    print(e)

　　2.捕捉全部异常

try:
    a = 10/'10'
    b = 10/0#捕捉到错误就不会执行这个这个代码
except Exception as e :#捕捉所有异常
    print(e)
else:#不出异常,执行else
    a =a+1
finally:#出异常,不出异常都会执行,可以不写
    b = b+1

 　　3.finally特殊用法

def func():
    try:
        a = (1,)
        a[1000]
        return a
    except Exception as e:
        pass
    finally:
        print('我被执行了')
        b = 2
        return  b
a = func() #我被执行了

print(a)#2
#可以看到在函数中使用finally不管使用了return,最后还是会执行finally里面的代码,所有a的值是2

 　　4.python约束处理

　　　　python不像java,其实并没有约束,但大型项目中如果用到约束必须自定义,约束表示约束就是对类的约束。其实就是父类对子类进行约束，我是项目主管,我写了一个类,告诉手下你们必须继承我这个类的一个方法(子类必须要写xxx方法)不写我就给你报错,所以你不得不写

　　　　方法一:自定义异常实现

import sys
class Base(object):
    def send(self):
        raise NotImplementedError('子类中必须实现%s方法' % sys._getframe().f_code.co_name)
class Foo(Base):
    """如果不写send方法，会返回错误信息"""
    pass

def send(self):
    print('234')


obj = Foo() #报错了,试试把send写在Foo里面
obj.send()

　　　　方法二:抽象类_抽象方法实现

from abc import ABCMeta,abstractmethod
# 引入抽象方法的模块

class Base(metaclass=ABCMeta): #定义抽象类 maetaclass=ABCmeta
    @abstractmethod#抽象方法的关键字
    def send(self):
        pass
    def other(self):
        pass

class Foo(Base):
    def shui(self):
        print ("睡你麻痹")
f=Foo()#Can't instantiate abstract class Foo with abstract methods he ,报错了试试加send方法吧

 　　5.打印以文件路径的报错信息

import traceback
try:
    int('sdf')
except Exception as e:
    print(traceback.format_exc())
else:
    pass

 

版权声明：本文原创发表于 博客园，作者为 RainBol 本文欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则视为侵权。