九、Python 一些类、实例、内建函数笔记

dir(Myclass)   用来展示一些类的内部属性还有方法，今天IBM面试问到了，居然忘记了，your sister.
print Myclass.__dict__也可以
del c1清除一个引用
跟踪实例

class InstCt(object):
    count =0
    
    def __init__(self):
        InstCt.count +=1

    def __del__(self):
        InstCt.coutn -=1
    def howMany(self):
        return InstCt.count
[type(getattr(x,i)) for i in ('conjugate','imag','real')]

       5.Python 多继承

python和C++一样，支持多继承。概念虽然容易，但是困难的工作是如果子类调用一个自身没有定义的属性，它是按照何种顺序去到父类寻找呢，尤其是众多父类中有多个都包含该同名属性。
class P1 #(object): 
   def foo(self):           
       print 'p1-foo' 
 
class P2 #(object): 
   def foo(self): 
       print 'p2-foo' 
   def bar(self): 
       print 'p2-bar' 
 
class C1 (P1,P2): 
   pass  
 
class C2 (P1,P2): 
   def bar(self): 
       print 'C2-bar'   
 
class GC(C1,C2): 
   pass 
  

对经典类和新式类来说，属性的查找顺序是不同的。现在我们分别看一下经典类和新式类两种不同的表现

1、经典类
d=GC() 
d.foo() # 输出 p1-foo 
d.bar() # 输出 p2-bar 

实例d调用foo()时，搜索顺序是 D => C1 => P1

实例d调用bar()时，搜索顺序是 D => C1 => P1 => P2

换句话说，经典类的搜索方式是按照“从左至右，深度优先”的方式去查找属性。d先查找自身是否有foo方法，没有则查找最近的父类C1里是否有该方法，如果没有则继续向上查找，直到在P1中找到该方法，查找结束。

2、新式类

使用新式类要去掉第一段代码中的注释
d=GC() 
d.foo() # 输出 p1-foo 
d.bar() # 输出 c2-bar 

实例d调用foo()时，搜索顺序是 D => C1 => C2 => P1

实例d调用bar()时，搜索顺序是 D => C1 => C2

可以看出，新式类的搜索方式是采用“广度优先”的方式去查找属性。

它首先查找同胞兄弟，采用的是一种广度优先查找。当查找foo(),它检查GC,然后是C1和C2，然后在P1中找到。如果P1中么有，查到将到达P2。

新式类中还有一个属性__mro__，告诉你的查找顺序。

GC.__mro__

.....

6.issubclass(sub,sup)方法:

True是 False 否

7.isinstance()布尔函数返回是否是另外一个对象的给定的实例。

isinstance(obj1,class)

例子:

class C1(object):pass

class C2(object):pass

c1=C1()

c2=C2()

isinstance(c1,C1) True

isinstance(c2,C1) False

类似JAVA中的instanceof()

hasattr(),getattr(),setattr(),delattr()

super

8.vars()内建函数与dir类似，返回一个字典。

9.classmethod：类方法staticmethod：静态方法

在python中，静态方法和类方法都是可以通过类对象和类对象实例访问。但是区别是：

    - @classmethod 是一个函数修饰符，它表示接下来的是一个类方法，而对于平常我们见到的则叫做实例方法。 类方法的第一个参数cls，而实例方法的第一个参数是self，表示该类的一个实例。 

    - 普通对象方法至少需要一个self参数，代表类对象实例
    - 类方法有类变量cls传入，从而可以用cls做一些相关的处理。并且有子类继承时，调用该类方法时，传入的类变量cls是子类，而非父类。 对于类方法，可以通过类来调用，就像C.f()，有点类似C＋＋中的静态方法,
也可以通过类的一个实例来调用，就像C().f()，这里C()，写成这样之后它就是类的一个实例了。 

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

Example 1:

>>> 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'>

Example 2:

class A(object):

@classmethod

def cm(cls):

print '类方法cm(cls)调用者：', cls.__name__

@staticmethod

def sm():

print '静态方法sm()被调用'

class B(A):

pass

A.cm()

B.cm()

A.sm()

B.sm()

输出：

类方法cm(cls)调用者： A

类方法cm(cls)调用者： B

静态方法sm()被调用

静态方法sm()被调用

dir(Myclass)   用来展示一些类的内部属性还有方法，今天IBM面试问到了，居然忘记了，your sister.
print Myclass.__dict__也可以
del c1清除一个引用
跟踪实例

class InstCt(object):
    count =0
    
    def __init__(self):
        InstCt.count +=1

    def __del__(self):
        InstCt.coutn -=1
    def howMany(self):
        return InstCt.count
[type(getattr(x,i)) for i in ('conjugate','imag','real')]

       5.Python 多继承

python和C++一样，支持多继承。概念虽然容易，但是困难的工作是如果子类调用一个自身没有定义的属性，它是按照何种顺序去到父类寻找呢，尤其是众多父类中有多个都包含该同名属性。
class P1 #(object): 
   def foo(self):           
       print 'p1-foo' 
 
class P2 #(object): 
   def foo(self): 
       print 'p2-foo' 
   def bar(self): 
       print 'p2-bar' 
 
class C1 (P1,P2): 
   pass  
 
class C2 (P1,P2): 
   def bar(self): 
       print 'C2-bar'   
 
class GC(C1,C2): 
   pass 
  

对经典类和新式类来说，属性的查找顺序是不同的。现在我们分别看一下经典类和新式类两种不同的表现

1、经典类
d=GC() 
d.foo() # 输出 p1-foo 
d.bar() # 输出 p2-bar 

实例d调用foo()时，搜索顺序是 D => C1 => P1

实例d调用bar()时，搜索顺序是 D => C1 => P1 => P2

换句话说，经典类的搜索方式是按照“从左至右，深度优先”的方式去查找属性。d先查找自身是否有foo方法，没有则查找最近的父类C1里是否有该方法，如果没有则继续向上查找，直到在P1中找到该方法，查找结束。

2、新式类

使用新式类要去掉第一段代码中的注释
d=GC() 
d.foo() # 输出 p1-foo 
d.bar() # 输出 c2-bar 

实例d调用foo()时，搜索顺序是 D => C1 => C2 => P1

实例d调用bar()时，搜索顺序是 D => C1 => C2

可以看出，新式类的搜索方式是采用“广度优先”的方式去查找属性。

它首先查找同胞兄弟，采用的是一种广度优先查找。当查找foo(),它检查GC,然后是C1和C2，然后在P1中找到。如果P1中么有，查到将到达P2。

新式类中还有一个属性__mro__，告诉你的查找顺序。

GC.__mro__

.....

6.issubclass(sub,sup)方法:

True是 False 否

isinstance()布尔函数返回是否是另外一个对象的给定的实例。

isinstance(obj1,class)

例子:

class C1(object):pass

class C2(object):pass

c1=C1()

c2=C2()

isinstance(c1,C1) True

isinstance(c2,C1) False

类似JAVA中的instanceof()

hasattr(),getattr(),setattr(),delattr()

super

7.vars()内建函数 返回一个字典。

8.classmethod：类方法staticmethod：静态方法

在python中，静态方法和类方法都是可以通过类对象和类对象实例访问。但是区别是：

    - @classmethod 是一个函数修饰符，它表示接下来的是一个类方法，而对于平常我们见到的则叫做实例方法。 类方法的第一个参数cls，而实例方法的第一个参数是self，表示该类的一个实例。 

    - 普通对象方法至少需要一个self参数，代表类对象实例
    - 类方法有类变量cls传入，从而可以用cls做一些相关的处理。并且有子类继承时，调用该类方法时，传入的类变量cls是子类，而非父类。 对于类方法，可以通过类来调用，就像C.f()，有点类似C＋＋中的静态方法,
也可以通过类的一个实例来调用，就像C().f()，这里C()，写成这样之后它就是类的一个实例了。 

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

Example 1:

>>> 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'>

Example 2:

class A(object):

@classmethod

def cm(cls):

print '类方法cm(cls)调用者：', cls.__name__

@staticmethod

def sm():

print '静态方法sm()被调用'

class B(A):

pass

A.cm()

B.cm()

A.sm()

B.sm()

输出：

类方法cm(cls)调用者： A

类方法cm(cls)调用者： B

静态方法sm()被调用

静态方法sm()被调用