实例方法、函数装饰器、类方法、静态方法、访问控制
本文是来源于上雷俊丽老师python课的课件。
4.实例方法
实例方法指的是只有实例对象才可以调用的方法。
在类对象中定义实例方法时，第一个形参表示调用该方法的实例对象，其对应的实参由系统自动传入。第一个形参的名称通常是self，也可以是其他名称。
实例方法只能被实例对象所调用，有两种调用方式：
- 在类对象的内部（其它实例方法中）
语法格式： self.function([实参]) - 在类对象的外部
语法格式：实例对象.方法名([实参])
类对象的所有实例对象都有一个指向类对象的指针，所以类对象的所有实例对象都可以调用类对象中定义的实例方法。
调用实例方法时，系统自动将调用该实例方法的实例对象作为实参传递给第一个形参。第一个实参会传递给第二个形参，第二个实参会传递给第三个形参，依次类推。
class MyClass(object):
#在类对象中定义实例方法
def im1(self, p1, p2):
print(p1, p2)
#在类对象中定义实例方法
def im2(self):
#在类对象的内部（其他实例方法中）调用实例方法
self.im1(1, 2)
mc = MyClass()
#在类对象的外部调用实例方法
mc.im1(1, 2)
[out]: 1 2
mc.im2()
[out]: 1 2
Python是动态语言，所有在实例对象或类对象创建之后，可以对其动态地绑定实例方法。
同一个类对象的不同实例对象所绑定的实例方法是相互独立的。也就是说，给一个实例对象绑定的实例方法，对于另一个实例对象是不起作用的。
为了能让一个类对象的所有实例对象都能调用某个实例方法，可以给类对象绑定该实例方法。
#定义一个函数作为实例方法
def do_sth(self):
print("do_sth()被调用")
#导入标准库types中的类MethodType
from types import MethodType
#给实例对象mc动态地绑定实例方法
mc.do_sth = MethodType(do_sth, mc)
#调用绑定的实例方法
mc.do_sth()
[out]: do_sth()被调用
mc2 = MyClass()
#mc2.do_sth()
[out]: AttributeError: 'MyClass' object has no attribute 'do_sth'
#再定义一个函数作为实例方法
def im3(self):
print('im3()被调用了')
#给类对象动态地绑定实例方法
#MyClass.im3 = im3
#类对象的所有实例对象都能调用给类对象动态绑定的实例方法
mc.im3()
[out]: im3()被调用了
mc2.im3()
[out]: im3()被调用了
5.函数装饰器
对于某个函数，如果我们希望在不改变该函数代码的前提下，为该函数增加额外的功能，那么就可以使用装饰器来装饰该函数。
对于某个函数，如果我们希望在不改变该函数代码的前提下，为该函数增加额外的功能，那么就可以使用装饰器来装饰该函数。
装饰器是一个函数，装饰器接受一个函数作为参数（传入的实参是被装饰的函数）
装饰器的内部嵌套定义另一个函数，内函数中会引用装饰器的函数，并且装饰器的返回值是内函数。
为了让内函数接收任意类型的参数，将内函数的形参定义为(*args, **kwargs)
在函数中，首先完成 为被装饰函数添加的新功能，然后调用被装饰的函数。
把装饰器应用到被装饰函数的语法为：在被装饰函数的前面添加“@装饰器的函数名”
def notice(func):
def wrapper(*args, **kwargs):
print("公告，")
print("......")
return func(*args, **kwargs)
return wrapper
@notice
def add(a, b):
return a + b
def subt(a, b):
return a - b
def multi(a, b):
return a * b
def divi(a, b):
if b != 0:
return a / b
print(add(3, 5))
[out]: 公告，
......
8
注：@notice等同于add = notice(add)
6.类方法
类方法指的是类对象中使用装饰器@classmethod进行装饰的方法。
在类对象中定义类方法时，必须使用装饰器@classmethod进行装饰，此外，第一个形参表示类对象，其对应的实参由系统自动传入。第一个形参的名称通常是cls，也可以是其他名称。
类方法可以被类对象所调用，语法格式为：类对象.方法名([实参]) 或 cls.方法名([实参])。
类方法也可以被实例对象所调用，语法格式为：实例对象.方法名([实参])或 self.方法名([实参])。
类对象的所有实例对象都有一个指向类对象的指针，所以类对象的所有实例对象都可以调用类对象中定义的类方法。
调用类方法时，系统自动酱类对象作为实参传递给第一个形参。第一个实参会传递给第二个形参，第二个实参会传递给第三个形参，依次类推。
class MyClass(object):
#在类对象中定义类方法
@classmethod
def class_func(cls, a, b):
print(a, b)
#通过类对象调用类方法
MyClass.class_func('Hi', 'everyone!')
[out]: Hi everyone!
#通过实例对象调用类方法
mc = MyClass()
mc.class_func(1, 2)
[out]: 1 2
class MyClass(object):
#在类对象中定义类方法
@classmethod
def class_func_1(cls, a, b):
print(a, b)
#在类对象内部调用类方法
@classmethod
def class_func_2(cls):
MyClass.class_func_1(1, 2)
#or
cls.class_func_1(1, 2)
#通过实例对象调用类方法
def ins_func(self):
self.class_func_1(1, 2)
mc = MyClass()
mc.class_func_2()
[out]: 1 2
1 2
mc.ins_func()
[out]: 1 2
MyClass.class_func_2()
[out]: 1 2
1 2
MyClass.ins_func()
[out]:
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-3-684345a0b8ee> in <module>
1 #类对象不能直接调用实例对象的方法。
2
----> 3 MyClass.ins_func() #会报错
TypeError: ins_func() missing 1 required positional argument: 'self'
7.静态方法
类对象的静态方法只是一个普通函数。吧某个普通函数归属于类对象，可能只是为了易于代码管理。在类对象中定义静态方法时，必须使用装饰器@staticmethod进行装饰。
静态方法只是一个普通函数，因此，第一个形参没有特殊含义和要求。
静态方法可以被类对象所调用，语法格式为: 类对象.方法名([实参])或cls.方法名([实参])。
静态方法也可以被实例对象所调用，语法格式为：实例对象.方法名([实参])或self.方法名([实参])。
调用静态方法是的参数传递与调用普通函数是一样的。
class MyClass(objject):
@staticmethod
def sm(p1, p2):
print(p1, p2)
MyClass.sm(1, 2)
[out]: 1 2
mc = MyClass()
mc.sm(1, 2)
[out]: 1 2
8.访问控制
访问控制指的是：控制类对象的属性和方法在类对象的外部是否可以直接访问。
如果在类对象的某个属性或方法前添加两个下划线__，那么在类对象的外部就不能直接访问该属性或方法了。
class MyClass(object):
def __init__(self):
self.__pia = 18
def __pim(self):
print("__pim()")
mc = MyClass()
print(mc.__pia)
[out]:
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-15-0565b1fd764f> in <module>
1 mc = MyClass()
----> 2 print(mc.__pia)
AttributeError: 'MyClass' object has no attribute '__pia'
mc.__pim()
[out]:
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-16-9fe9859603b5> in <module>
----> 1 mc.__pim
AttributeError: 'MyClass' object has no attribute '__pim'
class MyClass(object):
def __init__(self):
self.__pia = 18
def __pim(self):
print("__pim()")
def do_sth(self):
print(self.__pia)
self.__pim
mc = MyClass()
print(mc.do_sth())
[out]: 18
__pim
None
之所以不能在类对象的外部直接访问以双下划线开头的属性或方法是因为:Python解释器对外把属性或方法__xxx改成了另一个名字：_类名__xxx。所以在类对象的外部仍然可以通过_类名__xxx访问属性或方法__xxx。但是，强烈建议不要这样访问，因为不同版本的Python解释器可能会把属性或方法__xxx改成不同的名字。
print(mc._MyClass__pia)
[out]: 18
mc._MyClass__pim()
[out]: __pim
#调用内置函数dir()获得指定对象所有可以访问的属性和方法
print(dir(mc))
仍然可以在类对象的外部动态绑定名为__xxx的属性或方法，这与类对象内部名为__xxx的属性或方法是不同的。
mc.__pia = 'Hi'
print(mc.__pia)
[out]: Hi
print(dir(mc))
除了在类对象的属性或方法前添加两个下划线__，还可以在类对象的属性或方法前添加单下划线_，这表示：虽然可以在类对象的外部访问该属性或方法，但是最好不要访问。
class SomeClass(object):
def __init__(self):
self._pia = 18
def _pim(self):
print("_pim")
sc = SomeClass()
print(sc._pia)
[out]: 18
sc._pim
[out]: _pim