python之类
1. 类属性
特殊的类属性
C.__name__ 类Ｃ的名字（字符串）
C.__doc__ 类Ｃ的文档字符串
C.__bases__ 类Ｃ的所有父类构成的元组
C.__dict__ 类Ｃ的属性
C.__module__ 类Ｃ定义所在的模块（1.5 版本新增）
C.__class__ 实例Ｃ对应的类（仅新式类中）
2. 实例属性
实例仅有两个特殊属性
__class__ 实例的类
__dict__ 实例的属性
>>> class C(object):
pass
>>> c = C()
>>> c.foo = 1
>>> c.bar = 2
>>> c.__dict__
{'foo': 1, 'bar': 2}
>>> c.__class__
<class '__main__.C'>
使用__slots__限制实例添加属性
class Student(object):
__slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称
>>> s = Student() # 创建新的实例
>>> s.name = 'Michael' # 绑定属性'name'
>>> s.age = 25 # 绑定属性'age'
>>> s.score = 99 # 绑定属性'score'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'score'
实例属性 vs 类属性
类和实例都是名称空间。类是类属性的名称空间，实例则是实例属性的。可采用类来访问类属性，如果实例没有同名属性，则也可用实例来访问。
但修改类属性要使用类名，而不是实例名
>>> class C(object):
version = 1.0
>>> c = C()
>>> C.version
1.0
>>> c.version
1.0
>>> c.version += 0.1 # 创建了一个实例属性version， 覆盖了同名类属性
>>> c.version
1.1
>>> C.version
1.0
>>> C.version += 0.1
>>> C.verison
1.1
>>> c.version
1.1 # 类属性的修改会影响到所有实例
补充：Python 没有提供任何内部机制来跟踪一个类有多少个实例被创建了, 但可以通过一个类属性来记录实例的个数。
class Hello(object):
count = 0
def __init__(self):
Hello.count += 1
def __del__(self):
Hello.count -= 1
>>> a = Hello()
>>> b = Hello()
>>> Hello.count
2
>>> del a
>>> Hello.count
1
3. classmethod 、 staticmethod 、@property
@property
class Student(object):
#birth是可读写属性(多定义了一个setter的装饰器)，而age就是一个只读属性
@property
def birth(self):
return self._birth
@birth.setter
def birth(self, value):
self._birth = value
@property
def age(self):
return 2014 - self._birth
---------------------------------
>>>s = Student()
>>>s.birth = 2000
>>>s.birth
2000
>>>s.age
14
@classmethod 和 @staticmethod都可以让直接以类方式访问某个内置函数。但@classmethod要求的第一个参数为cls(即类自身，而不是实例自身(实例自身用self))
@classmethod 的函数可以在类中继承，而@staticmethod不行。
class Date(object):
def __init__(self, month, day, year):
self.month = month
self.day = day
self.year = year
@staticmethod
def millenium_1(month, day):
return Date(month, day, 2000)
@classmethod
def millenium_2(cls, month, day):
#cls is an object that holds class itself
return cls(month, day, 2000)
class DateTime(Date):
def display(self):
return "{0}-{1}-{2} - 00:00:00PM".format(self.month, self.day, self.year)
new_year = Date(1, 1, 2013)
millenium_new_year_1 = Date.millenium_1(1, 1)
millenium_new_year_2 = Date.millenium_2(1, 1)
isinstance(new_year, Date) # True
isinstance(millenium_new_year_1, Date) # True
isinstance(millenium_new_year_2, Date) # True
datetime1 = DateTime(10, 10, 1990)
datetime2 = DateTime.millenium_1(10, 10)
datetime3 = DateTime.millenium_2(10, 10)
isinstance(datetime1, DateTime) # True
isinstance(datetime2, DateTime) # False
isinstance(datetime2, DateTime) # True
4. 类的继承
一般没有什么可以继承时，继承object(采用新式类)。
如果有同名属性，则子类的属性会覆盖基类的属性(__doc__属性不会继承)，但可以用super显示调用基类属性。
>>> class P(object):
def __init__(self):
print "It's P"
>>> class C(P):
def __init__(self):
print "It's C"
>>> c = C()
It's C
>>> class C(P):
def __init__(self):
super(C, self).__init__()
print "It's C"
>>> c = C()
It's P
It's C
4.1 从标准类型派生
4.2 多重继承
class P1(object): # parent class 1 父类1
def foo(self):
print 'called P1-foo()'
class P2(object): # parent class 2 父类2
def foo(self):
print 'called P2-foo()'
class C1(P1, P2): # child 1 der. from P1, P2 #子类1，从P1，P2派生
pass
class C2(P1, P2): # child 2 der. from P1, P2 #子类2，从P1，P2派生
def bar(self):
print 'called C2-bar()'
class GC(C1, C2): # define grandchild class #定义子孙类
pass # derived from C1 and C2 #从C1，C2派生
# 新式类采用广度优先的继承方式
>>> gc = GC()
>>> gc.foo() # GC ==> C1 ==> C2 ==> P1
called P1-foo()
>>> gc.bar() # GC ==> C1 ==> C2
called C2-bar()
# 但如果是经典类， 即P1，P2不是继承object, 则采用深度优先，从左至右的继承方式
>>> gc = GC()
>>> gc.foo() # GC ==> C1 ==> P1
called P1-foo()
>>> gc.bar() # GC ==> C1 ==> P1 ==> P2
called P2-bar()
5. 类、实例和其他对象的内建函数
issubclass()
isinstance()
hasattr()、getattr()、setattr()、delattr()
dir()
super()
vars() # 同__dict__
6. 定制类
https://docs.python.org/2/reference/datamodel.html#special-method-names
6.1 __str__、 __repr__
class Student(object):
def __init__(self, name):
self.name = name
def __str__(self):
return 'Student object (name=%s)' % self.name
__repr__ = __str__
>>>print Student('David')
>>>Student('David')
----------------
Student object (name=David) #__str__
Student object (name=David) #__repr__
6.2 __getattr__
class Student(object):
def __init__(self, name):
self.name = 'Michael'
def __getattr__(self, attr):
if attr=='score':
return 99
>>>student = Student('David')
>>>student.name
>>>student.score
>>>print student.grade
---------------
'David'
99
None #可以让class只响应特定的几个属性(通过抛出AttributeError的错误)
6.3 __iter__
如果一个类想被用于for ... in循环，类似list或tuple那样，就必须实现一个__iter__()方法，该方法返回一个迭代对象，然后，Python的for循环就会不断调用该迭代对象的next()方法拿到循环的下一个值，直到遇到StopIteration错误时退出循环。
class Fib(object):
def __init__(self):
self.a, self.b = 0, 1 # 初始化两个计数器a，b
def __iter__(self):
return self # 实例本身就是迭代对象，故返回自己
def next(self):
self.a, self.b = self.b, self.a + self.b # 计算下一个值
if self.a > 1000: # 退出循环的条件
raise StopIteration();
return self.a # 返回下一个值
>>> for n in Fib():
... print n,
------------------------
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
6.4 __getitem__
class Fib(object):
def __getitem__(self, n):
a, b = 1, 1
for x in range(n):
a, b = b, a + b
return a
-------------------------
>>> f = Fib()
>>> f[0]
1
>>> f[1]
1
>>> f[2]
2
>>> f[10]
89
>>> f[100]
573147844013817084101
6.5 __call__
而且通过callable()函数，我们就可以判断一个对象是否是“可调用”对象
class Student(object):
def __init__(self, name):
self.name = name
def __call__(self):
print('My name is %s.' % self.name)
>>>student = Student('Daivd')
>>>student()
---------------------
My name is David.
7. 私有化
名称前的单下划线
名称前的单下划线，用于指定该名称属性为“私有”。这有点类似于惯例，为了使其他人（或你自己）使用这些代码时将会知道以“_”开头的名称只供内部使用。正如Python文档中所述：
以下划线“_”为前缀的名称（如_spam）应该被视为API中非公开的部分（不管是函数、方法还是数据成员）。此时，应该将它们看作是一种实现细节，在修改它们时无需对外部通知。
名称前的双下划线
名称（具体为一个方法名）前双下划线（__）的用法并不是一种惯例，对解释器来说它有特定的意义。
Python中的这种用法是为了避免与子类定义的名称冲突。Python文档指出，“__spam”这种形式（至少两个前导下划线，最多一个后续下划线）的任何标识符将会被“_classname__spam”这种形式原文取代，在这里“classname”是去掉前导下划线的当前类名。
>>> class A(object): ... def _internal_use(self): ... pass ... def __method_name(self): ... pass ... >>> dir(A()) ['_A__method_name', ..., '_internal_use'] >>> class B(A): ... def __method_name(self): ... pass ... >>> dir(B()) ['_A__method_name', '_B__method_name', ..., '_internal_use']
8. 元类
metaclasses are what create these objects.They are the classes' classes.
http://stackoverflow.com/questions/100003/what-is-a-metaclass-in-python
任何子类可以通过metaclass扫描映射关系，并存储到基类的class中。(往往用于那些需要动态创建类的场合，如orm)
type
type is the metaclass Python uses to create all classes behind the scenes.
age = 35
age.__class__
#<type 'int'>
age.__class__.__class__
#<type 'type'>
自定义metaclass
The main purpose of a metaclass is to change the class automatically, when it's created. You usually do this for APIs, where you want to create classes matching the current context. A typical example of this is the Django ORM.
当用户定义一个类时，Python解释器首先在当前类的定义中查找__metaclass__，如果没有找到，就继续在父类中查找，找到了，就使用父类中定义的__metaclass__来创建，也就是说，metaclass可以隐式地继承到子类，但子类自己却感觉不到。
class UpperAttrMetaclass(type): # __new__ is the method called before __init__ # it's the method that creates the object and returns it # while __init__ just initializes the object passed as parameter # you rarely use __new__, except when you want to control how the objectis created. # here the created object is the class, and we want to customize it, so we override __new__ # you can do some stuff in __init__ too if you wish # some advanced use involves overriding __call__ as well def __new__(cls, clsname, bases, dct): uppercase_attr = {} for name, val in dct.items(): if not name.startswith('__'): uppercase_attr[name.upper()] = val else: uppercase_attr[name] = val return super(UpperAttrMetaclass, cls).__new__(cls, clsname, bases, uppercase_attr)
__new__接收到的参数依次是：
-
当前准备创建的类的对象
-
类的名字
-
类继承的父类集合
-
类的方法集合
2015-06-01
