python基础---面向对象相关知识

面向对象

可以把数据以及功能打包为一个整体

类:

  • 名称
  • 属性(数据)
  • 方法
class Person:
    def __init__(self, name, age):
        self.age = age
        self.name = name
    def print_info:
        print(self.name, self.age)

定义

#经典类
class Dog1:
    pass

# 新式类
class Dog2(object):
    pass

在python3里面这都一样, 用于继承

self

self指向当前的这一个对象自己, python会自动传递当前的对象

self的名字可以不叫self, 但是推荐使用self, 会使用类的方法的第一个参数

属性

class Dog1:
    def set_name(self, name):
        self.name = name
    def print_name(self):
        print(self.name)

class Dog2:
    pass

dog1 = Dog1()
# dog1.set_name('dog1')
dog1.print_name()

这一个属性会在调用dog1.set_name('dog1')的时候才会创建, 不调用的时候使用这一个变量会出问题

也可以使用dog1.name = "dog1"来进行指定, 但是一般不使用这一个方式

私有属性

普通的属性可以在外部进行修改, 这种方式一般是不希望出现的

可以在变量名前面加两个__进行设置

class Dog1:
    def __init__(self, name):
        self.__name = name
    def print_name(self):
        print(self.__name)
 
dog = Dog1("dog1")
print(dog.__name)
PS E:\JHY\python\2024-4-22> python -u "e:\JHY\python\2024-4-22\main.py"
Traceback (most recent call last):
File "e:\JHY\python\2024-4-22\main.py", line 9, in <module>
 print(dog.__name)
AttributeError: 'Dog1' object has no attribute '__name'
dog = Dog1("dog1")
dog.__name = "dog2"
dog.print_name()

这样实际也不能修改这一个变量, 打印的还是dog1

实际使用的时候可以通过_ClassName__name进行调用, 但是不建议使用

dog = Dog1("dog1")
dog._Dog1__name = "dog2"
dog.print_name()

python实际是对这一个变量进行了一个重命名

私有方法

外部不能直接调用的方法

在函数名的前面加一个__

继承

一个新的类里面有之前的一个类里面的数据, 这时候可以使用继承的方式

class NewClass(OldClass1, OldClass2, ...):
    pass

实际继承的时候可以有多个类

继承获取的方法可以重写进行覆盖(方法的名字需要一样)

class Parent(object):
    x = 1

class son1(Parent):
    pass

class son2(Parent):
    pass

print(Parent.x, son1.x, son2.x)
son1.x = 2			# 这一个实际是一个定义
print(Parent.x, son1.x, son2.x)
Parent.x = 3
print(Parent.x, son1.x, son2.x)
PS E:\JHY\python\2024-4-22> python -u "e:\JHY\python\2024-4-22\main.py"
1 1 1
1 2 1
3 2 3

在类里面的变量是使用字典的方式进行记录的, 在当前的类里面没有找到的话会从祖先的类里面找, 子类里面重写会创建一个新的变量在他的里面记录这一个新的值, 不会影响父类里面的值

super

有可能存在父类的方法不可以满足子类的需求, 但是不是需要全部重写, 而是加了一部分新的数据, 全部重写会出现代码的冗余

可以重写的时候调用一下父类的方法

class Chile(Father):
    def Father_func():
        super.Father_func()
        子类的新的处理

也可以使用Father.Father_func(), 但是使用这一个方法的时候会导致多继承的时候可能有的函数会被多次调用, 如果没有相同的祖先, 这一个就不会出现问题

class Father(object):
    def __init__(self, name):
        print("Father")
        self.name = name

class Son1(Father):
    def __init__(self, name):
        print("Son1 Begin")
        super().__init__(name)
        print("Son1 End")

class Son2(Father):
    def __init__(self, name):
        print("Son2 Begin")
        super().__init__(name)
        print("Son2 End")

class GrandSon(Son1, Son2):
    def __init__(self, name):
        print("GrandSon")
        super().__init__(name)
        print("GrandSon End")

grandson = GrandSon("Shi")
PS E:\JHY\python\2024-4-22> python -u "e:\JHY\python\2024-4-22\main.py"
GrandSon
Son1 Begin  
Son2 Begin  
Father      
Son2 End    
Son1 End    
GrandSon End

这一个调用的时候需要计算出来实际调用的是哪一个父类, python里面实际使用了一个C3算法

可以使用print(GrandSon.__mro__)查看实际调用的顺序, 每一次遇到一个super会进入下一层的函数里

(<class '__main__.GrandSon'>, <class '__main__.Son1'>, <class '__main__.Son2'>, <class '__main__.Father'>, <class 'object'>)

使用这一个的时候会出现一个问题: 多进程的时候传入的参数的个数的问题, 这一个的顺序是不一定的, 所以传递的时候需要把所有的参数都传递

多态

在python里面不是很明显

多态是指一类事物有多种形态,比如动物类,可以有猫,狗,猪等等。(一个抽象类有多个子类,因而多态的概念依赖于继承)

多态性是指具有不同功能的函数可以使用相同的函数名,这样就可以用一个函数名调用不同内容的函数。在面向对象方法中一般是这样表述多态性:向不同的对象发送同一条消息,不同的对象在接收时会产生不同的行为(即方法)。也就是说,每个对象可以用自己的方式去响应共同的消息。所谓消息,就是调用函数,不同的行为就是指不同的实现,即执行不同的函数。

实际使用的时候可以传递一系列类过去, 这些类里面有一个相同名字的函数, 但是这一个函数的实际执行的任务不同, 传不同的类会使用不同的行为, 但是实际调用的时候看起来调用的都一样

特殊属性方法

静态方法

在class里面有一个函数, 实际不需要class这一个参数, 这一个方法就是一个静态方法, 实际使用的时候需要使用参数@staticmethod进行修饰

class Class(Object):
    @staticmethod
    def func():
        pass

这一个静态方法可以直接使用类名进行调用

Class.func()

类属性

通过一个类创建的对象之间的数据是相互隔离的, 但是有的数据需要是共享的

在Class里面, 但是位于def外面的属性是一个类属性

class Class(object):
    类属性 = value

实际调用的时候需要使用类名.类属性来调用这一个属性

class Tools(object):
    num = 0
    def __init__(self):
        Tools.num += 1

类里面的属性实际存储的时候使用的是字典里面的键值对, 所以实际去调用一个参数的时候传给属性拦截器的是一个字符串

类方法

专门用于对类属性操作的方法, 使用@classmethod, 这个时候传递的参数是cls

class Tools(object):
    num = 0
    @classmethod
    def add_1(cls):
        cls.num += 1 
    def __init__(self):
        self.add1()

实际调用的时候可以使用实例对象.类方法或者类名.类方法

记录的时候实际也是一个属性, 指向一个代码段

可以直接使用实例或者类.名字 = 方法这种方式进行动态添加一个一个方法, 但是这一种方式不会自动传入self参数, 可以使用types进行动态添加方法

  • 实例方法
import types

class Person (object):
    def __init__(self, name=None, age=None):
        self.name = name
        self.age = age

p = Person("jiao", 21)

def show_info(self):
    print("----info----")
 
p.show_info = types.MethodType(show_info, p) # 自动把这一个参数传进去
p.show_info()
  • 类方法/静态方法

这两个可以直接在加了修饰器以后添加

类对象

在python里面定义class的时候这一个定义也是一个对象, 这一个对象里面有类属性等信息, 还有各种方法的代码

创建的实例里面有一个参数__class__, 这一个参数指向这个类对象

实例调用方法的时候会使用这一个类对象, 用于节省空间, 避免代码重复

可以使用dir(实例对象)查看有哪一些方法, 属性

dir() 函数不带参数时,返回当前范围内的变量、方法和定义的类型列表;带参数时,返回参数的属性、方法列表。如果参数包含方法__dir__(),该方法将被调用。如果参数不包含__dir__(),该方法将最大限度地收集参数信息。

变量特殊命名方法

xx: 共有变量

_xx:私有化属性和方法, 使用from module import *禁止导入, 类对象和子类可以使用

__xx: 无法在外部直接访问, 私有属性

__xx__用户名名空间的魔法对象和属性

xx_: 用于避免和python关键字冲突

property动态数据

使用实例对象.属性 = xxx的时候会自动调用一个方法, 一个属性使用的时候是动态生成的, 需要在使用的时候通过一个函数进行生成

在使用=进行赋值的时候也可以使用这一个函数进行数据的检查

装饰器使用

class Foo(object):
    def func(self):
        print("fun running...")
    
    @property
    def prop(self):
        print("prop running...")

foo_boj = Foo()
foo_boj.func()
foo_boj.prop			#这一个调用的时候没有()但是会执行这一个函数

这一个函数的返回值会作为最后的结果, 可以使用这一个进行产生动态的数据

新式类

class Foo(object):
    def __init__(self) -> None:
        self.aaa = 1

    @property
    def prop(self):
        print("prop running...")

    @prop.setter
    def prop(self, value):
        print("prop setting...")
        self._prop = value
    
    @prop.getter
    def prop(self):
        print("prop getting...")
        return self._prop
    
    @prop.deleter
    def prop(self):
        print("prop deleting...")
        del self._prop
    

foo_boj = Foo()

foo_boj.prop = 2
print(foo_boj.prop)
del foo_boj.prop
PS E:\JHY\python\2024-4-22> python -u "e:\JHY\python\2024-4-22\main.py"
prop setting...
prop getting...
2
prop deleting...

@prop.getter没有定义的时候会使用@property的返回值, 后面两个必须在@property后面使用, 这一个属性是必须有的

另一种调用方式

class Foo(object):
    def __init__(self):
        self.bar = "jiao"
    def get_bar(self):
        return self.bar

    def set_bar(self, value):
        self.bar = value
    
    BAR = property(get_bar, set_bar, None, "This is a bar")

obj = Foo()
result = obj.BAR
print(result) 
obj.BAR = "haoyang"
print(obj.BAR)
print(Foo.BAR.__doc__)

image-20240503112644197

第四个参数是一个字符串, 使用类名.属性.__doc__可以获取

PS E:\JHY\python\2024-4-22> python -u "e:\JHY\python\2024-4-22\main.py"
jiao
haoyang
This is a bar

这一个使用+=进行赋值的时候相当于obj.BAR = obj.BAR + value , 所以实际调用的时候会使用一次获取以及一次写入

  • 实际使用实例

Django框架里面的property里面属性使用的就是这一个

不足

如果有多个属性需要设置的时候, 这里面需要实现很多的函数

内建函数集合

__init__引入

创建的时候会调用的函数

class Person:
    def __init__(self, name, age):
        self.age = age
        self.name = name
    def print_info:
        print(self.name, self.age)

__str__打印

这一个函数的返回值是使用print函数打印这一个类的时候结果

__call__

如果使用一个类创建了一个对象, 直接使用这一个对象当函数调用会执行这一个函数

__slots__静态

添加这一个属性可以使得这一个类不能在运行的时候进行添加属性, 只可以使用声明了的属性

class Person(object):
    __slots__ = ("name", "age")

p = Person()
p.name = "John"
p.age = 20
print(p.name, p.age)
p.address = "henan"
print(p.address)
PS E:\JHY\python\2024-4-22> python -u "e:\JHY\python\2024-4-22\main.py"
John 20
Traceback (most recent call last):
File "e:\JHY\python\2024-4-22\main.py", line 8, in <module>
p.address = "henan"
AttributeError: 'Person' object has no attribute 'address'

这一个效果只在定义他的类里面有效, 不会进行继承

import math

class Person:
    # 初始化
    def __init__(self, name, age):
        self.age = age
        self.name = name

    def print_info(self):
        print(self.name, self.age)
	
    # print直接打印的时候
    def __str__(self):
        return f'{self.name} is {self.age} years old'
    
    def __repr__(self):
        return f'Person({self.name}, {self.age})'
    
    def __eq__(self, other):
        return self.age == other.age
    
    def __lt__(self, other):
        return self.age < other.age

    def __gt__(self, other):
        return self.age > other.age

    def __le__(self, other):
        return self.age <= other.age
    
    def __ge__(self, other):
        return self.age >= other.age
    
    def __ne__(self, other):
        return self.age != other.age
    
    def __add__(self, other):
        return self.age + other.age
    
    def __sub__(self, other):
        return self.age - other.age
    
    def __mul__(self, other):
        return self.age * other.age
    
    def __truediv__(self, other):
        return self.age / other.age
    
    def __floordiv__(self, other):
        return self.age // other.age
    
    def __mod__(self, other):
        return self.age % other.age
    
    def __pow__(self, other):
        return self.age ** other.age
    
    def __and__(self, other):
        return self.age & other.age
    
    def __or__(self, other):    
        return self.age | other.age
    
    def __xor__(self, other):
        return self.age ^ other.age
    
    def __lshift__(self, other):
        return self.age << other.age
    
    def __rshift__(self, other):
        return self.age >> other.age
    
    def __neg__(self):
        return -self.age
    
    def __pos__(self):
        return +self.age
    
    def __abs__(self):
        return abs(self.age)
    
    def __invert__(self):
        return ~self.age
    
    def __round__(self, n=0):
        return round(self.age, n)
    
    def __floor__(self):
        return math.floor(self.age)
    
    def __ceil__(self):
        return math.ceil(self.age)
    
    def __trunc__(self):
        return math.trunc(self.age)
    
    def __index__(self):
        return self.age
    
    def __len__(self):
        return len(self.name)
    
    def __contains__(self, item):
        return item in self.name
    
    def __getitem__(self, key):
        return self.name[key]
    
    def __setitem__(self, key, value):
        self.name[key] = value

    def __delitem__(self, key):
        del self.name[key]

    def __iter__(self):
        return iter(self.name)
    
    def __reversed__(self):
        return reversed(self.name)
    
    def __next__(self):
        return next(self.name)
    
    def __hash__(self):
        return hash(self.name)
    
    def __call__(self):
        return self.print_info()
    
    def __enter__(self):
        print('Entering')

    def __exit__(self, exc_type, exc_value, traceback):
        print('Exiting')

    def __del__(self):
        print('Deleting')

p1 = Person('John', 30)
p2 = Person('Jane', 25)

p1.print_info()

print(p1 == p2)
print(p1 < p2)
print(p1 > p2)
print(p1 <= p2)
print(p1 >= p2)
print(p1 != p2)
print(p1 + p2)
print(p1 - p2)
print(p1 * p2)
print(p1 / p2)
print(p1 // p2)
print(p1 % p2)
print(p1 ** p2)
print(p1 & p2)
print(p1 | p2)
print(p1 ^ p2)
print(p1 << p2)
print(p1 >> p2)
print(-p1)
print(+p1)
print(abs(p1))
print(~p1)
print(round(p1, 1))
print(math.floor(p1))
print(math.ceil(p1))
print(math.trunc(p1))
print(hash(p1))
p1()
with p1:
    pass
del p1
John 30
False
False
True
False
True
True
55
5
750
1.2
1
5
8472886094430000000000000000000000000
24
31
7
1006632960
0
-30
30
30
-31
30
30
30
30
2252686827583093840
John 30
Entering
Exiting
Deleting
Deleting
常用的属性说明触发
__init__构建初始化的时候初见实际赋值的时候调用, 初始化new创建的实例
__new__生成的实例时候创建实际时, 最先调用, 返回实例
__class__实例所在的类实例.__class__
__str__实例的字符串显示, 可读性print打印的时候显示
__repr__实例的字符串显示, 准确性print(repr(实例类))或print直接调用, 优先级比较高
__del__析构(删除的时候执行)del实例
__dict__实例的自定义属性vars(实例.__dict__), 类.__dict__的时候只打印实例属性
__doc__类文档, 子类不会继承help(类或实例), 函数会打印他的描述
__getattribute__属性访问拦截器访问实例属性的时候, 传入的参数是这一个参数的字符串
__bases__类的所有的父类构成的元素print(类名.__bases__)

常用属性

  • __module__: 查看他所在的模块(文件)
  • __class__: 这一个实例使用的类

类字典实现

  • __getitem__, __setitem__, __delitem__: 使用实例[索引]和的时候会调用这三个
class Foo(object):
    def __getitem__(self, key):
        print("__getitem__", key)

    def __setitem__(self, key, value):
        print("__setitem__", key, value)

    def __delitem__(self, key):
        print("__delitem__", key)

foo = Foo()
foo["bar"] = "baz"
del foo["bar"]
foo["bar"]
PS E:\JHY\python\2024-4-22> python -u "e:\JHY\python\2024-4-22\main.py"
__setitem__ bar baz
__delitem__ bar
__getitem__ bar

传递的时候是一个字符串

  • __getslice__, __setslice__, __delslice__: 在python2里面的实现切片

元类

一个特殊的类, 用于定义其他的类

元类(type)–>类(类对象)–>实例对象

类的创建也可以使用类似于闭包的方式

def choice_class(name):
    if name == "foo":
        class Foo(object):
            pass
        return Foo
    else:
        class Bar(object):
            pass
        return Bar

使用type创建类

type实际有两个功能, 一个是测试类型, 另一个是创建一个类

type(类名, 父类的名称组成的元组(可以为空), 包含属性的字典(名称和值))
c_j = type("JIAO", (object,), {"name":"jiao", "age":18})
print(type(c_j))

obj_j = c_j()
print(obj_j.name)
print(obj_j.age)
PS E:\JHY\python\2024-4-22> python -u "e:\JHY\python\2024-4-22\main.py"
<class 'type'>
jiao
18

元类的定义

函数type实际上就是一个元类, 是python里面用于创建所有类的元类, Python里面的所有的类都是一个对象

JIAO = type("JIAO", (), {})
print(dir(JIAO))
print(JIAO.__dict__)
print(JIAO.__bases__) # 查看这一个对象继承的类
print(JIAO.__class__) # 查看它构建这一个实例使用的类
PS E:\JHY\python\2024-4-22> python -u "e:\JHY\python\2024-4-22\main.py"
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 
'__weakref__']
{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'JIAO' objects>, '__weakref__': <attribute '__weakref__' of 'JIAO' objects>, '__doc__': None}        
(<class 'object'>,)
<class 'type'>

str, int这一些数据实际使用也是一个type类生成的对象, type这一个类的父类是object

自己创建元类

class Foo(object, metaclass=xxxxx):

在定义一个类的时候没有指定这一个metaclass, 会默认使用type进行创建, 否则使用这一个参数指定的那一个函数进行创建

class UperAttrMetaClass(type):
    #
    def __new__(cls, clsname, bases, dct):
        new_attr = {}
        for name, value in dct.items():
            if not name.startswith('__'):
                new_attr[name.upper()] = value
            else:
                new_attr[name] = value
        return type(clsname, bases, new_attr)
    

class Foo(metaclass=UperAttrMetaClass):
    bar = 'bip'

print(hasattr(Foo, 'bar'))
print(hasattr(Foo, 'BAR'))

f = Foo()
print(f.BAR)
PS E:\JHY\python\2024-4-22> python -u "e:\JHY\python\2024-4-22\main.py"
False
True
bip

创建这一个类里面的属性的时候都使用大写

class UperAttrMetaClass(type):
    # 这一个函数会在类被创建的时候被调用
    # clsname: 类的名字
    # bases: 类的基类
    # dct: 类的属性
    # 默认的实现是返回一个新的类
    # 这个新的类会将属性名转换为大写
    def __new__(cls, clsname, bases, dct):
        new_attr = {}
        for name, value in dct.items():
            if not name.startswith('__'):
                new_attr[name.upper()] = value
            else:
                new_attr[name] = value
        return type(clsname, bases, new_attr)
    

class Foo(metaclass=UperAttrMetaClass):
    bar = 'bip'

print(hasattr(Foo, 'bar'))
print(hasattr(Foo, 'BAR'))

f = Foo()
print(f.BAR)

类定义的过程

python解释器遇到一个类的时候实际会进行一次调用, 为了知道实际有的属性以及方法, 之后把这些方法属性传递到元类type里面, 创建一个对象, 这个就是类对象

如果类里面有放在外面代码的话, 这些代码会执行

描述符对象

property的实现, @classmethod等的实现都可以使用描述符

在大型的项目里面对MySQL数据库的操作的传媒也可以使用这一个进行实现

__getattr__

这一个是在调用一个不存在的属性的时候调用, 访问的属性存在的时候不会调用这一个方法

class A:
    def __init__(self, name):
        self.name = name
    # def __getattribute__(self, item):
    #     if item == "name":
    #         return "haha"
    #     else:
    #         return super().__getattribute__(item)
    def __getattr__(self, item):
        print("error item %s" % item)

a = A("jiao")
print(a.age) # 默认访问这一个的时候会报错, 现在不会
PS E:\JHY\python\2024-4-22> python -u "e:\JHY\python\2024-4-22\main.py"
error item age
None

默认这一个会产生一个异常

__getattribute__

访问一个对象的时候会调用这一个函数, 实际使用的时候可以使用这一个函数进行拦截

class A:
    def __init__(self, name):
        self.name = name
    def __getattribute__(self, item):
        if item == "name":
            return "haha"
        else:
            return super().__getattribute__(item)

a = A("jiao")
print(a.name)
PS E:\JHY\python\2024-4-22> python -u "e:\JHY\python\2024-4-22\main.py"
haha

**注: **这两个同时出现的时候会调用__getattribute__

描述符

之前使用的@property这一个属性会使得一个函数的方法属于的类从function变为property

这个property实际就是一个描述符, 严格来说, 如果一个类里面有__get__, __set__, __delete__这三个属性里面的任意一个, 那么这一个类实际就是一个描述符对象

如果有一个类, 这一个类里面有类属性对应的是上面的描述符对象创建的实例对象, 这一个类属性就是一个描述符

class A:
    def __get__(self, instance, owner):
        print("---get---")

    def __set__(self, instance, value):
        print("---set---")

    def __delete__(self, instance):
        print("---delete---")

class B:
    a = A()     # 这一个是一个描述符

b = B()
print(b.a)      # 调用__get__方法, b为instance, B是owner
b.a = 100       # 调用__set__方法, b为instance, 100是value
del b.a         # 调用__delete__方法
PS E:\JHY\python\2024-4-22> python -u "e:\JHY\python\2024-4-22\main.py"
---get---
None        
---set---   
---delete---

实际property就是这一个方式实现的

如果直接使用B.a进行调用的时候, instance这一个是None, owner还是B

使用描述符的原因

python里面没有属性, 所以可以使用这一个进行类型检测, 使用的时候比

实际使用

实现数据监测
class NonNegative(object):
    def __init__(self, default):
        self.default = default # 没有某一个参数的时候返回值
        self.data = dict()

    def __get__(self, instance, owner):
        return self.data.get(instance, self.default)
    
    def __set__(self, instance, value):
        if value < 0:
            raise ValueError('value must be non-negative')
        self.data[instance] = value

class Order(object):
    price = NonNegative(0)
    quantity = NonNegative(1)

    def __init__(self, name, price, quantity):
        self.name = name
        self.price = price
        self.quantity = quantity

    def total(self):
        return self.price * self.quantity
    

order = Order('apple', 1, 10)
print(order.total())
order.price = 10
print(order.total())
order.price = -10 # ValueError: value must be non-negative
实现classmethed
class classmethed_new(object):
    def __init__(self, func):
        self.func = func

    def __get__(self, instance, owner):
        def new_func(*args, **kwargs):
            return self.func(owner, *args, **kwargs)
        return new_func # 这是一个闭包, 返回实际调用的函数
    
class A(object):
    M = 100
    def a(self):
        print('A.a')
    
    @classmethed_new
    def b(cls):		# 这里实际为b = classmethed_new(b)
        print('A.b')
        print(cls.M)


obj = A()
obj.a()
print('-'*20)
obj.b()   # 从b获取一个函数, 之后执行这一个函数, 这时候的参数会给new_func, 之后new_func调用self.func
实现惰性计算

惰性计算就是需要一个值, 这一个值不是提前准备的, 是啥时候需要啥时候计算的

class LazyPropety(object):
    def __init__(self, fun) -> None:
        self.fun = fun
    
    def __get__(self, instance, owner):
        print("Calling __get__")
        if instance is None:
            return self
        value = self.fun(instance)
        # setattr(instance, area, value) 把这一个函数的名字指向的对象改为这一个计算值
        setattr(instance, self.fun.__name__, value)
        return value


class ReadOnlyNumber(object):
    def __init__(self, value) -> None:
        self.value = value
    
    def __get__(self, instance, owner):
        return self.value
    
    def __set__(self, instance, value):
        raise AttributeError("Can't set attribute")
    

class Circle(object):
    pi = ReadOnlyNumber(3.14)

    def __init__(self, radius):
        self.radius = radius
    # 初始的时候area这一个类保存的是一个描述符
    @LazyPropety
    def area(self):
        print("Calculating area")
        return self.pi * self.radius * self.radius
    

print("1.----")
a = Circle(4)
print("2.----")
print(a.area)
print("3.----")
print(a.area)
print("4.----")

image-20240504202648657

__dict__作用

使用这一个可是查看一个类里面的已经定义的属性

在python里面所有的属性以及方式使用的都是字典的方式进行存储的, 实力对象里面只有这一个对象的私有属性, 方法以及类的文档在类属性里面

这一个实际调用print(对象.__dict__), 也可以使用vars(对象)这一个函数进行替代

数据在调用的时候找到的是一个普通的属性的时候会直接调用, 如果这一个属性是一个描述符则会调用他的__get__方法

在获取数据的时候会首先从自己的字典里面获取数据, 没有这一个数据的话查找父类的字典

class M:
    def __init__(self) -> None:
        self.x = 1

    def __get__(self, instance, owner):
        print('get')
        return self.x
    
    def __set__(self, instance, value):
        print('set')
        self.x = value
    
class AA:
    m = M()
    n = 2
    def __init__(self, score) -> None:
        self.score = score


a = AA(3)
print(a.m)
print("-" * 20)
print(type(a).__dict__["m"].__get__(a, AA)) # 这个和上面的那一个等价

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

同时有__get____set__的时候这是一个数据描述符

只有一个__get__的时候是一个非数据的描述符

这两个区别是:

属性名和描述符的名字一样的时候, 访问这一个属性的时候, 如果这一个描述符是数据描述符, 就会优先访问这一个描述符, 不是的话访问这一个属性

class M:
    def __init__(self) -> None:
        self.x = 1

    def __get__(self, instance, owner):
        return self.x
    
    def __set__(self, instance, value):
        self.x = value
    
class N:
    def __init__(self) -> None:
        self.x = 1

    def __get__(self, instance, owner):
        return self.x

class AA(object):
    m = M()     # 资料描述符
    n = N()     # 非资料描述符

    def __init__(self, m, n) -> None:
        self.m = m # 属性m和描述符m同名, 调用的时候会发生冲突
        # 数据描述符优先级高, 不会创建一个新的m, 会给m描述符赋值
        self.n = n # 属性n和描述符n同名, 这一个会创建一个新的属性
    
aa = AA(2, 3)
print('-'*20)
print(aa.__dict__)
print(AA.__dict__)
print('-'*20)
print(aa.n)     # 这俩是不一样的, 这个调用属性
print(AA.n)	    # 描述符
print('-'*20)
print(aa.m)     # 这俩是一样的, 都是用的描述符     
print(AA.m)
PS E:\JHY\python\2024-4-22> python -u "e:\JHY\python\2024-4-22\main.py"
--------------------
{'n': 3}
{'__module__': '__main__', 'm': <__main__.M object at 0x0000015CB8287FD0>, 'n': <__main__.N object at 0x0000015CB8287CD0>, '__init__': <function AA.__init__ at 0x0000015CB82AB0A0>, '__dict__': <attribute '__dict__' of 'AA' objects>, '__weakref__': <attribute '__weakref__' of 'AA' objects>, '__doc__': None}
--------------------
3
1
--------------------
2
2

只读描述符

同时定义两个属性, 但是在调用__set__的时候会触发一个AttributeError, 引发一个异常

实际调用的细节

使用默认的__getattribute__的时候访问一个属性的时候会使用hasattr进行判断是不是有一个属性__get__如果有的话会使用这一个函数的返回值

如果重新这一个函数会使得描述符失效

没有这一个属性的时候调用__getattr__

注意

  1. 使用描述符的时候这一个必须是一个类属性, 不能是实例属性, 否则的话这一个属性调用的时候不会调用这一个属性的方法
  2. 由于使用的是类属性, 所以这一个描述符在实现的时候需要区分不同的实例, 这个时候可以使用instance做一个字典的key

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mfbz.cn/a/597371.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

LeetCode-741. 摘樱桃【数组 动态规划 矩阵】

LeetCode-741. 摘樱桃【数组 动态规划 矩阵】 题目描述&#xff1a;解题思路一&#xff1a;动态规划&#xff0c;定推初遍举。解题思路二&#xff1a;倒序循环解题思路三&#xff1a;0 题目描述&#xff1a; 给你一个 n x n 的网格 grid &#xff0c;代表一块樱桃地&#xff0…

VMware虚拟机中Linux系统奔溃,怎么办?

一大早启动虚拟机准备开始工作&#xff0c;却遭遇到Linux系统崩溃&#xff0c;屏幕上显示以下错误提示&#xff1a; 这段文本看起来是来自系统引导时的日志信息&#xff0c;提到了一些关于文件系统的问题和建议。根据这段信息&#xff0c;似乎 /dev/sda1 分区中的文件系统存在一…

红日靶场ATTCK 1通关攻略

环境 拓扑图 VM1 web服务器 win7&#xff08;192.168.22.129&#xff0c;10.10.10.140&#xff09; VM2 win2003&#xff08;10.10.10.135&#xff09; VM3 DC win2008&#xff08;10.10.10.138&#xff09; 环境搭建 win7&#xff1a; 设置内网两张网卡&#xff0c;开启…

SeetaFace6人脸检测C++代码实现Demo

SeetaFace6包含人脸识别的基本能力&#xff1a;人脸检测、关键点定位、人脸识别&#xff0c;同时增加了活体检测、质量评估、年龄性别估计&#xff0c;并且顺应实际应用需求&#xff0c;开放口罩检测以及口罩佩戴场景下的人脸识别模型。 官网地址&#xff1a;https://github.co…

dockerk8s常用知识点

1、什么是docker 容器化和虚拟化对比 ▪开源的应用容器引擎&#xff0c;基于 Go 语言开发 ▪容器是完全使用沙箱机制,容器开销极低 ▪Docker就是容器化技术的代名词 ▪Docker也具备一定虚拟化职能 docker三大核心&#xff1a; Docker Engine: 提供了一个可以用来运行和管…

代码+视频,R语言绘制生存分析模型的时间依赖(相关)性roc曲线和时间依赖(相关)性cindex曲线

ROC曲线分析是用于评估一个因素预测能力的手段&#xff0c;是可以用于连续型变量分组的方法。在生存分析中&#xff0c;疾病状态和因素取值均会随时间发生变化。而标准的ROC曲线分析将个体的疾病状态和因素取值视作固定值&#xff0c;未将时间因素考虑在分析之中。在这种情况下…

edge使用心得

1. **性能提升**&#xff1a;基于Chromium的Edge浏览器在速度和响应方面有显著提升&#xff0c;特别是在处理复杂的网页结构和执行JavaScript代码时。这意味着无论是日常浏览还是运行Web应用程序&#xff0c;都能享受流畅的用户体验。 2. **更好的兼容性**&#xff1a;由于与G…

大模型最新消息

最新消息如下&#xff1a; 大语言模型服务的多样化&#xff1a;互联网上出现了许多免费的大语言模型服务&#xff0c;如OpenAI的ChatGPT、Google的Gemini、Anthropic的Claude、Meta的Llama等。这些服务的推出使得大语言模型的应用更加广泛和便捷。软银和苹果的AI新动向&#x…

​​【收录 Hello 算法】3.3 数字编码

目录 3.3 数字编码 3.3.1 原码、反码和补码 3.3.2 浮点数编码 3.3 数字编码 Tip 在本书中&#xff0c;标题带有 * 符号的是选读章节。如果你时间有限或感到理解困难&#xff0c;可以先跳过&#xff0c;等学完必读章节后再单独攻克。 3.3.1 原码、反码和补码 在…

迅睿CMS中实现关键词搜索高亮

在迅睿CMS系统中实现关键词搜索高亮是提升用户体验和搜索效果的重要手段。当用户搜索某个关键词时&#xff0c;将搜索结果中的关键词高亮显示&#xff0c;可以帮助用户更快速地定位到所需信息。 关键词高亮的实现 在迅睿CMS中&#xff0c;你可以使用内置的dr_keyword_highlig…

Study--Oracle-01-单实例部署Oracle11G-R2

Oracle版本发布介绍 Oracle 19c和12c和11g功能区别_数据库_oracle_支持 一、CentOS 7 环境准备 1、软件准备 操作系统&#xff1a;CentOS 7 数据库版本: Oracle11g R2 2、操作系统环境配置 关闭selinux &#xff0c;编辑 /etc/selinux/config文件&#xff0c;设置SELINU…

C语言例题34、反向输出字符串(递归方式)

题目要求&#xff1a;输入5个字符后&#xff0c;使用递归方式逆序输出 #include <stdio.h>void reverse(int num) {char cur_char;if (num 1) {cur_char getchar();printf("逆序输出为&#xff1a;");putchar(cur_char);} else {cur_char getchar();revers…

宏电全栈式IoT赋能供排水智能监测,护航城市生命线

城市供水、排水系统是维系城市正常运行、满足群众生产生活需要的重要基础设施&#xff0c;是城市的“生命线”。随着城市化进程加快&#xff0c;城市规模不断扩大&#xff0c;地下管线增长迅速&#xff0c;城市“生命线安全”的监管日益面临挑战。 宏电作为物联网行业的领航者…

软件测试与管理:黑盒测试-等价类划分法和 边界值分析法

知识思维导图&#xff1a; 例题1&#xff1a;日期检查功能的等价类划分 设有一个档案管理系统&#xff0c;要求用户输入以年月表示的日期。假设日期限定在1990年1月~2049年12月&#xff0c;并规定日期由6位数字字符组成&#xff0c;前4位表示年&#xff0c;后2位表示月。现用等…

后台启动HIVE的JDBC连接

后台启动HIVE的JDBC连接 生活就像一杯咖啡&#xff0c;有时苦涩&#xff0c;有时香甜&#xff0c;但都是值得品味的经历。无论遇到什么挑战&#xff0c;记住在每一天的开始&#xff0c;你都有机会给自己倒上一杯清新的力量&#xff0c;为心灵添一抹温暖。勇敢地面对生活的苦与甜…

10000 字详细讲解 Spring 中常用注解及其使用

如下图京东购物页面&#xff0c;当我们选择点击访问某一类商品时&#xff0c;就会向后端发起 HTTP 请求&#xff0c;当后端收到请求时&#xff0c;就会找到对应的代码逻辑对请求进行处理&#xff0c;那么&#xff0c;后端是如何来查找处理请求相对应的代码呢&#xff1f;答案就…

C++使用单链表实现一元多项式的加,乘操作

相邀再次喝酒 待 葡萄成熟透 但是命运入面 每个邂逅 一起走到了 某个路口 是敌与是友 各自也没有自由 位置变了 各有队友 首先&#xff0c;按照惯例&#xff0c;十分欢迎大家边听歌边观看本博客&#xff01;&#xff01; 最佳损友 - 陈奕迅 - 单曲 - 网易云音乐 (163.com) 一…

leetcode295. 数据流的中位数

class MedianFinder {//A为小根堆&#xff0c;B为大根堆List<Integer> A,B;public MedianFinder() {A new ArrayList<Integer>();B new ArrayList<Integer>();}public void addNum(int num) {int m A.size(),n B.size();if(m n){insert(B,num);int top …

开源模型 Prometheus 2 能够评估其他语言模型,其效果几乎与 GPT-4 相当

每周跟踪AI热点新闻动向和震撼发展 想要探索生成式人工智能的前沿进展吗&#xff1f;订阅我们的简报&#xff0c;深入解析最新的技术突破、实际应用案例和未来的趋势。与全球数同行一同&#xff0c;从行业内部的深度分析和实用指南中受益。不要错过这个机会&#xff0c;成为AI领…

springboot使用研究

map-underscore-to-camel-case: true 开启驼峰命名 GetMapping("/userInfo")public Result<Users> userInfo(RequestHeader(name "Authorization") String token,HttpServletResponse response) {Map<String, Object> map JwtUtil.parseT…
最新文章