Python类是否可以访问成员，但不能从类的实例中访问？

Question

所以我不是来自计算机科学背景，而且我很难搜索/搜索正确的术语来回答这个问题。如果我有一个Python类与类变量objects像这样：

class MyClass(object): 
    objects = None 
    pass 

MyClass.objects = 'test' 
print MyClass.objects # outputs 'test' 

a = MyClass() 
print a.objects   # also outputs 'test' 

类和类的实例都将有机会获得objects变量。我明白，我可以改变的实例值，如下所示：

a.objects = 'bar' 
print a.objects   # outputs 'bar' 
print MyClass.objects # outputs 'test' 

，但有可能有Python中的类变量，访问类的用户（即不只是从类中），但不该类别的实例可以访问？我认为这被称为私人会员或其他语言的静态会员？

Answer 1

的Python被设计为允许类的实例，通过实例来访问类的属性。

这只能一个层次深，所以你可以使用一个元类：

class T(type): 
    x = 5 

class A(object): 
    __metaclass__ = T 

注意，元类语法是不同的Python 3.本作品：

>>> A.x 
5 
>>> A().x 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
AttributeError: 'A' object has no attribute 'x' 

它不尽管如此，阻止您设置该类的实例的属性;防止你有__setattr__魔术方法玩法：

class A(object): 
    x = 1 
    def __getattribute__(self, name): 
     if name == 'x': 
      raise AttributeError 
     return super(A, self).__getattribute__(name) 
    def __setattr__(self, name, value): 
     if name == 'x': 
      raise AttributeError 
     return super(A, self).__setattr__(name, value) 
    def __delattr__(self, name): 
     if name == 'x': 
      raise AttributeError 
     return super(A, self).__delattr__(name) 

Answer 2

如果你希望这是一个为objects“单一来源”，你可以把一个可变类型：

class MyClass(object): 
    objects = [] 

有了稳定的类型，但事实上，每个实例的开始是相同的来自MyClass是无关紧要的，因为该属性第一次被更改为实例时，它将从该类的值中“断开”。

然而，如果属性是可变的，在一个实例改变它改变它的类和类的所有其他实例：

>>> MyClass.objects.append(1) 
>>> MyClass.objects 
[1] 
>>> a = MyClass() 
>>> a.objects 
[1] 
>>> a.objects.append(2) 
>>> a.objects 
[1, 2] 
>>> MyClass.objects 
[1, 2] 

在Python中，没有什么是真的“私人”，所以你不能真的阻止实例访问或改变objects（在这种情况下，它是一个合适的类属性？），但是如果你通常不希望它们被访问直接：_objects。

一个真正保护objects从实例的接入方式将覆盖__getattribute__：

def __getattribute__(self, name): 
    if name == "objects": 
     raise AttributeError("Do not access 'objects' though MyClass instances.") 
    return super(MyClass, self).__getattribute__(name) 

>>> MyClass.objects 
[1] 
>>> a.objects 
... 
AttributeError: Do not access 'objects' though MyClass instances. 

Answer 3

不，你不能（编辑：你不能在一个方式，是完全不可访问，就像在Java中或C++）。

你可以做到这一点，如果你喜欢：

class MyClass(object): 
    objects = None 
    pass 

MyClass_objects = 'test' 
print MyClass_objects # outputs 'test' 

a = MyClass() 
print a.objects   # outputs 'None' 

或这样的：

在your_module.py：

objects = 'test' 
class MyClass(object): 
    objects = None 
    pass 

在yourapp.py：

import your_module 
print your_module.objects # outputs 'test' 

a = your_module.MyClass() 
print a.objects   # outputs 'None' 

的原因是：

当你创建一些类的实例没有什么可以阻止 你从内闲逛，并使用各种内部，私人 方法，这些方法（一）所需类的功能，但（b）不是 ，旨在直接使用/访问。

python中没有什么是真正的私有。 没有任何课堂或班级实例可以让你远离所有内在的东西（这使得自省 可能和强大）。 Python相信你。它说：“嘿，如果你想在黑暗的地方四处张望，我会相信你有一个很好的理由，而且你不会遇到麻烦。” Karl Fast

Answer 4

实现它的最简单的方法是使用descriptor。描述符是的，它意味着对属性访问进行更高级别的控制。例如：

class ClassOnly(object): 
    def __init__(self, name, value): 
     self.name = name 
     self.value = value 
    def __get__(self, inst, cls): 
     if inst is not None: 
      msg = 'Cannot access class attribute {} from an instance'.format(self.name) 
      raise AttributeError(msg) 
     return self.value 

class A(object): 
    objects = ClassOnly('objects', []) 

用作：

In [11]: a = A() 

In [12]: a.objects 
--------------------------------------------------------------------------- 
AttributeError       Traceback (most recent call last) 
<ipython-input-12-24afc67fd0ba> in <module>() 
----> 1 a.objects 

<ipython-input-9-db6510cd313b> in __get__(self, inst, cls) 
     5  def __get__(self, inst, cls): 
     6   if inst is not None: 
----> 7    raise AttributeError('Cannot access class attribute {} from an instance'.format(self.name)) 
     8   return self.value 

AttributeError: Cannot access class attribute objects from an instance 

In [13]: A.objects 
Out[13]: []