python---内建函数学习

1、issubclass()

      issubclass() 布尔函数判断一个类是另一个类的子类或子孙类。

issubclass(sub, sup) 

 issubclass() 返回 True 的情况：给出的子类 sub 确定是父类 sup 的一个子类（反之，则为 False）。这个函数也允许“不严格”的子类，意味着，一个类可视为其自身的子类。issubclass() 的第二个参数可以是可能的父类组成的元组（tuple），这时，只要第一个参数是给定元组中任何一个候选类的子类时，就会返回 True。

2、isinstance()

      isinstance() 布尔函数在判断一个对象是否是另一个给定类的实例时，非常有用。

isinstance(obj1, Class)  

isinstance() 在 obj1 是类Class的一个实例，或者是Class的子类的一个实例时，返回True（反之，则为 False）。

>>> class C1:
...     pass
...
>>> class C2:
...     pass
...
>>> c1 = C1()
>>> c2 = C2()
>>> isinstance(c1, C1)
True
>>> isinstance(c2, C1)
False
>>> isinstance(c1, C2)
False
>>> isinstance(c2, C2)
True
>>> isinstance(C2, c2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: isinstance() arg 2 must be a type or tuple of types

注意：第二个参数应该是类；不然，会得到一个TypeError。

       同 issubclass() 一样，isinstance() 也可以使用一个元组作为第二个参数。如果第一个参数是第二个参数中给定元组的任何一个候选类型或类的实例时，就会返回 True。

3、hasattr()、getattr()、setattr()、delattr()

当使用这些函数时，传入正在处理的对象作为第一个参数，但属性名，也就是这些函数的第二个参数，是这些属性的字符串名字。

      hasattr() 的目的就是为了决定一个对象是否有一个特定的属性，一般用于访问某属性前先做一个检查。getattr() 和 setattr() 函数相应地取得和赋值给对象的属性，getattr() 会在你试图读取一个不存在的属性时，引发AttributeError异常，除非给出那个可选的默认参数。setattr() 将要么加入一个新的属性，要么取代一个已存在的属性。而delattr()函数会从一个对象中删除属性。

>>> class myClass:
...     def __init__(self):
...         self.foo = 100
... myInt = myClass()
>>> hasattr(myInt,'foo')
True
>>> getatte(myInt,'foo')
Traceback (most recent call last):
  File "<input>", line 1, in <module>
NameError: name 'getatte' is not defined
>>> getattr(myInt,'foo')
100
>>> hasattr(myInt,'bar')
False
>>> getattr(myInt,'bar')
Traceback (most recent call last):
  File "<input>", line 1, in <module>
AttributeError: myClass instance has no attribute 'bar'
>>> getattr(myInt,'bar','oops1')
'oops1'
>>> hasattr(myInt,'bar')
False
>>> setattr(myInt,'bar','123456')
>>> hasattr(myInt,'bar')
True
>>> getattr(myInt,'bar')
'123456'
>>> delattr(myInt,'foo')
>>> hasattr(myInt,'foo')
False

4、dir()

      用 dir() 列出一个模块所有属性的信息。

      a. dir() 作用在实例上时，显示实例变量，还有在实例所在的类及所有它的基类中定义的方法和类属性

      b. dir() 作用在类上时，则显示类以及它的所有基类的__dict__中的内容。

      c. dir() 作用在模块上时，则显示模块的 __dict__的内容。

      d. dir() 不带参数时，则显示调用者的局部变量。

>>> dir(myInt)
['__doc__', '__init__', '__module__', 'bar']
>>> dir(myClass)
['__doc__', '__init__', '__module__']
>>> dir()
['__builtins__', 'myClass', 'myInt', 'sys']

5、super()

       这个函数的目的就是帮助程序员找出相应的父类，然后方便调用相关的属性。super() 返回了一个 super 对象，这个对象负责进行方法解析。当对其特性进行反问时，他会查找所有的超类(以及超类的超类)，直到找到所需的特性为止。

class a(object):
    def __init__(self):
        print 'i am father class'

class b(a):
    def __init__(self):
        super(b,self).__init__()
        print 'i am subclass of a'

b1 = b()

super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。总之前人留下的经验就是：保持一致性。要不全部用类名调用父类，要不就全部用 super，不要一半一半。

普通继承和super继承是一样的。但是其实它们的内部运行机制不一样，这一点在多重继承时体现得很明显。在super机制里可以保证公共父类仅被执行一次，至于执行的顺序，是按照mro进行的（E.__mro__）。
注意super继承只能用于新式类，用于经典类时就会报错。
新式类：必须有继承的类，如果没什么想继承的，那就继承object
经典类：没有父类，如果此时调用super就会出现错误：『super() argument 1 must be type, not classobj』

关于super用法的详细研究可参考「http://blog.csdn.net/johnsonguo/article/details/585193」

6、vars()

      vars() 返回一个字典，它包含了对象存储于其 __dict__ 中的属性（键）和值。

class a(object):
    def __init__(self):
        print 'i am father class'
        self.foo = 100
        self.bar = 'hello'

class b(a):
    def __init__(self):
        super(b,self).__init__()
        print 'i am subclass of a'

b1 = b()

print b1.__dict__
print vars(b1)

输出结果：

i am father class
i am subclass of a
{'foo': 100, 'bar': 'hello'}
{'foo': 100, 'bar': 'hello'}

7、dict([arg])

说明：创建数据字典

>>> a = dict() #空字典
>>> a
{}
>>> b = dict(one = 1, two = 2)
>>> b
{'two': 2, 'one': 1}
>>> c = dict({'one':1, 'two':2})
>>> c
{'two': 2, 'one': 1}
>>> d= dict([['two', 2], ['one', 1]])
>>> d
{'two': 2, 'one': 1}
>>> e ={'two': 2, 'one': 1}
>>> e
{'two': 2, 'one': 1}

8、divmod(a,b)函数

中文说明：

divmod(a,b)方法返回的是a//b（除法取整）以及a对b的余数

返回结果类型为tuple

参数：

a,b可以为数字（包括复数）

版本：

在python2.3版本之前不允许处理复数，这个大家要注意一下

英文说明：

Take two (non complex) numbers as arguments and return a pair of numbers consisting of their quotient and remainder when using long division. With mixed operand types, the rules for binary arithmetic operators apply. For plain and long integers, the result is the same as (a // b, a % b). For floating point numbers the result is (q, a % b), where q is usually math.floor(a / b) but may be 1 less than that. In any case q * b + a % b is very close to a, if a % b is non-zero it has the same sign as b, and 0 <= abs(a % b) < abs(b).

Changed in version 2.3: Using divmod() with complex numbers is deprecated.

>>> divmod(9,2)
(4, 1)
>>> divmod(11,3)
(3, 2)
>>> divmod(1+2j,1+0.5j)
((1+0j), 1.5j)