码迷,mamicode.com
首页 > 编程语言 > 详细

python基础之面向对象进阶

时间:2017-04-25 16:52:20      阅读:206      评论:0      收藏:0      [点我收藏+]

标签:auth   内存优化   自己   地方   共享   兼容   obj   解释器   应该   

__slots__是什么:是一个类变量,变量值可以是列表,元祖,或者可迭代对象,也可以是一个字符串(意味着所有实例只有一个数据属性)

 

引子:使用点来访问属性本质就是在访问类或者对象的__dict__属性字典(类的字典是共享的,而每个实例的是独立的。

为何使用__slots__:字典会占用大量内存,如果你有一个属性很少的类,但是有很多实例,为了节省内存可以使用__slots__取代实例的__di

当你定义__slots__后,__slots__就会为实例使用一种更加紧凑的内部表示。实例通过一个很小的固定大小的数组来构建,而不是为每个实例定义一个字典,这跟元组或列表很类似。在__slots__中列出的属性名在内部被映射到这个数组的指定小标上。使用__slots__一个不好的地方就是我们不能再给
实例添加新的属性了,只能使用在__slots__中定义的那些属性名。

注意事项:__slots__的很多特性都依赖于普通的基于字典的实现。另外,定义了__slots__后的类不再 支持一些普通类特性了,比如多继承。大多数情况下,你应该
只在那些经常被使用到 的用作数据结构的类上定义__slots__比如在程序中需要创建某个类的几百万个实例对象 。
关于__slots__的一个常见误区是它可以作为一个封装工具来防止用户给实例增加新的属性。尽管使用__slots__可以达到这样的目的,但是这个并不是它的初衷。           更多的是用来作为一个内存优化工具。

 ‘‘‘

1. class Foo:
       __slots__=‘x‘


   f1=Foo()
   f1.x=1
   f1.y=2#报错
   print(f1.__slots__) #f1不再有__dict__

   class Bar:
       __slots__=[‘x‘,‘y‘]
      
   n=Bar()
   n.x,n.y=1,2
   n.z=3#报错
2. class Foo:
      __slots__=[‘name‘,‘age‘]

   f1=Foo()
   f1.name=‘alex‘
   f1.age=18
   print(f1.__slots__)

   f2=Foo()
   f2.name=‘egon‘
   f2.age=19
   print(f2.__slots__)

   print(Foo.__dict__)
   #f1与f2都没有属性字典__dict__了,统一归__slots__管,节省内存


 

__next__和__iter__实现迭代器协议

简单示范

#_*_coding:utf-8_*_
__author__ = ‘Linhaifeng‘
class Foo:
    def __init__(self,x):
        self.x=x

    def __iter__(self):
        return self

    def __next__(self):
        n=self.x
        self.x+=1
        return self.x

f=Foo(3)
for i in f:
    print(i

 

__module__和__class__

 __module__ 表示当前操作的对象在那个模块

 __class__     表示当前操作的对象的类是什么

#!/usr/bin/env python
# -*- coding:utf-8 -*-

class C:

    def __init__(self):
        self.name = ‘SB‘


 





from lib.aa import C

obj = C()
print obj.__module__  # 输出 lib.aa,即:输出模块
print obj.__class__      # 输出 lib.aa.C,即:输出类




__del__

 

析构方法,当对象在内存中被释放时,自动触发执行。

 

简单示范

class Foo:

    def __del__(self):
        print(‘执行我啦‘)

f1=Foo()
del f1
print(‘------->‘)

#输出结果
执行我啦
------->



 __enter__和__exit__

 

我们知道在操作文件对象的时候可以这么写

1 with open(‘a.txt‘) as f:
2   ‘代码块‘

 

上述叫做上下文管理协议,即with语句,为了让一个对象兼容with语句,必须在这个对象的类中声明__enter__和__exit__方法

class Open:
    def __init__(self,name):
        self.name=name

    def __enter__(self):
        print(‘出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量‘)
        # return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print(‘with中代码块执行完毕时执行我啊‘)


with Open(‘a.txt‘) as f:
    print(‘=====>执行代码块‘)
    # print(f,f.name)

 

__exit__()中的三个参数分别代表异常类型,异常值和追溯信息,with语句中代码块出现异常,则with后的代码都无法执行class Open:

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

    def __enter__(self):
        print(‘出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量‘)

    def __exit__(self, exc_type, exc_val, exc_tb):
        print(‘with中代码块执行完毕时执行我啊‘)
        print(exc_type)
        print(exc_val)
        print(exc_tb)



with Open(‘a.txt‘) as f:
    print(‘=====>执行代码块‘)
    raise AttributeError(‘***着火啦,救火啊***‘)
print(‘0‘*100) #------------------------------->不会执行



如果__exit()返回值为True,那么异常会被清空,就好像啥都没发生一样,with后的语句正常执行

class Open:
    def __init__(self,name):
        self.name=name

    def __enter__(self):
        print(‘出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量‘)

    def __exit__(self, exc_type, exc_val, exc_tb):
        print(‘with中代码块执行完毕时执行我啊‘)
        print(exc_type)
        print(exc_val)
        print(exc_tb)
        return True



with Open(‘a.txt‘) as f:
    print(‘=====>执行代码块‘)
    raise AttributeError(‘***着火啦,救火啊***‘)
print(‘0‘*100) #------------------------------->会执行
 

__call__

对象厚面加括号,触发执行

class Foo:

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

        print(‘__call__‘)


obj = Foo() # 执行 __init__
obj()       # 执行 __call__
 

metaclass

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

1 #type函数可以查看类型,也可以用来查看对象的类,二者是一样的
2 print(type(f1)) # 输出:<class ‘__main__.Foo‘>     表示,obj 对象由Foo类创建
3 print(type(Foo)) # 输出:<type ‘type‘>  


什么是元类:
元类是类的类,是类的模板
元类是用来控制如何创建类的,正如类是创建对象模板一样
元类的实例为类,正如类的实例为对象(f1对象是Foo类的一个实例,Foo类是type类的一个实例)
type是python的一个内奸元类,用来直接控制生成类,python中任何class定义的类其实都是type类实例化的对象
创建类的两种方式:
1.

class Foo:
    def func(self):
        print(‘from func‘)
2.
def func(self):
         print(‘from func‘)
 x=1
 Foo=type(‘Foo‘,(object,),{‘func‘:func,‘x‘:1})

一个类没有声明自己的元类,默认他的元类就是type,除了使用元类type,用户也可以通过继承type来定义元类
 































































































 

python基础之面向对象进阶

标签:auth   内存优化   自己   地方   共享   兼容   obj   解释器   应该   

原文地址:http://www.cnblogs.com/w123sc/p/6762719.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!