Python学习第十八天

2021-02-09 22:17

阅读:626

标签:sys   数据类型   场景   click   ict   函数   xxxxx   无限   派生类   

https://www.cnblogs.com/linhaifeng/articles/6204014.html

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

二 反射

1 什么是反射

反射的概念是由Smith在1982年首次提出的,主要是指程序可以访问、检测和修改它本身状态或行为的一种能力(自省)。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。

2 python面向对象中的反射:通过字符串的形式操作对象相关的属性。python中的一切事物都是对象(都可以使用反射)

四个可以实现自省的函数

下列方法适用于类和对象(一切皆对象,类本身也是一个对象)

技术图片技术图片
判断object中有没有一个name字符串对应的方法或属性
hasattr(object,name)
技术图片技术图片
def getattr(object, name, default=None): # known special case of getattr
    """
    getattr(object, name[, default]) -> value

    Get a named attribute from an object; getattr(x, ‘y‘) is equivalent to x.y.
    When a default argument is given, it is returned when the attribute doesn‘t
    exist; without it, an exception is raised in that case.
    """
    pass
getattr(object, name, default=None)
技术图片技术图片
def setattr(x, y, v): # real signature unknown; restored from __doc__
    """
    Sets the named attribute on the given object to the specified value.

    setattr(x, ‘y‘, v) is equivalent to ``x.y = v‘‘
    """
    pass
setattr(x, y, v)
技术图片技术图片
def delattr(x, y): # real signature unknown; restored from __doc__
    """
    Deletes the named attribute from the given object.

    delattr(x, ‘y‘) is equivalent to ``del x.y‘‘
    """
    pass
delattr(x, y)
技术图片技术图片
class BlackMedium:
    feature=Ugly
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr

    def sell_house(self):
        print(%s 黑中介卖房子啦,傻逼才买呢,但是谁能证明自己不傻逼 %self.name)
    def rent_house(self):
        print(%s 黑中介租房子啦,傻逼才租呢 %self.name)

b1=BlackMedium(万成置地,回龙观天露园)

#检测是否含有某属性
print(hasattr(b1,name))
print(hasattr(b1,sell_house))

#获取属性
n=getattr(b1,name)
print(n)
func=getattr(b1,rent_house)
func()

# getattr(b1,‘aaaaaaaa‘) #报错
print(getattr(b1,aaaaaaaa,不存在啊))

#设置属性
setattr(b1,sb,True)
setattr(b1,show_name,lambda self:self.name+sb)
print(b1.__dict__)
print(b1.show_name(b1))

#删除属性
delattr(b1,addr)
delattr(b1,show_name)
delattr(b1,show_name111)#不存在,则报错

print(b1.__dict__)
四个方法的使用演示
技术图片技术图片
class Foo(object):
 
    staticField = "old boy"
 
    def __init__(self):
        self.name = wupeiqi
 
    def func(self):
        return func
 
    @staticmethod
    def bar():
        return bar
 
print getattr(Foo, staticField)
print getattr(Foo, func)
print getattr(Foo, bar)
类也是对象
技术图片技术图片
import sys
def s1():
    print (s1)
def s2():
    print (s2)
this_module = sys.modules[__name__]
h=hasattr(this_module, s1)
g=getattr(this_module, s2)
print(this_module,h,g)
反射当前模块成员

导入其他模块,利用反射查找该模块是否存在某个方法

技术图片技术图片
#!/usr/bin/env python
# -*- coding:utf-8 -*-

def test():
    print(from the test)
module_test.py
# !/usr/bin/env python
# -*- coding:utf-8 -*-

"""
程序目录:
    module_test.py
    index.py
当前文件:
    index.py
"""

import module_test as obj
# obj.test()
print(hasattr(obj, test))
getattr(obj, test)()

3 为什么用反射之反射的好处

好处一:实现可插拔机制

有俩程序员,一个lili,一个是egon,lili在写程序的时候需要用到egon所写的类,但是egon去跟女朋友度蜜月去了,还没有完成他写的类,lili想到了反射,使用了反射机制lili可以继续完成自己的代码,等egon度蜜月回来后再继续完成类的定义并且去实现lili想要的功能。

总之反射的好处就是,可以事先定义好接口,接口只有在被完成后才会真正执行,这实现了即插即用,这其实是一种‘后期绑定’,什么意思?即你可以事先把主要的逻辑写好(只定义接口),然后后期再去实现接口的功能

技术图片技术图片
class FtpClient:
    ftp客户端,但是还么有实现具体的功能
    def __init__(self,addr):
        print(正在连接服务器[%s] %addr)
        self.addr=addr
egon还没有实现全部功能
技术图片技术图片
#from module import FtpClient
f1=FtpClient(192.168.1.1)
if hasattr(f1,get):
    func_get=getattr(f1,get)
    func_get()
else:
    print(---->不存在此方法)
    print(处理其他的逻辑)
不影响lili的代码编写

好处二:动态导入模块(基于反射当前模块成员)

技术图片 

三 __setattr__,__delattr__,__getattr__

#三者的用法演示
class Foo:
    x=1
    def __init__(self,y):
        self.y=y

    def __getattr__(self, item):
        print(----> from getattr:你找的属性不存在)


    def __setattr__(self, key, value):
        print(----> from setattr)
        # self.key=value #这就无限递归了,你好好想想
        # self.__dict__[key]=value #应该使用它

    def __delattr__(self, item):
        print(----> from delattr)
        # del self.item #无限递归了
        self.__dict__.pop(item)

#__setattr__添加/修改属性会触发它的执行
f1=Foo(10)
print(f1.__dict__) # 因为你重写了__setattr__,凡是赋值操作都会触发它的运行,你啥都没写,就是根本没赋值,除非你直接操作属性字典,否则永远无法赋值
f1.z=3
print(f1.__dict__)

#__delattr__删除属性的时候会触发
f1.__dict__[a]=3#我们可以直接修改属性字典,来完成添加/修改属性的操作
del f1.a
print(f1.__dict__)

#__getattr__只有在使用点调用属性且属性不存在的时候才会触发
f1.xxxxxx

四 二次加工标准类型(包装)

包装:python为大家提供了标准数据类型,以及丰富的内置方法,其实在很多场景下我们都需要基于标准数据类型来定制我们自己的数据类型,新增/改写方法,这就用到了我们刚学的继承/派生知识(其他的标准类型均可以通过下面的方式进行二次加工)

 

Python学习第十八天

标签:sys   数据类型   场景   click   ict   函数   xxxxx   无限   派生类   

原文地址:https://www.cnblogs.com/sundanceS/p/12747793.html


评论


亲,登录后才可以留言!