Python面向对象小备忘

最近学到面向对象了，感觉到Python这方面的语法也有点神奇，这里专门归纳一下Python面向对象中我觉得比较重要的笔记。

• 本文目前有的内容：实例属性和类属性的访问，使用@property修饰器

实例属性和类属性的访问

Python里面向对象编程的类属性和实例属性与普通情况下全局变量和局部变量还是有相似之处的：

1. 我们可以通过实例名访问实例属性和类属性，就像上面例子中的

   new_instance.test_var

   和

   new_instance.pub_var

   。就像局部作用域能访问局部变量和全局变量。

2. 我们可以通过创建赋值让实例对象有 与类属性同名 的属性，比如

   new_instance.pub_var = 'own property'

   就会在new_instance本身创建一个属性，从而屏蔽 通过实例名对于类属性的访问。而在没有global关键字的情况下，局部变量在局部作用域被创建赋值后也会屏蔽同名的全局变量。

对于第2点可以试试通过实例名来删除类属性：

class Test:
pub_var = 'Hello' # 类属性

def __init__(self):
pass

new_instance = Test()
print(new_instance.pub_var)  # Hello
del new_instance.pub_var  # AttributeError: pub_var

很明显通过实例名是无法删除类属性

pub_var

# 紧接上面例子
new_instance = Test()
print(new_instance.pub_var)  # 此时访问了类属性，输出：Hello
new_instance.pub_var = 'Hello World'
print(new_instance.pub_var)  # 此时访问的是实例自身属性，输出：Hello World
del new_instance.pub_var  # 删除了实例自身属性，一切正常
print(new_instance.pub_var)  # 实例在自身找不到同名属性了，就又指向了类属性，输出：Hello
del Test.pub_var # 可以通过类名删除类属性
print(new_instance.pub_var) # 在实例自身和类里都找不到pub_var属性了，返回no attribute异常

可以看出通过实例名可以删除实例自身的属性，当实例在自身上找不到属性时，就会转而寻找类属性。类比局部变量和全局变量，局部变量也是先在局部作用域找，如果没找到就去找同名的全局变量。

通过类名，可以在很多地方访问到类属性，并可以进行修改（比如在实例的方法函数里就可以直接通过类名访问。

使用@property修饰器

class Test:
def __init__(self, val):
self.__secret_value = val

def my_value(self):
return self.__secret_value

new_instance = Test(233)
print(new_instance.my_value())

上面例子中我们将类实例化为对象

new_instance

my_value()

__init__

new_instance

__value

当我们要获得值的时候就要调用实例对象

new_instance

my_value()

print(new_instance.my_value())

如果 使用了@property修饰器 呢？

class Test:
def __init__(self, val):
self.__secret1value = val

@property
def my_value(self):
return self.__secret1value

new_instance = Test(233)
print(new_instance.my_value) # 末尾不用再加()了，因为这不是一个可调用的方法，而是一个属性

@property的作用正如其名，将实例的方法转换为了属性，上面例子中原本的方法

my_value()

my_value

这个修饰器本质上其实仍然是对方法的调用，咱改一下上面的例子：

class Test:
def __init__(self, val):
self.__value = val

@property
def my_value(self):
print('Here I am.') # 调用方法的时候输出'Here I am.'
return self.__value
new_instance = Test(233) # 实例化的时候没有任何输出
print(new_instance.my_value) # 访问这个属性时实际上内部调用了my_value()的方法，因为输出了 'Here I am.' 和 233

再进一步想想，

new_instance.my_value

my_value()

return

接着再钻一下，原本

my_value()

__value

被@property修饰后产生的属性是只读的

可以试试修改这个属性：

new_instance.my_value = 450
# AttributeError: can't set attribute

很明显，

my_value

new_instance

my_value()

• 作为实例对象的一个属性，其和方法有一定的区别，我们调用实例对象的方法时候是可以传参的，但属性不行，这意味着

  @property

  修饰的方法只能有

  self

  一个参数（否则访问属性的时候会报参数缺少的异常）。

• 另外一个实例对象是有其他属性的，@property等修饰器修饰的方法也好，普通的实例方法也好，一定不要和已有的属性重名。举个例子：

  class Test:
  def __init__(self, val):
  self.__secret1value = val
  self.my_value = 'pre'
  
  @property
  def my_value(self):
  print('Here I am.')
  return self.__secret1value
  
  new_instance = Test(233)
  # self.my_value='pre' -> AttributeError: can't set attribute
  # 其实从这里还能看出来，@property修饰先于实例初始化进行，导致抛出的异常是无法修改属性值

上面我们尝试修改了@property修饰而成的属性，但返回了

can't set attribute

需要修改这个@property属性的话，我们就需要请出附赠的修饰器

@已被修饰的方法名.setter

class Test:
def __init__(self, val):
self.__secret1value = val

@property
def my_value(self):
return self.__secret1value

@my_value.setter # [被@property修饰的方法名].setter
def my_value(self, val2set): # 这里的方法仍然是my_value
self.__secret1value = val2set

new_instance = Test(233)
print(new_instance.my_value) # 233
new_instance.my_value = 450 # 此时这个属性有修改(setter)的方法了，我们可以修改它
print(new_instance.my_value) # 450

和

@property

@已被修饰的方法名.setter

self

val2set

有了读和写，还差什么呢——删！

和setter类似，@property修饰器还赠有

@已被修饰的方法名.deleter

self

class Test:
def __init__(self, val):
self.__secret1value = val

@property
def my_value(self):
return self.__secret1value

@my_value.deleter # [被@property修饰的方法名].deleter
def my_value(self):  # 注意这里只接受一个self参数
del self.__secret1value

new_instance = Test(233)
print(new_instance.my_value)  # 233
try:
new_instance.my_value = 450
except:
print('Set failed.')  # Set failed.
del new_instance.my_value
print(new_instance.my_value)
# AttributeError: 'Test' object has no attribute '_Test__secret1value'

这个例子中咱没有定义

my_value

setter

deleter

del

总结一下

修饰器@property

1. @property

   让实例方法作为属性被访问。

2. 这一类修饰器能在一定程度上保护实例的私有属性不被随意修改（之所以是说一定程度上，是因为一旦用户知道了私有属性名就可以用

   _类名__私有属性名

   进行访问，Python，很神奇吧 (￣ε(#￣)☆╰╮o(￣皿￣///)） 。

3. 实例的方法名不要和自身其他方法或属性重名。

4. @property

   和

   @已被修饰的方法名.deleter

   修饰的方法只能接受

   self

   一个参数；而

   @已被修饰的方法名.setter

   修饰的方法除了

   self

   外可以接受第二个参数作为被修改的值。

除了

@property

property(getter,setter,deleter,doc)

class Test:
pub_var = 'Hello'

def __init__(self, val):
self.__secret1value = val
self.test_val = 'World'

def __getter(self):
return self.__secret1value

def __deleter(self):
del self.__secret1value

my_value = property(__getter, None, __deleter)

new_instance = Test(233)
print(new_instance.test_var) # World (通过实例名访问实例属性)
print(Test.pub_var)  # Hello (尝试通过类名访问类属性)
print(new_instance.pub_var)  # Hello (尝试通过实例访问类属性)
print(Test.my_value) # <property object at 0x0000025990BC5770> （这个其实也是类属性，通过类名能访问到）
print(new_instance.my_value)  # 233 （通过实例名访问类属性，间接调用了__getter，绑定上了self

property(getter,setter,deleter,doc)

读方法

写方法

删方法

描述信息

unreadable attribute

通过上面的例子可以看出，

property

类属性

new_instance.my_value

new_instance.my_value

new_instance

my_value

再回去看实例属性和类属性的访问，加上这个内置方法

property()

class Test:
def __init__(self, val):
Test.test_var = property(lambda self: val) # 闭包写法

new_instance = Test(233)
print(new_instance.test_var) # 233

1. 这个操作中首先利用了一个匿名函数充当getter方法，传入

   property

   第一个参数，然后property会返回一个类属性。

2. 因为在实例方法里我们也能访问到类名，于是我们将这个property类属性赋值给

   Test.test_var

   ，

   test_var

   便是一个名副其实的类属性了。

3. 通过实例名

   new_instance

   能访问到类属性

   test_var

   。

4. 从之前的这个例子可以看出，当我们通过类名访问property属性时只会返回一个property object，但是通过已创建的实例对象来访问就能间接调用getter方法。

5. 在上面过程中，始终没有

   new_instance

   的自身属性出现，取而代之我们利用闭包机制保护了创建实例时传入的值，我们完全无法通过实例名修改或者删除

   test_var

   这个属性，真正将其保护起来了。

当然，别让用户知道了类名，不然一句

Test.test_var = xxx

To be updated......