内置方法

你也可以使用以下函数的方式来访问属性：

• getattr(obj, name[, default]) : 访问对象的属性。
• hasattr(obj,name) : 检查是否存在一个属性。
• setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。
• delattr(obj, name) : 删除属性。

Python内置类属性

__dict__ : 类的属性（包含一个字典，由类的数据属性组成）
__doc__ :类的文档字符串
__name__: 类名
__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
__bases__: 类的所有父类构成元素（包含了以个由所有父类组成的元组）

1. abs() 求绝对值
   exp: abs(x)
   x 是 整型

2. all(iterable)
   判断iterable可迭代对象中所有元素都是True,(元素除0，空，None，False外)

3. any(iterable)
   判断可迭代对象iterable 中任意一个元素是True,则返回True.

4. basestring()
   basestring() 方法是 str 和 unicode 的超类（父类），也是抽象类，因此不能被调用和实例化，但可以被用来判断一个对象是否为 str 或者 unicode 的实例，isinstance(obj, basestring) 等价于 isinstance(obj, (str, unicode))。

5. bin()
   bin() 返回一个整数 int 或者长整数 long int 的二进制表示。

6. bool()
   转换成布尔值(True, False)

7. bytearray()
   方法返回一个新字节数组(bytearray()).

>>> bytearray([1,2])
bytearray(b'\x01\x02')

8.callable()

1. 方法用来检测对象是否可被调用，可被调用指的是对象能否使用()括号的方法调用。
2. 可调用对象，在实际调用也可能调用失败；但是不可调用对象，调用肯定不成功。
3. 类对象都是可被调用对象，类的实例对象是否可调用对象，取决于类是否定义了__call__方法。
对于函数、方法、lambda 函式、 类以及实现了 __call__ 方法的类实例, 它都返回 True。

9. chr(i) i -- 可以是10进制也可以是16进制的形式的数字。
   返回一个与acsii码对应的字符。

>>>print chr(0x30), chr(0x31), chr(0x61)   # 十六进制
0 1 a
>>> print chr(48), chr(49), chr(97)         # 十进制
0 1 a

10. classmethod()
    classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

class A():
    bar = 1
    def __init__(self):
        pass
    
    def func1(self):
        print("func1")
    
    @classmethod
    def foo(cls):
        print("this is foo ")
        print(cls.bar)
        cls().func1()  # 先实例化再调用

A.foo()

11. cmp(x, y) 比较x,y两个数值表达式，如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。
    Python 3.X 的版本中已经没有 cmp 函数，如果你需要实现比较功能，需要引入 operator 模块，适合任何对象，包含的方法有：

operator.lt(a, b)
operator.le(a, b)
operator.eq(a, b)
operator.ne(a, b)
operator.ge(a, b)
operator.gt(a, b)
operator.__lt__(a, b)
operator.__le__(a, b)
operator.__eq__(a, b)
operator.__ne__(a, b)
operator.__ge__(a, b)
operator.__gt__(a, b)

调用：
>>> import operator
>>> operator.eq(1,2)
False
>>> operator.__lt__(1,2)
True
>>> operator.__eq__(1,2)
False

12. compile()
    compile() 函数将一个字符串编译为字节代码。
    不详细介绍

13. complxe()
    complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。

>>> complex(1)    # 数字
(1 + 0j)
 
>>> complex("1")  # 当做字符串处理
(1 + 0j)
 
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
>>> complex("1+2j")
(1 + 2j)

14. delattr(object, name)
    删除对象中 name
    delattr(x, 'foobar') 相等于 del x.foobar。

15. dict() 函数用于创建一个字典。

16. dir([object])
    dir() # 获得当前模块的属性列表.
    dir([ ]) # 查看列表的方法.

17. divmod(x,y)
    返回一个包含商和余数的元组(a // b, a % b)。

>>> divmod(7,3)
(2, 1)
>>> a = divmod(7,3)
>>> a[0]
2
>>> a[1]

18. enumerate() 枚举

enumerate(sequence, [start=0])
第二个参数，默认枚举从0 开始.
用for in enumerate()的好处就是在 第二个参数上.

>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))       # 下标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

19. eval() 执行的是一个字符串表达式
    eval() 函数用来执行一个字符串表达式，并返回表达式的值。

eval(expression[, globals[, locals]])

>>> eval("1+2")
3
>>> eval("n+2")
4
>>> eval("n==6")
False
>>> eval("pow(2,3)")
8

20. execfile()
    execfile() 函数可以用来执行一个文件。

execfile(filename[, globals[, locals]])

21. file() 函数用于创建一个 file 对象，它有一个别名叫 open()，更形象一些，它们是内置函数。

>>>f = file('test.txt')
>>> f.read()
'RUNOOB1\nRUNOOB2\n'
>>>f.close()

22. filter() 筛选返回一个新列表
    filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

filter(function, iterable)

23. float() 转换成浮点数
    float() 函数用于将整数和字符串转换成浮点数。

24. formate() 格式化

25. frozenset() 不可变的集合
    set 值是不重复的.

>>> set('zxczxce')
set(['x', 'c', 'z', 'e'])
>>> frozenset('zxczxce')
frozenset(['x', 'c', 'z', 'e'])

26. hash() 用于获取一个对象（字符串或者数值等）的哈希值。
    hash() 函数可以应用于数字、字符串和对象，不能直接应用于 list、set、dictionary。

hash()用途:
如果程序（字符）在传输过程中被修改hash值即发生变化，如果没有被修改，则 hash 值和原始的 hash 值吻合

27. hex() 函数用于将10进制整数转换成16进制，以字符串形式表示。

>>> hex(10)
'0xa'
>>> type(hex(10))
<type 'str'>

28. id() 函数用于获取对象的内存地址。

29. issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。

issubclass(class, classinfo)

30. iter() 函数用来生成迭代器。

iter(object[, sentinel])

>>> x = lambda x: [x for x in range(x)]
>>> for i in iter(x(4)):
...     print(i)
...
0
1
2
3

31. globals(), locals()
    直接调用

locals()
globals()

32. long() 函数将数字或字符串转换为一个长整型。

class long(x, base=10) # 默认是十进制

33. map()

map(function, iterable, ...)
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

>>> x = lambda x: [x for x in range(x)]
>>> map(x,[2,3])
[[0, 1], [0, 1, 2]]

34. oct() 函数将一个整数转换成8进制字符串。

35. ord() 返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。

36. pow() 方法返回 xy（x的y次方） 的值。

37. property() 函数的作用是在新式类中返回属性值。

class property([fget[, fset[, fdel[, doc]]]])

##定义一个可控属性值 x
class C(object):
    def __init__(self):
        self._x = None
 
    def getx(self):
        return self._x
 
    def setx(self, value):
        self._x = value
 
    def delx(self):
        del self._x
 
    x = property(getx, setx, delx, "I'm the 'x' property.")

class Parrot(object):
    def __init__(self):
        self._voltage = 100000
 
    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

##property 的 getter,setter 和 deleter 方法同样可以用作装饰器：

class C(object):
    def __init__(self):
        self._x = None
 
    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x
 
    @x.setter
    def x(self, value):
        self._x = value
 
    @x.deleter
    def x(self):
        del self._x

38. range()

range(start=0, stop[, step])
参数说明：
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

39. reduce() 函数会对参数序列中元素进行累积。

reduce(function, iterable[, initializer])

>>> x = lambda x,y:x*y
>>> reduce(x,[2,3,4])
24
>>> x = lambda x,y:x+y
>>> reduce(x,[2,3,4])
9

40. reload() 用于重新载入之前载入的模块。

>>>import sys
>>> sys.getdefaultencoding()            # 当前默认编码
'ascii'
>>> reload(sys)                         # 使用 reload
<module 'sys' (built-in)>
>>> sys.setdefaultencoding('utf8')      # 设置编码
>>> sys.getdefaultencoding()
'utf8'
>>>

41. repr()
    repr() 函数将对象转化为供解释器读取的形式。即返回一个对象的字符串形式。

>>> repr(frozenset({1,2,3}))
'frozenset([1, 2, 3])'
>>> dict = {'x':1, 'y':2}
>>> dict
{'y': 2, 'x': 1}
>>> repr(dict)
"{'y': 2, 'x': 1}"

42. reverse() 函数用于反向列表中元素。

list.reverse()
该方法没有返回值，但是会对列表的元素进行反向排序。

43. round() 方法返回浮点数x的四舍五入值。

44. slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。
    不常用

45. sorted(iterable, cmp=None, key=None, reverse=False)

46. python staticmethod 返回函数的静态方法。
    该方法不强制要求传递参数，如下声明一个静态方法：

class C(object):
    @staticmethod
    def f(arg1, arg2, ...):
        ...

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class C(object):
    @staticmethod
    def f():
        print('runoob');
 
C.f();          # 静态方法无需实例化
cobj = C()
cobj.f()        # 也可以实例化后调用

47. unichr() 函数 和 chr()函数功能基本一样， 只不过是返回 unicode 的字符。

48. vars() 函数返回对象object的属性和属性值的字典对象。

vars([object])
返回对象object的属性和属性值的字典对象，
如果没有参数，就打印当前调用位置的属性和属性值 类似 locals()。

49. xrange()
    xrange() 函数用法与 range 完全相同，所不同的是生成的不是一个数组，而是一个生成器。

xrange则不会直接生成一个list，而是每次调用返回其中的一个值

>>> x = xrange(10)
>>> x
xrange(10)
>>> x[2]
2
>>> x[0]
0
>>> x[9]
9
>>> y = range(10)
>>> y
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

所以xrange做循环的性能比range好，尤其是返回很大的时候。尽量用xrange吧，除非你是要返回一个列表。

50. zip() 打包函数

zip([iterable, ...])

>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c)              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped)          # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]

51. import() 函数用于动态加载类和函数 。

如果一个模块经常变化就可以使用__import__()来动态载入。