python 正则化表达式和泛型函数的使用及异常

目录

一、正则表达式

3.1匹配函数

3.2检索和替换

3.3正则表达式对象

 二、常用方法使用

三、泛型函数的使用

四、上下文管理器

五、装饰器

六、异常

6.1抛出和捕获异常


一、正则表达式

正则表达式是一个特殊的字符序列,它帮助检查一个字符串是否与某种模式匹配

python中增加了re 模块,使 Python 语言拥有全部的正则表达式功能

  • re.match():从字符串起始位置匹配,不成功则返回 none。
  • re.search():匹配整个字符串,直到找到一个匹配。
  • re.groups():返回匹配的表达式
  • re.sub():用于替换字符串中的匹配项。
  • re.compile ():用于编译正则表达式,生成一个正则表达式( Pattern )对象,供 match() 和 search() 这两个函数使用
  • re.finditer():在字符串中找到正则表达式所匹配的所有子串,并把它们作为一个迭代器返回。
  • re.split():匹配的子串将字符串分割后返回列表

(1)特殊字符类及其表示含义

python 正则化表达式和泛型函数的使用及异常_第1张图片

 (2)字符类

python 正则化表达式和泛型函数的使用及异常_第2张图片

 (3)正则表达式模式

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

字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。多数字母和数字前加一个反斜杠时会拥有不同的含义标点符号只有被转义时才匹配自身,否则它们表示特殊的含义。反斜杠本身需要使用反斜杠转义(\\)。由于正则表达式通常都包含反斜杠,所以最好使用原始字符串来表示它们。模式元素(如 r'\t',等价于 '\\t')匹配相应的特殊字符。

下表列出了正则表达式模式语法中的特殊元素。使用模式的同时提供了可选的标志参数,某些模式元素的含义会改变。

python 正则化表达式和泛型函数的使用及异常_第3张图片

3.1匹配函数

(1)re.match函数

从字符串的起始位置匹配一个模式,匹配成功,则输出该字符的区间(前闭后开),若不是起始位置匹配成功的话,match() 就返回 none。

re.match(pattern, string, flags=0)   #pattern:匹配的正则表达式;
import re  #导入模块
print(re.match('www', 'www.runoob.com').span())  # 在起始位置匹配   输出(0,3)
print(re.match('com', 'www.runoob.com'))         # 不在起始位置匹配   输出None

使用匹配对象函数来获取匹配表达式:

  •  group(num): 获取对应num下标的元素;
  •  group()  获取所有元素。
  • groups():返回一个所有包含小组字符串的元组,从1到所含的小组号
import re
 
line = "Cats are smarter than dogs"   #定义一个字符串变量
 
matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)
 
if matchObj:
matchObj:
   print("matchObj.group() : ", matchObj.groups())  #  ('Cats', 'smarter')
   print("matchObj.group() : ", matchObj.group())  #  matchObj.group() :  Cats are smarter than dogs
   print("matchObj.group(1) : ", matchObj.group(1))    #  matchObj.group(1) :  Cats
   print("matchObj.group(2) : ", matchObj.group(2))   #  matchObj.group(2) :  smarter
else:
   print("No match!!")

(2)re.search方法

扫描整个字符串并返回第一个成功的匹配。使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

re.search(pattern, string, flags=0)
import re
print(re.search('www', 'www.runoob.com').span())  #  www所在位置为(0,3)
print(re.search('com', 'www.runoob.com').span())         # com所在位置为(11,14)前闭后开

line = "Cats are smarter than dogs"
 
searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)
 
if searchObj:
   print("searchObj.group() : ", searchObj.group())  # Cats are smarter than dogs
   print("searchObj.group(1) : ", searchObj.group(1))  # Cats
   print("searchObj.group(2) : ", searchObj.group(2))   # smarter
else:  
   print("Nothing found!!")

(3) re.match与re.search的区别

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

import re  
line = "Cats are smarter than dogs"
 
matchObj = re.match( r'dogs', line, re.M|re.I)  #从字符串开始匹配dog,因为起始值不是dog,所以匹配不成功
if matchObj:
   print("match --> matchObj.group() : ", matchObj.group())
else:
   print("No mtch!!")   # 执行此条语句
 
matchObj = re.search( r'dogs', line, re.M|re.I)   #遍历整个字符串匹配dogs,可以匹配成功
if matchObj:
   print("search --> searchObj.group() : ", matchObj.group())  #执行此语句,输出dogs(具体输出参考matchobj)
else: 
   print("No match!!")

3.2检索和替换

(1)re 模块提供了re.sub用于替换字符串中的匹配项。

re.sub(pattern, repl, string, count=0, flags=0)
  • pattern : 正则中的模式字符串
  • repl : 替换的字符串,也可为一个函数。
  • string : 要被查找替换的原始字符串
  • count : 模式匹配后替换的最大次数,默认 0 表示替换所有的匹配。
import re
 
phone = "2004-959-559 # 这是一个国外电话号码"
 
# 删除字符串中的 Python注释 
num = re.sub(r'#.*$', "", phone) 
print("电话号码是: ", num)  #电话号码是:  2004-959-559
 
# 删除非数字(-)的字符串 
num = re.sub(r'\D', "", phone)
print("电话号码是 : ", num)  #电话号码是 :  2004959559

(2)re.compile 函数

用于编译正则表达式,生成一个正则表达式( Pattern )对象,供 match() 和 search() 这两个函数使用。

  1. re.I 忽略大小写
  2. re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
  3. re.M 多行模式
  4. re.S 即为 . 并且包括换行符在内的任意字符(. 不包括换行符)
  5. re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
  6. re.X 为了增加可读性,忽略空格和 # 后面的注释

python 正则化表达式和泛型函数的使用及异常_第4张图片

 在上面,当匹配成功时返回一个 Match 对象,其中:

  • group([group1, …]) 方法用于获得一个或多个分组匹配的字符串,当要获得整个匹配的子串时,可直接使用 group() 或 group(0)
  • start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始位置(子串第一个字符的索引),参数默认值为 0;
  • end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置(子串最后一个字符的索引+1),参数默认值为 0;
  • span([group]) 方法返回 (start(group), end(group))

(3)findall

在字符串中找到正则表达式所匹配的所有子串,并返回一个列表;若有多个匹配模式,则返回元组列表,如果没有找到匹配的,则返回空列表。

注意!!! match 和 search 是匹配一次, findall 匹配所有。

findall(string[, pos[, endpos]])
  • string : 待匹配的字符串。
  • pos : 可选参数,指定字符串的起始位置,默认为 0。
  • endpos : 可选参数,指定字符串的结束位置,默认为字符串的长度。
import re
 
pattern = re.compile(r'\d+')   # 只查找数字
result1 = pattern.findall('runoob 123 google 456')
result2 = pattern.findall('run88oob123google456', 0, 10)
 
print(result1)
print(result2)

多个匹配模式:

result = re.findall(r'(\w+)=(\d+)', 'set width=20 and height=10')
print(result)  # 输出  [('width', '20'), ('height', '10')]

3.3正则表达式对象

re.compile() 返回 RegexObject 对象。

group() 返回被 RE 匹配的字符串。

  • start() 返回匹配开始的位置
  • end() 返回匹配结束的位置
  • span() 返回一个元组包含匹配 (开始,结束) 的位置

 二、常用方法使用

import re
print(re.match('www', 'www.runoob.com').span())  # 在起始位置匹配(0,3)
print(re.match('com', 'www.runoob.com'))         # 不在起始位置匹配none


#------查找字符串中的所有数字--------# 
pattern = re.compile(r'\d+')   # 查找数字
result1 = pattern.findall('runoob 123 google 456')
result2 = pattern.findall('run88oob123google456', 0, 10)
print(result1)   # ['123', '456']
print(result2)   #['88', '12']


#------#多个匹配模式,返回元组列表--------# 
result = re.findall(r'(\w+)=(\d+)', 'set width=20 and height=10')
print(result)    #[('width', '20'), ('height', '10')]

1.正则查找网址

import re

str1 = input()
result = re.match("https://www",str1)
print(result.span())    ##输出返回结果的范围
# print(re.match('https://www', str1).span())  #输出网址从开头匹配到第一位不匹配的范围。

2.map()函数:

from collections.abc import Iterator   #导入迭代器

map_obj = map(lambda x: x*2, [1,2,3,4,5])
print(isinstance(map_obj,Iterator))  #True
print(list(map_obj))      #[2, 4, 6, 8, 10]   
 
def square(x):   #定义一个函数square()
    v = x**2
    print(v)
    
print(list(map(square, [1,2,3,4,5]))) 

3.filter()函数:

filter_obj = filter(lambda x: x > 5,range(0,10))
print(list(filter_obj))

4.isinstance() :可以确定一个对象是否是某个特定类型或定制类的实例。

print(isinstance("hello world",str))   #True
print(isinstance(10,int))    #True
print(isinstance(10.0,float))   #True
print(isinstance(5,float))     #False

5.hasattr(obj,attribute):判断目标对象obj是否包含属性attribute

aa = hasattr(json,"dumps")
print(aa)   ##True

bb = getattr(json,"__path__")   #获取属性__path__的值
print(bb)  # ['D:\\Anacoda3\\lib\\json']

6.callable():确定一个对象是否是可调用的(如函数,类这些对象都是可以调用的对象。)

print(callable("hello python"))   #False
print(callable(list))   #True

7.模块

print(json.__doc__)  #查询模块json的文档,它输出的内容和 help() 一样
print(json.__name__)  #查询模块json的名字
print(json.__file__)  #查询模块json的文件路径。若内建的模块没有这个属性,访问它会抛出异常!
print(json.__dict__)  #查询模块json的字典类型对象

三、泛型函数的使用

泛型: Python 中叫 singledispatch:根据传入参数类型的不同调用不同的函数

from functools import singledispatch

@singledispatch
def age(obj):
    print('请传入合法类型的参数!')

@age.register(int)
def _(age):
    print('我已经{}岁了。'.format(age))

@age.register(str)
def _(age):
    print('I am {} years old.'.format(age))


age(23)  # int  我已经23岁了。
age('twenty three')  # str    I am twenty three years old.
age(['23'])  # list    请传入合法类型的参数!

(1)函数的拼接 

from functools import singledispatch

def check_type(func):   #通用的拼接函数
    def wrapper(*args):
        arg1, arg2 = args[:2]
        if type(arg1) != type(arg2):
            return '【错误】:参数类型不同,无法拼接!!'
        return func(*args)
    return wrapper

@singledispatch
def add(obj, new_obj):
    raise TypeError

@add.register(str)
@check_type
def _(obj, new_obj):
    obj += new_obj    #字符串拼接
    return obj

@add.register(list)
@check_type
def _(obj, new_obj):
    obj.extend(new_obj)   #列表拼接
    return obj

@add.register(dict)
@check_type
def _(obj, new_obj):
    obj.update(new_obj)  #字典拼接
    return obj

@add.register(tuple)
@check_type
def _(obj, new_obj):
    return (*obj, *new_obj)   #元组拼接

print(add('hello',', world'))    #hello, world
print(add([1,2,3], [4,5,6]))         #[1, 2, 3, 4, 5, 6]
print(add({'name': 'wangbm'}, {'age':25}))    #{'name': 'wangbm', 'age': 25}
print(add(('apple', 'huawei'), ('vivo', 'oppo')))   #('apple', 'huawei', 'vivo', 'oppo')

#list 和 字符串 无法拼接(不同类型无法拼接)
print(add([1,2,3], '4,5,6'))  # 输出:【错误】:参数类型不同,无法拼接!!

四、上下文管理器

上下文管理器的好处:提高代码的复用率、优雅度、可读性;

(1)读取文件内容

file = open("C:\\Users\HY\\Desktop\\Autotest\\1.txt")
print(file.readline())  #读取首行
print(file.read())   #读取文件全部内容
file.close()    #手动关闭文件句柄

(2)使用with关键字读取文件,读取结束后可自动关闭文件句柄(with即是上下文管理器

  • 上下文表达式:with open('test.txt') as file:
  • 上下文管理器:open('test.txt')
  • file 是资源对象
with open("C:\\Users\HY\\Desktop\\Autotest\\1.txt") as file:
    print(file.read())

(3)在类里实现一个上下文管理器:也即是在类里定义:__enter__和__exit__方法,这个类的实例也即是上下文管理器

class Resource():
    def __enter__(self):
        print("-----connect to resource-----")
        return self
    
    def __exit__(self,exc_type,exc_val,exc_tb):
        print("-----close resource connection------")
        
    def func(self):
        print("----执行函数内部的逻辑")
    
with Resource() as result:
    result.func()

#输出:
# -----connect to resource-----
# ----执行函数内部的逻辑
# -----close resource connection------

在 写__exit__ 函数时,需要注意的事,它必须要有这三个参数:

  • exc_type:异常类型

  • exc_val:异常值

  • exc_tb:异常的错误栈信息

当主逻辑代码没有报异常时,这三个参数将都为None。

(4)使用 contextlib构建一个上下文管理器(通过一个函数来实现上下文管理器,而不用一个类)

python中,contextlib 的协议实现了一个打开文件(with open)的上下文管理器。

import contextlib

@contextlib.contextmanager
def open_func(file_name):
    
# __enter__方法
    print("open file:",file_name,"in__enter__")
    file_handler = open(file_name,"r")   #打开文件
    
    yield file_handler    #生成器(带有yield)
    
# __exit__方法
    print("close file:",file_name,"in__exit")
    file_handler.close()   #关闭句柄
    return

with open_func("C:\\Users\HY\\Desktop\\Autotest\\1.txt") as file_in: 
    for line in file_in:
        print(line)

上面这段代码只能实现上下文管理器的第一个目的(管理资源),并不能实现第二个目的(处理异常)如果要处理异常,可以改成:

import contextlib

@contextlib.contextmanager
def open_func(file_name):
    
# __enter__方法
    print("open file:",file_name,"in__enter__")
    file_handler = open(file_name,"r")   #读取文件
    
    try:
        yield file_handler    #生成器(带有yield)
    except Exception as exc:
        print("the exception was thrown")
    finally:   
        print("close file:",file_name,"in__exit")     # __exit__方法
        file_handler.close()   #关闭句柄
        return

with open_func("C:\\Users\HY\\Desktop\\Autotest\\1.txt") as file_in: 
    for line in file_in:
        1/0
        print(line)

五、装饰器

装饰器本质上是一个Python函数,它可以让其他函数在不需要做任何代码变动的前提下增加额外功能,装饰器的返回值也是一个函数对象。

常用于有切面需求的场景:如插入日志、性能测试、事务处理、缓存、权限校验等场景。有了装饰器,我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。

装饰器的使用方法:

  • 先定义一个装饰器decorator(帽子)

  • 再定义你的业务函数或者类(人)wrapper

  • 最后把这装饰器(帽子)扣在这个函数(人)头上

#=================装饰器的使用==========================
# 定义装饰器
def decorator(func):
    def wrapper(*args,**kw):
         return func()
    return wrapper

# 定义业务函数并进行装饰
@decorator
def function():
    print("hello world")

(1)普通装饰器

#=================普通装饰器的使用==========================
#定义装饰器函数,logger是装饰器,参数func是被装饰的函数

def logger(func):
    def wrapper(*args,**kw):
        print('开始执行{}函数:'.format(func.__name__))   #
        
        #函数逻辑体:真正需要执行的逻辑
        func(*args,**kw)
        
        print('执行完毕')
    return wrapper
        
#写函数,具体功能
@logger
def add(x,y):
    print(f"{x}+{y}={x+y}")  #两种输出都可
    print("{}+{}={}".format(x,y,x+y))

add(20,30)

六、异常

异常:导致程序在运行过程中出现异常中断和退出的错误。正常情况下,异常都不会被程序处理,而是以错误信息的形式展现出来。所有异常都是异常类,首字母是大写的!

  • SyntaxError:语法错误
  • TypeError:类型错误,也就是说将某个操作或功能应用于不合适类型的对象时引发,比如整型与字符型进行加减法
  • IndexError:索引出现了错误,比如最常见下标索引超出了序列边界
  • KeyError:关键字错误,主要发生在字典中,比如当用户试图访问一个字典中不存在的键时会被引发。
  • ValueError:传入一个调用者不期望的值时引发,即使这个值的类型是正确的,比如想获取一个列表中某个不存在值的索引。
  • AttributeError:属性错误,试图访问一个对象不存在的属性时引发。(如字典有get方法,列表没有,若列表对象调用get方法就会引发该异常。)
  • NameError:变量名称发生错误,如用户试图调用一个未被赋值或初始化的变量时被触发。
  • IOError:打开文件错误,当用户试图以读取方式打开一个不存在的文件时引发。
  • StopIteration:迭代器错误,当访问至迭代器最后一个值时仍然继续访问,就会引发这种异常,提醒用户迭代器中已经没有值可供访问了
  • AssertionError:断言错误,当用户利用断言语句检测异常时,如果断言语句检测的表达式为假,则会引发这种异常。
  • IndentationError:缩进异常
  • ImportError:导包过程中出现的错误,包名错误或者路径不对、包未安装,抛出 ImportError

6.1抛出和捕获异常

异常处理工作包括:抛出、捕获。

捕获指的是使用try....except包裹特定语句,而raise则是主动抛出异常

(1)抛出异常

异常产生有两种来源:

  • 程序自动抛出:如 1/0 会自动抛出 ZeroDivisionError

  • 开发者主动抛出:使用 raise 关键字抛出。

def demo_func(filename):
    if not os.path.isfile(filename):
        raise Exception       #raise抛出异常

(2)捕获异常

异常的捕获的语法有如下四种:

#====================只捕捉,不获取异常信息===================#
try:
    代码A
except [EXCEPTION]:
    代码B

#=========捕捉了,还要获取异常信息,赋值给 e 后,把异常信息打印到日志中。================#
try:
    代码A
except [EXCEPTION] as e:
    代码B

#==================代码A发生了异常,则会走到代码B的逻辑=======================#
try:
    代码A
except [exception] as e :
    代码B

#============代码A发生了异常,则走到代码B的逻辑,如果没有发生异常,则会走到代码C=============#
try:
    代码A
except [exception] as e:
    代码B
else:
    代码C

#============代码A发生了异常,则走到代码B的逻辑,最后不管有没有异常都会执行代码C=============#
try:
    代码A
except [exception] as e:
    代码B
finally:
    代码C

(3)捕获多个异常:except可以捕获一个或者多个异常

        1)每个except捕获一个异常

一个 try 语句可能有多个 except 子句,以指定不同异常的处理程序,但是最多会执行一个处理程序。

try:
    1/0     #此处抛出异常,因为除数不能为0
except IOError:
    print("IO读写出错")
except FloatingPointError:
    # 浮点计算错误
    print("计算错误")
except ZeroDivisionError:   #因此这里捕捉到异常,执行这部分的代码,其余异常代码不执行
    # 除数不能为 0
    print("计算错误")    #最后输出为:计算错误

        2)一个except捕获多个异常

except 后面可以接多个异常的,多个异常之间使用括号包裹。只要匹配上一个就算捕获到,就会进入相应的代码分支。

try:
    1/0
except IOError:
    print("IO读写出错")
except (ZeroDivisionError, FloatingPointError):    #此处捕获到异常
    print("计算出错")

(4)自定义异常

自定义异常应该继承 Exception 类,直接继承或者间接继承都可

自定义的异常或错误类,下面使用 InputError (异常的名字都以Error结尾,我们在为自定义异常命名的时候也需要遵守这一规范,就跟标准的异常命名一样),表示接受用户输入时发生问题。

class InputError(Exception):
    def __init__(self, msg):
        self.message = msg

    def __str__(self):
        return self.message

def get_input():
    name = input("请输入你的姓名:")
    if name == '':
        raise InputError("未输入内容")
    
try:
    get_input()  
except InputError as e:
    print(e)

(5)如何关闭异常自动关联上下文

如果在异常处理程序或 finally 块中引发异常,默认情况下,异常机制会隐式工作会将先前的异常附加为新异常的 __context__属性。这就是 Python 默认开启的自动关联异常上下文。

若想控制这个上下文,可以加个 from 关键字(from 语法会有个限制,就是第二个表达式必须是另一个异常类或实例。),来表明你的新异常是直接由哪个异常引起的

try:
    print(1/0)    #抛出异常
except Exception as exc:
    raise RuntimeError("Something bad happened") from exc   #执行此语句抛出RuntimeError同时抛出1/0产生的ZeroDivisionError异常

也可以通过with_traceback()方法为异常设置上下文__context__属性,这也能在traceback更好的显示异常信息。

try:
    print(1 / 0)
except Exception as exc:
    raise RuntimeError("bad thing").with_traceback(exc)

总结:

  • 只捕获可能会抛出异常的语句,避免含糊的捕获逻辑

  • 保持模块异常类的抽象一致性,必要时对底层异常类进行包装

  • 使用“上下文管理器”可以简化重复的异常处理逻辑

你可能感兴趣的:(python,正则表达式)