Python修炼10------面向对象

一、isinstance(obj, cls) & issubclass(sub, super)

isinstance(obj, cls)

检查是否obj是否是类 cls 的对象

class Foo(object):

pass

obj = Foo()

isinstance(obj, Foo)

issubclass(sub, super)

检查sub类是否是 super 类的派生类

class Foo(object):

pass

class Bar(Foo):

pass

issubclass(Bar, Foo)

二、反射

python中的反射功能是由以下四个内置函数提供：hasattr、getattr、setattr、delattr，改四个函数分别用于对对象内部执行：检查是否含有某成员、获取成员、设置成员、删除成员。

# commons.py 文件

name = "nick"

def f1():

    return "This is f1."

def f2():

    return "This is f2."

def nb():

    return "This is niubily."

# index.py 文件

import commons

#根据字符串的形式去某个模块中寻找东西

target_func = getattr(commons,"f1")     # 找函数

result = target_func()

print(result)

target_func = getattr(commons,"name")   # 找全局变量

print(target_func)

target_func = getattr(commons,"age",None)   # 找不到返回None

print(target_func)

#根据字符串的形式去某个模块中判断东西是否存在

tarhas_func = hasattr(commons,"f5")     # 找函数

print("before:",tarhas_func)

# tarhas_func = hasattr(commons,"name") # 找全局变量

# print(tarhas_func)

#根据字符串的形式去某个模块中设置东西

setattr(commons,"f5","lambda x: return \"This is new func.\"")  # 设置一个函数

setattr(commons,"age",)       # 设置全局变量

tarhas_func = hasattr(commons,"f5")     # 检查函数是否存在

print("after:",tarhas_func)

#根据字符串的形式去某个模块中删除东西

delattr(commons,"f5")       # 删除一个函数

tarhas_func = hasattr(commons,"f5")     # 检查函数是否存在

print("end:",tarhas_func)

# 通过字符串的形式，导入模块。起个别名 ccas。

comm = input("Please:")

ccas = __import__(comm)

ccas.f1()

# 需要做拼接导入时后加 fromlist=True（否则只导入lib）

ccas = __import__("lib."+comm, fromlist=True)

补充__import__

##### 路由系统 #####

# 输入 模块名/函数名  （例如：commons/nb）

url = input("Please input you want url:")

target_module, target_func = url.split("/")

#m = __import__("lib."+target_module,fromlist=True)

m = __import__(target_module)

if hasattr(m,target_func):

    target_func = getattr(m,target_func)

    result = target_func()

    print(result)

else:

    print("Sorry,it's 404 not found.")

路由系统

路由系统

三、类装饰器

def deco(func):

    print('===================')

    return func  #fuc=test

@deco    #test=deco(test)

def test():

    print('test函数运行')

test()

框架

def deco(obj):

    print('============',obj)

    obj.x=   #增加属性

    obj.y=

    obj.z=

    return obj

@deco   #Foo=deco(Foo)   #@deco语法糖的基本原理

class Foo:

    pass

print(Foo.__dict__)  #加到类的属性字典中

输出

============ <class '__main__.Foo'>

{'__module__': '__main__', 'z': , 'x': , '__dict__': <attribute '__dict__' of 'Foo' objects>, '__doc__': None, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, 'y': }

对类增加类属性

def Typed(**kwargs):

    def deco(obj):

        for key,val in kwargs.items():

            setattr(obj,key,val)

        return obj

    return deco

@Typed(x=,y=,z=)  #typed(x=,y=,z=)--->deco

class Foo:

    pass

print(Foo.__dict__)

@Typed(name='egon')

class Bar:

    pass

print(Bar.name)

控制台输出

{'y': , '__dict__': <attribute '__dict__' of 'Foo' objects>, 'z': , '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__module__': '__main__', 'x': , '__doc__': None}

egon

增强版

多一例

四、元类

ython中一切皆是对象，类本身也是一个对象，当使用关键字class的时候，python解释器在加载class的时候就会创建一个对象(这里的对象指的是类而非类的实例)

寻找类的父亲

#type函数可以查看类型，也可以用来查看对象的类，二者是一样的

print(type(f1)) # 输出：<class '__main__.Foo'>     表示，obj 对象由Foo类创建

print(type(Foo)) # 输出：<type 'type'>

元类是类的类，是类的模板
元类是用来控制如何创建类的，正如类是创建对象的模板一样
元类的实例为类，正如类的实例为对象(f1对象是Foo类的一个实例，Foo类是 type 类的一个实例)

type是python的一个内建元类，用来直接控制生成类，python中任何class定义的类其实都是type类实例化的对象

一个类没有声明自己的元类，默认它的元类就是type，除了使用元类type，用户也可以通过继承type来自定义元类（顺便我们也可以瞅一瞅元类如何控制类的创建，工作流程是什么）

class Mytype(type):

    def __init__(self,a,b,c):

        print(self)

        print(a)

        print(b)

        print(c)

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

        print("call")

class Slamdunk(metaclass=Mytype): # Mytype("Slamdunk",(object,),{}) 实际上就是这么做,但是传了4个参数

    # 声明Foo类由Mytype创建，声明自己的元类

    def __init__(self,name):

        self.name = name

s1 = Slamdunk("樱木花道")

# 根据python一切皆对象，Slamdunk() 本质上就是在触发创建 Slamdunk类的 元类的__call__

控制台输出

<class '__main__.Slamdunk'>  # 元类创建的实例(对象)

Slamdunk # 实例名

() # 继承的类，在python3中都默认继承object,即都为新式类

{'__qualname__': 'Slamdunk', '__init__': <function Slamdunk.__init__ at 0x000002106AFBF840>, '__module__': '__main__'} # 实例类的属性字典

call # 实例+() 触发了元类的__call__方法

模拟初步认识

class Mytype(type):

    def __init__(self,a,b,c):

        print(self)

    def __call__(self, *args, **kwargs): # 传的值是怎么传进去的，就去怎么接收

        print("call")

        obj = object.__new__(self) # 生成一个实例

        self.__init__(obj,*args,**kwargs)   # 这里的self是Mytype产生的实例,这一步触发 Slamdunk 的构造方法

        return obj # __call__方法下的返回值是 self 产生的实例 赋值给s1

class Slamdunk(metaclass=Mytype):

    #  Slamdunk = Mytype("Slamdunk",(object,),{}) 实际上就是这么做,但是传了4个参数

    # 声明Foo类由Mytype创建，声明自己的元类

    # 触发元类的__init__(元类的构造方法)

    def __init__(self,name):

        self.name = name

s1 = Slamdunk("樱木花道")

# 根据python一切皆对象，Slamdunk() 本质上就是在触发创建 Slamdunk类的 元类的__call__

print(s1.__dict__) # 可以访问到实例对象的属性字典

class Mytype(type):

    def __init__(self,a,b,c):

        print(self)

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

        obj = object.__new__(self)

        self.__init__(obj,*args,**kwargs)

        return obj

class Slamdunk(metaclass=Mytype):

    def __init__(self,name):

        self.name = name

s1 = Slamdunk("樱木花道")

print(s1.__dict__) 

控制台输出

<class '__main__.Slamdunk'>

{'name': '樱木花道'}

# 可以加断点体验

实现创建类的流程 精简版

实现创建类的流程精简版

五、单例模式

　　单例模式存在的目的是保证当前内存中仅存在单个实例

　　（程序如果并发量大的话，内存里就会存在非常多功能上一模一样的对象。存在这些对象肯定会消耗内存，对于这些功能相同的对象可以在内存中仅创建一个，需要时都去调用）

初级：

# 单例模式

class Foo:

    __n = None

    def __init__(self):

        self.name = "nick"

        self.age =

        self.job = "pythoner"

    @staticmethod

    def dl():

        if Foo.__n:

            return Foo.__n

        else:

            Foo.__n = Foo()

            return Foo.__n

# 创建对象时不能再直接使用：obj = Foo()，而应该调用特殊的方法：obj = Foo.dl() 。

f1 = Foo.dl()

print(f1)

f2 =Foo.dl()

print(f2)

f3 =Foo.dl()

print(f3)

# 运行结果

<__main__.Foo object at 0x0000000001142390>

<__main__.Foo object at 0x0000000001142390>

<__main__.Foo object at 0x0000000001142390>

装饰器方式单例模式

# 装饰器方式单例模式

def singleton(argv):

    dic = {}

    def s(*args, **kwargs):

        if argv not in dic:

            dic[argv] = argv(*args, **kwargs)

            return dic[argv]

        else:

            return dic[argv]

    return s

# 类上加单例装饰器

@singleton

class Foo:

    pass

@singleton

class Foo2:

    pass

升级：

from abc import abstractmethod, ABCMeta

class Singleton(object):

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

        if not hasattr(cls, "_instance"):

            cls._instance = super(Singleton, cls).__new__(cls)

        return cls._instance

class MyClass(Singleton):

    def __init__(self, name=None):

        if name:

            self.name = name

a = MyClass("a")

print(a)

print(a.name)

b = MyClass('b')

#

print(b)

print(b.name)

#

print(a)

print(a.name)

巴特西

Python修炼10------面向对象

一、isinstance(obj, cls) & issubclass(sub, super)

二、反射

三、类装饰器

四、元类

五、单例模式

最新文章

热门文章