面向对象编程2（装饰器、静态方法，访问控制）

实例方法

实例方法指的是只有实例对象才可以调用的方法。
在类对象中定义实例方法是，第一个形参表示调用该方法的实例对象，其对应的实参由系统自动输入。第一个形参的名称通常为self，当然，也可以有其他名称，但self是大家默认的，用它作为形参名称更容易让人读懂你的程序。
实例方法只能被实例对象所调用，有两种调用方法：
1、在类对象内部（其他实例方法中）：

➢ 语法格式为：self.方法名([实参])

2、在类对象外部

➢ 语法格式：实例对象.方法名([实参])

类对象的所有实例对象都有一个指向类对象的指针，所以，类对象的所有实例对象都可以调用类对象中定义的实例方法。

调用实例方法时，系统自动将调用该实例方法的实例对象作为实参传递给第一个形参。第一个实参传递給第二个形参，第二个实参会传递給第三个形参，依次类推。

class My_Class(object):
    #### 在类对象中定义实例方法
    def eg1(self, m, n):
        print(m, n)
    #### 在类对象中定义实例方法
    def eg2(self):
        ### 在类对象的内部（其他实例方法中） 调用实例方法
        self.eg1(3,2)

my= My_Class()
print(my.eg1(1,2))
print(my.eg2())
##############            输出              #################
1 2
3 2

My_Class.eg2()
##############            输出              #################
TypeError: eg2() missing 1 required positional argument: 'self'

我们知道，Python是动态语言，所以，在实例对象或类对象创建之后，可以对其动态地绑定实例方法。

但是同一类对象的不同实例对象所绑定的实例方法是相互独立的，也就是说，给一个实例对象绑定的实例方法，对于另一个实例对象是不起作用的。

### 定义一个函数作为实例方法
def do_one(self):
    print("do_one这个方法被调用了")

#### 导入标准库 types 中的类 MethodType
from types import MethodType
#### 給实例对象 my 动态地绑定实例方法
my.do_one = MethodType(do_one, my)

print(my.do_one())

###############   输出   ###############
do_one这个方法被调用了

my2 = My_Class()
my2.do_one()

#########        输出       ########
AttributeError: 'My_Class' object has no attribute 'do_one'

为了能让一个类对象的所有实例对象都能调用某个实例方法，可以给类对象绑定该实例方法。

def eg(self):
    print("eg()这个方法被调用了！")

### 給实例对象动态地绑定实例方法，这里不特指某一个实例对象
My_Class.eg = eg

### 类对象的所用实例对象都能调用给类对象动态绑定的实例方法

print(my.eg())
print(my2.eg())

###################     输出     ###################
eg()这个方法被调用了！
eg()这个方法被调用了！

函数装饰器

装饰器是用来装饰函数的，对于某个函数，如果我们希望在不改变该函数代码的前提下，为该函数增加额外的功能，那么就可以使用装饰器来装饰该函数。

装饰器是一个函数，它接收一个函数作为参数（传入旳实参是被装饰的函数）

装饰器的内部嵌套定义另一个函数，内函数中会引用装饰器的参数

并且装饰器的返回值是内函数

为了让内函数接收任意类型的参数，将内函数的形参定义为（args,* kwargs）

在函数中，首先完成为被装饰函数添加的新功能，然后调用被装饰的函数

把装饰器应用到被装饰函数的语法为：在被装饰的函数的前面添加“@装饰器的函数名”

def notice(func):
    def wrapper(*args, **kwargs):
        print("公告：请注意身体，加强锻炼！")
        print("锻炼身体可以提高免疫力")
        return func(*args, **kwargs)
    return wrapper

@notice   ### 表示 add = notice(add)
def add(a,b):
    return a + b

print(2,7,add(2,3)) ###在函数中，首先完成为被装饰函数添加的新功能，然后调用被装饰的函数

###############              输出              ##################
公告：请注意身体，加强锻炼！
锻炼身体可以提高免疫力
2 7 5

类方法

类方法指的是类对象中使用@classmethod进行装饰的方法.

在类对象中定义类方法时,必须使用装饰器@classmethod进行装饰，此外，第一次形参表示类对象，其对应的实参有系统自动传入。第一个形参的名称通常是 cls ，也可以是其他名称，同self。

类方法可以被类对象所调用，语法格式为：类对象.方法名([实参]) 或 cls.方法名([实参])。

类方法也可以被实例对象所调用，语法格式为： 实例对象.方法名([实参]) 或 self.方法名([实参])。
类对象的所有实例对象都有一个指向类对象的指针，所以，类对象的所有实例对象都可以调用类对象中定义的类方法。

调用类方法时，系统自动将类对象作为实参传递給第一个形参。第一个是参会传递給第二个形参，第二个是参会传递給第三个形参，依次类推。

class My_Class1(object):
    ### 在类对象中定义类方法
    @classmethod
    def class_func(cls, a, b):
        print(a, b)
        
##### 通过类对象调用类方法
My_Class1.class_func("Hi","friends!")  ##### 有输出

#### 通过实例对象调用类方法
my = My_Class1()
my.class_func(2,5)   #####  有输出

##############            输出             ###############
Hi friends!
2 5

class My_Class2(object):
    ### 在类对象中定义类方法
    @classmethod
    def class_func_1(cls, a, b):
        print(a, b)
    ### 在类对象内部调用类方法
    @classmethod
    def class_func_2(cls):
        My_Class2.class_func_1(5,6)  ### 等价于 cls.class_func_1(5,6)
        
    ### 通过实例对象调用类方法
    def fac_func(self):
        self.class_func_1(8,9)

my = My_Class2()
my.class_func_2()
my.fac_func()
#############     输出     ############
5 6
8 9

My_Class2.class_func_2()
 ###########           输出           ############
 5 6

My_Class2.fac_func()

#########         输出        #########
TypeError: fac_func() missing 1 required positional argument: 'self'

静态方法

类对象的静态方法只是一个普通函数。把某个普通函数归属于类对象,可能只是为了易于代码管理。

在类对象中定义静态方法时,必须使用装饰器@staticmethod进行装饰。

静态方法只是一个普通函数,因此,第一个形参没有特殊含义和要求。

静态方法可以被类对象所调用,语法格式为:类对象,方法名([实参]) 或: cls.方法名([实参])。
静态方法也可以被实例对象所调用,语法格式为:实例对象,方法名([实参]) 或: self.方法名([实参])。
调用静态方法时的参数传递与调用普通函数是一样的。

class My_Class3(object):
    @staticmethod
    def some(s1, s2):
        print(s1, s2)

My_Class3.some(2,3)    

#######                 输出                  #########
2 3

my = My_Class3()
my.some(3,5)
########                  输出                  ############
3 5

访问控制

访问控制指的是：控制类对象的属性和方法在类对象的外部是否可以直接访问。
如果在类对象的某个属性和方法前添加两个下划线__,那么在类对象的外部就不能直接访问该属性或方法了。

class My_Class(object):
    def __init__(self):
        self.__eg1 = 23
    def __egs(self):
        print("__egs()这个方法已经被调用了！")

my = My_Class()
print(my.__eg1)
###########                   输出                  ##############
AttributeError: 'My_Class' object has no attribute '__eg1'

my.__egs()
###########                   输出                  ############## 

AttributeError: 'My_Class' object has no attribute '__egs'

class My_Class(object):
    def __init__(self):
        self.__eg1 = 23
    def __egs(self):
        print("__egs()这个方法已经被调用了！")
    def do_some(self):
        print(self.__eg1)
        self.__egs()

my = My_Class()
print(my.do_some())
###########                   输出                  ############## 
23
__egs()这个方法已经被调用了！
None

之所以不能在类对象的外部直接访问以双下划线开头的属性或方法,是因为: Python解释器对外把属性或方法__xxx改成了另外一个名字:_类名__xxx。所以,在类对象的外部仍然可以通过_类名__xxx访问属性或方法_xxx。但是，强烈建议不要这样访问,因为不同版本的Python解释器可能会把属性或方法__xxx改成不同的名字。

print(my._My_Class__eg1)
23

print(my._My_Class__egs())
__egs()这个方法已经被调用了！
None

调用内置函数dir()可获得指定对象所有可以访问的属性和方法

但是可以在类对象的外部动态绑定名为__xxx的属性或方法，这与类对象内部名为__xxx的属性或方法是不同的。

my.__eg1 = "I can"
print(my.__eg1)
print(My_Class.__eg1)
############                      输出                    #############
I can
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-24-ad99973d3898> in <module>()
      2 my1 = My_Class()
      3 print(my.__eg1)
----> 4 print(my1.__eg1)

AttributeError: 'My_Class' object has no attribute '__eg1'

除了在类对象的属性或方法前添加两个下划线__，还可以在类对象的属性或方法前添加单下划线_,这表示：虽然可以在类对象的外部访问该属性或方法，但是最好不要访问。