Python第13天笔记——面向对象(补充）

面向对象3

isinstance和issubclass

isinstance(obj,cls) #检查obj是否为类cls的对象

class Foo():
    pass
foo=Foo()
print(isinstance(foo,Foo))
print(isinstance(1,int))

class Foo:
    pass
class Bar(Foo):
    pass
print(issubclass(Bar,Foo))

反射

是指程序可以访问、检测和修改它本身状态或者行为的一种能力。在Python中，面向对象中的反射是指通过字符串的形式操作对象的相关属性。

class Foo:
    f="类的静态变量"
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def say(self):
        print("Hello,%s"%self.name)
obj=Foo("Tom",22)
print(obj.__dict__)

#输出结果：
{'name': 'Tom', 'age': 22}

四个可以实现自省的函数：

• hasattr
  • hasattr(*args,**kwargs)

#检测是否含有某个属性
print(hasattr(obj,'name'))
print(hasattr(obj,'say'))

#输出结果：
True
True

• getattr
  • getattr(obj,name,default=None)

#获取属性
gt=getattr(obj,'age')
print(gt)
g=getattr(obj,'say')
g()

#输出结果：
22
Hello,Tom

• setattr

#设置属性
setattr(obj,"good man",True)
setattr(obj,"show_name",lambda self:self.name+' good man')
print(obj.__dict__)
print(obj.show_name(obj))

#输出结果：
{'name': 'Tom', 'age': 22, 'good man': True, 'show_name': <function <lambda> at 0x000002267D401E18>}
Tom good man

• delattr

#删除属性
delattr(obj,'show_name')
print(obj.__dict__)

#输出结果：
{'name': 'Tom', 'age': 22, 'good man': True}

联想，字符串，列表，元组都可以通过索引值引用值，字典可以通过关键字引用值

item系列

class Foo:
    def __init__(self,name):
        self.name=name
    def __getitem__(self,item):
        print(self.__dict__[item])
    def __setitem__(self,key,value):
        self.__dict__[key]=value
    def __delitem__(self,key):
        print("del obj[key]时：")
        self.__dict__.pop(key)
    def __delattr__(self,item):
        print("del obj.key时：")
        self.__dict__.pop(item)
obj1=Foo('Tom')
obj1['age']=18
obj1['age1']=19
print(obj1.__dict__)
del obj1['age']
del obj1.age1
print(obj1.__dict__)
obj1['name']="Jack"
print(obj1.__dict__)

#输出结果：
{'name': 'Tom', 'age': 18, 'age1': 19}
del obj[key]时：
del obj.key时：
{'name': 'Tom'}
del obj[key]时：
del obj.key时：
{'name': 'Jack'}

__del__

当对象在内存中被释放，就会自动触发执行，一般不需要自定义。

class Foo:
    def __del__(self):
        print("执行del函数。")

obj = Foo()
del obj

#输出结果：
执行del函数。

__str__

• 如果直接print打印对象。会看到创建对象的内存地址。
• 当我们使用print()，输出对象，如果对象定义了__str__方法，就会打印该方法return的信息描述

class Cat:
    def __init__(self,new_name,new_age):
        self.new_name = new_name
        self.new_age =new_age
    def __str__(self):
        return "名字是：%s,年龄是：%s"%(self.new_name,self.new_age)

obj = Cat("Tom",6)
print(obj)

Python正则表达式的基础

单字符匹配规则

字符	功能
.	匹配任何一个字符（除了\n）
[]	匹配[]中列举的字符
\d	匹配数字（0-9）
\D	匹配非数字（\d取反）
\w	匹配字，A-Z，a-z，0-9，_
\W	\w取反

• re.match(pattern,string,flags=0)
  • 作用：从字符串的开头开始匹配一个模式
    • 匹配成功，返回一个匹配成功的对象
    • 否则，返回None
  • 参数说明：
    • pattern：匹配的正则表达式
    • string：要匹配的字符串
    • flags：标志位，用于控制正则表达式的匹配方式。比如是否匹配多行，是否区分大小写。
• re.group([group1,…])字符串或元组
  • 作用：获得一个或多个分组截获的字符串
  • 指定多个参数时就会以元组形式返回
  • group1可以使用编号，也可以使用别名
  • 编号0代表匹配整个子串，默认返回group(0)
  • 如果没有截获字符串，返回None
  • 截获了多次的组，返回最后一次截获的子串
• re.groups([default=None]) tuple
  • 作用：以元组形式返回全部分组截获的字符串。类似调用re.group(1,2,…last)
  • 如果没有截获字符串，返回None

>>> m=re.match('.','s')
>>> print(m.group())
s
>>> m=re.match('.','a')
>>> print(m.group())
a
>>> m=re.match('.','city')
>>> print(m.group())
c

数量匹配规则

字符	功能
*	匹配前一个字符出现0次多次或无限次，可有可无，可多可少
+	匹配前一个字符出现1次多次或无限次，直到出现一次
*	匹配前一个字符出现0次或任意次
+	匹配前一个字符出现1次或任意次，直到出现一次
？	匹配前一个字符出现1次或0次，要么有1次，要么没有
{m}	匹配前一个字符出现m次
{m,}	匹配前一个字符至少出现m次
{m,n}	匹配前一个字符出现m到n次
^	匹配字符串开头
$	匹配字符串的结尾
\b	匹配一个单词的边界
\B	\b取反，匹配非单词边界

import re
sr=input("请输入匹配字符串：")
pattern=input("请输入匹配规则:")
m=re.match(pattern,sr)
print(m.group())

请输入匹配字符串：ci ty university
请输入匹配规则:\w+\s\bty\b\s\w+
ci ty university

匹配分组

字符	功能
	匹配左右任意一个表达式
(ab)	将括号中的字符作为一个分组
\num	引用分组num匹配到的字符串
(?P)	分组起别名
(?P=name)	引用别名为name分组匹配到的字符串

str="<h1>hello world!</h1>"
pat="<h1>(.*)</h1>"
res=re.match(pat,str)
print(res.group())
print(res.group(1))
print(res.groups())

#输出结果：
<h1>hello world!</h1>
hello world!
('hello world!',)

• re.search(pattern,str,flags=0)
  • 作用：扫描整个字符串，返回第一次成功匹配的对象
  • 如果匹配失败，返回None
  • 参数:

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

• 作用：获取字符串所有匹配的子串，并以列表形式返回。

re.finditer(pattern,str,flags=0)

• 作用：获取字符串所有匹配的子串，并返回一个迭代器。

re.match()和re.search()的区别

• re.match()从字符串开头开始匹配，如果匹配失败，None；
• re.search()匹配整个字符串，直到找到一个匹配，如果匹配失败，None。

print(re.search('yun','Aliyun is yun.').group())
print(re.findall('yun','Aliyun is a yun'))
print(re.finditer('yun','Aliyun is yun.'))

for i in re.finditer('yun','Aliyun is yun.'):
    print(i.group())
    
#输出结果：
yun
['yun', 'yun']
<callable_iterator object at 0x0000017863056630>
yun
yun