Python 面向对象编程（2）-CSDN博客

本文链接：https://blog.csdn.net/weixin_44440552/article/details/89961270

将从以下几个方面介绍：实例方法、函数装饰器、类方法、静态方法、访问控制

实例方法：

在类对象中定义实例方法时，第一个形参表示调用该方法的实例对象，其对应的实参由系统自动传入。第一个形参的名称通常是self，也可以是其他名称。

实例方法只能被实例对象所调用，有两种调用方式：

1、在类对象内部（其他实例方法中）
语法格式：self.方法名 ( [实参] )
2、在类对象的外部
语法格式：实例对象.方法名( [实参] )

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

class MyClass(object):
	# 在类对象中定义实例方法
	def im1(self, p1, p2):
		print(p1, p2)
		
	def im2(self):
		# 在类对象的内部调用实例方法
		self.im1(1,2)

mc = MyClass()

#  在类对象的外部调用实例方法
mc.im1(1,2)   #1 2
mc.im2()      #1 2

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

def do_sth(self):
	print("do_sth()被调用了")
# 导入标准库types中的；类MethodType
from types import MethodType
# 给实例对象mc动态地绑定实例方法
mc.do_sth = MethodType(do_sth, mc)

# 调用绑定的实例方法
>>>mc.do_sth()
do_sth()被调用了

mc2 = MyClass()
# 再定义一个函数作为实例方法
def im3(self):
	print("im3()被调用了")
# 给实例对象mc动态地绑定实例方法	
MyClass.im3 = im3

>>>mc.im3()
im3()被调用了
>>>mc2.im3()
im3()被调用了

函数装饰器

装饰器是一个函数，装饰器接受一个函数作为参数（传入的实参是被装饰的函数）
装饰器的内部嵌套定义另一个函数，内含数中会引用装饰器的参数，并且装饰器的返回值是内函数
为了让内函数接受任意类型的参数，将内函数的形参定义为（*args, **kwargs）
*args表示的参数以列表的形式传入
**kwargs表示的参数以字典的形式传入
在函数中，首先完成为被装饰函数添加的新功能，然后调用被装饰的函数
把装饰器应用到被装饰函数的语法为：在被装饰函数的前面添加“@装饰器的函数名”

def notice(func):
    def wrapper(*args,**kwargs):
        print("hello!")
        print("........")
        return func(*args,**kwargs)
    return wrapper

@notice
def add(a,b):
    return a+b

print(add(3,5))

    
hello!
........
8

类方法

在类对象中定义类方法时，必须使用装饰器@classmethod进行装饰，此外，第一个形参表示类对象，其对应的实参由系统自动传入。第一个形参的名称通常是cls，也可以是其他名称。
类方法可以被类对象所调用，语法格式：类对象.方法名( [实参] ) 或 cls.方法名( [实参] )
类方法也可以被实例对象所调用，语法格式：实例对象. 方法名( [实参] ) 或 self.方法名( [实参] )
类对象的所有实例对象都有一个指向类对象的指针，所以类对象的所有实例对象都可以调用类对象中定义的类方法

class MyClass(object):
	# 在类对象中定义方法
    @classmethod
    def class_func(cls,a,b):
        print(a,b)
        
# 通过类对象调用类方法        
>>>MyClass.class_func('Hi','everyone!')
Hi everyone!

#通过实例对象调用类方法
>>>mc = MyClass()
>>>mc.class_func(1,2)
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()
1 2
1 2

>>>mc.ins_func()
1 2

>>>MyClass.class_func_2()
1 2
1 2

>>>MyClass.ins_func()
TypeError: ins_func() missing 1 required positional argument: 'self'

静态方法

类对象的静态方法只是一个普通函数，第一个形参没有特殊含义和要求
有类对象中定义静态方法时，必须使用装饰器@staticmethod进行装饰
可以被类对象调用，语法格式：类对象.方法名( [实参] ) 或 cls.方法名( [实参] )
也可以被实例对象调用，语法格式：实例对象. 方法名( [实参] ) 或 self.方法名( [实参] )

class MyClass(object):
    @staticmethod
    def sm(p1,p2):
        print(p1,p2)
        
>>>MyClass.sm(1,2)
1 2

>>>mc = MyClass()
>>>mc.sm(1,2)
1 2

访问控制

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

class MyClass(object):
    def __init__(self):
        self.__pia = 18
        
    def __pim(self):
        print("__pim()被调用了")
        
>>>mc = MyClass()
>>>print(mc.__pia)
AttributeError: 'MyClass' object has no attribute '_MyClass_pia'

>>>mc.__pim()
AttributeError: 'MyClass' object has no attribute '_MyClass_pim'


class MyClass(object):
    def __init__(self):
        self.__pia = 18
        
    def __pim(self):
        print("__pim()被调用了")
        
    def do_sth(self):
        print(self.__pia)
        self.__pim()
        
>>>print(mc._MyClass__pia)
18
>>>mc._MyClass__pim()
__pim()被调用了

# 仍然可以在类对象的外部动态绑定名为__xxx的属性或方法，这与类对象内部名为__xxx的属性或方法是不同的
>>>mc.__pia = "Hi"
>>>print(mc.__pia)
Hi

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

class SomeClass(object):
    def __init__(self):
        self._pia = 18
        
    def _pim(self):
        print("_pim()被调用了")

>>>sc = SomeClass()
>>>print(sc._pia)
18

>>>sc._pim()
_pim()被调用了