Python类与对象
| 内置方法 | 说明 |
| __init__(self,...) | 初始化对象，在创建新对象时调用 |
| __del__(self) | 释放对象，在对象被删除之前调用 |
| __new__(cls,*args,**kwd) | 实例的生成操作 |
| __str__(self) | 在使用print语句时被调用 |
| __getitem__(self,key) | 获取序列的索引key对应的值，等价于seq[key] |
| __len__(self) | 在调用内联函数len()时被调用 |
| __cmp__(stc,dst) | 比较两个对象src和dst |
| __getattr__(s,name) | 获取属性的值 |
| __setattr__(s,name,value) | 设置属性的值 |
| __delattr__(s,name) | 删除name属性 |
| __getattribute__() | __getattribute__()功能与__getattr__()类似 |
| __gt__(self,other) | 判断self对象是否大于other对象 |
| __lt__(slef,other) | 判断self对象是否小于other对象 |
| __ge__(slef,other) | 判断self对象是否大于或者等于other对象 |
| __le__(slef,other) | 判断self对象是否小于或者等于other对象 |
| __eq__(slef,other) | 判断self对象是否等于other对象 |
| __call__(self,*args) | 把实例对象作为函数调用 |
__init__():
__init__方法在类的一个对象被建立时，马上运行。这个方法可以用来对你的对象做一些你希望的初始化。注意，这个名称的开始和结尾都是双下划线。
代码例子:
| #!/usr/bin/python # Filename: class_init.py class Person: def __init__(self, name): self.name = name def sayHi(self): print 'Hello, my name is', self.name p = Person('Swaroop') 输出： |
__new__():
__new__()在__init__()之前被调用，用于生成实例对象.利用这个方法和类属性的特性可以实现设计模式中的单例模式.单例模式是指创建唯一对象吗，单例模式设计的类只能实例化一个对象.
| #!/usr/bin/python # -*- coding: UTF-8 -*- class Singleton(object): def __init__(self): def __new__(cls, *args, **kwd): # 在__init__之前调用 |
__getattr__()、__setattr__()和__getattribute__():
当读取对象的某个属性时，python会自动调用__getattr__()方法.例如，fruit.color将转换为fruit.__getattr__(color).当使用赋值语句对属性进行设置时，python会自动调用__setattr__()方法.__getattribute__()的功能与__getattr__()类似，用于获取属性的值.但是__getattribute__()能提供更好的控制，代码更健壮.注意，python中并不存在__setattribute__()方法.
代码例子：
| #!/usr/bin/python # -*- coding: UTF-8 -*- class Fruit(object): def __setattr__(self, name, value): if __name__ == "__main__": |
__getitem__():
如果类把某个属性定义为序列，可以使用__getitem__()输出序列属性中的某个元素.假设水果店中销售多钟水果，可以通过__getitem__()方法获取水果店中的没种水果
代码例子:
| #!/usr/bin/python # -*- coding: UTF-8 -*- class FruitShop: if __name__ == "__main__": 输出为: |
__str__():
__str__()用于表示对象代表的含义，返回一个字符串.实现了__str__()方法后，可以直接使用print语句输出对象，也可以通过函数str()触发__str__()的执行.这样就把对象和字符串关联起来，便于某些程序的实现，可以用这个字符串来表示某个类
代码例子：
| #!/usr/bin/python # -*- coding: UTF-8 -*- class Fruit: if __name__ == "__main__": |
__call__():
在类中实现__call__()方法，可以在对象创建时直接返回__call__()的内容.使用该方法可以模拟静态方法，实现了__call__的方法，则对象可以通过函数调用的方式 去执行__call__里面的内容
代码例子:
| #!/usr/bin/python # -*- coding: UTF-8 -*- class Fruit: grow = Growth() # 调用Growth()，此时将类Growth作为函数返回,即为外部类Fruit定义方法grow(),grow()将执行__call__()内的代码 |
1、自定义类的字符串的格式化，需要在类上面定义__format__ ():
_formats = {
'ymd' : '{d.year}-{d.month}-{d.day}',
'mdy' : '{d.month}/{d.day}/{d.year}',
'dmy' : '{d.day}/{d.month}/{d.year}'
}
class Date:
def __init__(self, year, month, day):
self.year = year
self.month = month
self.day = day
def __format__(self, code):
if code == '':
code = 'ymd'
fmt = _formats[code]
return fmt.format(d=self)
测试：
>>> d = Date(2012, 12, 21)
>>> format(d)
'2012-12-21'
>>> format(d, 'mdy')
'12/21/2012'
>>> 'The date is {:ymd}'.format(d)
'The date is 2012-12-21'
>>> 'The date is {:mdy}'.format(d)
'The date is 12/21/2012'
2、让对象支持上下文管理协议(with)，为了让一个对象兼容with 语句，你需要实现__enter__ () 和__exit__ () 方法。
from socket import socket, AF_INET, SOCK_STREAM
class LazyConnection:
def __init__(self, address, family=AF_INET, type=SOCK_STREAM):
self.address = address
self.family = family
self.type = type
self.sock = None
def __enter__(self):
if self.sock is not None:
raise RuntimeError('Already connected')
self.sock = socket(self.family, self.type)
self.sock.connect(self.address)
return self.sock
def __exit__(self, exc_ty, exc_val, tb):
self.sock.close()
self.sock = Nonefrom functools import partial
conn = LazyConnection(('www.python.org', 80))
with conn as s:
s.send(b'GET /index.html HTTP/1.0\r\n')
s.send(b'Host: www.python.org\r\n')
s.send(b'\r\n')
resp = b''.join(iter(partial(s.recv, 8192), b''))
当出现with语句的时候，对象的__enter__ () 方法被触发，它返回的值(如果有的话) 会被赋值给as 声明的变量。然后，with 语句块里面的代码开始执行。最后， __exit__ () 方法被触发进行清理工作不管with 代码块中发生什么，上面的控制流都会执行完，就算代码块中发生了异常也是一样的。事实上， exit () 方法的三个参数包含了异常类型、异常值和追溯信息(如果有的话)。exit () 方法能自己决定怎样利用这个异常信息，或者忽略它并返回一个None 值。如果exit () 返回True ，那么异常会被清空，就好像什么都没发生一样， with 语句后面的程序继续在正常执行.在需要管理一些资源比如文件、网络连接和锁的编程环境中，使用上下文管理器是很普遍的
3、创建大量对象时，节省内存空间
对于主要是用来当成简单的数据结构类而言，可以通过给类添加__slots__属性来极大的减少实例所占用的内存比如：
class Date:
__slots__ = ['year', 'month', 'day']
def __init__(self, year, month, day):
self.year = year
self.month = month
self.day = day
4、在类中封装属性名
Python 程序员不去依赖语言特性去封装数据，而是通过遵循一定的属性和方法命名规约来达到这个效果。第一个约定是任何以单下划线开头的名字都应该是内部实现。比如：
5、创建新的类或实例属性
class A:
def __init__(self):
self._internal = 0 # An internal attribute
self.public = 1 # A public attribute
def public_method(self):
'''A public method'''
pass
def _internal_method(self):
passclass B:
def __init__(self):
self.__private = 0
def __private_method(self):
pass
def public_method(self):
pass5、创建新的类或实例属性
如果你想创建一个新的拥有一些额外功能的实例属性类型，比如类型检查。那么久可以通过一个描述器类的形式来定义它的功能。下面是一个例子：
class Integer:
def __init__(self, name):
self.name = name
def __get__(self, instance, cls):
if instance is None:
return self
else:
return instance.__dict__[self.name]
def __set__(self, instance, value):
if not isinstance(value, int):
raise TypeError('Expected an int')
instance.__dict__[self.name] = value
def __delete__(self, instance):
del instance.__dict__[self.name]class Point:
x = Integer('x')
y = Integer('y')
def __init__(self, x, y):
self.x = x
self.y = y>>> p = Point(2, 3)
>>> p.x # Calls Point.x.__get__(p,Point)
2
>>> p.y = 5 # Calls Point.y.__set__(p, 5)
>>> p.x = 2.3 # Calls Point.x.__set__(p, 2.3)
Traceback (most recent call last):
File "", line 1, in
File "descrip.py", line 12, in __set__
raise TypeError('Expected an int')
TypeError: Expected an int
>>> # Does NOT work
class Point:
def __init__(self, x, y):
self.x = Integer('x') # No! Must be a class variable
self.y = Integer('y')
self.x = x
self.y = y# Descriptor for a type-checked attribute
class Typed:
def __init__(self, name, expected_type):
self.name = name
self.expected_type = expected_type
def __get__(self, instance, cls):
if instance is None:
return self
else:
return instance.__dict__[self.name]
def __set__(self, instance, value):
if not isinstance(value, self.expected_type):
raise TypeError('Expected ' + str(self.expected_type))
instance.__dict__[self.name] = value
def __delete__(self, instance):
del instance.__dict__[self.name]
# Class decorator that applies it to selected attributes
def typeassert(**kwargs):
def decorate(cls):
for name, expected_type in kwargs.items():
# Attach a Typed descriptor to the class
setattr(cls, name, Typed(name, expected_type))
return cls
return decorate
# Example use
@typeassert(name=str, shares=int, price=float)
class Stock:
def __init__(self, name, shares, price):
self.name = name
self.shares = shares
self.price = price6、使用延迟计算属性
如果希望一个只读属性定义成一个Property，并且只有在访问的时候才会去计算结果，但是一旦属性被访问之后，你希望结果被缓存起来，不用每次去计算。实现如下：
import math
class lazyproperty:
def __init__(self,func):
self._func = func
def __get__(self, instance, owner):
if instance is None:
return self
else:
value = self._func(instance)
setattr(instance,self._func.__name__,value)
return value
class Circle()
def __init__(self,radius):
self.radius = radius
@lazyproperty
def area(self):
print("Compute Area")
return math.pi * self.radius**2
7、简化数据结果的初始化
可以在一个基类中写一个公用的__init__()函数：
class Base():
_fields = []
def __init__(self,*args):
if len(args) != len(self._fields):
raise TypeError("Expected {} arguments".format(len(self._fields)))
for name, value in zip(self._fields,args):
setattr(self,name,value)
class Stock(Base):
_fields = ['name','shares','price']
class Point(Base):
_fields = ['x','y']
使用实例：
>>> s = Stock('ACME', 50, 91.1)
>>> p = Point(2, 3)
>>> s2 = Stock('ACME', 50)
Traceback (most recent call last):
File "", line 1, in
File "structure.py", line 6, in __init__
raise TypeError('Expected {} arguments'.format(len(self._fields)))
TypeError: Expected 3 arguments
>>> p = Point(2, 3)
>>> s2 = Stock('ACME', 50)
Traceback (most recent call last):
File "
File "structure.py", line 6, in __init__
raise TypeError('Expected {} arguments'.format(len(self._fields)))
TypeError: Expected 3 arguments
如果还想支持关键字参数，可以将关键字参数设置为实例属性：
class Base2():
_fields = []
def __init__(self,*args,**kwargs):
if len(args) > len(self._fields):
raise TypeError('Expected {} arguments'.format(len(self._fields)))
for name,value in zip(self._fields,args)
setattr(self,name,value)
for name in self._fields[len(args):]:
setattr(self,name,kwargs.pop(name))
if kwargs:
raise TypeError('invalid argument(s):{}'.format(','.join(kwargs)))
其他定义额外的 关键字参数 只要修改__init__方法中的实现就可以了，总体思路 设置到 实例的 属性中去
8、定义接口或者抽象基类
定义一个接口或者抽象类，并且通过执行类型检查来确保子类实现了某些特定的方法，使用abc模块可以很轻松的定义抽象基类。
from abc import ABCMeta,abstractmethod
class ISteram(metaclass=ABCMeta):
@abstractmethod
def read(self,maxbytes = -1):
pass
@abstractmethod
def write(self,data):
passclass SocketStream(ISteram):
def read(self,maxbytes = -1):
pass
def write(self,data):
passdef serialize(obj, stream):
if not isinstance(stream, IStream):
raise TypeError('Expected an IStream')
passimport io
# Register the built-in I/O classes as supporting our interface
IStream.register(io.IOBase)
# Open a normal file and type check
f = open('foo.txt')
isinstance(f, IStream) # Returns Trueclass D(metaclass=ABCMeta):
@property
@abstractmethod
def name(self):
pass
@name.setter
@abstractmethod
def name(self,value):
pass
@classmethod
@abstractmethod
def methon1(cls):
pass
@staticmethod
@abstractmethod
def method2():
pass9、实现数据模型的类型约束
class Descriptor:
def __init__(self,name=None,**opts):
self.name = name
for key, value in opts.items():
setattr(self,key,value)
def __set__(self, instance, value):
instance.__dict__[self.name] = value
class Typed(Descriptor):
excepted_type = type(None)
def __set__(self, instance, value):
if not isinstance(value,self.excepted_type):
raise TypeError('excepted ' + str(self.excepted_type))
super().__set__(instance,value)
class Unsigned(Descriptor):
def __set__(self, instance, value):
if value < 0:
raise ValueError('except >= 0')
super().__set__(instance,value)
class MaxSized(Descriptor):
def __init__(self,name=None,**opts):
if 'size' not in opts:
raise TypeError('miss size option')
super().__init__(name,**opts)
def __set__(self, instance, value):
if len(value) >= self.size:
raise ValueError('size must be < ' + str(self.size))
super().__set__(instance,value)
class Interger(Typed):
excepted_type = int
class UnsignedInterger(Interger,Unsigned):
pass
class Float(Typed):
excepted_type = float
class UnsignedFloat(Float,Unsigned):
pass
class String(Typed):
excepted_type = str
class SizedString(String,MaxSized):
pass
#使用这些自定义数据类型，我们自定义一个类
class Stock():
name = SizedString('name',size=8)
shares = UnsignedInterger('shares')
price = UnsignedFloat('price')
def __init__(self,name_,shares,price):
self.name = name_
self.shares = shares
self.price = price
s1 = Stock('acm',100,50.0)10、实现自定义的容器
想要实现自定义的类来模拟内置的容器类功能，比如列表和字典。collections定义了很多抽象基类，当你想要自定义容器类的时候，会很有用。比如想要自己实现的类支持迭代，那就从collections.Iterable类继承。例如：
import collections
class A(collections.Iterable):
def __init__(self,fruits):
self.fruits = fruits
def __iter__(self):
for item in self.fruits:
yield item
a = A(["a","b","c","d"])
for key in a:
print(key)
比如想要自己实现的类支持序列操作、切片操作，可以从collections.Sequence类继承，并且实现基类的抽象函数__len__ 和 __getitem__ 。比如：
import collections
import bisect
class SortedItems(collections.Sequence):
def __init__(self,initial=None):
self._items = sorted(initial) if initial is not None else []
def __getitem__(self, index):
return self._items[index]
def __len__(self):
return len(self._items)
def add(self,item):
bisect.insort(self._items,item)
items = SortedItems([5,1,3])
print(list(items))
print((items[0],items[-1]))
items.add(2)
print(list(items))
print(items[0:2])
[1, 3, 5]
(1, 5)
[1, 2, 3, 5]
[1, 2]
[1, 2, 3, 5]
[1, 2]
使用collections模块中的抽象基类可以确保你自定义的容器实现了所有必要的方法，并且还能简化类型检查。提供一些常见的容器操作提供默认的实现，这样一来你只需要实现那些你感兴趣的方法即可。
11、属性的代理访问
如果你想要将某个实例的属性访问代理到内部的另外一个实例中去，目的可能是作为继承的一个替代方法或者实现代理模式。简单来说，代理是一种编程模式，它将摸个操作转移到另外一个对象来实现。最简单的实现如下：
class A:
def spam(self,x):
pass
def foo(self):
pass
class B1():
def __init__(self):
self._a = A()
def spam(self,x):
return self._a.spam(x)
def foo(self):
return self._a.foo()
def bar(self):
passclass B2():
def __init__(self):
self._a = A()
def bar(self):
pass
def __getattr__(self, item):
"这个方法在访问的attribute不存在的时候调用"
return getattr(self._a,item)
另外一个代理例子是实现代理模式，例如：
class Proxy:
def __init__(self,obj):
self._obj = obj
def __getattr__(self, item):
return getattr(self._obj,item)
def __setattr__(self, key, value):
if key.startswith('_'):
super().__setattr__(key,value)
else:
setattr(self._obj,key,value)
def __delattr__(self, item):
if item.startswith('_'):
super().__delattr__(item)
else:
delattr(self._obj,item)
class Spam:
def __init__(self,x):
self.x = x
def bar(self,y):
print('Spam.bar:',self.x,y)
12、在类中定义多个构造器
如果你想实现一个类，除了使用__init__()方法之外，还有其他方式可以初始化它。例如：
import time
class Date:
def __init__(self,year,month,day):
self.year = year
self.month = month
self.day = day
@classmethod
def today(cls):
t = time.localtime()
return cls(t.tm_year,t.tm_mon,t.tm_mday)13、创建一个不调用__init__()方法的实例
可以通过__new__()方法创建一个未初始化的实例，直接使用 类.__new__()
14、利用Mixins拓展类功能
假如你又很多有用的方法，想使用它们来拓展其他类的功能，但是这些类并没有任何继承的关系，因此你不能简单的将这些方法放到一个基类中，然后被其他类继承。假设你想拓展映射对象，给它们添加日志、唯一性设置、类型检查等等功能。下面是一些混入类：
class LoggedMappingMixin:
"添加logging到get set delete 操作，在调试模式下"
__slots__ = () #混入类没有实例变量，因为直接实例化混入类没有任何意义
def __getitem__(self, item):
print("Getting "+ str(item))
return super().__getitem__(item)
def __setitem__(self, key, value):
print("Setting {} = {!r}".format(key,value))
return super().__setitem__(key,value)
def __delitem__(self, key):
print("Delete " + str(key))
return super().__delitem__(key)
class SetOnceMappingMixin:
"仅仅允许值被设置一次"
__slots__ = ()
def __setitem__(self, key, value):
if key in self:
raise KeyError(str(key)+ ' already set')
else:
return super().__setitem__(key,value)
class StringKeysMappingMixin:
"键值只允许是字符串"
__slots__ = ()
def __setitem__(self, key, value):
if not isinstance(key,str):
raise TypeError('key must be strings')
else:
super().__setitem__(key,value)class LoggedDict(LoggedMappingMixin,dict):
pass
d = LoggedDict()
d['x'] = 23
print(d['x'])
del d['x']
Setting x = 23
Getting x
23
Delete x
还有一种使用混入类的方式是使用类装饰器。例如：
Getting x
23
Delete x
还有一种使用混入类的方式是使用类装饰器。例如：
def LoggedMapping(cls):
""" 第二种方式：使用类装饰器"""
cls_getitem = cls.__getitem__
cls_setitem = cls.__setitem__
cls_delitem = cls.__delitem__
def __getitem__(self, key):
print('Getting ' + str(key))
return cls_getitem(self, key)
def __setitem__(self, key, value):
print('Setting {} = {!r}'.format(key, value))
return cls_setitem(self, key, value)
def __delitem__(self, key):
print('Deleting ' + str(key))
return cls_delitem(self, key)
cls.__getitem__ = __getitem__
cls.__setitem__ = __setitem__
cls.__delitem__ = __delitem__
return cls
@LoggedMapping
class LoggedDict(dict):
pass
15、实现状态对象或者状态机
如果你想事项一个状态机或者在不同状态下执行操作对象，但是又不想在代码中出现太多的条件判断语句。解决方法为每个状态定义一个对象：
class Connection:
def __init__(self):
self.new_state(ClosedConnectionState)
def new_state(self,newstate):
self._state = newstate
def read(self):
return self._state.read(self)
def write(self,data):
return self._state.write(self,data)
def open(self):
return self._state.open(self)
def close(self):
return self._state.close(self)
class ConnectionState:
@staticmethod
def read(conn):
raise NotImplementedError()
@staticmethod
def write(conn,data):
raise NotImplementedError()
@staticmethod
def open(conn):
raise NotImplementedError()
@staticmethod
def close(conn):
raise NotImplementedError()
class CloseConnectionState(ConnectionState):
@staticmethod
def read(conn):
raise RuntimeError('Not open')
@staticmethod
def write(conn,data):
raise RuntimeError('Not open')
@staticmethod
def open(conn):
conn.new_state(OpenConnectionState)
@staticmethod
def close(conn):
raise RuntimeError('alread closed')
class OpenConnectionState:
@staticmethod
def read(conn):
print('reading')
@staticmethod
def write(conn,data):
print('write')
@staticmethod
def open(conn):
raise RuntimeError('already open')
@staticmethod
def close(conn):
conn.new_state(CloseConnectionState)
如果让某个类支持标准的比较运算(比如>= ,!=, <= , <)等，但是又不想去实现那一大堆的特殊方法。使用装饰器functools.total_ordering来简化这个处理，使用它装饰一个类，只需要定义一个__eq__()方法，外加（__lt__、 __gt__、 __le__、 __ge__ ）中的一个就可以了。然后装饰器会自动填充其他方法。