面象对象 高阶篇

静态方法@staticmethod：不可访问类中的变量与方法，唯一的关联就是通过类名去调用

class Dog(object):
    def __init__(self,name):
        self.name = name

    @staticmethod
    def eat(name):
        print("%s is eating" % name)

d = Dog("alex")
d.eat("hehe")

类方法@classmethod：只能访问类变量，不能访问实例变量

class Dog(object):
    name = "我是类变量"
    def __init__(self,name):
        self.name = name

    @classmethod
    def eat(self):
        print("%s is eating" % self.name)

d = Dog("alex")
d.eat()

 属性方法@property：把类里面的方法变成属性，其跟普通类没有关系

class Dog(object):
    name = "我是类变量"
    def __init__(self,name):
        self.name = name

    @property
    def eat(self):
        print("%s is eating" % self.name)

d = Dog("alex")
d.eat

 属性方法例子

class Flight(object):
    def __init__(self,name):
        self.flight = name
        self.status = 1

    def checking_status(self):
        print("checking flight %s status %s" % (self.flight,self.status))

    @property
    def flight_status(self):
        if self.status == 0:
            print("flight got canceled...")
        elif self.status == 1:
            print("flight is arrived...")
        elif self.status == 2:
            print("flight has departured already...")
        else:
            print("cannot confirm the flight status...,please check later")

    @flight_status.setter     # 修改属性,不添加修改属性无法直接修改
    def flight_status(self,status):
        self.status = status
        print("flight status change %s" % self.status)

    @flight_status.deleter     # 删除属性
    def flight_status(self):
        del self.status
        print("status got remove....")

f = Flight("CA980")

f.flight_status

f.flight_status = 2

f.checking_status()

f.flight_status

del f.flight_status

# f.flight_status

类中特殊成员方法

__doc__ : 类的描述信息

__module__ : 当前操作的对象在哪个模块

__class__ : 当前操作的对象的类名

__init__ : 构造方法，通过类创建对象时自动触发执行

__del__ : 析构方法，当对象在内存中被释放时自动触发执行（解释器进行垃圾回收时自动执行）

__call__ : 对象后加（），触发执行（由对象后加括号触发的，即：对象() 或者 类()()）

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

    def __call__(self, *args, **kwargs):
        print("__call__")

    def talk(self):
        print("talk")
obj = Foo()
print(obj)
obj()
obj.talk()

__dict__ : 查看类或对象中的所有成员

class Province(object):
    country = "China"
    def __init__(self,name,count):
        self.name = name
        self.count = count

    def func(self,*args,**kwargs):
        print('func')

print("33[32;1mProvince:33[0m",Province.__dict__)   # 获取类的成员,静态字段、方法


obj1 = Province("alex",300)
print("33[32;1mobj1:33[0m",obj1.__dict__)    # 获取obj1对象成员

__str__ : 类中定义了__str__方法，打印对象时输出__str__的返回值

class Foo(object):
    def __str__(self):
        return 'alex Li'
    def talk(self):
        return "talk"


class Dog(object):
    def talk(self):
        return "talk"

obj = Foo()
print(obj)

d = Dog()
print(d)

__getitem__、__setitem__、__delitem__ : 索引操作，如字典。分别表示获取、设置、删除

class Foo(object):
    def __getitem__(self, item):
        print('__getitem__',item)

    def __setitem__(self, key, value):
        print('__setitem__',key,value)

    def __delitem__(self, key):
        print('__delitem__',key)

obj = Foo()

result = obj['k1']  # 触发__getitem__
obj['k2'] = 'alex'   # 触发__setitem__
del obj['k1']   # 触发__delitem__

python 中一切皆对象，类对象是type类的一个实例，创建类特殊方式 ：

type第一个参数：类名

type第二个参数：当前类的基类

type第三个参数：类的成员

__new__ : 在__init__之前执行

__metaclass__ : 用来表示该类由 谁 来实例化创建

class MyType(type):
    def __init__(self,*args,**kwargs):  # 构造方法

        print("Mytype __init__")

    def __call__(self, *args, **kwargs):
        print("Mytype __call__")
        obj = self.__new__(self)
        print("obj ",obj)
        print(self)
        self.__init__(obj,*args, **kwargs)
        return obj

    def __new__(cls, *args, **kwargs):
        print("Mytype __new__")
        return type.__new__(cls, *args, **kwargs)


class Foo(object,metaclass=MyType):  # 表示由MyType这个类来实例化Foo类
    def __init__(self,name):
        self.name = name
        print("Foo __init__")

    def __new__(cls, *args, **kwargs):
        print("Foo __new__",cls)
        return object.__new__(cls)

f = Foo("Alex")
print("f",f)
print("f.name",f.name)

类的生成 调用 顺序依次是 __new__ --> __init__ --> __call__

反射

getattr : getattr(object, name[, default]) -> value

hastattr : 判断对象中有没有与字符串对应的方法或属性

setattr : setattr(x, 'y', v)   ==》 "x.y = v''

delattr : 删除成员变量 delattr(x,y)

class Foo(object):
    def __init__(self):
        self.name = 'alex'

    def func(self):
        return 'func'


obj = Foo()

print(hasattr(obj,'name'))  # 判断obj是否存在name属性或方法
print(getattr(obj,'func'))   # 获取name属性的值、func方法是获取内存地址

setattr(obj,'age',18)    # 设置obj中的age属性,如果有会对其相应的值进行更改
print(obj.age)

delattr(obj,'name')    # 删除obj中的name属性
print(hasattr(obj,'name'))

动态导入模块

动态导入模块方法1： __import__ 

说明：

　　1. 函数功能用于动态的导入模块，主要用于反射或者延迟加载模块。

　　2. __import__(module)相当于import module

举例说明：

首先创建一个模块目录lib,然后在目录内创建一个模块为：aa.py

模块代码为：

class c(object):
    def __str__(self):
        return 'C language'

在lib目录平级新建一个测试的模块，使用 __import__ 动态以字符串形式导入lib下的aa模块。

lib = __import__('lib.aa') # 相当于import lib
c = lib.aa.c()
print(c)

动态导入模块方法2：import importlib

实例还是上面的lib.aa模块，这里使用importlib进行动态导入（这个方法好理解，也是官方建议使用的）

import importlib
aa = importlib.import_module('lib.aa')
c = aa.c()
print(c)

补充知识
isinstance(obj,cls): 检查obj是否为cls的对象
issubclass(sub,super): 检查sub是否super类的派生类

class Foo(object):
    def __init__(self):
        self.name = 'alex'

    def func(self):
        return 'func'

class Bar(Foo):
    pass

obj = Foo()
#
# print(hasattr(obj,'name'))  # 判断obj是否存在name属性或方法
# print(getattr(obj,'func'))   # 获取name属性的值、func方法是获取内存地址
#
# setattr(obj,'age',18)    # 设置obj中的age属性,如果有会对其相应的值进行更改
# print(obj.age)
#
# delattr(obj,'name')    # 删除obj中的name属性
# print(hasattr(obj,'name'))

print(isinstance(obj,Foo))
print(issubclass(Bar,Foo))