接上一文

• 伪私有目的：
  防止外界直接访问
  防止被子类同名称属性覆盖
• 为什么叫伪私有？
  print(Animal.__x)访问不到
  但是——print(Animal._Animal__x)可以访问到
• 但还是不建议这么去访问私有属性

只读属性

• 只能读取，不能写入，一般是实例属性

设置方法一

• 内置方法去读取

class Person:
  def __init__(self):
    self.__age=18 #不能访问了
  
  def getAge(self):
    return self.__age #这样就可以读取

p1=Person()
print(p1.__age) #不行 报错
print(p1.getAge()) #可以

设置方法二

class Person:
  def __init__(self):
    self.__age=18 #不能访问了

  #作用：可以以使用属性读取的方式来使用这个方法
 @property
  def getAge(self):
    return self.__age #这样就可以读取

p1=Person()
print(p1.age) #可以
p1.age=666 #不可以

对于property的理解

• 以读取属性的方式用方法

• 可以将一些属性的操作（删、改、查）关联到属性中

• 补充概念
  经典类：没有继承object（类）
  新式类：继承object
  在python3里面直接定义一类，直接默认定义的是新式类，继承object

在新式类的使用方式

class Person(object):
  def __init__(self):
    self.__age=18
 
  def get_age(self):
    return self.__age

  def set_age(self,value):
    self.__age=value

  
   age=property(get_age, set_age)

p=Person()
print(p.age)  #可以获取age，18

p.age=90
print(p.age) #90

第二种使用方式

class Person(object):
  def __init__(self):
    self.__age=18

  @property
  def age(self):
    return self.__age
  @age.setter
  def age(self,value):
    self.__age=value


p=Person()
print(p.age) #18

p.age=10
print(p.age) #10

在经典类中的使用方式

• 首先要将版本换成python2，否则定义类之后默认继承object，即是新式类，没法定义成经典类

class Person:
  def __init__(self):
    self.__age=18
 
  def get_age(self):
    return self.__age

  def set_age(self,value):
    self.__age=value

  
   age=property(get_age, set_age)

p=Person()
print(p.age) #18

p.age=19
print(p.age) #19
#但是这个值为19的age是一个新的变量，不是原来的类里面的__age的值改为了19

• 装饰器的方式

class Person:
  def __init__(self):
    self.__age=18

  @property
  def age(self):
    print '---get'
    return self.__age
 
 @age.setter
 def age(self,value):
    self.__age=value

p=Person()
print p.age #---get 18

p.age=19
print p.age #19
print p.__dict__ #{'age':19,'_Person__age':18}

• 这里要告诉我们的是：
  在经典类里面设置age值是可以做的，但是这样做的并不是对__age值的改变，只是添加了多一个值age
• 切记这一现象
• 建议以后都使用新式类

用系统内置的方法设置只读属性

• 刚刚提到的方式设置只读属性还是有漏洞，因为其实还是有办法可以修改只读属性

p1._Person__age = 999
p1.__dict__['_Person__age']=999

• 因此我们提出：__setattr__的使用

class Person:
  #当我们通过实例.属性 =值，给一个实例增加一个属性，或者说，修改一下属性值的时候，都会调用这个方法
  #在这个方法内部，才会真正把这个属性以及对应的值给存储到__dict__字典里面
  def __setattr__(self, key, value):
    print(key, value)

p1=Person()
p1.age=18 # age 18

print(p1.age) #报错
print(p1.__dict__) #{}

• 这里告诉我们实例p1并没有获得age属性

class Person:
  #当我们通过实例.属性 =值，给一个实例增加一个属性，或者说，修改一下属性值的时候，都会调用这个方法
  #在这个方法内部，才会真正把这个属性以及对应的值给存储到__dict__字典里面
  def __setattr__(self, key, value):
    print(key, value)

    #1.判定，key，是否是我们要设置的只读属性的名称
    if key=='age':
      print('这个属性是只读属性，不能设置数据')
    #2 .如果不是，只读属性的名次，真正的给它添加到这个实例里面去
     else:
      self.__dict__[key]=value

p1=Person() # age 18
p1.age=18 # 这个属性是只读属性，不能设置数据
print(p1.__dict__) #{}
p1.name='sz' # name sz
print(p1.__dict__) #{'name':'sz'}

• 可以添加属性name，不能添加属性age
• 下面再在if条件里多加一个and条件
• 添加这条条件之后在第一次添加属性age的时候可以添加
• 但后来不能在修改了，是只读属性

class Person:
  #当我们通过实例.属性 =值，给一个实例增加一个属性，或者说，修改一下属性值的时候，都会调用这个方法
  #在这个方法内部，才会真正把这个属性以及对应的值给存储到__dict__字典里面
  def __setattr__(self, key, value):
    print(key, value)

    #1.判定，key，是否是我们要设置的只读属性的名称
    if key=='age' and key in self.__dict__.keys():
      print('这个属性是只读属性，不能设置数据')
    #2 .如果不是，只读属性的名次，真正的给它添加到这个实例里面去
     else:
      self.__dict__[key]=value

p1=Person() # age 18
p1.age=18 # 18
print(p1.__dict__) #{'age':18}

p1.age=999# age 999
#这个属性只是只读属性，不能设置数据
p1.age=18 # 18
print(p1.__dict__) #{'age':18}

系统内置的特殊属性

• 创建好类之后自动就有的一些属性
• __dict__:类的属性
  __bases__：类的所有父类构成元组
  __doc__：类的文档字符串
  __name__：类名
  __model__：类定义所在的模块

一、类属性

class Person:
  """ 
  这是一个人，类
  """
  age =19
  def __init__(self):
    self.name='sz'

  def run(self):
    print('run')

print(Person.__dict__) #输出好多东西的字典，有__model__，有age，有run等等
print(Person.__bases__) # (<class 'object'>,)
print(Person.__doc__) #这是一个人，类
print(Person.__name__) # Person
pritn(Person.__module__) #__main__

二、实例属性

• __class__

class Person:
  """ 
  这是一个人，类
  """
  age =19
  def __init__(self):
    self.name='sz'

  def run(self):
    print('run')

p=Person()
print(p.__class__) #<class '__main__>Person'>