第二十八天：内置函数的讲解：

1.在我们学的数据类型中字典可以通过[]来进行获取value的值，那么对象是否可以通过[]来获取属性和方法吗？

2可以通过getitem获得：

class A:
    def __init__(self,name,sex,age):
        self.name=name
        self.sex=sex
        self.age=age
    def __getitem__(self, item):
        pass
        if hasattr(self,item):
            return self.__dict__[item]
f=A(‘alex‘,‘男‘,10)
print(f[‘name‘])  #遇到这种格式会直接执行__getitemz函数如果不存在就报错
结果为
alex

3.也可以通过此方法进行对象属性的添加：

class A:
    def __init__(self,name,sex,age):
        self.name=name
        self.sex=sex
        self.age=age
    def __getitem__(self, item):
        pass
        if hasattr(self,item):
            return self.__dict__[item]
    def __setitem__(self, key, value):
        self.__dict__[key]=value
f=A(‘alex‘,‘男‘,10)
print(f[‘name‘])  #遇到这种格式会直接执行__getitemz函数如果不存在就报错
f[‘hobby‘]=‘basktball‘  #进行属性的添加需要执行setitem函数
print(f.__dict__)
结果为
alex
{‘name‘: ‘alex‘, ‘sex‘: ‘男‘, ‘age‘: 10, ‘hobby‘: ‘basktball‘}

class A:
    def __init__(self,name,sex,age):
        self.name=name
        self.sex=sex
        self.age=age
    def __getitem__(self, item):
        pass
        if hasattr(self,item):
            return self.__dict__[item]
    def __setitem__(self, key, value):
       self.key=value
f=A(‘alex‘,‘男‘,10)
print(f[‘name‘])  #遇到这种格式会直接执行__getitemz函数如果不存在就报错
f[‘hobby‘]=‘basktball‘  #进行属性的添加需要执行setitem函数
print(f.__dict__)

4.删除一个对象中属性的方法：

class A:
    def __init__(self,name,sex,age):
        self.name=name
        self.sex=sex
        self.age=age
    def __getitem__(self, item):
        pass
        if hasattr(self,item):
            return self.__dict__[item]
    def __setitem__(self, key, value):
       self.key=value
f=A(‘alex‘,‘男‘,10)
print(f[‘name‘])  #遇到这种格式会直接执行__getitemz函数如果不存在就报错
f[‘hobby‘]=‘basktball‘  #进行属性的添加需要执行setitem函数
print(f.__dict__)
del f.name
print(f.__dict__)
结果为
alex
{‘name‘: ‘alex‘, ‘sex‘: ‘男‘, ‘age‘: 10, ‘key‘: ‘basktball‘}
{‘sex‘: ‘男‘, ‘age‘: 10, ‘key‘: ‘basktball‘}

class A:
    def __init__(self,name,sex,age):
        self.name=name
        self.sex=sex
        self.age=age
    def __getitem__(self, item):
        pass
        if hasattr(self,item):
            return self.__dict__[item]
    def __setitem__(self, key, value):
       self.key=value
    def __delitem__(self, key):
        del self.key
f=A(‘alex‘,‘男‘,10)
print(f[‘name‘])  #遇到这种格式会直接执行__getitemz函数如果不存在就报错
f[‘hobby‘]=‘basktball‘  #进行属性的添加需要执行setitem函数
print(f.__dict__)
del f[‘name‘]
print(f.__dict__)
结果为
alex
{‘name‘: ‘alex‘, ‘sex‘: ‘男‘, ‘age‘: 10, ‘key‘: ‘basktball‘}
{‘name‘: ‘alex‘, ‘sex‘: ‘男‘, ‘age‘: 10}

5.__new__就是构造方法，创建类中的对象，我们每次创建类时自带的self就是通过此方法进行创建的

class A:
    def __init__(self,x):
        self.x=x
    def __new__(cls, *args, **kwargs):
        print(‘调用即打印‘)
        return object.__new__(cls)
a=A(‘alex‘) #实例化之后就会执行__new__里面的语句
结果为
调用即打印

6.在对类进行实例化时每一个对象所占用的内存都不同：

class A:
    def __init__(self):
        self.x=1
    def __new__(cls, *args, **kwargs):
        return object.__new__(cls)
a=A() #实例化之后就会执行__new__里面的语句
a1=A()
a2=A()
print(a)
print(a1)
print(a2)
结果为<__main__.A object at 0x00000280CFCB90F0>
<__main__.A object at 0x00000280CFE56A90>
<__main__.A object at 0x00000280CFE56AC8>

7.在编程过程中有一种；单例模式：就是说一个类只能实例化一次，当你第一次实力化之后使用这个对象，进行第二次实例化后不在进行创建对象，而是把上一次创建的对象给他，属性也存在，但是可以进行修改，在等第一个值调用时，属性已经变成第二个对象修改的属性了。

class A:
    __key=False
    def __init__(self,name,sex):
        self.name=name
        self.sex=sex
    def __new__(cls, *args, **kwargs):
        if cls.__key:
            return cls.__key
        cls.__key=object.__new__(cls)
        return cls.__key
a=A(‘alex‘,‘男‘)
b=A(‘bin‘,‘不想‘)
print(a.name)
print(b.name)
print(a)
print(b)
结果为
bin
bin
<__main__.A object at 0x0000016E4F4C5F28>
<__main__.A object at 0x0000016E4F4C5F28>

8.如果创建两个对象，两个对象中的传入值相同，那么这两个对象相等吗？

class A:
    def __init__(self,name):
        self.name=name
a=A(‘alex‘)
b=A(‘alex‘)
print(a==b)
结果为
False

　　既然他们传入的值都一样结果时false，那么有什么方法能让他们相等吗？

class A:
    def __init__(self,name):
        self.name=name
a=A(‘alex‘)
b=A(‘alex‘)
print(hash(a))
print(hash(b))
结果为
-9223371933925107417
-9223371933925107445

　　通过hash值我们不难发现他们的内存地址不同，计算机判断是否相等就是看内存地址是否相同，如果相同就为True，通过下面方法就可以让上述结果为True

class A:
    def __init__(self,name):
        self.name=name
    def __hash__(self):
        return hash(self.name)  #会跟据自己的定义来判断某个对象的hash值
a=A(‘alex‘)
b=A(‘alex‘)
print(hash(a))
print(hash(b))
print(a==b)
结果为
7807086709747762995
7807086709747762995
False

　　通过这一步可以让其hash值相等，再通过下面程序就可以让他们相等：

class A:
    def __init__(self,name):
        self.name=name
    def __hash__(self):
        return hash(self.name)  #会跟据自己的定义来判断某个对象的hash值
    def __eq__(self, other):  #
        if self.name==other.name:#让hash值相等的对象返回True
            return True
        return False

a=A(‘alex‘)
b=A(‘alex‘)
print(hash(a))
print(hash(b))
print(a==b)
结果为
1822651601806597939
1822651601806597939
True

原文地址：https://www.cnblogs.com/ab461087603/p/12386374.html