首页 / PYTHON / Python_基础_(面向对象进阶)

Python_基础_(面向对象进阶)

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Python_基础_(面向对象进阶)，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含14174字，纯文字阅读大概需要21分钟。

内容图文

一，isinstance(obj,cls)　　issubclass(sub,super)

isinstance(obj,cls)　　# 判断对象obj是否是cls的一个实例

            class
             Test:
    
            pass
            
t = Test()
print(isinstance(t,Test))   # True

issubclass(sub,super)　　# 判断类sub是否为类super的子类

            class
             Test:
    
            pass
            class
             Sub(Test):
    
            pass
            print(issubclass(Sub,Test))     # True
s = Sub()
print(isinstance(s,Sub))        # Trueprint(isinstance(s,Test))       # True

type(f)　　# 可以用来看对象f使用哪个类产生的

            class
             Foo:
    
            pass
            
f = Foo()
print(type(f))
# <class ‘__main__.Foo‘>

....

二，__getattribute__

## 当 __getattr__和 __getattribute__同时出现时

            class
             Test:
    
            def
            __init__
            (self,name):
        self.name = name
    
    def__getattr__(self,item):
        print("执行的是__getattr__")
        
    def__getattribute__(self,item):
        print("执行的是__getattribute__")
        
t = Test("henry")
t.name     # 当调用存在的属性：触发 __getattribute__  不触发 __getattr
t.xxxxxx# 当调用不存在的属性：触发 __getattribute__

## __getattribute__ 抛出异常时

            class
             Test:
    
            def
            __init__
            (self,name):
        self.name = name
    
    def__getattr(self,item):
        print("执行的是__getattr__")
        
    def__getattribute__(self,item):
        print("执行的是__getattribute__")
        raise AttributeError("抛出一个属性异常")
t = Test("henry")
t.xxxxxx    # 执行 __getattribute__时会抛出一个属性异常，不会直接报错，而后会去执行 __getattr__
## 输出执行的是__getattribute__
执行的是__getattr__
# 注：当抛出的异常不是AttributeError，不会去执行 __getattr__ ，而是直接终止程序

...

三，__setitem__　　__getitem__　　__delitem__

# 字典形式的操作属性就是和item相关
# 点的形式操作属性，就是和内置方法相关

            class
             Test:
    
    
            def
            __setitem__
            (self,key,value):
        parint(
            "
            __sttitem__
            "
            )
        self.
            __dic__[key] = value
    
    def__getitem__(self,item):
        parint("__getitem__")
        
    def__delitem__(self,key):
        print("__delitem__")
        self.__dic__.pop(key)
## 添加
t = Test()
t["name"] = "henry"# 添加一个属性和值，会触发 __setitem__
t["user"] = "alex"print(t.__dic__)    # {"name":"henry"}## 删除del t.name            # 不会触发item操作 只是普通的操作print(t.__dic__)    # {}del t["name"]        # 会触发__delitem__print(t.__dic__)    # {}## 获取
t.user                # 不会触发getitem操作
t["user"]            # 会触发__getitem__

...

四，__str__　　__repr__

# 当打印一个实例化的对象时

            class
             Test:
    
            pass
            
t = Test()
print(t)    # <__main__.Test object at 0x00000299CE10EBA8>

# __str__ 可以控制打印实例化的对象时的信息

            class
             Test:
    
            def
            __str__
            (self):
        
            return
            "
            我是实例化的对象打印的信息
            "
            
t = Test()
print(t)    # 我是实例化的对象打印的信息

# __repr__ 也是用于控制输出，应用于解释器中（cmd）

            class
             Test:
    
            def
            __repr__
            (self):
        
            return
            "
            我是实例化的对象打印的信息
            "
            
t = Test()
print(t)    # 我是实例化的对象打印的信息

# 注意

## 两者共存时，优先选择str
## 如果__str__没有被定义，那么就会用__repr__来替代输出
## str 和 repr 输出的结果返回的值都为字符串类型

            class
             Test:
    
            def
            __str__
            (self):
        
            return
            "
            自定义的对象显示方式str
            "
            def
            __repr__
            (self):
        
            return
            "
            自定义的对象显示方式repr
            "
            
t = Test()
print(t)    # 输出：自定义的对象显示方式str

 ...

五，自定义格式化 __format__ 

            class
             Test:
    
            def
            __init__
            (self,year,mon,day):
        self.year = year
        self.mon = mon
        self.day = day
t = Test(2018,12,22)
x = "{0.year},{0.mon},{0.day}".format(t)
y = "{0.year}:{0.mon}:{0.day}".format(t)
z = "{0.year}-{0.mon}-{0.day}".format(t)
print(x)    # 2018,12,22print(y)    # 2018:12:22print(z)    # 2018-12-22

# 当上方的程序要换一种日期输出格式时，必须得用户来定义，这必然是不行的

format_dic = {
    "ymd":"{0.year},{0.mon},{0.day}",
    "y:m:d":"{0.year}:{0.mon}:{0.day}",
    "y-m-d":"{0.year}-{0.mon}-{0.day}"
}
class Test:
    def__init__(self, year, mon, day):
        self.year = year
        self.mon = mon
        self.day = day
    def__format__(self, format_spec):
        ifnot format_spec or format_spec notin format_dic:
            # 当用户没有输入格式时，程序自己选择为ymd# 当用户输入的格式不存在时
            format_spec = "ymd"
        fm = format_dic[format_spec]
        return fm.format(self)  # 相当于"{0,year}-{0,mon}-{0,day}",format(t)
t = Test(2018, 12, 22)
format(t)  # 相当于执行了 t.__format__()print(format(t, "ymd"))     # 2018,12,22print(format(t, "y:m:d"))   # 2018:12:22print(format(t, "y-m-d"))   # 2018-12-22

...

六，__slots__

1：__slots__：是一个变量，变量的值可以是列表，元组，字符串，可迭代的对象
2：当用点来访问一个属性时，实际上是在访问类或者对象的__dict__属性字典（类的属性字典是共享的，可被每个实例对象访问；二实例的字典是独立的）
3：为何使用了__slots__：因为字典会占用大量的内存，使用了__slots__不能再给其添加属性，只能使用之前在__slots__中定义的
4：定义了__slots__后不在支持一些普通类的特性，比如继承

# 基本形式

            class
             Test:
    
            __slots__ = "name"# __slots__ = [‘name‘,‘age‘]    
t = Test()
t.name = "henry"
t.age = 18            
# 报错，当前 __slots__替代了 __dic__，不能添加该属性
# 限制创建属性print(t.__slots__)        # nameprint(Test.__slots__)    # name

 ...

七，__doc__　　__module__　　__class__

# __doc__

            #
             注：该属性不能被继承
            class
             Test:
    
            ‘
            我是文档注释
            ‘
            pass
            
    
pring(Test.
            __doc__
            )


            #
             不能被继承
            class
             Test:
    
            ‘
            我是文档注释
            ‘
            pass
            class
             Foo(Test):
    
            pass
            print(Foo.__doc__)    # 无法继承给子类

# __module__    __class__    

            #
             test1.py位于文件 lib下
            class
             A:
    
            def
            __init__
            (self):
        self.name = name

# 在test2.py文件中导入 test1.py模块from lib.test1 import A

obj = A()
print(obj.__module__)    # 输出lib.test1        # 输出模块print(obj.__class__)    # 输出 lib.test1.A    # 输出类

...

八，__del__析构方法

 1：当对象在内存中被释放时，自动触发执行

2：在Python中程序员无需关心内存的分配和释放，Python解释器会自动来执行，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的，该方法一般无需定义

# 当删除一个对象时，触发__del__

            class
             Test:
    
            def
            __del__
            (self):
        
            print("执行了del方法")
t = Test()
del t        # 删除对象print("程序执行完毕")
# 输出执行了del方法
程序执行完毕

# 当程序执行完毕后，触发__del__

            class
             Test:
    
            def
            __del__
            (self):
        
            print("执行了del方法")
t = Test()
print("程序执行完毕")
# 输出程序执行完毕
执行了del方法
# 在程序执行完成后，会执行垃圾回收机制

# 当删除一个属性时，不会触发__del__

            #
             当删除一个属性时，不会执行__del__方法
            class
             Test:
    
            def
            __init__
            (self,name):
        self.name = name
    def__del__(self):
        print("执行了del方法")
t = Test("henry")
del t.name
print("程序执行完毕")
# 输出程序执行完毕
执行了del方法

...

九，__call__ 

            class
             Test:
    
            def
            __call__(self, *args, **kwargs):
        print("执行了__call__")

t = Test()
t()     # 一个对象后加括号，触发执行__call__

# 一切皆对象，假如Test类由类Foo产生，则执行Test()，相当于执行了类Foo下的__call__方法

十，__next__　　__iter__

 ..待完成

十一，描述符的基本概况

 # 描述符：本质就是在一个新式类中，这个新式类中至少实现 __get__(),__set__(),__delete__()中的一个，这三个也被称为描述符协议

__get__() # 调用一个属性时触发

__set__() # 给一个属性赋值时触发

__delete__() # 利用del删除属性时触发

# 什么情况下会触发着三个方法（以下为错误示范）

            class
             Test:
    
            def
            __init__
            (self,name,age):
        self.name = name
        self.age = age

    def__set__(self, instance, value):
        print("__set__")

    def__get__(self, instance, owner):
        print("__get__")

    def__delete__(self, instance):
        print("__delete__")

t = Test("henry",18)
t.name          # 没调用
t.name = "alex"# 没调用del t.name      # 没调用

# 什么情况下会触发这三个方法（以下为正确示范）

            class
             Test:
    
            def
            __get__
            (self, instance, owner):
        
            print("触发__get__")
    def__set__(self, instance, value):
        print("触发__set__")
    def__delete__(self, instance):
        print("触发__delete__")

class Bar:
    name = Test()
    # 数据描述符# 表示一个描述符 所有与name有关的操作都去找类Test# 表示在类Bar中利用类Test来描述name属性def__init__(self,name):    # name被Test()代理
        self.name = name

b = Bar("henry")        # 触发__set__，instance为b，value为henry
b.name                  # 触发__get__
b.name = "heihei"# 触发__set__del b.name              # 触发__delete__print(b.__dict__)       # {}print(Bar.__dict__)     # ‘name‘: <__main__.Test object at 0x0000017E78719470>
技术分享图片 技术分享图片 
                class
                 Test_1:
    
                def
                __get__
                (self, instance, owner):
        
                print("Test_1触发__get__")
    def__set__(self, instance, value):
        print("Test_1触发__set__")
    def__delete__(self, instance):
        print("Test_1触发__delete__")
class Test_2:
    def__get__(self, instance, owner):
        print("Test_2触发__get__")
    def__set__(self, instance, value):
        print("Test_2触发__set__")
    def__delete__(self, instance):
        print("Test_2触发__delete__")

class Bar:
    name = Test_1()
    age = Test_2()
    def__init__(self,name,age):    # name被Test_1()代理,age被Test_2()代理
        self.name = name
        self.age = age

b = Bar("henry",18)
# Test_1触发__set__
# Test_2触发__set__# Test_1b.name
b.name = "heihei"del b.name
# Test_1触发__get__
# Test_1触发__set__
# Test_1触发__delete__# Test_2b.age
b.age = 19
del b.age
# Test_2触发__get__
# Test_2触发__set__
# Test_2触发__delete__print(b.__dict__)       # {}print(Bar.__dict__)
# ‘name‘: <__main__.Test_1 object at 0x0000021EF9F7F780>, 
# ‘age‘: <__main__.Test_2 object at 0x0000021EF9F7FCC0>,
相同的一种示范

# 数据描述符和非数据描述符

技术分享图片 技术分享图片 
                #
                 数据描述符
                class
                 Foo:
    
                def
                __set__
                (self, instance, value):
       
                print(‘set‘)    
    def__get__(self, instance, owner):
       print(‘get‘)

# 二 非数据描述符:没有实现__set__()class Foo:
    def__get__(self, instance, owner):
        print(‘get‘)
示例代码

# 描述符的注意事项

一：描述符不本身应该定义成新式类，被代理的类也应该时形式类

二：必须把描述符定义成则个类的类属性，不能为定义到构造函数中

三：要严格遵循优先级

1，类属性

2，数据描述符　　　　 # 具有 __get__()和__set__()

3，实例属性

4，非数据描述符　　 # 没有__set__()

5，找不到属性触发 __getattr__()

# 描述符优先级问题

## 类属性>数据描述符

技术分享图片 技术分享图片 
                class
                 Test:
    
                def
                __get__
                (self, instance, owner):
        
                print("调用get")
    def__set__(self, instance, value):
        print("调用set")
    def__delete__(self, instance):
        print("调用delete")

class Foo:
    name = Test()
    def__init__(self,name):
        self.name = name

Foo.name            # # 输出：调用get
# 在Foo的属性字典中，‘name‘: <__main__.Test object at 0x00000262B7BF97B8>,
# 当调用属性name时，属性name为描述符伪装成类属性name，当在类中找不到属性对饮的值，就到类Test中，触发了__get__()
Foo.name = "henry"# 直接赋值类的一个属性，因为类属性拥有更高的优先级，相当于覆盖了描述符，不会触发描述符中的__set__()print(Foo.__dict__)     # "name":"henry"del Foo.name            # 删除的为类中的类属性，没有触发__delete__()
示例代码

## 数据描述符>实例属性

技术分享图片 技术分享图片 
                class
                 Test:
    
                def
                __get__
                (self, instance, owner):
        
                print("调用get")
    def__set__(self, instance, value):
        print("调用set")
    def__delete__(self, instance):
        print("调用delete")

class Foo:
    name = Test()
    def__init__(self,name):
        self.name = name

f = Foo("henry")
print(f.__dict__)   # {}
# 实例的属性字典中没有name，因为name是一个数据描述符，优先级高于实例属性，查看/赋值/删除/都和实例无关
f.name = "heihei"# 输出：调用set
# 先在自己的实例属性中找，找不到则到类中找
# f.name的调用与赋值都是触发描述符的操作，与f本身无法无关，相当于覆盖了实例属性del f.name  # 调用delete
示例代码

## 实例属性>非数据描述符

技术分享图片 技术分享图片 
                class
                 Test:
    
                def
                __get__
                (self, instance, owner):
        
                print("调用get")
    # def __delete__(self, instance):#     print("调用delete")class Foo:
    name = Test()       # 变成了非数据描述符# name是一个非数据描述符，因为name=Test() 而Test()没有实现set方法，因而比实例属性由更低的优先级
f = Foo()
f.name  # 调用get
f.name = "henry"# 相当于在类Foo中进行设置属性的值print(f.__dict__)       # {‘name‘: ‘henry‘}
# 实例属性的优先级高于非数据描述符，当描述符中没有set时，就在自己的实例上添加属性
示例代码

...

十二，描述符的应用

# 描述符中的参数

技术分享图片 技术分享图片 
                class
                 Test:
    
                def
                __get__
                (self, instance, owner):
        
                print("执行get")
        print("instance参数为:%s" %instance)
        print("owner参数为:%s" % owner)
    def__set__(self, instance, value):
        print("执行set")
        print("instance参数为:%s" % instance)
        print("value参数为:%s" % value)
    def__delete__(self, instance):
        print("执行delete")
        print("instance参数为:%s" % instance)

class Foo:
    name = Test()
    def__init__(self,name,age,salary):
        self.name = name
        self.age = age
        self.salary = salary

f = Foo("henry",18,10.1)
# 执行set
# instance参数为:<__main__.Foo object at 0x000001F1E436E748>
# value参数为:henry
f.name
# 执行get
# instance参数为:<__main__.Foo object at 0x000001F1E436E748>
# owner参数为:<class ‘__main__.Foo‘>print(f.__dict__)
# name不存在对象f的字典中
# {‘age‘: 18, ‘salary‘: 10.1}
示例代码

# 简单操作

技术分享图片 技术分享图片 
                class
                 Test:
    
                def
                __init__
                (self,key):
        self.key = key

    def__get__(self, instance, owner):
        print("执行get")
        return instance.__dict__[self.key]     # instance为对象f，owner为类Foodef__set__(self, instance, value):
        print("执行set")
        instance.__dict__[self.key] = value        # 相当于给对象f添加键值对def__delete__(self, instance):
        print("执行delete")
        instance.__dict__.pop(self.key)

class Foo:
    name = Test("name")
    def__init__(self,name,age,salary):
        self.name = name
        self.age = age
        self.salary = salary

f = Foo("henry",18,10.1)
print(f.name)       # henryprint(f.__dict__)   # {‘key‘: ‘henry‘, ‘age‘: 18, ‘salary‘: 10.1}
f.name = "heihei"print(f.__dict__)   # {‘key‘: ‘heihei‘, ‘age‘: 18, ‘salary‘: 10.1}del f.name
print(f.__dict__)   # {‘age‘: 18, ‘salary‘: 10.1}
示例代码

# 针对name赋值时的类型检查

技术分享图片 技术分享图片 
                class
                 Test:
    
                def
                __init__
                (self,key):
        self.key = key

    def__get__(self, instance, owner):
        print("执行get")
        return instance.__dict__[self.key]     # instance为对象f，owner为类Foodef__set__(self, instance, value):
        print("执行set")
        ifnot type(value) == str:  # 判断类型raise TypeError("你传入的不是字符串类型")
        instance.__dict__[self.key] = value

    def__delete__(self, instance):
        print("执行delete")
        instance.__dict__.pop(self.key)

class Foo:
    name = Test("name")
    def__init__(self,name,age,salary):
        self.name = name
        self.age = age
        self.salary = salary

f = Foo(123,18,10.1)
执行set
Traceback (most recent call last):
  File "F:/Python_Project/Test/描述符的应用.py", line 26, in <module>
    f = Foo(123,18,10.1)
  File "F:/Python_Project/Test/描述符的应用.py", line 22, in__init__
    self.name = name
  File "F:/Python_Project/Test/描述符的应用.py", line 12, in__set__raise TypeError("你传入的不是字符串类型")
TypeError: 你传入的不是字符串类型
示例代码

# 针对name和age赋值时的类型检查

技术分享图片 技术分享图片 
                class
                 Test:
    
                def
                __init__(self,key,expected_type):   # expected_type想要检测的类型
        self.key = key
        self.expected_type = expected_type

    def__get__(self, instance, owner):
        print("执行get")
        return instance.__dict__[self.key]     # instance为对象f，owner为类Foodef__set__(self, instance, value):
        print("执行set")
        ifnot type(value) == self.expected_type:  # 判断类型raise TypeError("你传入的不是%s类型" %self.expected_type)
        instance.__dict__[self.key] = value

    def__delete__(self, instance):
        print("执行delete")
        instance.__dict__.pop(self.key)

class Foo:
    name = Test("name",str)
    age = Test("age",int)
    def__init__(self,name,age,salary):
        self.name = name
        self.age = age
        self.salary = salary

# f = Foo(123,18,10.1)    # TypeError: 你传入的不是<class ‘str‘>类型
f = Foo("henry","18",10.1)  # TypeError: 你传入的不是<class ‘int‘>类型
示例代码

...

十三，__enter__　　__exit__   上下文管理协议 

            #
            # 第一种文件操作（使用完得关闭文件）
f = open("xxx","r")
文件操作
f.close

## 另一种文件操作（使用完不必关闭文件）
with open("xxxx","r") as file
    "文件操作代码块"

# 上述称为上下文管理协议，即with语句，为了让一个对象兼容with语句，必须在这个对象的类中声明__enter__和__exit__方法

## 上下文管理协议

            #
             一 数据描述符:至少实现了__get__()和__set__()
            class
             Open:
    
            def
            __init__
            (self,name):
        self.name = name

    def__enter__(self):        # 在with Open("a.txt") as f:执行时触发print("执行了enter")
        return self

    def__exit__(self, exc_type, exc_val, exc_tb):  # 等到代码块执行完成后执行print("执行了exit")
        return self

with Open("a.txt") as f:
    print("代码块执行完成")
# 输出执行了enter
代码块执行完成
执行了exit

# Open("a.txt")的过程创建了一个对象，当执行with时执行了__enter__()，__enter__()返回一个值(self)赋值给f，f就是类Open产生的一个对象

## 当with中的代码块出现异常时

            class
             Open:
    
            def
            __init__
            (self,name):
        self.name = name

    def__enter__(self):        # 在with Open("a.txt") as f:执行时触发print("执行了enter")

    def__exit__(self, exc_type, exc_val, exc_tb):  # 等到代码块执行完成后执行print("执行了exit")
        print(exc_type)
        print(exc_val)
        print(exc_tb)
        # return True        当在exit中返回一个True时，代表不抛出程序出现异常 
with Open("a.txt") as f:
    print("代码块开始执行执行")
    print(abc)      # 当在with中出现一个错误时print("代码块执行完成")
print("11111111111")
            #
             当不return True时的 输出的结果
            　　执行了enter
　　代码块开始执行执行
　　执行了exit
　　Traceback (most recent call last):
　　<class‘NameError‘>
　　  File "F:/Python_Project/Test/利用描述符定制property.py", line 17, in <module>
　　name ‘abc‘isnot defined
　　    print(abc)      # 当在with中出现一个错误时
　　<traceback object at 0x000001E2A2D59FC8>
　　NameError: name ‘abc‘isnot defined
            #
             当return True时的结果
            执行了enter
代码块开始执行执行
执行了exit
<class‘NameError‘>
name ‘abc‘isnot defined
<traceback object at 0x000001E205DB9F88>
11111111111

## exit中的三个参数

exc_type：异常类
exc_val：异常值
exc_tb：异常追踪信息


<class ‘NameError‘>
　　　　+
name ‘abc‘ is not defined
　　　　+
<traceback object at 0x0000016F7FAE9FC8>
　　　　=
NameError: name ‘abc‘ is not defined

## 总结

with obj as f:
"代码块"
1：with obj # 触发obj.__enter__()，获得返回值self
2：as f # 将__enter__返回值赋值给f，f = 返回值
3：with obj as f # 等同于 f = obj.__enter__()
4：执行代码块
　　1：在没有发生异常的情况下，整个代码块执行完成后触发__exit__，exit中的三个参数都为None
　　2:在有异常的情况下，从异常出现的位置直接触发__exit__
　　　　a:如果__exit__的返回值为True，代表吞掉异常，不抛出异常，程序不报错
　　　　b:如果__exit__的返回值不为True，表示抛出异常，程序报错
　　　　c:__exit__的运行完毕，表示整个with语句的执行完毕

 ...

原文：https://www.cnblogs.com/Doaoao/p/10166411.html

内容总结

以上是互联网集市为您收集整理的Python_基础_(面向对象进阶)全部内容，希望文章能够帮你解决Python_基础_(面向对象进阶)所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1114747.html

来源：【匿名】