Python-Buildin-面向对象类

python32python23 代表最新的Python3.x和2.x都可以用

python2python2 代表只有最新的Python2.x可以用

python3python3 代表只有最新的Python3.x可以用

classmethod staticmethod

isinstance

issubclass

hasattr

setattr

getattr

delattr

super

classmethod & staticmethod

python32python23

classmethod

：类方法

staticmethod

：静态方法

类方法和静态方法皆可以访问类的静态变量(类变量)，但不能访问实例变量

在Python中，静态方法和类方法都是可以通过类对象和类对象实例访问。

但是区别是：

1.

staticmethod

可以不接收参数，

classmethod

的第一个参数必须是

cls

类方法有类变量cls传入，从而可以用cls做一些相关的处理。

并且有子类继承时，调用该类方法时，传入的类变量cls是子类，而非父类。

静态方法则没有，它基本上跟一个全局函数相同，一般来说用的很少

普通方法必须通过类对象的实例进行调用

>>> class a():
@staticmethod
def staticm():
print 'static'
def normalm(self):
print 'nomarl',self
@classmethod
def classm(cls):
print 'class',cls

>>> a1=a()
>>> a1.normalm()
nomarl <__main__.a instance at 0x84dddec>
>>> a1.staticm()
static
>>> a1.classm()
class __main__.a
>>> type(a)
<type 'classobj'>
>>> type(a1)
<type 'instance'>

>>> class A(object):
@classmethod
def cm(cls):
print '类方法cm(cls)调用者：', cls.__name__
@staticmethod
def sm():
print '静态方法sm()被调用'

>>> class B(A):
pass

>>> A.cm()
类方法cm(cls)调用者： A
>>> B.cm()
类方法cm(cls)调用者： B
>>> A.sm()
静态方法sm()被调用
>>> B.sm()
静态方法sm()被调用

isinstance

python32python23

isinstance(object, classinfo)

本函数用来判断对象实例object是否是类classinfo的实例，

如果是就返回True，否则返回False。

参数classinfo可以是类型，也可以是tuple/dict/list等类型。

>>> class fooA:
pass

>>> class fooB:
pass

>>> class fooC(fooA):
pass

>>> a = fooA()
>>> b = fooB()
>>> c = fooC()
>>> print isinstance(a,fooA)
True
>>> print isinstance(a,fooB)
False
>>> print isinstance(b,fooB)
True
>>> print isinstance(b,fooA)
False
>>> print isinstance(c,fooA)
True
>>> print isinstance([],list)
True
>>> print isinstance((1,),tuple)
True
>>> print isinstance(dict(one=1),dict)
True

issubclass

python32python23

issubclass(class, classinfo)

判断是否是子类

>>> class fooA:
pass

>>> class fooC(fooA):
pass

>>> print issubclass(fooC,fooA)
True

hasattr

setattr

getattr

delattr

python32python23

hasattr(object,name)

：用于判断一个对象里中是否存在

name

这一特性．

setattr(object, name, value)

:该函数给对象中的属性赋值，该属性若不存在，则会在对象里创建新的属性

getattr(object, name[, default])

,

object

为对象名，

name

为对象属性（必须是字符串），

default

为name属性不存在时指定的返回内容（可以是字符串，也可以是部分指令），

若对象中存在该属性，则函数返回

object.name

，

否则返回

default

中的内容，若省略default,则返回

AttributeError

．

delattr(object, name)

:删除指定对象的属性，可以配合

hasattr

使用

In [4]: class test(object):
...:     name = "john"
...:     def greet(self):
...:         print "hello,my name is %s"% name
...:

In [5]: a = test()

In [6]: hasattr(a,'name')
Out[6]: True

In [7]: hasattr(a,'greet')
Out[7]: True

In [8]: setattr(a,'name','mark')

In [9]: print a.name
mark

In [10]: getattr(a,'name','no exit')
Out[10]: 'mark'

In [11]: getattr(a,'greet','no exit')
Out[11]: <bound method test.greet of <__main__.test object at 0x0000000003AB8470
>>

In [12]: getattr(a,'age','no exit')
Out[12]: 'no exit'

In [13]: setattr(a,'name','jane')

In [14]: a.name
Out[14]: 'jane'

In [15]: setattr(a,'age',20)

In [16]: a.age
Out[16]: 20

In [17]: getattr(a,'nationality',setattr(a,'nationality','Englend'))
Out[17]: 'Englend'

In [18]: a.nationality
Out[18]: 'Englend'

In [19]: if hasattr(a,'age'):
....:     delattr(a,'age')
....:

In [20]: a.age
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-20-d50340e1fbb7> in <module>()
----> 1 a.age

AttributeError: 'test' object has no attribute 'age'

In [21]: b = test()

In [22]: b.nationality
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-22-fd8c7f39aa50> in <module>()
----> 1 b.nationality

AttributeError: 'test' object has no attribute 'nationality'

super

python32python23

super(type[, object-or-type])

1. super并不是一个函数，是一个类名，形如super(B, self)事实上调用了super类的初始化函数，产生了一个super对象；

2. super类的初始化函数并没有做什么特殊的操作，只是简单记录了类类型和具体实例；

3. super(B, self).func的调用并不是用于调用当前类的父类的func函数；

4. Python的多继承类是通过mro的方式来保证各个父类的函数被逐一调用，而且保证每个父类函数只调用一次（如果每个类都使用super）；

5. 混用super类和非绑定的函数是一个危险行为，这可能导致应该调用的父类函数没有调用或者一个父类函数被调用多次。

(OBJECT)
|     |
|     A
|   / |
|  /  |
B C   |
\|   D
E   |
\  |
\ |
F

class A(object):
def __init__(self):
print "enter A"
print "leave A"

class B(object):
def __init__(self):
print "enter B"
print "leave B"

class C(A):
def __init__(self):
print "enter C"
super(C, self).__init__()
print "leave C"

class D(A):
def __init__(self):
print "enter D"
super(D, self).__init__()
print "leave D"

class E(B, C):
def __init__(self):
print "enter E"
B.__init__(self)
C.__init__(self)
print "leave E"

class F(E, D):
def __init__(self):
print "enter F"
E.__init__(self)
D.__init__(self)
print "leave F"
f = F()

enter F
enter E
enter B
leave B
enter C
enter D
enter A
leave A
leave D
leave C
leave E
enter D
enter A
leave A
leave D
leave F
[Finished in 0.2s]

class A(object):
def __init__(self):
print "enter A"
super(A, self).__init__()  # new
print "leave A"

class B(object):
def __init__(self):
print "enter B"
super(B, self).__init__()  # new
print "leave B"

class C(A):
def __init__(self):
print "enter C"
super(C, self).__init__()
print "leave C"

class D(A):
def __init__(self):
print "enter D"
super(D, self).__init__()
print "leave D"
class E(B, C):
def __init__(self):
print "enter E"
super(E, self).__init__()  # change
print "leave E"

class F(E, D):
def __init__(self):
print "enter F"
super(F, self).__init__()  # change
print "leave F"
f = F()

enter F
enter E
enter B
enter C
enter D
enter A
leave A
leave D
leave C
leave B
leave E
leave F
[Finished in 0.2s]

class Person(object):
def __init__(self, name, gender):
self.name = name
self.gender = gender
class Educator(object):
def __init__(self,course):
self.course = course
class Teacher(Person,Educator):
def __init__(self,name,gender,course):
Person.__init__(self,name,gender)
Educator.__init__(self,course)

t = Teacher('Alice', 'Female', 'English')
print t.name
print t.course

Alice
English
[Finished in 0.2s]