第065讲：类和对象（VIII）

nikezhi

不会英语名字不会起怎么办。每次都是abc

小甲鱼

nikezhi 发表于 2022-6-25 01:28
不会英语名字不会起怎么办。每次都是abc

推荐 -> https://fanyi.baidu.com

实在不行用拼音简写也可以哈

云会飞

在类与对象第八讲里面，最后一个关于用del让对象重生的例子，请问一下self（也就是e）是怎么传进外围函数的呀？调用self.func(self)，但是这个参数是怎么传进去的呀，outter（）函数没有参数呀？又是怎么把self给x的呢？

hveagle

nikezhi 发表于 2022-6-25 01:28
不会英语名字不会起怎么办。每次都是abc

1. def jia(a, b):
   
2.     return a + b
   
3. 
   
4. #也行

复制代码

小古比鱼

久仰Python“魔法方法”大名，现在我们终于要来揭开它的神秘面纱了！魔法方法拥有神奇而强大的功效，与众不同的“超能力”，可以让你的对象听你的！魔法方法的名称前后通常都各有两个下横线，如构造函数__init__()就是我们接触到的第一个魔法方法，能够在类实例化对象的时候自动进行调用。这节课还讲到了另外两个魔法方法：__new__()方法和__del__()方法，分别用于创建和销毁对象。其中，__new__()方法的重写通常用于两种情况，一种是在“元类”中定制类，另一种是在继承不可变数据类型时从中作梗，在实例对象创建之前进行拦截，从而达到修改不可变对象的目的；__del__()方法仅在对象被销毁，即最后一个引用消失的时候才会被自动调用。除此之外，__del__()方法还可以通过创建一个该实例的新引用来推迟其销毁，使对象重生。具体的操作方法是在对象被销毁之前将self通过某种形式（如全局变量或闭包）“送出去”，暗度陈仓，将其保存（备份）起来，这样即使对象被销毁了，我们仍可通过备份访问到它，这不禁让我们再次想起了那句名言：“有的人死了，他还活着……”

小古比鱼

云会飞 发表于 2022-8-28 17:46
在类与对象第八讲里面，最后一个关于用del让对象重生的例子，请问一下self（也就是e）是怎么传进外围函数的 ...

self是通过内部函数inner()窃取的，__del__()在调用内部函数inner()时带参数self，故可将self保存在外部函数的变量x当中（执行“x = y”），而执行“g = f()”时由于不带参数，便可由外部函数outter()返回该self对象（执行“return x”），赋值给g，使d重生。
@小甲鱼

wujiafeng

还是不怎么理解最后一个程序执行的逻辑，

wuchenghua

多做多练即可慢慢的熟能生巧

migu_sm1

Learning...
class E:
    def __init__(self,name,func):
        self.name = name
        self.func = func
    def __del__(self):
        self.func(self)

        
def outter():
    x = 0
    def inner(y=None):
        nonlocal x
        if y:
            x = y
        else:
            return x
    return inner

f = outter()
e = E("小甲鱼",f)
e
<__main__.E object at 0x000001E753393CA0>
e.name
'小甲鱼'
del e
e
Traceback (most recent call last):
  File "<pyshell#26>", line 1, in <module>
    e
NameError: name 'e' is not defined. Did you mean: 'E'?
g = f()
g
<__main__.E object at 0x000001E753393CA0>
g.name
'小甲鱼'

Ensoleile

魔法方法

1. #通过对魔法方法重写，我们就能从中作梗
   
2. #参与构建对象之前还有个__new__()方法，在__init__()之前被调用，P161
   
3. #事实上对象就是由__new__(cls[, ...])方法来创建的，所以它的第一个参数是cls，而不是self
   
4. #所以对象的诞生流程是先调用__new__()方法创建一个类的实例对象，然后将其传递给__init__()方法
   
5. #需要重写__new__()方法的情况极少，通常只有两种情况可能用到：
   
6. #一种情况是在元类中定制类，在后续课程中讲解，先按住不表
   
7. #另一种情况是在继承不可变数据类型时，可以通过重写__new__()方法进行拦截
   
8. class CapStr(str):
   
9.     def __new__(cls, string):
   
10.         string = string.upper()
    
11.         return super().__new__(cls, string)
    
12.         #不需要考虑__new__()怎么去构造对象，直接让其父类<class 'str'>去做
    
13. 
    
14. cs = CapStr('FishC')
    
15. print(cs) #FISHC
    
16. #这里之所以能对不可变对象进行修改，是因为我们赶在实例对象被创建前就进行了拦截，
    
17. # 然后才调用super().__new__()创建真正的实例，由于CapStr类继承自str类，所以字符串该有的方法也继承了下来
    
18. print(cs.lower()) #fishc
    
19. 
    
20. #__del__(self)：当对象将被销毁的时候调用此方法，P162
    
21. class C:
    
22.     def __init__(self):
    
23.         print('我来了')
    
24.     def __del__(self):
    
25.         print('我走了')
    
26. 
    
27. c = C() #我来了
    
28. del c #我走了
    
29. 
    
30. #并非调用del c就一定会触发__del__()魔法方法，仅当对象被销毁时才会触发
    
31. #python中引入了垃圾回收机制garbage collection，当检测到一个对象没有任何引用的时候，才会将它销毁
    
32. c = C() #我来了
    
33. d = c
    
34. del c #没有我走了
    
35. del d #我走了
    
36. 
    
37. #__del__方法可以通过创建一个该实例的新引用来推迟其销毁，也被称之为对象的重生
    
38. #官方不建议，但是可以实现
    
39. #虽然对象通过del语句被删除了，但如果在对象被销毁之前将self送出去，那么对象就算是得以重生
    
40. #del是个语句，没法执行这个语句的同时，又把它的返回值赋值给另一个变量存储，即没法通过返回值的形式返回self
    
41. class D:
    
42.     def __init__(self, name):
    
43.         self.name = name
    
44.     def __del__(self):
    
45.         global x
    
46.         x = self
    
47. 
    
48. d = D('fishc')
    
49. print(d) #<__main__.D object at 0x000001574FDB7F70>
    
50. del d
    
51. print(x) #<__main__.D object at 0x000001574FDB7F70>
    
52. print(x.name) #fishc
    
53. 
    
54. #为避免污染全局变量，使用闭包
    
55. class E:
    
56.     def __init__(self, name, func):
    
57.         self.name = name
    
58.         self.func = func
    
59.     def __del__(self):
    
60.         self.func(self)
    
61. 
    
62. def outter():
    
63.     x = 0
    
64.     def inner(y=None):
    
65.         nonlocal x
    
66.         if y:
    
67.             x = y
    
68.         else:
    
69.             return x
    
70.     return inner
    
71. 
    
72. f = outter()
    
73. e = E('fishc', f)
    
74. print(e) #<__main__.E object at 0x0000024B6E6AA8E0>
    
75. print(e.name) #fishc
    
76. del e
    
77. print(f()) #<__main__.E object at 0x0000024B6E6AA8E0>
    
78. print(f().name) #fishc
    
79. #e删除后f()就是e
    
80. #outter()返回值为inner()，f赋值为inner，c被删除时执行__del__()魔法方法
    
81. #c.func(c)，即f(c)，即inner(c)，将c传给外层变量x，
    
82. #在再次调用f()时，y未传参，执行return x，即返回c

复制代码

andyleesh

打卡

Monster_JC

有点看不懂了

01010101010

cmu052115

#通过对魔法方法重写，我们就能从中作梗
#参与构建对象之前还有个__new__()方法，在__init__()之前被调用，P161
#事实上对象就是由__new__(cls[, ...])方法来创建的，所以它的第一个参数是cls，而不是self
#所以对象的诞生流程是先调用__new__()方法创建一个类的实例对象，然后将其传递给__init__()方法
#需要重写__new__()方法的情况极少，通常只有两种情况可能用到：
#一种情况是在元类中定制类，在后续课程中讲解，先按住不表
#另一种情况是在继承不可变数据类型时，可以通过重写__new__()方法进行拦截
class CapStr(str):
    def __new__(cls, string):
        string = string.upper()
        return super().__new__(cls, string)
        #不需要考虑__new__()怎么去构造对象，直接让其父类<class 'str'>去做

cs = CapStr('FishC')
print(cs) #FISHC
#这里之所以能对不可变对象进行修改，是因为我们赶在实例对象被创建前就进行了拦截，
# 然后才调用super().__new__()创建真正的实例，由于CapStr类继承自str类，所以字符串该有的方法也继承了下来
print(cs.lower()) #fishc

#__del__(self)：当对象将被销毁的时候调用此方法，P162
class C:
    def __init__(self):
        print('我来了')
    def __del__(self):
        print('我走了')

c = C() #我来了
del c #我走了

#并非调用del c就一定会触发__del__()魔法方法，仅当对象被销毁时才会触发
#python中引入了垃圾回收机制garbage collection，当检测到一个对象没有任何引用的时候，才会将它销毁
c = C() #我来了
d = c
del c #没有我走了
del d #我走了

#__del__方法可以通过创建一个该实例的新引用来推迟其销毁，也被称之为对象的重生
#官方不建议，但是可以实现
#虽然对象通过del语句被删除了，但如果在对象被销毁之前将self送出去，那么对象就算是得以重生
#del是个语句，没法执行这个语句的同时，又把它的返回值赋值给另一个变量存储，即没法通过返回值的形式返回self
class D:
    def __init__(self, name):
        self.name = name
    def __del__(self):
        global x
        x = self

d = D('fishc')
print(d) #<__main__.D object at 0x000001574FDB7F70>
del d
print(x) #<__main__.D object at 0x000001574FDB7F70>
print(x.name) #fishc

#为避免污染全局变量，使用闭包
class E:
    def __init__(self, name, func):
        self.name = name
        self.func = func
    def __del__(self):
        self.func(self)

def outter():
    x = 0
    def inner(y=None):
        nonlocal x
        if y:
            x = y
        else:
            return x
    return inner

f = outter()
e = E('fishc', f)
print(e) #<__main__.E object at 0x0000024B6E6AA8E0>
print(e.name) #fishc
del e
print(f()) #<__main__.E object at 0x0000024B6E6AA8E0>
print(f().name) #fishc
#e删除后f()就是e
#outter()返回值为inner()，f赋值为inner，c被删除时执行__del__()魔法方法
#c.func(c)，即f(c)，即inner(c)，将c传给外层变量x，
#在再次调用f()时，y未传参，执行return x，即返回c

cmu052115

听不懂

dearfish

type(str)  #str是类

shu_gumeng

不怎么理解最后一个程序执行的逻辑