第064讲：类和对象（VII）

gcice

1. class C:
   
2.     def __init__(self,x):
   
3.         self.__x=x
   
4.     def set_x(self,x):
   
5.         self.__x=x
   
6.     def get_x(self):
   
7.         print(self.__x)
   
8. 
   
9.         
   
10. c=C(250)
    
11. c.__x
    
12. Traceback (most recent call last):
    
13.   File "<pyshell#249>", line 1, in <module>
    
14.     c.__x
    
15. AttributeError: 'C' object has no attribute '__x'
    
16. c.get_x()
    
17. 250
    
18. c.set_x(520)
    
19. c.get_x()
    
20. 520
    
21. c.__dict__
    
22. {'_C__x': 520}
    
23. c._C__x
    
24. 520
    
25. class D:
    
26.     def __func(self):
    
27.         print("hello fishc.")
    
28. 
    
29.         
    
30. d=D()
    
31. d.__func()
    
32. Traceback (most recent call last):
    
33.   File "<pyshell#260>", line 1, in <module>
    
34.     d.__func()
    
35. AttributeError: 'D' object has no attribute '__func'. Did you mean: '_D__func'?
    
36. d._D__func()
    
37. hello fishc.
    
38. c.__y=250
    
39. c.__dict__
    
40. {'_C__x': 520, '__y': 250}

复制代码

gcice

1. class C:
   
2.     def __init__(self,x):
   
3.         self.x=x
   
4. 
   
5.         
   
6. c=C(250)
   
7. c.x
   
8. 250
   
9. c.__dict__
   
10. {'x': 250}
    
11. c.y=520
    
12. c.__dict__
    
13. {'x': 250, 'y': 520}
    
14. c.__dict__['z']=666
    
15. c.__dict__
    
16. {'x': 250, 'y': 520, 'z': 666}
    
17. c.z
    
18. 666
    
19. class C:
    
20.     __slots__=["x","y"]
    
21.     def __init__(self,x):
    
22.         self.x=x
    
23. 
    
24.         
    
25. c=C(250)
    
26. c.x
    
27. 250
    
28. c.y=520
    
29. c.y
    
30. 520
    
31. c.z=666
    
32. Traceback (most recent call last):
    
33.   File "<pyshell#287>", line 1, in <module>
    
34.     c.z=666
    
35. AttributeError: 'C' object has no attribute 'z'
    
36. class D:
    
37.     __slots__=["x","y"]
    
38.     def __init__(self,x,y,z):
    
39.         self.x=x
    
40.         self.y=y
    
41.         self.z=z
    
42. 
    
43.         
    
44. d=D(3,4,5)
    
45. Traceback (most recent call last):
    
46.   File "<pyshell#295>", line 1, in <module>
    
47.     d=D(3,4,5)
    
48.   File "<pyshell#294>", line 6, in __init__
    
49.     self.z=z
    
50. AttributeError: 'D' object has no attribute 'z'
    
51. class E(C):
    
52.     pass
    
53. 
    
54. e=E(250)
    
55. e.x
    
56. 250
    
57. e.y=520
    
58. e.y
    
59. 520
    
60. e.z=666
    
61. e.__slots__
    
62. ['x', 'y']
    
63. e.__dict__
    
64. {'z': 666}

复制代码

小古比鱼

私有变量是一种保护机制，指通过某种手段，使得对象中的属性或方法无法被外部所访问。Python引入的“name mangling”（名字改编、名称改写或名称修饰）机制可以实现“私有化”，只要在变量名前加上两个连续的下横线即可实现，方法名也与之类似。然而，Python其实是将该变量或方法偷换了名字，以此来掩人耳目；__dict__属性可以揭开真相，我们仍可通过“下横线+类名+私有变量名”或“下横线+类名+私有方法名”的方式访问到该变量或方法，只不过在现实中并不提倡这么做，毕竟这会违背私有化的初衷。事实上，Python给予程序员最大的自由度，并不存在仅限从对象内部访问的私有变量。此外，名字改编仅发生在类实例化对象时，实例化对象后添加的属性并不会被改编。
通常来说，单个下横线开头的变量是仅供内部使用的变量，尽量不要随意访问或修改；单个下横线结尾的变量可用于解决命名冲突（如与Python关键字重名）的问题，这是约定俗成的规则。
由于Python动态添加属性背后的实现原理是字典，以空间换时间，会牺牲大量的内存空间，因此，当我们不需要动态添加属性的功能时，便可以使用__slots__属性来避免利用字典造成的空间浪费。我们只需将必要的属性放入列表赋值给__slots__，这样对象就会划分一个固定大小的空间来存放指定的属性，省去了为__dict__属性划分的字典，有时可以大幅减少内存消耗，不失为一个好方法！继承自父类的__slots__属性是不会在子类中生效的，该子类仍可动态添加属性（拥有__dict__字典），因为Python只关注各个具体的类中定义的__slots__属性。虽然使用__slots__属性会牺牲Python动态语言的灵活性，但利用这一副作用又可以限制类属性的滥用，由此可见：技术永远是中立的，因地制宜，对症下药，方能实现最佳疗效！

Ensoleile

私有变量和__slots__()

1. #私有变量：P147 Name Mangling，
   
2. # 定义方法：__变量名，外部访问方法：_类名__变量名
   
3. 
   
4. #舍得之道：对象中灵活添加的属性，是用字典存储，字典效率快的背后是占用了大量内存（空间换时间）
   
5. class C:
   
6.     def __init__(self, x):
   
7.         self.x = x
   
8. 
   
9. c = C(250)
   
10. print(c.__dict__)
    
11. #{'x': 250}
    
12. c.__dict__['y'] = 520
    
13. print(c.__dict__)
    
14. #{'x': 250, 'y': 520}
    
15. 
    
16. #__slots__：如果已经明确一个类的对象设计出来不会有动态添加属性的需求，可以使用__slots__的类属性避免利用字典存放造成空间浪费
    
17. class D:
    
18.     __slots__ = ['x', 'y'] #列表中的就是希望的属性名
    
19.     def __init__(self, x):
    
20.         self.x = x
    
21. 
    
22. d = D(10)
    
23. d.y = 20
    
24. print(d.x, d.y, sep='   ')
    
25. try:
    
26.     print(d.__dict__)
    
27. except AttributeError as e:
    
28.     print(e)
    
29. #'D' object has no attribute '__dict__'
    
30. try:
    
31.     d.z = 66
    
32. except AttributeError as e:
    
33.     print(e)
    
34. #'D' object has no attribute 'z'
    
35. 
    
36. #类的内部同样不允许创建__slots__不包含的属性
    
37. class D:
    
38.     __slots__ = ['x', 'y']
    
39.     def __init__(self, x, y, z):
    
40.         self.x = x
    
41.         self.y = y
    
42.         self.z = z
    
43. # d = D(3, 4, 5)
    
44. #AttributeError: 'D' object has no attribute 'z'
    
45. #使用__slots__后，对象就会划分一个固定大小的空间来存放指定属性
    
46. #__slots__限制动态添加属性，也可以用来防止属性的滥用
    
47. 
    
48. #继承在父类的__slots__属性不会在子类中生效
    
49. class E(C):
    
50.     pass
    
51. 
    
52. e = E(3)
    
53. e.z = 10
    
54. print(e.__dict__)
    
55. #{'x': 3, 'z': 10}
    
56. print(e.__slots__)
    
57. #AttributeError: 'E' object has no attribute '__slots__'

复制代码

yukari123

Ensoleile 发表于 2023-1-2 23:06
私有变量和__slots__()

感谢，以后我也要边学边记笔记然后发评论区

qzzhang2

子类继承__solts__的属性，不会对新加属性造成影响

weiliao

class C:
    def __init__(self,x):
        self.__x = x
    def set_x(self,x):
        self.__x = x
    def get_x(self):
        print(self.__x)

wanglyndon

get私有变量

啊啊小姐姐

下节课没知识备忘了，也没作业了

cmu052115

ulimate

懂了，就像电算时代之前，银行不乐意给个人储户开活期储存，以缩限每个账户（存折）属性量，进而大大减小人工操作和局端存底成本。

leizhenzi23

在线等，求教:一个函数中如何添加多个私有变量啊

skyteam超级吕布

leizhenzi23 发表于 2024-1-22 14:14
在线等，求教:一个函数中如何添加多个私有变量啊

请问你是说这样子吗

1. class A:
   
2.     def __init__(self,x,y):
   
3.         self.__x=x
   
4.         self.__y=y

复制代码

ahluo

>>> class E(C):
...     pass
...
>>> e = E(250)
>>> e.x
250
>>> e.y = 520
>>> e.z = 666
>>> e.__slots__
['x', 'y']

在最后的这个继承中，为什么e.__dict__中只有z，没有x,y呢

CristianoR

# 1. 私有变量
# 在大多数面向对象的编程语言中，都存在着私有变量（private variable）的概念，所谓私有变量，就是指通过某种手段，使得对象中的属性或方法无法被外部所访问。
# Python对于私有变量的实现是引入了一种叫name mangling 的机制（翻译过来叫“名字改编”“名称改写”或者“名称修饰”），语法是在变量名前面加上两个连续下划线（__）
class C:
    def __init__(self, x):
        self.__x = x
    def set_x(self, x):
        self.__x = x
    def get_x(self):
        print(self.__x)

c = C(250)
#此时，我们是无法直接通过变量名访问到该变量的：
# c.__x
# Traceback (most recent call last):
#   File "<pyshell#13>", line 1, in <module> c.__x
# AttributeError: 'C' object has no attribute '__x

#想要访问变量的值，就需要使用指定的接口，比如这段代码中的 set_x() 和 get_x() 方法：
c.get_x()
c.set_x(520)
c.get_x()

#2. name mangling 机制的实现原理   我们看看 __dict__ 属性里面有啥：
print(c.__dict__)  #虽然这里面没有看到 __x，但是，却多了一个 _C__x 的属性对不对？
#访问一下试试：
print(c._C__x)   #果然如此……这个就是传说中的名字改编术！

#方法名也是同样的道理：
class D:
    def __func(self):
        print("Hello FishC.")

d = D()
#d.__func()
# Traceback (most recent call last):
#   File "<pyshell#12>", line 1, in <module>
#     d.__func()   AttributeError: 'D' object has no attribute '__func'
d._D__func()
#注意：name mangling 机制是发生在类实例化对象时候的事情，给对象动态添加属性则不会有同样的效果!!!

# 3. 不同数量的前缀下划线含义
# 不同数量的前缀下划线均有不同的特殊含义：

# 单下划线前缀  _FishC  仅供内部使用的变量（约定俗成，无强制措施）
# 双下划线前缀  __FishC  私有变量，Python 启用 name mangling 机制修改变量名称
# 单下划线后缀  class_  通常为了避免与 Python 关键字命名冲突使用，比如想定义一个叫class的变量名，但无奈class是属于 Python 的关键字，所以你可以写成 class_
# 前后均有双下划线  __init__  Python 魔法方法的命名方案，我们应该避免自己的属性使用这种命名形式
# 单独一个下划线  _  表示一个临时变量，在 IDLE 的交互模式中，_ 是最后一个表达式的结果


# 4. 效率提升之道
# Python 对象存储属性的工作原理 —— 字典（__dict__）：
# 对象动态添加属性，就是将键值对添加到 __dict__ 中：
# 甚至你可以直接通过给字典添加键值对的形式来创建对象的属性：c.__dict__['z'] = 666

# 但是，字典高效率的背后是以付出更多存储空间为代价的（字典和集合高效背后的玄机）
# 如果我们明确知道一个类的对象设计出来，就只是需要那么固定的某几个属性，并且不需要有动态添加属性这样的功能，那么利用字典来存放属性，这种空间上的牺牲就是纯纯地浪费！
# 针对这个情况，Python 专门设计了一个 __slots__ 类属性，避免了利用字典存放属性造成空间上的浪费
class C:
    __slots__ = ['x', 'y']
    def __init__(self, x):
        self.x = x
c = C(250)
print(c.x)
c.y=666
print(c.y)
#如果想要动态地添加一个属性，那就不好意思了：
# c.z = 100
# Traceback (most recent call last):
#   File "<pyshell#27>", line 1, in <module>
#     c.z = 100
# AttributeError: 'C' object has no attribute 'z'

# 这种限制不仅体现在动态添加属性上，如果在类的内部，想创建一个 __slots__ 不包含的属性，也是不被允许的
class D:
    __slots__ = ['x', 'y']
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

# d = D(3, 4, 5)
#   File "<pyshell#6>", line 6, in __init__
#     self.z = z
# AttributeError: 'D' object has no attribute 'z'


# 甚至是 __dict__ 属性，也不存在了：
#  d.__dict__
# AttributeError: 'D' object has no attribute '__dict__'


#因为使用了 __slots__ 属性，那么对象就会划分一个固定大小的空间来存放指定的属性，这时候 __dict__ 属性就不需要了，空间也就节约了出来。
# 不过这里有一点是需要特别强调的，就是使用 __slots__ 属性的副作用其实也相当明显，那就是要以牺牲 Python 动态语言的灵活性，作为前提。
# 使用了 __slots__ 属性，就没办法再拥有动态添加属性的功能了……
# 这可以说是它的一个副作用，但实际上很多开发者却利用这个副作用，来限制类属性的滥用4

#最后，还有一点需要大家知道的是，继承自父类的 __slots__ 属性是不会在子类中生效的，Python 只关注各个具体的类中定义的 __slots__ 属性：
class E(C):
    pass

e = E(250)
e.x

e.y = 520
e.z = 666
print(e.__slots__)   #对象 e 虽然拥有 __slots__ 属性，但它同时也拥有 __dict__ 属性：
print(e.__dict__)