面向对象进阶-2

 面向对象进阶-2    所有类均继承object
 
    1.类的嵌套：
    函数：参数可以是任意类型。
    字典：对象和类都可以做字典的key和value
    继承的查找关系
对象和类都可以做字典的key和value

1. class StackConfig(object):
2.     pass
4. class UserConfig(StackConfig):
5.     pass
7. class AdminSite(object):
8.     def __init__(self):
9.         self._register = {}
11.     def registry(self,key,arg=StackConfig):
12.         self._register[key] = arg
14.     def run(self):
15.         for key,value in self._register.items():
16.             obj = value()
17.             print(key,obj)
18. site = AdminSite()
19. site.registry(1)
20. site.registry(2,StackConfig)
21. site.registry(3,UserConfig)
22. site.run()
24. >>>
25. 1 <__main__.StackConfig object at 0x000002ABEEE3AB08>
26. 2 <__main__.StackConfig object at 0x000002ABEEE3ABC8>
27. 3 <__main__.UserConfig object at 0x000002ABEEE3AB88>

复制代码

 
    2.特殊成员    特殊成员：就是为了能够快速实现执行某些方法而生
__init___:  初始化方法：对对象的属性进行初始化
__new__:  构造方法： 创建一个空对象
由于所有类均继承object  object中含有__new__  所以创建类的对像士实际上是先__new__再__init__
__call__:  让类的实例可以像函数一样被调用  直接用 实例名(参数) 调用，等同于执行 实例名.__call__(参数)  

1. class Foo:
2.     def __init__(self):
3.         self.__content = 0
4.     def __call__(self):
5.         self.__content+=1
6.         return self.__content
7. obj = Foo()
8. print(obj())    #1
9. print(obj())    #2

复制代码

 __str__:  只有在打印对象时，会自动化调用此方法，并将其返回值在页面显示出来
      __str__ 方法需要返回字符串
      简单说：想让 print(对象) 输出有意义的信息，就用 __str__ 定义规则

1. class User(object):
2.     def __init__(self,name,email):
3.         self.name = name
4.         self.email = email
5.     def __str__(self):
6.         return "%s %s" %(self.name,self.email,)
7. user_list = [User('二狗','2g@qq.com'),User('二蛋','2d@qq.com'),User('狗蛋','xx@qq.com')]
8. for item in user_list:
9.     print(item)

复制代码

__dict__:  打印对象中封装的所有值

1. class Foo:
2.     def __init__(self,name,age):
3.         self.name = name
4.         self.age = age
5. obj = Foo('guohan',22)
6. print(obj.__dict__)

复制代码

__add__:   用于定义对象的 “加法运算” 逻辑，给自定义类 “赋能”，让它能像数字、字符串那样用 + 运算符    
       当使用 + 运算符时，Python 会自动调用该方法

1. class info:
2.     def __init__(self,x,y):
3.         self.x = x
4.         self.y = y
5. class Point:
6.     def __init__(self, x, y):
7.         self.x = x  # x轴坐标
8.         self.y = y  # y轴坐标
10.     # 重写 __add__，定义 Point 对象的加法逻辑：x相加，y相加
11.     def __add__(self, other):
12.         # 先判断 other 是否为 Point 类型，避免非法运算
13.         if isinstance(other, Point):
14.             # 返回新的 Point 实例（不修改原对象）
15.             return Point(self.x + other.x, self.y + other.y)
16.         # 若 other 类型不支持，抛出错误（符合 Python 内置类型的行为）
17.         raise TypeError(f"不支持 {type(other)} 类型与 Point 类型相加")
19. # 使用 + 运算，自动调用 __add__
20. try:
21.     p1 = Point(1, 2)
22.     p2 = info(3, 4)
23.     p3 = p1 + p2  # 等价于 p1.__add__(p2)
24.     print(p3.x, p3.y)  
25. except Exception as e:
26.     print(f'失败原因：{e}') #失败原因：不支持 <class '__main__.info'> 类型与 Point 类型相加

复制代码

__len__:  自定义 “长度” 逻辑
       当对对象使用 len() 函数时，Python 会自动调用 __len__ 方法，返回对象的 “长度”

1. class Students:
2.     def __init__(self):
3.         self.list = []
4.     def add(self,name):
5.         self.list.append(name)
6.     def __len__(self):
7.         return len(self.list)   
8. obj1 = Students()
9. obj1.add('guahan')
10. obj1.add('gh')
11. print(len(obj1))>>>2

复制代码

__eq__:  自定义 “相等” 逻辑  返回布尔类型
     当对两个对象使用 == 运算符时，Python 会自动调用 __eq__ 方法，判断两个对象是否 “相等”

1. class Students:
2.     def __init__(self,name):
3.         self.name = name
4. class info:
5.     def __init__(self,name):
6.         self.name = name  
7.     def __eq__(self,other):
8.         if isinstance(other,info):
9.             return self.name == other.name
10.         raise Exception('对象类型不匹配')
11. try:
12.     obj1 = info('guohan')
13.     obj2 = Students('guohan')
14.     print(obj1 == obj2)
15. except Exception as e:
16.     print(f'比较失败原因：{e}')
17. >>>比较失败原因：对象类型不匹配
24. self：代表当前对象（比如 obj1）。
25. other：代表被比较的另一个对象（比如 obj2）。
26. self.name：当前对象的 name 属性（比如 obj1.name 是 "guohan"）。
27. other.name：被比较对象的 name 属性（比如 obj2.name 是 "gh"）。
28. ==：判断两者的 name 是否相同。
29. return：将判断结果（True 或 False）返回给 == 运算符

复制代码

__iter__:  让对象成为迭代器

1. class Foo:
2.         def __iter__(self):
3.             yield 1
4.             yield 2
5.             yield 3
6. obj = Foo()
7. for i in obj:
8.       print(i)
9. >>>
10. 1
11. 2
12. 3

复制代码

 
 让你自己写的类，能用和列表、字典一样的 “键 / 索引操作”（比如 obj[key]），不用额外记新方法，还能按需求自定义规则:
__setitem__:
__getitem__:
__delitem__:

1. #1
2. class Foo(object):
3.     def __init__(self):
4.         self.dict = {}
5.     def __setitem__(self, key, value):
6.         self.dict[key] = value
7.     def __getitem__(self,key):
8.         return self.dict[key]
9.     def __delitem__(self,key):
10.         del self.dict[key]
11.     def __call__(self):
12.         return self.dict
14. obj = Foo()
15. obj['k1'] = 123  # 内部会自动调用 __setitem__方法
16. obj['k2'] = 666
17. print(obj(),type(obj()))        >>>{'k1': 123, 'k2': 666} <class 'dict'>
18. print(obj['k1'])
19. print(obj['k2'])
20. del obj['k2']
21. print(obj(),type(obj()))
23. #2
24. class Foo(object):
25.     def __init__(self):
26.         self.dict = {}
27.     def __setitem__(self, key, value):
28.         self.dict[key] = value
29.     def __getitem__(self,key):
30.         return self.dict[key]
31.     def __delitem__(self,key):
32.         del self.dict[key]
33.     def __str__(self):
34.         return f'{self.dict}'
36. obj = Foo()
37. obj['k1'] = 123  # 内部会自动调用 __setitem__方法
38. obj['k2'] = 666
39. print(obj,type(obj))        >>>{'k1': 123, 'k2': 666} <class '__main__.Foo'>
40. print(obj['k1'])
41. print(obj['k2'])
42. del obj['k2']
43. print(obj,type(obj))

复制代码

 
上下文管理：  __enter__(self)  __exit__(self,exc_type,exc_val,exc_tb)  

1. class Foo(object):
2.     def __enter__(self):
3.         print('开始')
4.         return 333
5.     def __exit__(self,exc_type,exc_val,exc_tb):
6.         print('结束')
7. #上下文管理语句
8. with Foo() as f:    #先执行enter方法将其返回值给f再执行上下文管理语句中的内容最后去执行exit方法
9.     print(f)
10. >>>
11. 开始
12. 333
13. 结束

复制代码

 
     3.内置函数补充
        1.isinstance，判断是不是类的实例  返回布尔类型

1. class Foo:
2.     def __init__(self):
3.         pass
4. obj = Foo()
5. print(isinstance(obj,Foo))

复制代码

        
        2.issubclass，判断是否为某个类的派生类  返回布尔类型

1. class Foo:
2.     def __init__(self):
3.         pass
4. class Base(Foo):
5.     pass
6. class Bar(Base):
7.     pass
8. print(issubclass(Bar,Foo))

复制代码

  
        3.super（），往上一级

1. class Foo():
2.     def func(self):
3.         return 'guohan'
4. class Base(Foo):
5.     pass
6. class Bar(Base):
7.     def __str__(self):
8.         return f'{super().func()}'
9. obj = Bar()
10. print(obj)
11. #super().func() 根据类的继承关系，按照顺序挨个找func方法并执行(找到第一个就不在找了)

复制代码

 
 
      4.异常处理
        1.基本格式：

1. try:
2.     pass
3. except Exception as e:
4.     print(e)

复制代码

        2.主动触发异常：    raise Exception (  '  异常原因‘  ）

1. def run():
2.     try:
3.         num = input('输入数字：')
4.         if not num.isdecimal():
5.             raise Exception('输入的不是数字')#主动触发异常，将异常信息再最后面显示
6.         else:
7.             print(int(num))
8.     except Exception as e:
9.         print(f'异常原因:{str(e)}')
11. if __name__ == '__main__':
12.     run()
13.    
14. >>>输入数字：g
15. >>>异常原因:输入的不是数字

复制代码

 
        3.finally

 
 
 
 
 
 
自定义异常\抛出异常：待补（写项目时）
19-8 异常：自定义和抛出异常_哔哩哔哩_bilibili
 
 
 
 
 
 
 
       5.迭代器，生成器，可迭代对象

 

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！