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 下的函数

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() # 私有方法,报错

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__)