关于类和实例的问题

qq511383041

先列举一个代码：
class C:
        count = 0
        def __init__(self):
                C.count = C.count +1
这个代码实现的功能就是每创造一个实例对象，就会记录一次，看到这里，我突然就产生几个问题疑惑

问题1：
a=C(),运行后得到结果C.count=1；实例拥有类的属性和方法，那么我再用b=a，为什么C.count还是等于1，__init__方法没有被成功调用？

问题2：
基于问题1，我上网查了资源，有这么一个猜想，__init__方法是需要类创建实例才会被调用，由于b=a，不属于类创建实例，所以没有成功调用；那么b=a属于一个怎样的过程操作？

问题3：
看到这个问题，自然就想起了之前闭包的知识，有没有办法实现在不修改类的初始值的前提下，实现每创造一个实例对象，就会记录一次的功能？

以上的问题属于基础问题，本人查了很多资料，有一定想法，但总感觉不踏实，希望得到各位大大的解答，谢谢

°蓝鲤歌蓝

1. 不是没成功调用，而是根本就没调用。
2. 你的想法是正确的， b=a时并不会创建一个新的实例。
a = C()时创建一个实例对象，这时会分配一个内存空间用来存储这个实例，这块内存空间有自己的地址(查看对象地址使用 id(a))，a = C() 表明 a 指向存储该实例的内存空间，b=a 则表示 b也指向该内存空间，如果是创建了一个新的实例，则 b 会指向一个新的内存空间。
你可以输入

1. print(a is b)

复制代码

（is 用来判断地址是否相同，== 则是判断值是否相同）
3. 类的初始值是什么意思？

Stubborn

只能再初始化的时候记录，不在初始化记录没法子

1. class C:
   
2.     count = 0
   
3. 
   
4.     def __init__(self):
   
5.         print("正在调用")
   
6.         self.prin()
   
7. 
   
8.     def prin(self):
   
9.         self.count = self.count + 1
   
10.         print("测试=",self.count)
    
11. 
    
12. a = C()
    
13. b = a
    
14. print("a的类型={}.内存id={},值{}".format(type(a),id(a),a))
    
15. print("a的类型={}.内存id={},值{}".format(type(b),id(b),b))
    
16. print("a对象测试：",a.prin())
    
17. print("b对象测试：",b.prin())
    
18. 
    
19. aa = 2
    
20. bb = aa
    
21. print("aa的类型={}.内存id={},值{}".format(type(aa),id(aa),aa))
    
22. print("a的类型={}.内存id={},值{}".format(type(bb),id(bb),bb))

复制代码

结果

1. 正在调用
   
2. 测试= 1 #初始化类调用函数一次，下面都是调用函数才发生的次数
   
3. a的类型=<class '__main__.C'>.内存id=44007320,值<__main__.C object at 0x00000000029F7F98>
   
4. a的类型=<class '__main__.C'>.内存id=44007320,值<__main__.C object at 0x00000000029F7F98>
   
5. 测试= 2
   
6. a对象测试： None
   
7. 测试= 3
   
8. b对象测试： None
   
9. aa的类型=<class 'int'>.内存id=8791298004032,值2
   
10. a的类型=<class 'int'>.内存id=8791298004032,值2

复制代码

qq511383041

°蓝鲤歌蓝 发表于 2019-2-21 23:28
1. 不是没成功调用，而是根本就没调用。
2. 你的想法是正确的， b=a时并不会创建一个新的实例。
a = C() ...

感谢大大的回答 初始值就是指 让C.count=0  而不是经过几次调用后，count就不等于0了

qq511383041

°蓝鲤歌蓝 发表于 2019-2-21 23:28
1. 不是没成功调用，而是根本就没调用。
2. 你的想法是正确的， b=a时并不会创建一个新的实例。
a = C() ...

再追问大大一个问题
为什么a.count()的结果会随着C.count的变化而变化，但是在del C 后依然能使用a.count()

stonejianbu

1.2. b=a, 是b引用a的值，即b引用了实例a，并不产生新的类实例化对象。
3. 常用的闭包函数-->以装饰器实现count实例：

1. # decorator
   
2. def count_info(func):
   
3.     count_info.count = 0
   
4.     def inner(*args, **kwargs):
   
5.         count_info.count += 1
   
6.         return func(*args, **kwargs)
   
7.     return inner
   
8. 
   
9. @count_info
   
10. class Myclass:
    
11.     pass
    
12. 
    
13. mc1 = Myclass()
    
14. mc2 = Myclass()
    
15. print(count_info.count)  # 2
    
16. 
    
17. # 或者利用类方法实现count实例
    
18. class Stone:
    
19.     count = 0
    
20.     def __init__(self):
    
21.         type(self).count += 1
    
22. 
    
23.     @classmethod
    
24.     def count_info(cls):
    
25.         return cls.count
    
26. 
    
27. stone1 = Stone()
    
28. stone2 = Stone()
    
29. stone3 = Stone()
    
30. print(Stone.count_info()) # 3

复制代码

qq511383041

stonejianbu 发表于 2019-2-22 12:43
1.2. b=a, 是b引用a的值，即b引用了实例a，并不产生新的类实例化对象。
3. 常用的闭包函数-->以装饰器实现 ...

嗯嗯，这三个问题已经明白了
现在还有这个问题
为什么a.count的结果会随着C.count的变化而变化，但是在del C 后依然能使用a.count

stonejianbu

qq511383041 发表于 2019-2-22 13:44
嗯嗯，这三个问题已经明白了
现在还有这个问题
为什么a.count的结果会随着C.count的变化而变化，但是在 ...

1. class Foo:
   
2.     count = 1
   
3. 
   
4. f = Foo()
   
5. # del Foo
   
6. print(f.count) # 1
   
7. print(f.__class__, f.__class__.__dict__['count']) # <class '__main__.Foo'> 1
   
8. # print(Foo)  # name 'Foo' is not defined, 类和实例都是独立的命名空间，删除类并不影响由其已创建的实例
   
9. print(Foo.__mro__) # 父类元组，左至右开始查找顺序
   
10. 
    
11. # 在未设置__slots__时，一般的查找顺序instance.__dict__==> __class__.__dict__===>___bases__.__dict__(广度优先)

复制代码