1.多态 2.ininstance,issubclass3.str,del,call,slots 4. .取值 5.[]取值 6.运算符重载 7.迭代器类 8.上下文 # 23...

快来打我* 2021-09-30 10:02 157阅读 0赞

面向对象知识点

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 """"""
     2 """
     3 多态
     4     一种事物具备多种不同的形态
     5     例:水:固态 气态 液态
     6     大黄蜂:汽车人,汽车,飞机
     7 
     8 官方解释:
     9     多个不同对象可以响应同一个方法,产生不同的结果
    10 首先强调
    11     多态不是一种特殊的语法,
    12     而是一种状态,特性
    13     (即:多个不同对象可以响应同一个方法,产生不同的结果)
    14     即:多个对象有相同的使用方法
    15     
    16     好处:对于使用者而言,大大降低了使用难度
    17     
    18     例如 :之前写的USB接口,鼠标,键盘都属于多态
    19     
    20 实现多态:
    21     接口 抽象 鸭子类型
    22     都可以写出具备多态的代码,最简单的就是鸭子类型
    23     
    24 """
    25 #"""案例"""
    26 """
    27 要管理鸡,鸭,鹅
    28 如何能够最方便的管理,即我说同一句话,他们都能理解,即他们拥有同一种方法
    29 """
    30 class Ji:
    31     def bart(self):
    32         print('咯咯咯...')
    33     def spawn(self):
    34         print('下蛋了...')
    35 class Duck:
    36     def bart(self):
    37         print('嘎嘎嘎...')
    38     def spawn(self):
    39         print('下蛋了...')
    40 class E:
    41     def bart(self):
    42         print('鹅鹅鹅...')
    43     def spawn(self):
    44         print('下蛋了...')
    45 # 规范
    46 def mange(obj):
    47     obj.bart()
    48     obj.spawn()
    49 
    50 j = Ji()
    51 mange(j)
    52 d= Duck()
    53 mange(d)
    54 e = E()
    55 mange(e)
    56 """
    57 咯咯咯...
    58 下蛋了...
    59 嘎嘎嘎...
    60 下蛋了...
    61 鹅鹅鹅...
    62 下蛋了...
    63 """
    64 # """案例2"""
    65 # python中到处都有多态
    66 a = 10
    67 b = "10"
    68 c = [10]
    69 
    70 print(type(a))
    71 print(type(b))
    72 print(type(c))
    73 """
    74 <class 'int'>
    75 <class 'str'>
    76 <class 'list'>
    77 """

1.多态和多态性的实现.py

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 """"""
     2 """
     3 1.isinstance  
     4     判断一个对象是否是某个类的实例
     5     参数1:要判断的对象
     6     参数2:要判断的类型
     7     语法:
     8     isinstance(实例化对象,数据类型)
     9 """
    10 # 案例
    11 def add_cost(x,y):
    12     if isinstance(x,str) and isinstance(y,str):
    13         return x+y
    14     return None
    15 a = add_cost('12','45')
    16 print(a)  # 1245
    17 b = add_cost('1',2)
    18 print(b)  # None
    19 """
    20 2.issubclass
    21     判断一个类是否是另一个类的子类
    22     参数1:子类
    23     参数2 :父类
    24     语法:
    25     issubclass(子类,父类)
    26 """
    27 # 案例:
    28 class Animal:
    29 
    30     def eat(self):
    31         print("动物得吃东西...")
    32 class Pig(Animal):
    33     def eat(self):
    34         print('猪吃猪食...')
    35 
    36 class Dog(Animal):
    37     def eat(self):
    38         print('狗吃狗粮...')
    39 
    40 class Tree:
    41     def lifht(self):
    42         print('植物光合作用')
    43 
    44 # 协议
    45 def sucess(obj):
    46     # obj 的类是否继承自obj
    47     if issubclass(type(obj),Animal):
    48         obj.eat()
    49     else:
    50         print('123')
    51 
    52 p = Pig()
    53 sucess(p)  # 猪吃猪食...
    54 d = Dog()
    55 sucess(d)  # 狗吃狗粮...
    56 t = Tree()
    57 sucess(t)  # 123
    58 print(issubclass(Tree,object))  # True

2.OOP相关内置函数.py

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 ''''''
     2 """
     3 1.str
     4     __str__会在对象被转换为字符串时,转换的结果就是这个函数的返回值
     5     
     6     作用:自定义打印结果
     7     
     8     使用场景:我们可以利用该函数来自定义,对象的打印格式
     9 """
    10 # 案例:
    11 class Person:
    12     def __init__(self,name,age):
    13         self.name = name
    14         self.age = age
    15     def __str__(self):
    16         return 'name:%s age:%s'%(self.name,self.age)  # name:llx age:123
    17 p = Person('llx','123')
    18 print(p)  # name:llx age:123
    19 '''
    20 2.del
    21     执行时机:手动删除对象时立马执行,或是程序运行结束时,也会自动执行
    22     
    23     使用场景:
    24     当你的对象在使用过程中,打开了不属于解释器的资源:例如文件,网络端口
    25 
    26 '''
    27 # 案例
    28 class FileTool:
    29     """该类用于简化文件的读写操作"""
    30     def __init__(self,path):
    31         self.file = open(path,"rt",encoding="utf-8")
    32         self.a = 100
    33     def read(self):
    34         return self.file.read()
    35     # 在这里可以确定一个事,这个对象肯定不使用了 所以可以放心的关闭问文件了
    36     def __del__(self):
    37         self.file.close()
    38 f = FileTool('a.txt')
    39 # print(f.read())
    40 print(f.__del__())  # 已关闭
    41 """
    42 3.call
    43 执行时机:在调用自身时执行(即,对象+())
    44 """
    45 # 案例:
    46 # call的执行时机
    47 class A:
    48     def __call__(self,*args,**kwargs):
    49         print("call run")
    50         print(args)
    51         print(kwargs)
    52 a = A()
    53 a(1,2,3,4,5)  # (1, 2, 3, 4, 5)
    54 print(a)
    55 """
    56 4.__slots__
    57     该属性是一个类属性.
    58     作用:用于优化对象内存占用,
    59     
    60     优化的原理:将原本不固定的属性数量变得固定了
    61     
    62     这样解释器也就不会为这个对象创建名称空间,所以__dict__也没了
    63     
    64     从而达到减少内存开销的结果
    65     
    66     另外当类中出现slots时将导致这个类的对象将无法再添加新的属性
    67 """
    68 # 案例
    69 class Person:
    70     __slots__ = ["name","age","money"]
    71     def __init__(self,name,age,money):
    72         self.name = name
    73         self.age = age
    74         self.money =money
    75         # 当类中出现slots时将导致这个类的对象将无法再添加新的属性,只能添加他所在类的属性
    76         # print(self.__dict__)  # dict 没有了
    77         # AttributeError: 'Person' object has no attribute '__dict__'
    78 p = Person('jck','20',10000)
    79 import sys
    80 # sys.getsizeof 方法可以查看 python 对象的内存占用，单位：字节 (byte)
    81 print(sys.getsizeof(p))   # 64
    82 # print(p)

3.类中的魔法函数.py

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 """"""
     2 """
     3 getattr 用点访问属性时,如果属性不存在时执行
     4 setattr 用点设置属性时
     5 delattr 用del 对象.属性 删除属性时执行
     6 
     7 ps:
     8     getattribute 该函数也是用来获取属性的,
     9     在获取属性时,如果存在getattribute则先执行该函数,
    10     如果没有拿到属性则继续调用getattr函数,
    11     如果拿到则直接返回
    12 """
    13 # 案例:
    14 class A:
    15     def __setattr__(self,key,value):
    16         print(key)
    17         print(value)
    18         print("__setattr__")
    19         self.__dict__[key] = value
    20 
    21     def __delattr__(self, item):
    22         print("__delattr__")
    23         print(item)
    24         self.__dict__.pop(item)
    25     def __getattr__(self,item):
    26         print("__getattr__")
    27         return 1
    28     def __getattribute__(self, item):
    29         print("__getattribute__")
    30         # return self.__dict__[item]
    31         return super().__getattribute__(item)
    32 
    33 a = A()
    34 # setattr 用点设置属性时
    35 a.name = 'llx'
    36 print(a.name)
    37 """
    38 name
    39 llx
    40 __setattr__
    41 __getattribute__
    42 __getattribute__
    43 llx
    44 """
    45 # delattr 用del 对象.属性 删除属性时执行
    46 del a.name
    47 print(a.name)
    48 """
    49 __delattr__
    50 name
    51 __getattribute__
    52 __getattribute__
    53 __getattr__
    54 1
    55 """
    56 # getattr 用点访问属性时,如果属性不存在时执行
    57 print(a.xxx)
    58 """
    59 __getattribute__
    60 __getattr__
    61 1
    62 """
    63 """
    64 ps:
    65     getattribute 该函数也是用来获取属性的,
    66     在获取属性时,如果存在getattribute则先执行该函数,
    67     如果没有拿到属性则继续调用getattr函数,
    68     如果拿到则直接返回
    69 """
    70 a.name = 'xxx'
    71 print(a.name)
    72 """
    73 name
    74 xxx
    75 __setattr__
    76 __getattribute__
    77 __getattribute__
    78 xxx
    79 """
    80 b = A()
    81 b.__dict__["name"] = "wyf"
    82 print(b.name)
    83 """
    84 __getattribute__
    85 __getattribute__
    86 wyf
    87 """

4.(.取值)属性的get set 和del.py

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 """"""
     2 """[]的实原理"""
     3 """getitem,setitem,delitem"""
     4 """
     5 任何符号,都会被解释器解释成特殊含义,例如 . [] ()
     6 """
     7 """
     8 getitem 当你用中括号去获取属性时 执行
     9 setitem 当你用中括号去设置属性时 执行
    10 delitem 当你用中括号去删除属性时 执行 
    11 """
    12 # 案例1:
    13 # class A:
    14 #     def __getitem__(self, item):
    15 #         print("__getitem__")
    16 #         return self.__dict__[item]
    17 #     def __setitem__(self, key, value):
    18 #         print("__setitem__")
    19 #         self.__dict__[key] = value
    20 #     def __delitem__(self, key):
    21 #         del self.__dict__[key]
    22 #         print("__delitem__")
    23 # a = A()
    24 # # getitem 当你用中括号去获取属性时 执行
    25 # a.name = 'llx'
    26 # # setitem 当你用中括号去设置属性时 执行 覆盖
    27 # # a['name'] = 'llw'
    28 # print(a['name'])
    29 # delitem 当你用中括号去删除属性时 执行 删掉
    30 # del a['name']
    31 # print(a['name'])
    32 
    33 """案例2"""
    34 """
    35 需求让一个对象支持 点语法来取值 也支持括号取值
    36 """
    37 class MyDict(dict):
    38 
    39     def __getattr__(self, key):
    40         return self.get(key)
    41     def __setattr__(self, key, value):
    42         self[key] = value
    43     def __delattr__(self, item):
    44         del self[item]
    45 
    46 b = MyDict()
    47 b["name"] = "jack"
    48 print(b["name"])
    49 print(b.name)
    50 """
    51 jack
    52 jack
    53 """
    54 b.age = 20
    55 print(b["age"])  # 20

5.(\[\]取值)getitem,setitem,delitem.py

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 """"""
     2 """
     3 运算符重载
     4     当我们在使用某个符号时,
     5     Python解释器都会为这个符号定义一个含义,
     6     同时调用对应的处理函数,
     7     
     8     当我们需要自定义对象比较规则时,
     9     就可在子类中覆盖 大于 等于 等一系列方法...
    10 """
    11 """
    12 案例:
    13 
    14     原本自定义对象无法直接使用大于小于来进行比较 ,
    15     我们可自定义运算符来实现,
    16     让自定义对象也支持比较运算符  
    17 """
    18 class Student:
    19     def __init__(self,name,height,age):
    20         self.name = name
    21         self.height = height
    22         self.age = age
    23     def __gt__(self, other):
    24         print(self)
    25         print(other)
    26         print("__gt__")
    27         return self.height>other.height
    28     def __lt__(self, other):
    29         return self.height<other.height
    30     def __eq__(self, other):
    31         if self.name == other.name and self.age == other.age and self.height == other.height:
    32             return True
    33         return False
    34 s1 = Student('llw','174','18')
    35 s2 = Student('llx','180','24')
    36 
    37 print(s1 == s2)  # False
    38 print(s1>s2)
    39 """
    40 <__main__.Student object at 0x0000024008F821D0>
    41 <__main__.Student object at 0x0000024008F82208>
    42 __gt__
    43 False
    44 """
    45 print(s1<s2)  # True
    46 """
    47 上述代码中,other指的是另一个参与比较的对象,
    48 
    49 大于和小于只要实现一个即可,符号如果不同  解释器会自动交换两个对象的位置 
    50 """

6.(运算符重载)对象比较大小.py

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 """"""
     2 """
     3 迭代器协议
     4 
     5     迭代器是指具有__iter__和__next__的对象
     6     
     7     我们可以为对象增加两个方法来让对象变成一个迭代器
     8 """
     9 # 语法
    10 # 案例:自定义一个range
    11 class MyRange:
    12     def __init__(self,start,end,step=1):
    13         self.start = start
    14         self.end = end
    15         self.step = step
    16     def __iter__(self):
    17         return self
    18     def __next__(self):
    19         a = self.start
    20         self.start += self.step
    21         if self.end > a:
    22             return a
    23         else:
    24             # 报错停止
    25             raise StopIteration
    26 m = MyRange(1,10,3)
    27 m.__iter__()
    28 print(m.__next__())
    29 print(m.__next__())
    30 print(m.__next__())
    31 # print(m.__next__())
    32 """
    33 1
    34 4
    35 7
    36 raise StopIteration
    37 StopIteration
    38 """
    39 for i in MyRange(1,100,10):
    40     print(i)

7.迭代器类 \_\_iter\_\_,\_\_next\_\_.py

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 """"""
     2 """
     3 1.上下文管理
     4 
     5     上下文 context
     6     
     7     这个概念属于语言学科,指的是一段话的意义,要参考当前场景,即:上下文
     8     
     9     在Python中,上下文可以理解为是一个代码区间,一个范围,
    10     例如with open打开的文件,仅在这个上下文中有效
    11 """
    12 """
    13 2.涉及到两个方法
    14     1.enter:表示进入上下文,(进入某个场景了)
    15     2.exit:表示退出上下文,(退出某个场景了)
    16     
    17     当执行with 语句时,会先执行enter,
    18     当代码执行完毕后执行exit,
    19     或者代码遇到异常会立刻执行exit,并传入错误信息
    20     
    21     错误信息类型:错误的信息,错误的追踪信息
    22     
    23 ps:
    24     enter 函数应该返回对象自己
    25     
    26     exit函数 可以有返回值,是一个bool类型,用于表示一场是否被处理,仅在上下文中出现异常有用
    27     
    28     如果为 True 意味着异常已经被处理
    29     False,异常未被处理,程序中断出错 
    30 """
    31 class MyOpen:
    32     def __init__(self,path):
    33         self.path = path
    34     def __enter__(self):
    35         self.file = open(self.path)
    36         print("enter....")
    37         return self
    38     def __exit__(self, exc_type, exc_val, exc_tb):
    39         print('exit...')
    40         print(exc_type, exc_val, exc_tb)
    41         self.file.close()
    42         return True
    43 with MyOpen('a.txt')as f:
    44     print(f)
    45     # print(f.file.read())
    46     # 中途不能插入其他无关数据,否则就不是的上下文了
    47     "123"+1
    48     f.file.read()
    49     print(f.file.read())
    50 """
    51 enter....
    52 <__main__.MyOpen object at 0x000001F503CF8518>
    53 asasasa
    54 exit...
    55 <class 'TypeError'> must be str, not int <traceback object at 0x000001F503D01F08>
    56 """

8.上下文管理.enter,exit.py

总结

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 1.多态
     2 
     3     是一种状态,如果程序具备这种状态,对象的使用者,可以很方便忽略对象之间的差异
     4 
     5     我们可以通过鸭子类型来让程序具备多态性
     6 
     7 2.一对函数
     8 
     9  isinstance(对象实例化,数据类型)   判断类型 优先
    10 
    11 issubclass(子类,父类) 判断两者是否是父子关系   优先
    12 
    13 3.类中的魔法函数
    14 
    15 str  优先
    16     __str__  会在对象被转换为字符串时,转换的结果就是这个函数的返回值
    17     使用场景:我们可以利用该函数来自定义,对象的是打印格式
    18 
    19 del  优先
    20     执行时机: 手动删除对象时立马执行,或是程序运行结束时也会自动执行
    21     使用场景:当你的对象在使用过程中,打开了不属于解释器的资源:例如文件,网络端口
    22 
    23 call
    24     执行时机:在调用对象时自动执行,(既对象加括号)
    25 
    26 slots   __slots__ = ["name"] 限制作用
    27     该属性是一个类属性,用于优化对象内存占用
    28     优化的原理,将原本不固定的属性数量,变得固定了
    29     这样的解释器就不会为这个对象创建名称空间,所以__dict__也没了
    30     从而达到减少内存开销的效果
    31 
    32 4.点语法的 实现   getattr setattr delattr
    33 print(a.name)
    34 
    35 5.[]取值的实现  getitem setitem delitem
    36 print(a["name"])
    37 
    38 6.运算符重载,可以让对象具备相互间比较的能力
    39 # 传进类中两个对象,在方法中进行比较,返回符合的结果
    40 7.迭代器的两个函数   iter next
    41 
    42 8.上下文管理    优先   可以实现自动清理     与del的区别 del管理的是对象的生命周期  会在对象销毁时执行清理
    43 
    44 上下文管理,管理的是一个代码范围 ,出了范围自动清理

总结

转载于:https://www.cnblogs.com/llx--20190411/p/11266630.html

[ContractedBlock.gif]: https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif
[ExpandedBlockStart.gif]: /images/20210724/e5960331e43e47b9bf1a8ec67dda7469.png