python 面向对象(进阶篇)

类的成员

• 字段
  • 普通字段

    保存在对象当中,执行只能通过对象访问

  • 静态字段

    保存在类当中, 执行可以通过类访问也可以通过对象访问

• 方法
  • 普通方法

    保存在类当中,由对象来调用

  • 静态方法

    静态方法,保存在类当中,由类直接调用,也可通过对象调用

  • 类方法

    保存在类当中,由类直接调用,也可通过对象调用

• 属性
  • 不用加括号也能执行的方法

class Foo:
    name = 'nathaniel_静态字段'# 静态字段
    def __init__(self):
        self.age = '19_普通字段'# 普通字段

# 静态字段,保存在类当中,执行可以通过类访问也可以通过对象访问
print('直接通过类访问静态字段',Foo.name)
obj = Foo()
print('通过对象访问静态字段',obj.name)
# 普通字段,保存在对象当中,执行只能通过对象访问
print('普通字段只能通过对象访问',obj.age)


class Foo1:
    def foo(self):
        print('普通方法')

    @staticmethod # 使用装饰器
    def foo1():
        print('静态方法')

    @classmethod
    def foo2(cls):
        # cls 类名
        print('类方法')

# 类方法,保存在类当中,由类直接调用,无需实例化类
Foo1.foo2()
# 静态方法,保存在类当中,由类直接调用,无需实例化类
Foo1.foo1()
# 普通方法,保存在类当中,由对象来调用
obj = Foo1()
obj.foo()
# 类方法和静态也可由对象调用
obj.foo1()
obj.foo2()

# 属性

# 属性
# 定义时，在普通方法的基础上添加 @property 装饰器；
# 定义时，属性仅有一个self参数
# 调用时，无需括号
#     方法：obj.func()
#     属性：obj.func

class Foo2:
    @property
    def foo2(self):
        print('属性')

    @foo2.setter
    def foo2(self,values):
        print('伪装赋值',values,)

    @foo2.deleter
    def foo2(self):
        print('伪装删除')

# 属性是方法,但是调用的时候不加括号
obj = Foo2()

obj.foo2 # 自动执行 @property 修饰的foo2方法并获取返回值

obj.foo2 = '123' # 自动执行 @foo2.setter 修饰的foo2方法并将 '123' 赋值给 values

del obj.foo2 # 自动执行 @foo2.deleter 修饰的foo2方法

# 上述代码的执行实际上有一个对应关系
# obj.foo2 对应 @property 下的函数
# obj.foo2 = '123' 对应 @foo2.setter 下的函数 # 需要一个参数
# del obj.foo2 对应 @foo2.deleter 下的函数

 注意:

• 经典类只有一种@property装饰器,即上述实例中与  obj.foo2 相对应的
• 新式类有有三种@property装饰器,即上述实例中,三种都可用

类的成员修饰符

一般来说,每一个类中都可以有两种成员

• 公有成员,在任何地方都可以访问
  • 公有字段
  • 公有方法
• 私有成员,只有在类的内部才可以访问 # 私有成员在命名时以双下划线开头 (特殊成员除外, __init__、__call__、__del__ 等
• 私有字段
• 私有方法
• 类的私有成员不会被子类继承

class Foo4:
    __static_foo = '123' # 静态私有字段,只能在内部访问

    def __init__(self,name,age):
        self.name = name # 公有字段
        self.__age = age # 私有字段,只能在内部访问
        
    def __foo41(self):
        # 私有方法,只能在类的内部访问
        print('私有方法,只能在类的内部访问,私有方法也可以访问私有字段%s'% self.name)

    def show(self):
        # 类的内部可以访问私有字段和私有方法
        print(self.__static_foo)
        print(self.__age)
        self.__foo41()

obj = Foo4('nathaniel','20')
print(obj.name) # 公有字段可以访问
print(obj.__age) # 私有字段,报错
obj.show() # 公有方法可以访问
obj.__foo41() # 私有方法,报错

类的特殊成员

1、__init__ 构造方法 类() 自动执行
2、__call__ 对象() 类()() 自动执行
3、__int__ int(对象) 自动执行对象中的 __int__ 方法,并将返回值赋给它
4、__str__ str(对象) 自动执行对象中的 __int__ 方法,并将返回值赋给它
5、__add__ 两个对象相加时,自动执行第一个对象的__add__方法,并将第二个对象当做参数传入
6、__dict__ 对象.__dict__ 将对象中的成员以列表返回 类.__dict__ 将类里的成员以字典返回
7、__del__ 析构方法,对象被销毁时执行
8、__getitem__ 切片(slice类型)或者索引
9、__setitem__ 按索引赋值
10、__delitem__ 按索引删除

class Foo5:
    """
    __doc__方法 打印类的描述信息
    """
    def __init__(self):
        print('构造方法  类()  自动执行')

    def __call__(self, *args, **kwargs):
        print('对象() 类()()  自动执行')

    def __int__(self):
        return 123

    def __str__(self):
        return '123'

    def __add__(self, other):
        print(str(1 + other))

    def __del__(self):
        print('析构方法,对象被销毁时执行')

    def __getitem__(self):
        print('对象进行切片操作,自动执行对象里的__getitem__方法')
    def __setitem__(self, key, value):
        print('对象按索引赋值,自动执行对象里的__setitem__方法')
    def __delitem__(self, key):
        print('对象按索引删除,自动执行对象里的__delitem__方法')
print(Foo5.__dic__)

 

class Foo5:
    pass
class F0051(Foo5):
    pass
obj = Foo5()

print(isinstance(obj, Foo5)) # 检查对象 obj 是否是类 cls 的对象
print(issubclass(F0051, Foo5)) # 检查 F0051 类是否是 Foo5 类的派生类