最近准备系统的看一下python文档,并将看到的东西记一下,所以[读文档]可能将会成为一个系列。
目前基本看完了内建函数部分,后续会继续更新(pass标记表示还未更新内容)。

  1. abs(x)
    返回x的绝对值,x可以是一个int型、long型或者是float型.
  2. all(iterable)
    输入参数为一个可迭代对象,如果iterable中每一个元素都为True或者iterable是一个空的对象返回True,否则返回False. (New in version 2.5.)

    1
    2
    3
    4
    5
    def all(iterable):
    for element in iterable:
    if not element:
    return False
    return True
  3. any(iterable)
    如果参数iterable中有任一个值为True就返回True,否则返回False,如果iterable为空,返回False. (New in version 2.5.)

    1
    2
    3
    4
    5
    def any(iterable):
    for element in iterable:
    if element:
    return True
    return False
  4. basestring() 🏭
    basestring是str和unicode的超类,它不能被实例化或者被调用,但它可以用来检测一个对象是否是str或者unicode的实例,isinstance(obj,basestring)等价于isinstance(obj, (str, unicode)).

  5. bin(x) 🏭
    参数x是一个int型数字,结果返回x的二进制字符串.

    1
    2
    3
    4
    5
    In [5]: bin(1)
    Out[5]: '0b1'

    In [6]: bin(10)
    Out[6]: '0b1010'
  6. class bool([x]) 🏭
    bool型是int的字类,并且它不能再派生其他的任何子类,它有且仅有两个实例:True,False.
    x参数在经过真值判断之后返回True或者False.

  7. class bytearray([source[, encoding[, errors]]]) 🏭
    pass
  8. callable(object)
    如果object是一个可调用对象返回True,否则返回False(如果返回结果为True,不代表object()就一定能够成功,但是如果返回值是False,object()一定不会成功).这里要注意的是:类都是可调用对象(调用一个类,会返回这个类的一个实例),但是如果想要让类实例也是可调用对象则需要实现这个类call()方法.
  9. chr(i)
    参数i必须是一个0-255范围内的整型数字,返回一个字符串,该字符串的ASCII码恰好等于i.

    1
    2
    3
    4
    5
    6
    7
    8
    In [21]: chr(0)
    Out[21]: '\x00'

    In [22]: chr(97)
    Out[22]: 'a'

    In [23]: chr(98)
    Out[23]: 'b'
  10. classmethod(function) (装饰器) 🏅️
    classmethod接收一个类作为默认的第一个参数,就像一个实例方法默认第一个参数是实例本身.classmethod是一个装饰器. 类方法(class method)可以直接通过Date.gen_date(str)调用,或者通过类实例调用Date().gen_date(str).

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    class Date(object):
    def __init__(self,month,day,year):
    # 实例方法,self就是实例本身
    self.month = month
    self.day = day
    self.year = year

    @classmethod
    def gen_date(cls,str):
    # 类方法,cls就是Date类
    day, month, year = map(int, date_as_string.split('-'))
    date1 = cls(day, month, year)
    return date1
  11. cmp(x, y)
    比较x,y两个对象,根据比较的结果返回对应的值(如果x<y返回负值,如果x>y返回正值,如果x==y返回0)

  12. compile(source, filename, mode[, flags[, dont_inherit]])
    pass
  13. class complex([real[, imag]])
    pass
  14. delattr(object, name)
    参数是一个对象和一个字符串,delattr的作用就是删除对象object名字叫做name的属性.delattr(x, foo)等价于del x.foo.delattr是内建函数setattr的逆操作.
  15. 1
    2
    3
    class dict(**kwarg)
    class dict(mapping, **kwarg)
    class dict(iterable, **kwarg) 🏭

    pass

  16. dir([object])
    pass
  17. divmod(a, b)
    参数是两个数字,可以是int,long甚至float类型,返回值是两个数相除的商和余数.
  18. enumerate(sequence, start=0)
    参数sequence必须是一个序列、迭代器或者其他任何可迭代对象,返回值可以当作一个生成器对象,可以通过如下代码理解enumerate方法:

    1
    2
    3
    4
    5
    def enumerate(sequence, start=0):
    n = start
    for elem in sequence:
    yield n, elem
    n += 1
  19. eval(expression[, globals[, locals]])
    pass

  20. execfile(filename[, globals[, locals]])
    pass
  21. file(name[, mode[, buffering]])
    pass
  22. filter(function, iterable) 🏅️
    参数function是一个返回值为bool型的函数,iterable是一个可迭代对象.如果iterable是一个string或者tuple,最终返回值也会保留原来的类型,其他的类型最终返回值是list类型.
    可以这样理解filter:
    filter(function, iterable)等价于
    如果function不为None:[item for item in iterable if function(item)]
    如果function为None:[item for item in iterable if item]

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    In [7]: a = (1,2,3,4,5,6)
    In [8]: filter(lambda x:x>3,a)
    Out[8]: (4, 5, 6)

    In [11]: filter(lambda x:x=='l',a)
    Out[11]: 'lll'
    In [12]: a = [1,2,3,4,5,6]

    In [13]: filter(lambda x:x>3,a)
    Out[13]: [4, 5, 6]
    In [14]: a = [[],[1],[2],[]]

    In [15]: filter(None,a)
    Out[15]: [[1], [2]]
  23. class float([x]) 🏭
    参数x可以是一个数字或者字符串,返回对应的float型数字.

  24. format(value[, format_spec])
    pass
  25. class frozenset([iterable]) 🏭
    参数是一个可迭代对象,返回一个frozenset对象.
  26. getattr(object, name[, default])
    参数object为一个对象,name为一个string,结果返回object对象名为name的属性值,getattr(x,'foo')等价于x.foo.
  27. globals()
    pass
  28. hasattr(object, name)
    参数object为一个对象,name是一个string,如果object对象有名为name的属性返回True,否则返回False.它实际上是通过调用getattr(object,name)看是否会造成异常来判断的.
  29. hash(object)
    返回对象object的hash值,object对象必须是一个可哈希的类型,否则会报错.并且值相等的两个数字型对象的哈希值是一样的,不管这两个数字是int或者float.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    In [1]: hash(1)
    Out[1]: 1

    In [3]: a = [1]
    In [4]: hash(a)
    ---------------------------------------------------------------------------
    TypeError Traceback (most recent call last)
    <ipython-input-4-fe724719d9a1> in <module>()
    ----> 1 hash(a)
    TypeError: unhashable type: 'list'

    In [2]: hash(1) == hash(1.0000)
    Out[2]: True
  30. help([object])
    调用python内建的帮助系统,例如help(int) / help(str).

  31. hex(x) 🏭
    将一个整形数字变为一个以’0x’开头的小写16进制字符串.
    x可以是一个int或者long类型对象,如果不是的话这个对象需要实现__index__()方法,并返回一个整形数字.
  32. id(object)
    返回一个对象的唯一标识,在它的生命周期内.

    1
    2
    3
    4
    5
    In [9]: a
    Out[9]: [1]

    In [10]: id(a)
    Out[10]: 4411575760
  33. input([prompt])
    pass

  34. class int(x=0)
    class int(x, base=10) 🏭
    返回一个int对象,x可以是一个数字或者string.如果不指定x,返回0.
  35. isinstance(object, classinfo)
    如果对象object是类classinfo的一个实例或者是由classinfo派生类的实例,返回True否则返回False.需要注意的是classinfo可以是一个由多个类构成的元组,如果object是这个元组中某一个类的实例或者这些类中派生类的实例返回True,否则返回False.
  36. issubclass(class, classinfo)
    如果类class是classinfo的派生类,返回True,否则返回False.这里需要注意的是一个类可以被当作是它自己的子类。同样地,classinfo也可以是一个由多个类构成的元组,如果clas是这个元组中某个类的子类也会返回True.
  37. iter(o[, sentinel]) 🏅️
    返回值是一个迭代器对象。
    第二参数sentinel是否存在对第一个o有比较大的影响。如果第二个参数不存在,第一个参数o必须是一个集合对象(实现了__iter__()方法的对象)或者实现了__getitem__()方法的对象,并且取值参数必须是从0开始的整型,否则在使用iter函数的时候会有TypeError的异常。
    如果第二个参数存在,第一个参数o则必须是一个可调用对象,o这个可调用对象在被调用的时候会返回一个可迭代对象,每次对o的调用相当于执行o返回迭代器的next()方法,如果o的返回值和第二个参数值相同则会引发StopIteration异常,否则返回正常的值。举个例子🌰,逐行读取mydata.txt,当读到空白行的时候终止操作:

    1
    2
    3
    with open('mydata.txt') as fp:
    for line in iter(fp.readline, ''):
    process_line(line)
  38. len(s)
    返回一个对象的长度。参数可以是一个序列(string,bytes,tuple,list或者range)或者是一个集合(dict,set或者frozenset).

  39. class list([iterable]) 🏭
    返回一个list对象,参数是一个可迭代对象,最终返回的list对象中元素顺序和迭代器中元素的顺序保持一致。
  40. locals()
    pass
  41. class long(x=0) 🏭
    class long(x, base=10)
    返回值是一个长整型数字,参数可以是一个字符串或者数字。
  42. map(function, iterable, …) 🏅️
    将参数可迭代对象iterable中的每个元素都传入function函数中,返回值是每个元素经过function函数调用之后的返回值构成的列表。
    如果有多个可迭代对象传入,function函数也必须能够同时接受对应数量的参数。如果其中一个可迭代对象长度比较短,则会向function函数传入None作为替代。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    In [26]: def map_func(a,b):
    ...: return a+b
    ...:
    In [27]: a = [0,1,2,3,4]
    In [28]: b = [10,11,12,13,14]
    In [29]: map(map_func,a,b)
    Out[29]: [10, 12, 14, 16, 18]

    In [32]: a = [0,1,2,3,4,5,6,7]
    In [33]: b = [10,11,12,13,14]
    In [35]: def map_func(a,b):
    ...: return b,a
    ...:
    In [36]: map(map_func,a,b)
    Out[36]: [(10, 0), (11, 1), (12, 2), (13, 3), (14, 4), (None, 5), (None, 6), (None, 7)]
  43. max(iterable[, key])
    max(arg1, arg2, *args[, key])
    返回一个可迭代对象中最大的元素或者多个对象的最大一个,这里的key是一个接受一个参数的排序函数,类似于list.sort()中的排序函数。

  44. memoryview(obj) 🏭
    返回一个memoryview对象。
  45. 1
    2
    min(iterable[, key])
    min(arg1, arg2, *args[, key])

    返回一个可迭代对象中的最小值或者几个对象中的最小值。于max()使用方法类似。

  46. next(iterator[, default]) 🏅️
    取出参数迭代器iterator的下一个值,等价于iterator.next()。如果给定了default,在迭代器中没有剩余元素的时候返回default的值,否则引发StopIteration异常。
  47. class object
    返回一个普通的新式类对象。object是所有新式类的基类。
  48. oct(x)
    将一个整型数字转为八进制字符串。
  49. open(name[, mode[, buffering]]) 🏅️
    打开一个文件,返回一个文件对象。如果文件不能被打开,会引发IOError异常。通常情况下在打开文件的时候都使用open()而避免直接使用file的构造函数。
  50. ord(c)
    给定一个长度为1的string,返回一个整型。这个方法是chr()的逆操作。
  51. pow(x, y[, z])
    返回值x的y次方。如果给定了z,就相当于是pow(x,y)%z。
  52. print(*objects, sep=' ', end='\n', file=sys.stdout)
    pass
  53. class property([fget[, fset[, fdel[, doc]]]])
    pass
  54. range(stop)
    range(start, stop[, step])
    range能够十分方便地返回一个等差数列list,其中参数start缺省值为0,step缺省值是1.如果step是正值,返回的list就是一个递增数列,如果step为负值,返回的list就是一个递减数列。
  55. raw_input([prompt])
    如果参数prompt不为空,它会被写入标准输出并等待用户输入,并将用户输入值转为string并当作返回值。

    1
    2
    3
    4
    In [1]: s = raw_input('input something:')
    input something:ahhhhhhhhh
    In [2]: s
    Out[2]: 'ahhhhhhhhh'
  56. reduce(function, iterable[, initializer]) 🏅️
    关于reduce的解释直接使用文档中的代码好像更能解释清楚:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    def reduce(function, iterable, initializer=None):
    it = iter(iterable)
    if initializer is None:
    try:
    initializer = next(it)
    except StopIteration:
    raise TypeError('reduce() of empty sequence with no initial value')
    accum_value = initializer
    for x in it:
    accum_value = function(accum_value, x)
    return accum_value

    实例:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    In [1]: a = [1]
    In [2]: reduce(lambda x,y:x+y,a)
    Out[2]: 1
    In [3]: reduce(lambda x,y:x+y,a,1)
    Out[3]: 2

    In [4]: a = [1,2]
    In [5]: reduce(lambda x,y:x+y,a)
    Out[5]: 3
  57. reload(module)
    pass

  58. repr(object)
    返回一个对象的字符串形式。通常这个字符串可以用过eval()返回一个值等于object的对象。另外,通过__repr__()可以自定义repr()的返回内容。

    1
    2
    3
    4
    5
    6
    7
    8
    In [4]: a = [1,2]
    In [8]: b = repr(a)

    In [9]: eval(b) == a
    Out[9]: True

    In [10]: eval(b) is a
    Out[10]: False
  59. reversed(seq)
    返回一个逆序的迭代器。参数seq必须是一个实现了__reversed__()方法的对象或者实现了__len__()方法并且__getitem__()方法的参数必须是从0开始的整型.

  60. round(number[, ndigits])
    参数number是一个浮点型数字,ndigits缺省值是0,round的作用就是一个四舍五入的过程。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    In [18]: a = 1.554332

    In [19]: round(a)
    Out[19]: 2.0

    In [20]: round(a,1)
    Out[20]: 1.6

    In [21]: round(a,2)
    Out[21]: 1.55

    In [22]: round(a,3)
    Out[22]: 1.554
  61. class set([iterable]) 🏭
    返回一个set对象,参数iterable是一个可迭代对象。

  62. setattr(object, name, value)
    这个方法和getattr()是一对,参数object是一个对象,name是一个字符串,value可以是任意值。name可以是一个新的属性名或者是一个已经存在的属性名。setattr(x,'name',value)等价于x.name = value
  63. class slice(stop)
    class slice(start, stop[, step])
  64. sorted(iterable[, cmp[, key[, reverse]]]) 🏅️
    pass
  65. staticmethod(function)
    staticmethod是一个装饰器,用于装起类中的static method。它不需要一个隐式的第一个参数。例如:

    1
    2
    3
    4
    class C(object):
    @staticmethod
    def f(arg1, arg2, ...):
    ...

    在调用的时候可以直接使用C.f(*args)或者C().f(*args).

  66. class str(object=’’) 🏭
    返回一个string类型的对象。它和repr(object)有所不同,pass
  67. sum(iterable[, start])
    返回可迭代对象iterable中所有元素的和再加上start之后的结果。start缺省值是0.并且默认要求iterable中的元素一般都为数值型的,start不能是字符串类型。
  68. super(type[, object-or-type])
    pass
  69. tuple([iterable]) 🏭
    pass
  70. class type(object)
    class type(name, bases, dict)
    pass
  71. unichr(i)
    pass
  72. unicode(object=’’)
    unicode(object[, encoding[, errors]])
    pass
  73. vars([object])
    pass
  74. xrange(stop)
    xrange(start, stop[, step])
    pass
  75. zip([iterable, …])
    pass