python 全栈开发，Day24(复习,__str__和__repr__,__format__,__call__,__eq__,__del__,__new__,item系列)

反射：

使用字符串数据类型的变量名来使用变量

wwwh即what，where，why，how  这4点是一种学习方法

反射 ：使用字符串数据类型的变量名来使用变量
　　1.文件中存储的都是字符串
　　2.网络上能传递的也最接近字符串
　　3.用户输入的也是字符串

上面的3种情况都是字符串，如果有这种情况的，需要操作类或者模块时，就需要用到反射

有4种应用

类调用静态属性
对象调用属性 和 方法
模块调用模块中的名字
调用自己模块中的名字

a = 1
import sys
b = getattr(sys.modules['__main__'],'a')
print(b)  # 输出变量a的值，即1

def func():print('11')
c = getattr(sys.modules['__main__'],'func')
print(c)  # 输出func的内存地址
getattr(sys.modules['__main__'],'func')()  # 执行方法，输出11

执行输出：

1
<function func at 0x000002189E107F28>
11

Teacher类 wahaha方法的连续反射

import sys
class Teacher():
    def wahaha(self):print('wa')
alex = getattr(sys.modules['__main__'],'Teacher')()  # 获取当前模块的Teacher,并执行
print(alex)  # Teacher类的内存地址
getattr(alex,'wahaha')()  # 执行方法wahaha

执行输出：

<__main__.Teacher object at 0x00000203554EBF28>
wa

反射静态方法

import sys
class Teacher(object):
    @staticmethod
    def wahaha():print('wa')

Teacher = getattr(sys.modules['__main__'],'Teacher')  # # 获取当前模块的Teacher类
getattr(Teacher,'wahaha')()  # 执行类方法，注意加括号

执行输出：

wa

找对象

import sys
class Teacher(object):
    def wahaha(self):print('wa')
    @staticmethod
    def qqxing():print('qq')

alex = Teacher()
b = getattr(sys.modules['__main__'],'alex')
print(b)

输出：

<__main__.Teacher object at 0x0000015469531048>

内置方法
__len__ len(obj)
obj对应的类中含有__len__方法，len(obj)才能正常执行

__hash__ hash(obj)  是object类自带的

只有实现了__hash__方法，hash(ojb)才能正常执行

hash是加加速寻址

print(hash('str'))

执行输出： 8500378945365862541

hash之后的数字，就是内存地址
hash之后，将value存储在对应的内存地址中

字典占用的内存相对的比，较用空间换时间
list占用的内存比较少，但是没有字典快

过一分钟，再次查看，发现数据都变了

-8079646337729346465

二、__str__,__repr__

repr() 函数将对象转化为供解释器读取的形式

print(repr('1'))
print(repr(1))

执行输出：

'1'
1

看起来，没啥作用

print(str('1'))
print(str(1))

执行输出：

1
1

li = [1,2,3,4]
print(li)

执行输出：

[1, 2, 3, 4]

class A:
    def __init__(self,*args):
        self.args = list(args)
li = A(1,2,3,4,5)
print(li)

执行输出：

<__main__.A object at 0x000001AAB3CDB9E8>

在类中，所有对象，默认打印的是内存地址

改变对象的字符串显示__str__,__repr__

class A:
    def __init__(self,*args):
        self.args = list(args)
    def __str__(self):
        return '[%s]' % (','.join([str(i) for i in self.args]))
li = A(1,2,3,4,5)
print(li)  # 输出的结果是obj.__str__()的结果
print(str(li))  # 结果同上
print('%s'%li)  # 结果同上

执行输出：

[1,2,3,4,5]

[1,2,3,4,5]

每一个对象，都有__str__方法

print执行时，实际是调用了__str__方法

class Teacher:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
        return "Teacher's object %s" % self.name

a = Teacher('alex',80)
b = Teacher('egon',80)
print(a)  # 实际调用了__str__
print(b)
print(repr(a))  # 打印对象的内存地址

执行输出：

Teacher's object alex
Teacher's object egon
<__main__.Teacher object at 0x0000012346B9BF28>

class Teacher:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):  # 重新定义内置方法
        return "Teacher's object %s" % self.name

    def __repr__(self):  # 重新定义内置方法，为了做个性化输出
        return 'repr function %s'%self.name

a = Teacher('alex',80)
b = Teacher('egon',80)
print(repr(a))  # 打印repr函数的返回值
print(a.__repr__()) #调用__repr__方法
print('%r'%a)
print(str(a)) # 打印str函数的返回值

执行输出：

repr function alex
repr function alex
repr function alex
Teacher's object alex

repr(obj)的结果和obj.__repr__()是一样的
'%r'%(obj)的结果和obj.__repr__()是一样的

所有的输出，本质就是向文件中写

print执行时，是去内部中寻找__str__方法
所以print没有输出不了的数据，因为每一个对象都有__str__方法

print一个对象是，打印的是内存地址

def repr(obj):  # 归一化设计
    return obj.__repr__()
print(repr('1'))

执行输出：'1'

repr执行时，其实是调用__repr__方法

repr(obj)的结果和obj.__repr__()是一样的

那么问题来了

repr(1)
repr('1')

的结果为什么不一样？

看下面的例子：

class int:
    def __repr__(self):
        return str(1)
a = int()
print(repr(a))

class str2:
    def __repr__(self):
        return "'%s'" % str(1)
b = str2()
print(repr(b))

执行输出：

1
'1'

repr的功能，之所以能还原数据原来的样子
是因为每一种数据对象的__reprt__都不一样

那么repr是做了归一化设计，接收一个对象。python一切皆对象

每个对象都有__repr__方法。执行rept，就执行了__repr__方法。

为什么做归一化设计呢？因为要更接近于面向函数编程

如果每一个对象，都要对象名.__str__这样执行，太麻烦了

使用函数的方法，要比类名.方法名 使用简单

当需要使用__str__的场景时找不到 __str__就找__repr__
当需要使用__repr__的场景时找不到__repr__的时候就找父类的repr
双下repr是双下str的备胎

总结：

len() obj.__len__() 返回值是一致的
len() 的结果是依赖 obj.__len__()
hash() 的结果是依赖 obj.__hash__()

str() 的结果是依赖 obj.__str__()
print(obj) 的结果是依赖 obj.__str__()
%s 的结果是依赖 obj.__str__() 语法糖
#
repr() 的结果是依赖 obj.__repr__()
%r 的结果是依赖 obj.__repr__()

repr是str的备胎

如果__str__和__repr__同时存在， 一定是选择repr

推荐几本书

《核心编程 第2版》 有很多基础知识
《核心编程 第3版》
《流畅的python》 有点难度，这本书比较火
《数据结构与算法》  机械工业出版社

对底层结构比较感兴趣的话，可以看《数据结构与算法》这本书

机械工业出版社，是比较权威的，
出的书是比较有代表性的
这本书，用例主要是用Python实现的

为什么int类型，可以使用%s，是因为int有___repr__方法

object.__repr__()
'%r' # __repr__()
int.__repr__()
str.__repr__()

%r 也是语法糖，不只是只有@
凡是不是调用函数，而是使用用一些符号之类的，都是语法糖
== 也是语法糖，它在内部执行时，是调用了内置方法，python解释器帮我们做了。

表面能使用的符号，内部其实是调用了方法，执行了计算过程。

三、__format__

format执行，就是调用了__format__方法

class A:
    def __init__(self,name,school,addr):
        self.name = name
        self.school = school
        self.addr = addr

a = A('大表哥','oldboy','沙河')
print(format(a))

执行输出：

<__main__.A object at 0x000001AD3B07BF28>

对象之所以能用format，是因为object有这个__format__方法

查看object源码

    def __format__(self, *args, **kwargs): # real signature unknown
        """ default object formatter """
        pass

format执行时，必须要有参数format_spec才行

查看源码

def format(*args, **kwargs): # real signature unknown
    """
    Return value.__format__(format_spec)

    format_spec defaults to the empty string
    """
    pass

自定义一个__format__方法

class A:
    def __init__(self,name,school,addr):
        self.name = name
        self.school = school
        self.addr = addr

    def __format__(self, format_spec):
        #format_spec = '{obj.name}-{obj.addr}-{obj.school}'
        return format_spec.format(obj=self) #此行的format_spec等同于上面一行

a = A('大表哥','oldboy','沙河')
format_spec = '{obj.name}-{obj.addr}-{obj.school}'
print(format(a,format_spec))

执行输出：

大表哥-沙河-oldboy

这样就可以在外部规定format的输出格式

{obj.name}-{obj.addr}-{obj.school}是用花括号{}的

比如正常情况下，也是用{}表示一个占位符，它是不能边的

如果输出的字符串，需要加中括号[ ]，可以这么写

class A:
    def __init__(self,name,school,addr):
        self.name = name
        self.school = school
        self.addr = addr
    def __format__(self, format_spec):
        return format_spec.format(obj=self)

a = A('大表哥','oldboy','沙河')
format_spec = '[{obj.name}]-[{obj.addr}]-[{obj.school}]'
print(format(a,format_spec))

执行输出：

[大表哥]-[沙河]-[oldboy]

下面一个列子

format_dict={
    'nat':'{obj.name}-{obj.addr}-{obj.type}',#学校名-学校地址-学校类型
    'tna':'{obj.type}:{obj.name}:{obj.addr}',#学校类型:学校名:学校地址
    'tan':'{obj.type}/{obj.addr}/{obj.name}',#学校类型/学校地址/学校名
}
class School:
    def __init__(self,name,addr,type):
        self.name=name
        self.addr=addr
        self.type=type

    def __format__(self, format_spec):   #format_spec = 'nat'
        if not format_spec or format_spec not in format_dict:  #判断参数是否为空或者是否在format_dict字典里
            format_spec='nat'  # 默认值为nat
        fmt=format_dict[format_spec]     #'{obj.name}-{obj.addr}-{obj.type}'
        return fmt.format(obj=self)     #'{obj.name}-{obj.addr}-{obj.type}'.format(obj=self)

s1=School('oldboy1','北京','私立')
print(format(s1,'nat'))  #s1.__format__('nat')
print(format(s1,'tna'))
print(format(s1,'tan'))
print(format(s1,'asfdasdffd'))  # 字典不存在，走默认值。s1.__format__('nat')

执行输出：

oldboy1-北京-私立
私立:oldboy1:北京
私立/北京/oldboy1
oldboy1-北京-私立

重新回忆一下if判断的知识

if True:print('执行if中的代码')
if False:print('不执行if中的代码')

if True or False:print('or两端的条件有一个为True就执行这个if中的代码')
if not True or False:pass  结果为False，不执行if代码
if not False or False:pass  结果为True，执行if代码
if not format_spec or format_spec not in format_dict  有一个条件为True，执行if代码

当数据为以下值时，分别是数字0，空列表，空字符串，空字典，空元组，None

0 [] '' {} () None

表示False，否则为True

四、__call__

对象后面加括号，触发执行。

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

class Teacher():
    def __call__(self):
        print(123)
t = Teacher()
t()  # 对象名() 相当于调用类内置的__call__
Teacher()()  #效果同上

执行输出：

123
123

有些源码会出现类名()()这种的，它其实是调用了__call__方法。所以一定要注意!!!

把__call__注释掉，再次执行

class Teacher():
    pass
    # def __call__(self):
    #     print(123)
t = Teacher()
t()

执行报错：

TypeError: 'Teacher' object is not callable

object默认没有__call__方法

使用callable方法，判断对象是否可调用

class Teacher():
    pass
    # def __call__(self):
    #     print(123)
t = Teacher()
print(callable(Teacher))
print(callable(t))

执行输出：

True
False

一个对象是否可调用 完全取决于这个对象对应的类是否实现了__call__

看Teacher类是否有__call__方法

print('__call__' in Teacher.__dir__(Teacher))

执行输出： True

查看callabble方法的解释，有一句话

Note that classes are callable (calling
a class returns a new instance); instances are callable if their class has a __call__() method.

翻译解释：

注意类是可调用的(调用)
一类返回一个新实例);实例调用如果类有一个__call __()方法。

print(callable(Teacher))的返回值是True

__call __()方法是针对对象的，而不是类。

python一切皆对象

class Teacher(object):
    def __call__(self):
        print(123)
    def call(self):
        print(456)

t = Teacher()
t.call()  # 手动执行call方法

执行输出： 456

五、__eq__

__eq__ 定义了类的等号(==)行为

class A:pass
a = A()
b = A()
print(a)
print(b)

执行输出：

<__main__.A object at 0x000001D32763BF28>
<__main__.A object at 0x000001D327641320>

从结果上来看，内存地址是不一样的

判断是否相等

class A:pass
a = A()
b = A()
print(a == b)

执行输出：False

==实际是调用了 __eq__方法，它是判断内存地址，是否一致

自定义__eq__方法

class A:
    def __eq__(self, other):
        return True
a = A()
b = A()
a.name = 'alex'  # 增加一个属性
b.name = 'egon'
print(a == b)

执行输出：True

== 是由__eq__的返回值来决定的

虽然明知道，a和b是不可能相等的。但是类方法__eq__强制改变了结果，不管是什么，结果总是为True

为了让__eq__方法更有意义，再改动一下。

class A:
    def __eq__(self, other):
        if self.__dict__ == other.__dict__:
            return True
        else:
            return False

a = A()
b = A()
a.name = 'alex'  # 增加一个属性
b.name = 'egon'
print(a == b)

执行输出：False

六、__del__

析构方法，当对象在内存中被释放时，自动触发执行。

注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

class A:
    def __init__(self):
        pass
    def __del__(self):
        print('执行我啦')

a = A()
print('aaa')

执行输出：

aaa
执行我啦

当类执行完毕时，自动执行析构方法

删除一个对象

class A:
    def __init__(self):
        pass
    def __del__(self):
        print('执行我啦')

a = A()
del a  # 主动删除对象
print('aaa')

执行输出：

执行我啦
aaa

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

看下面的例子

class A:
    def __init__(self):
        self.f = open('文件','w')  # 打开文件句柄
    # def __del__(self):
    #     print('执行我啦')

a = A()
del a
print('aaa')

执行输出：aaa

这段代码，有一个问题，文件打开了，但是文件句柄没有释放。那么就浪费内存了。

这个时候，需要在析构方法中，关闭文件句柄

class A:
    def __init__(self):
        self.f = open('文件','w')
    def __del__(self):
        self.f.close()  # 关闭文件句柄
        print('文件关闭了')

a = A()
del a

七、__new__

 __new__方法是创建类实例的方法，它的调用是发生在__init__之前的

object默认就有了

看__new__的源码

@staticmethod # known case of __new__
    def __new__(cls, *more): # known special case of object.__new__
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

它是一个静态方法，没有self，因为此刻还没有self
__new__()面试必考

先有对象，才能初始化
__new__方法不需要写，object自带

先来讲一个设计模式-->单例模式

如果面试中，只要 是问单例模式，就是问__new__
单例模式 就是一个类只能有一个实例

应用场景

1.当一个类，多次实例化时，每个实例都会占用资源，而且实例初始化会影响性能，这个时候就可以考虑使用单例模式，它给我们带来的好处是只有一个实例占用资源，并且只需初始化一次

2.当有同步需要的时候，可以通过一个实例来进行同步控制，比如对某个共享文件（如日志文件）的控制，对计数器的同步控制等，这种情况下由于只有一个实例，所以不用担心同步问题

看下面的代码：

class A:pass
a = A()
b = A()
print(a)
print(b)

执行输出：

<__main__.A object at 0x00000299A8D9BF28>
<__main__.A object at 0x00000299A8DA1320>

这不是单例模式，因为内存地址不一样
不是__init__的锅，是__new__的锅

__new__每次实例化，会创建一个新的内存地址

下面看一个真正的单例模式，使用__new__方法

class B:
    __instance = None
    def __new__(cls, *args, **kwargs):  # cls表示类
        if cls.__instance is None:  # 判断类变量__instance是否为None
            obj = object.__new__(cls)  # 创建一个实例对象
            cls.__instance = obj  # 赋值
        return cls.__instance  # 返回私有静态属性

a = B()
b = B()
print(a)
print(b)

执行输出：

<__main__.B object at 0x00000267F570BB00>
<__main__.B object at 0x00000267F570BB00>

上面的结果，内存地址是一样的。

注意：__new__每次实例化，都会执行！！！

实例化时，先执行__new__，再执行__init__

第一次执行时,cls.__instance 是None，创建一个对象
第二次执行时,cls.__instance 不是None，返回私有静态属性

再添加几个属性

class B:
    __instance = None

    def __new__(cls, *args, **kwargs):
        if cls.__instance is None:
            obj = object.__new__(cls)
            cls.__instance = obj
        return cls.__instance

    def __init__(self,name,age):
        self.name = name
        self.age = age
    def func(self):
        print(self.name)

a = B('alex',80)  #实例化,传值
b = B('egon',20)  #实例化,覆盖值
print(a)
print(b)
print(a.name)
print(b.name)

执行输出：

<__main__.B object at 0x000002483F7DFF28>
<__main__.B object at 0x000002483F7DFF28>
egon
egon

b实例化时，a对象的值指向就中断了。由于a和b共用一个内存空间，所以最终结果为egon

八、item系列

对象使用中括号的形式去操作 

__getitem__ 当访问不存在的属性时会调用该方法

__setitem__属性被赋值的时候都会调用该方法

__delitem__删除属性时调用该方法

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

    def __getitem__(self,item):
        return  self.__dict__[item]

    def __setitem__(self, key, value):
        self.__dict__[key]=value

    def __delitem__(self, key):
        print('del obj[key]时,我执行')
        self.__dict__.pop(key)

f = Foo('alex')
# f.name = ...
print(f['name'])  # f.__getitem__('name')
f['age'] = 18  # 赋值
print(f.age)  # 自带的语法
print(f['age'])  # 修改
f['age'] = 80
print(f['age'])  # 通过实现__getitem__得到的
del f['age']  # 删除
#print(f.age)  # 删除

执行输出：

alex
18
18
80
del obj[key]时,我执行

想要用对象名.[名字]
必须实现__getitem__方法

__getitem __只能有一个参数

__setitem__能接收2个参数，一个是等号左边，一个是等号右边的

__delitem__很少用

__delattr不用实现，因为object自带就有

class Foo:
    def __init__(self,name):
        self.name=name
    def __delattr__(self, item):
        print('del obj.key时,我执行')
        self.__dict__.pop(item)
f = Foo('alex')
del f.name     #相当于执行了__delattr__
# delattr(f,'name')

执行输出：

del obj.key时,我执行

面试题：

有一个类Person，它有3个属性，分别是name，sex，age。
实例化100次，每个对象的内存地址是不一样的。
其中有2个对象，name和sex是一样的，age不同
那么如何，去掉这2个重复的对象？

　　

答案：

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

    def __hash__(self):  # 实例化时，执行此方法
        return hash(self.name + self.sex)  # 对name和sex做hash，因为有2个对象name和sex一样，age不同

    def __eq__(self, other): # 实例化时，执行此方法
        if self.name == other.name and self.sex == other.sex:  # 判断每一个对象的name和sex是否相同
            return True

p_lst1 = []  #定义一个列表
#生成98个实例对象
for i in range(98):
    p_lst1.append(Person('egon' + str(i),i,'male'))
#手动增加2个重复的，name和sex值是一样的，age不同
p_lst1.append(Person('egon50',200,'male'))
p_lst1.append(Person('egon50',300,'male'))
#查看p_lst1的长度
print(len(p_lst1))
#使用集合去重,查看p_lst1的长度
print(len(set(p_lst1)))

执行输出：

100
98

注意：__hash__和__eq__方法，必须自己定义，否则无法去重

明日默写：

class B:
    __instance = None

    def __new__(cls, *args, **kwargs):
        if cls.__instance is None:
            obj = object.__new__(cls)
            cls.__instance = obj
        return cls.__instance

    def __init__(self,name,age):
        self.name = name
        self.age = age
    def func(self):
        print(self.name)

a = B('alex',80)
b = B('egon',20)
print(a)
print(b)
print(a.name)
print(b.name)