首页 > > 网络编程 > 其它 >

python3全栈开发-内置函数补充，反射，元类，__s…

2018-06-18 02:26:57来源：未知 阅读 ()

新老客户大回馈,云服务器低至5折

一、内置函数补充

1、isinstance(obj,cls)检查是否obj是否是类 cls 的对象

class Foo(object):
　　pass
obj = Foo()                 
print(isinstance(obj, Foo))  #结果为True

2、issubclass(sub, super)检查sub类是否是 super 类的派生类

class Foo(object):
　　pass
class Bar(Foo):
　　pass
print(issubclass(Bar, Foo))  #结果为True

二、 反射

1 、什么是反射

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

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

四个可以实现自省的函数：

hasattr、getattr、setattr、delattr

下列方法适用于类和对象（一切皆对象，类本身也是一个对象）

# 1、hasattr
# print(hasattr(People,'country'))  #True
# print('country' in People.__dict__)    #不知道hasattr方法时，用的方法
# print(hasattr(obj,'name'))          #True
# print(hasattr(obj,'country'))       #True
# print(hasattr(obj,'tell'))          #True

# 2、getattr
# x=getattr(People,'country1',None)      #查找指定属性，没有此属性（提前预防报错写None）显示None,有就返回值
# print(x)
# f=getattr(obj,'tell',None)#obj.tell
# print(f == obj.tell)                 #True
# f()                               #正常的调用函数
# obj.tell()

# 3、setattr
# People.x=111
# setattr(People,'x',111)              #添加x属性，值为111
# print(People.x)
# obj.age=18                      
# setattr(obj,"age",18)             # 添加age属性，值为18
# print(obj.__dict__)

# 4、delattr
# del People.country               #原始的方法
# delattr(People,"country")             
# print(People.__dict__)
# del obj.name
# delattr(obj,"name")
# print(obj.__dict__)

三、__str__

class People:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def __str__(self):
        # print('========>')
        return '<名字：%s 年龄：%s 性别：%s>' %(self.name,self.age,self.sex)

obj=People('duoduo',18,'male')
print(obj) #print(obj.__str__())  在print时触发__str__

四、 __del__

当对象在内存中被释放时，自动触发执行。

注：如果产生的对象仅仅只是python程序级别的（用户级），那么无需定义__del__,如果产生的对象的同时还会向操作系统发起系统调用，即一个对象有用户级与内核级两种资源

import time

class People:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def __del__(self): # 在对象被删除的条件下，自动执行
        print('__del__')

obj=People('duoduo',18,'male')

#del obj #obj.__del__()      #先删除的情况下，直接执行__del__

time.sleep(5)    #可以更形象的看出在资源回收前执行__del__

典型的应用场景：

创建数据库类，用该类实例化出数据库链接对象，对象本身是存放于用户空间内存中，而链接则是由操作系统管理的，存放于内核空间内存中

当程序结束时，python只会回收自己的内存空间，即用户态内存，而操作系统的资源则没有被回收，这就需要我们定制__del__，在对象被删除前向操作系统发起关闭数据库链接的系统调用，回收资源

这与文件处理是一个道理：

f=open('a.txt') #做了两件事，在用户空间拿到一个f变量，在操作系统内核空间打开一个文件
del f #只回收用户空间的f，操作系统的文件还处于打开状态
#所以我们应该在del f之前保证f.close()执行,即便是没有del，程序执行完毕也会自动del清理资源，于是文件操作的正确用法应该是
f=open('a.txt')
读写...
f.close()
#很多情况下大家都容易忽略f.close,这就用到了with上下文管理

class MyOpen:          #自己写个打开读文件类，封装内置的open
    def __init__(self,filepath,mode="r",encoding="utf-8"):
        self.filepath=filepath
        self.mode=mode
        self.encoding=encoding
        self.fobj=open(filepath,mode=mode,encoding=encoding)  #申请系统内存

    def __str__(self):
        msg="""
        filepath:%s
        mode:%s
        encoding:%s
        """ %(self.filepath,self.mode,self.encoding)
        return msg

    def __del__(self):
        self.fobj.close()

f=MyOpen('aaa.py',mode='r',encoding='utf-8')
# print(f.filepath,f.mode,f.encoding)
# print(f)

# print(f.fobj)
res=f.fobj.read()   #一样可以读
print(res)

五、exec

#例子 一
code="""                     
#global x     #shsh声明x为全局变量
x=0
y=2
"""
global_dic={'x':100000}
local_dic={}         #字符串中声明全局就是全局，不声明就是局部
exec(code,global_dic,local_dic)
#
# print(global_dic)
# print(local_dic)

#例子 二
# code="""
# x=1
# y=2
# def f1(self,a,b):
#     pass
# """
# local_dic={}
# exec(code,{},local_dic)
# print(local_dic)

六、元类

1、什么是元类：

　　类的类就是元类
#我们用class定义的类使用来产生我们自己的对象的
#内置元类type是用来专门产生class定义的类的

#一切皆为对象：
# Chinese=type(...)
 class Chinese:
     country="China"

     def __init__(self,name,age,sex):
         self.name=name
         self.age=age
         self.sex=sex

     def speak(self):
         print('%s speak Chinese' %self.name)

# print(Chinese)
# p=Chinese('duoduo',18,'male')
# print(type(p))     #最上层的类 type

# print(type(Chinese))

2、用内置的元类type，来实例化得到我们的类

#2、用内置的元类type，来实例化得到我们的类
class_name='Chinese'
class_bases=(object,)
lass_body="""
country="China"
def __init__(self,name,age,sex):
     self.name=name
     self.age=age
     self.sex=sex
 def speak(self):
     print('%s speak Chinese' %self.name)
 """
class_dic={}
exec(class_body,{},class_dic)
 #类的三大要素
# print(class_name,class_bases,class_dic)

Chinese=type(class_name,class_bases,class_dic)
# print(Chinese)

p=Chinese('duoduo',18,'male')
# print(p.name,p.age,p.sex)

3、 __call__ 

对象后面加括号，触发执行。

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

class Foo:
    def __init__(self):
        pass
    def __str__(self):
        return '123123'
    def __del__(self):
        pass
    # 调用对象，则会自动触发对象下的绑定方法__call__的执行，
    # 然后将对象本身当作第一个参数传给self，将调用对象时括号内的值
    #传给*args与**kwargs
    def __call__(self, *args, **kwargs):
        print('__call__',args,kwargs)

obj=Foo()
# print(obj)

obj(1,2,3,a=1,b=2,c=3) #

4、自定义元类

class Mymeta(type):
    # 来控制类Foo的创建
    def __init__(self,class_name,class_bases,class_dic): #self=Foo
        # print(class_name)
        # print(class_bases)
        # print(class_dic)
        if not class_name.istitle():     #加上判断
            raise TypeError('类名的首字母必须大写')

        if not class_dic.get('__doc__'):
            raise TypeError('类中必须写好文档注释')
             
    super(Mymeta,self).__init__(class_name,class_bases,class_dic)

    # 控制类Foo的调用过程，即控制实例化Foo的过程
    def __call__(self, *args, **kwargs): #self=Foo,args=(1111,) kwargs={}
        # print(self)
        # print(args)
        # print(kwargs)

        #1 造一个空对象obj
        obj=object.__new__(self)

        #2、调用Foo.__init__,将obj连同调用Foo括号内的参数一同传给__init__
        self.__init__(obj,*args,**kwargs)

        return obj

#Foo=Mymeta('Foo',(object,),class_dic)
class Foo(object,metaclass=Mymeta):
    """
    文档注释
    """
    x=1
    def __init__(self,y):
        self.Y=y

    def f1(self):
        print('from f1')

obj=Foo(1111) #Foo.__call__()

# print(obj)
# print(obj.y)
# print(obj.f1)
# print(obj.x)

5、单例模式

import settings   #调用配置文件的IP,PORT

class MySQL:
    __instance=None
    def __init__(self,ip,port):
        self.ip=ip
        self.port=port

    @classmethod   #绑定方法
    def singleton(cls):
        if not cls.__instance:
            obj=cls(settings.IP, settings.PORT)  
            cls.__instance=obj
        return cls.__instance

obj1=MySQL('1.1.1.2',3306)
obj2=MySQL('1.1.1.3',3307)
obj3=MySQL('1.1.1.4',3308)

# obj4=MySQL(settings.IP,settings.PORT)
# print(obj4.ip,obj4.port)

obj4=MySQL.singleton()
obj5=MySQL.singleton()
obj6=MySQL.singleton()

print(obj4 is obj5 is obj6)    #Ture

 

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：Python random 模块

下一篇：python3 import Crypto 失败的解决办法 （AES对称加密使用 模块

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签