面向对象进阶

class Animal(object):
    name = "hello"

    def __init__(self, name):
        self.name = name
        self.__num = 100

    @classmethod  # 类方法,只能访问类属性,不能调用实例属性
    def talk(self):
        print("%s talk wang" % self.name)

    def walk(self):
        print("%s walking now" % self.name)

    @staticmethod  # 静态方法,不能直接访问类属性,以及实例属性
    def habbit(self):
        print(" %s habbit ..." % self.name)

    @property  # 属性,将类方法变成类属性形式对外提供访问
    def total(self):
        print("total pro is %s" % self.__num)

    @property
    def total_num(self):
        print("total  num pro is %s" % self.__num)

    @total_num.setter
    def total_num(self, num):  # 静态属性修改值,如果要修改,则必须传入一个参数
        self.__num = num
        print("total num  set is %s" % self.__num)

    @total_num.deleter
    def total_num(self):
        print("total num del is %s" % self.__num)
        del self.__num

newdog = Animal("san")
newdog.talk()
newdog.walk()
newdog.habbit(newdog)
print(newdog._Animal__num)
newdog.total
newdog.total_num
newdog.total_num = 3
del newdog.total_num
newdog.total_num  # 已经删除了该实例属性,所以不存在了,报错

类的继承

class A:
    def f1(self):
        print("from A")

class B(A):
    def f1(self):
        print("from B")

class C(A):
    def f1(self):
        print("from C")

class D(B, C):
    def f3(self):
        print("from d")

    def f2(self):
        print("from D")


m = D()
m.f1()

#3.x时经典类和新式类都是默认广度优先
#2.x 时,新式类使用广度优先,经典类使用深度优先

class Foo:
    """
    hello,
    这里的代码通过类名.__doc__()可以获取到
    """

    def __init__(self):  # 构造方法,通过创建对象时.自动触发执行
        print("__init")
        #  静态字段

    def __del__(self):  #析构方法,当对象在内存中被释放时自动触发执行
        pass

    def __new__(cls, *args, **kwargs):
        pass

    def __call__(self, *args, **kwargs):  # 创建的对象加括号后,触发执行
        # 构造方法的执行是由创建对象触发的,即:对象 = 类名();call方法的执行是由对象加括号触发的,即对象()或者类()()
        pass

    def __str__(self):  # 当一个类中定义了__str__方法,则在打印对象时,默认输出该返回值
        return "zengchunyun"

    def __getitem__(self, item):
        pass  # 用于索引操作.如字典,这个方法主要用来获取数据

    def __setitem__(self, key, value):
        pass
        # 用于对索引对设置

    def __delitem__(self, key):
        pass
    # 用于删除索引的数据

    def __iter__(self):
        pass  # 用于迭代器,之所以列表,字典,元组可以进行FOR循环,是因为定义了该方法

    def __metaclass__(self):
        pass
    # 




a = Foo()
a.__doc__
# print(a.__module__)  # 表示当前操作的对象在哪个模块,仅限在另一个文件调用时才有该属性
print(a.__class__)  # 输出"NoneType  即当前操作的对象的类是什么

#获取类成员
class MM(object):
    def __init__(self):
        self.hello = None
    def say(self):
        pass
print(MM.__dict__)  # 获取类成员
obj = MM()
print(obj.__dict__)  # 获取对象成员

class Foo(object):
    def __init__(self):
        pass

obj = Foo()  # obj 是Foo类实例化的对象
print(type(obj))  # obj对由Foo类创建
print(type(Foo))    #Foo类对象由type类创建

#创建类的两种方式
# 第一种就是上面这种
# 第二种就是type类的构造函数
def func(self):
    print("hello")

Foo = type("Foo",(object,), {"func":func})
#type第一个参数为 类名
# type第二个参数为当前类的基类
# type第三个参数为类的成员