Python入门【动态添加属性和方法、正则表达式概述、match函数的使用、常用匹配符、限定符、限定符使用示例】(二十九)

本文链接：https://blog.csdn.net/abc19991119/article/details/132354117

👏作者简介：大家好，我是爱敲代码的小王，CSDN博客博主,Python小白
📕系列专栏：python入门到实战、Python爬虫开发、Python办公自动化、Python数据分析、Python前后端开发
📧如果文章知识点有错误的地方，请指正！和大家一起学习，一起进步👀
🔥如果感觉博主的文章还不错的话，请👍三连支持👍一下博主哦
🍂博主正在努力完成2023计划中：以梦为马，扬帆起航，2023追梦人

🔥🔥🔥 python入门到实战专栏：从入门到实战

🔥🔥🔥 Python爬虫开发专栏：从入门到实战

🔥🔥🔥 Python办公自动化专栏：从入门到实战

🔥🔥🔥 Python数据分析专栏：从入门到实战

🔥🔥🔥 Python前后端开发专栏：从入门到实战

动态添加属性和方法

动态编程语言是高级程序设计语言的一个类别，在计算机科学领域已被广泛应用。

它是指在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。

运行过程中给对象、类添加属性和方法

#coding=utf-8
import types
class Person():
    def __init__(self,namexiao,agetong):
        self.namexiao= namexiao
        self.agetong= agetong
p1 = Person("zhangsan",20)
p2 = Person("lisi",30)
#动态给对象添加属性和方法
p1.score = 100
print(p1.score)
def run(self):
    print(f"{self.namexiao},running...")#动态的对象添加方法
p1.run = types.MethodType(run,p1)
p1.run()

types.MethonType的使用

p1.run = types.MethodType(run,p1)
# 即使换成
xxx = types.MethodType(run,p1)
# xxx()调用一样还用
# 因为之前提示缺少参数，主要是不知道self到底是谁，
# 而types.MethodType(run,p1)则是告诉解释器，self指的就是p1

给类动态添加静态方法以及类方法

@staticmethod
def staticfunc():
    print("---static method---")
Person.staticfunc = staticfunc
Person.staticfunc()
@classmethod
def clsfunc(cls):
    print('---cls method---')
Person.clsfunc = clsfunc
Person.clsfunc()

slots 的作用

1、 __slots__ 对动态添加成员变量、成员方法有限制。对动态添加类属性、类方法没有限制。

2、 __slots__ 只对本类有限制，不限制子类

class Person():
    __slots__ = {"namexiao","agetong"}
    def __init__(self,namexiao,agetong):
        self.namexiao= namexiao
        self.agetong= agetong
    def eat(self):
        print("人是铁饭是钢，要吃！")
if __name__ == '__main__':
    p1 = Person("wang",18)
#   p1.gender = "man" #AttributeError: 'Person' object has no attribute 'gender'

正则表达式概述

概念

正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑（可以用来做检索，截取或者替换操作）。

作用

1、给定的字符串是否符合正则表达式的过滤逻辑（称作“匹配”）。

2、可以通过正则表达式，从字符串中获取我们想要的特定部分。

3、还可以对目标字符串进行替换操作。

基本函数

Python语言通过标准库中的re模块支持正则表达式。re模块提供了一些根据正则表达式进行查找、替换、分隔字符串的函数，这些函数使用一个正则表达式作为第一个参数。

函数	描述
match(pattern,string,flags=0)	根据pattern从string的头部开始匹配字符串，只返回第1次匹配成功的对象；否则，返回None
findall(pattern,string,flags=0)	根据pattern在string中匹配字符串。如果匹配成功，返回包含匹配结果的列表；否则，返回空列表。当 pattern中有分组时，返回包含多个元组的列表，每个元组对应1个分组。flags表示规则选项，规则选项用于辅助匹配。
sub(pattern,repl,string,count=0)	根据指定的正则表达式，替换源字符串中的子串。 pattern是一个正则表达式，repl是用于替换的字符串，string是源字符串。如果count等于0，则返回 string中匹配的所有结果；如果count大于0，则返回前count个匹配结果
subn(pattern,repl,string,count=0)	作用和sub()相同，返回一个二元的元组。第1个元素是替换结果，第2个元素是替换的次数
search(pattern,string,flags=0)	根据pattern在string中匹配字符串，只返回第1次匹配成功的对象。如果匹配失败，返回None
compile(pattern,flags=0)	编译正则表达式pattern，返回1个pattern的对象
split(pattern,string,maxsplit=0)	根据pattern分隔string，maxsplit表示最大的分隔数
escape(pattern)	匹配字符串中的特殊字符，如*、+、?等

match函数的使用

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回None。语法格式如下：

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

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。如下表列出正则表达式修饰符 - 可选标志

正则表达式修饰符

修饰符	描述
re.I	使匹配对大小写不敏感
re.L	做本地化识别（locale-aware）匹配
re.M	多行匹配，影响 ^ 和 $
re.S	使 . 匹配包括换行在内的所有字符
re.U	根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.X	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

意义：

1、re.match是用来进行正则匹配检查的方法，如果字符串开头的0个或多个字符匹配正则表达式模式，则返回相应的match对象。如果字符串不匹配模式，返回None（注意不是空字符串""）

2、匹配对象Match Object具有group()方法，用来返回字符串的匹配部分,具有span()方法。返回匹配字符串的位置（元组存储开始，结束位置），具有start(),end()方法，存储匹配数据的开始和结束位置。（也可以通过对象的dir(对象查看对象的方法)）

注意：如果想在目标字符串的任意位置查找，需要使用search

【示例】match方法的使用

import re
xiaos='hello python'
patterntong='hello'
v=re.match(patterntong,xiaos)
print(v)
print(v.group())
print(v.span())

【示例】match方法中flag可选标志的使用

import re
xiaos = 'hello Python!'
tongm=re.match('hello python',xiaos ,re.I)  #忽略大小写
if tongm is not None:
    print('匹配成功结果是：',tongm .group())
else:
    print('匹配失败')

常用匹配符

一个正则表达式是由字母、数字和特殊字符（括号、星号、问号等）组成。正则表达式中有许多特殊的字符，这些特殊字符是构成正则表达式的要素。

【示例】常用匹配符.的使用

import re
pattern='.' #匹配任意一个字符（除了\n）
sxiao='a'
print('匹配字符a：',re.match(pattern,sxiao))
sxiao='C'
print('匹配字符C：',re.match(pattern,sxiao))
sxiao='_'
print('匹配字符_：',re.match(pattern,sxiao))
sxiao='\n'
print('匹配字符\\n：',re.match(pattern,sxiao))

【示例】常用匹配符\d的使用

import re
pattern='\d'  #匹配数字,即0-9
sxiao='9'
print('匹配数字9：',re.match(pattern,sxiao))
sxiao='4'
print('匹配数字4：',re.match(pattern,sxiao))
sxiao='a'
print('匹配字符a：',re.match(pattern,sxiao))
sxiao='_'
print('匹配字符_：',re.match(pattern,sxiao))

【示例】常用匹配符\D的使用

import re
pattern='\D' #匹配非数字的字符
sxiao='9'
print('匹配数字9：',re.match(pattern,sxiao))
sxiao='4'
print('匹配数字4：',re.match(pattern,sxiao))
sxiao='a'
print('匹配字符a：',re.match(pattern,sxiao))
sxiao='_'
print('匹配数字_：',re.match(pattern,sxiao))

【示例】常用匹配符\s的使用

import re
pattern='\s' #匹配空白字符,即空格（\n,\t）
sxiao=' '
print('匹配字符' '：',re.match(pattern,sxiao))
sxiao='\t'
print('匹配字符\\t：',re.match(pattern,sxiao))
sxiao='\n'
print('匹配字符\\n：',re.match(pattern,sxiao))
sxiao='_'
print('匹配字符_：',re.match(pattern,sxiao))

【示例】常用匹配符\S的使用

import re
pattern='\S' #匹配不是空白的字符
sxiao=' '
print('匹配字符' '：',re.match(pattern,sxiao))
sxiao='\t'
print('匹配字符\\t：',re.match(pattern,sxiao))
sxiao='\n'
print('匹配字符\\n：',re.match(pattern,sxiao))
sxiao='_'
print('匹配字符_：',re.match(pattern,sxiao))

【示例】常用匹配符\w和\W的使用

import re
print('-------\w匹配字母、数字、下划线--------')
pattern='\w' #匹配字母、数字、下划线
sxiao='a'
print('匹配字符a：',re.match(pattern,sxiao))
sxiao='_'
print('匹配字符_：',re.match(pattern,sxiao))
sxiao='5'
print('匹配数字5：',re.match(pattern,sxiao))
sxiao='A'
print('匹配字符A：',re.match(pattern,sxiao))
sxiao='#'
print('匹配字符#：',re.match(pattern,sxiao))
print('-------\W匹配不是字母、数字、下划线--------')
pattern='\W' #匹配不是字母、数字、下划线
sxiao='a'
print('匹配字符a：',re.match(pattern,sxiao))
sxiao='_'
print('匹配字符_：',re.match(pattern,sxiao))
sxiao='5'
print('匹配数字5：',re.match(pattern,sxiao))
sxiao='A'
print('匹配字符A：',re.match(pattern,sxiao))
sxiao='#'
print('匹配字符#：',re.match(pattern,sxiao))

【示例】[]匹配列表中的字符

import re
pattern='[2468]' #匹配列表中的字符
sxiao='1'
print('匹配数字1：',re.match(pattern,sxiao))
sxiao='2'
print('匹配数字2：',re.match(pattern,sxiao))
sxiao='3'
print('匹配数字3：',re.match(pattern,sxiao))
sxiao='4'
print('匹配数字4：',re.match(pattern,sxiao))
sxiao='#'
print('匹配字符#：',re.match(pattern,sxiao))
print('---------手机号码-----------')
sxiao='13456788789'
pattern='\d\d\d\d\d\d\d\d\d\d\d'#匹配手机号
print('匹配手机号码：',re.match(pattern,sxiao))
pattern='1[35789]\d\d\d\d\d\d\d\d\d'#匹配手机号
print('匹配手机号码：',re.match(pattern,sxiao))

其中，匹配符“[]”可以指定一个范围，例如：“[ok]”将匹配包含“o”或 “k”的字符。同时“[]”可以与\w、\s、\d等标记等价。例如，[0-9a-zAZ]等价于\w,[ ^0-9 ] 等价于\D。

限定符

从上面示例中可以看到如果要匹配手机号码，需要形如 “\d\d\d\d\d\d\d\d\d\d\d”这样的正则表达式。其中表现了11次 “\d”，表达方式烦琐。正则表达式作为一门小型的语言，还提供了对表达式的一部分进行重复处理的功能。例如，“*”可以对正则表达式的某个部分重复匹配多次。这种匹配符号称为限定符。

符号	描述	符号	描述
*	匹配零次或多次	{m}	重复m次
+	匹配一次或多次	{m,n}	重复m到n次，其中n可以省略，表示m到任意次
?	匹配一次或零次	{m,}	至少m次

【示例】限定符*+?的使用

import re
print('------*匹配零次或多次--------')
pattern='\d*'  #0次或多次
sxiao='123abc'
print('匹配123abc：',re.match(pattern,sxiao))

sxiao='abc'  #这时候不是None而是''
print('匹配abc：',re.match(pattern,sxiao))
print('-----+匹配一次或多次---------')

pattern='\d+'  #1次或多次
sxiao='123abc'
print('匹配123abc：',re.match(pattern,sxiao))

sxiao='abc'  #这时候是None
print('匹配abc：',re.match(pattern,sxiao))
print('-----?匹配一次或零次---------')

pattern='\d?'  #0次或1次
sxiao='123abc'
print('匹配123abc：',re.match(pattern,sxiao))

sxiao='abc'  #这时候是空
print('匹配abc：',re.match(pattern,sxiao))

【示例】限定符{}的使用

import re
print('-----{m}重复m次---------')
pattern='\d{3}'  #出现m次
sxiao='123abc'
print('pattern为\\d{3}匹配123abc结果：',re.match(pattern,sxiao))
pattern='\d{4}'  #出现m次
print('pattern为\\d{4}匹配123abc结果：',re.match(pattern,sxiao))
print('-----{m,}至少m次---------')

sxiao='1234567abc'
pattern='\d{3,}'  #出现大于m次 尽可能满足的都返回
print('pattern为\\d{3,}匹配1234567abc结果：\n',re.match(pattern,sxiao))
print('-----{m,n}重复m到n次---------')
pattern='\d{2,4}'  #出现m到n次
print('pattern为\\d{2,4}匹配1234567abc结果：\n',re.match(pattern,sxiao))

限定符使用示例

【示例】匹配出一个字符串首字母为大写字符，后边都是小写字符，这些小写字母可有可无

pattern='[A-Z][a-z]*'
sxiao='Hello world'
sxiao='HEllo world'
v=re.match(pattern,sxiao)
print(v)

【示例】匹配出有效的变量名

import re
pattern='[A-Za-z_][0-9A-Za-z_]*'
print('pattern为[A-Za-z_][0-9A-Za-z_]*')
sxiao='a'
print('匹配变量名a的结果：',re.match(pattern,sxiao))

sxiao='ab'
print('匹配变量名ab的结果：',re.match(pattern,sxiao))

sxiao='_ab'
print('匹配变量名_ab的结果：',re.match(pattern,sxiao))

sxiao='2ab'
print('匹配变量名2ab的结果：',re.match(pattern,sxiao))

print('pattern为[A-Za-z_]\w*')
pattern='[A-Za-z_]\w*'
sxiao='a'
print('匹配变量名a的结果：',re.match(pattern,sxiao))

sxiao='ab'
print('匹配变量名ab的结果：',re.match(pattern,sxiao))

sxiao='_ab'
print('匹配变量名_ab的结果：',re.match(pattern,sxiao))

sxiao='2ab'
print('匹配变量名2ab的结果：',re.match(pattern,sxiao))

【示例】匹配出1-99之间的数字

import re
pattern='[1-9]\d?'
sxiao='1'
print('匹配数字1：',re.match(pattern,sxiao))

sxiao='55'
print('匹配数字55：',re.match(pattern,sxiao))

sxiao='99'
print('匹配数字99：',re.match(pattern,sxiao))

sxiao='199'
print('匹配数字199：',re.match(pattern,sxiao))

【示例】匹配出一个随机密码8-20位以内 (大写字母小写字母下划线数字)

import re
pattern='\w{8,20}'
sxiao='12345678'
print('匹配12345678的结果：\n',re.match(pattern,sxiao))

sxiao='123__456'
print('匹配123__456的结果：\n',re.match(pattern,sxiao))