Python常用内置函数-蒲公英云

Python 解释器内置了很多函数和类型，可以在任何时候使用它们。下面按字母表顺序列出它们。

abs(x)：

返回一个数（x）的绝对值，实参可以是整数或浮点数。如果实参是一个复数，返回它的模。

>>> abs(1)
1
>>> abs(-1)
1

all(iterable)：

如果iterable的所有元素为真（或迭代器为空），返回True。等价于：

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

可迭代对象：只要定义了__iter__()方法，我们就说该对象是可迭代对象，并且可迭代对象能提供迭代器。
迭代器：实现了__next__()或者next()(Python2)方法的称为迭代器，迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁，因此只占用固定的内存。
迭代：当我们使用一个循环来遍历某个东西时，这个过程本身就叫迭代。迭代器迭代的元素只能往前不能后退。

any(iterable):

如果iterable的任一元素为真则返回True。如果迭代器为空，返回False。等价于：

def any(iterable):
    for element in iterable:
        if element:
            return True
    return True

ascii(object)：

就像函数repr()，返回一个对象可打印的字符串，但是repr()返回的字符串中非ASCII编码的字符，会使用\x、\u、\U来转义。生成的字符串和Python2的repr()返回的结果相似。

bin(x)：

将一个整数转变为一个前缀为0b的二进制字符串。

>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'

class bool([x])：

返回一个布尔值，True或False。如果x是假的或者被省略，返回False；否则返回True。

>>> bool(1)
True
>>> bool(-1)
True
>>> bool(1 == 0)
False

callable(object)：

如果实参object是可调用的，返回True，否则返回False。返回真时调用仍可能失败，但返回假时调用必定失败。

delattr(object, name)：

setattr()相关的函数。实参是一个对象和一个字符串，该字符串必须是对象的某个属性。如果对象允许，该函数将删除指定的属性。

dir([object])：

如果没有实参，则返回当前本地作用域中的名称列表；如果有实参，它会尝试返回该对象的有效属性列表。

如果对象有一个名为__dir__()的方法，那么该方法将被调用，并且必须返回一个属性列表。

enumerate(iterable, start=0)：

返回一个枚举对象。iterable必须是一个序列，或iterable，或其他支持迭代的对象。enumerate()的迭代器的__next__()方法返回一个元组，里面包含一个计数值（从start开始，默认为0）和通过迭代iterable获得的值。

>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> for index, name in enumerate(L):
...     print(index, '-', name)
... 
0 - Adam
1 - Lisa
2 - Bart
3 - Paul

enumerate()函数把：

['Adam', 'Lisa', 'Bart', 'Paul']

变成了类似：

[(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]

filter(function, iterable)：

用iterable中函数function返回真的那些元素，构建一个新的迭代器。iterable可以是一个序列，一个支持迭代的容器，或一个迭代器。

filter(function, iterable)相当于一个生成器表达式，当function不是None的时候为(item for item in iterable if function(item))；function是None的时候为(item for item in iterable if item)

>>> l = [-3, 6, -5, -13, 2, 7]
>>> g = filter(lambda x: x > 0, l)
>>> list(g)
[6, 2, 7]

class float([x])：

返回从数字或字符串x生成的浮点数。如果实参是字符串，则它必须是包含十进制数字的字符串，字符串前面可以有符号，之前也可以有空格。

>>> float('+100')
100.0
>>> float('-1.111')
-1.111

getattr(object, name[, default])：

返回对象命名属性的值。name必须是字符串，如果该字符串是对象的属性之一，则返回该属性的值。

>>> l
[-3, 6, -5, -13, 2, 7]
>>> getattr(l,'__iter__')
<method-wrapper '__iter__' of list object at 0x7f212fa0e608>

globals()：

返回表示当前全局符号表的字典。这总是当前模块的字典（在函数或方法中，不是调用它的模块，而是定义它的模块）。

hasattr(object, name)：

该实参是一个对象和一个字符串。如果字符串是对象的属性之一的名称，则返回True，否则返回False。

>>> l
[-3, 6, -5, -13, 2, 7]
>>> hasattr(l,'__iter__')
True
>>> hasattr(l,'__callable__')
False

hash(object)：

返回该对象的哈希值，如果它有的话。哈希值是整数。

help([object])：

启动内置的帮助系统，主要在交互式中使用。类似shell中命令的-h或--help选项。

hex(x)：

将整数转换为以0x为前缀的小写十六进制字符串。如果x不是int对象，则必须定义返回整数的__index()方法。

>>> hex(166)
'0xa6'
>>> hex(-32)
'-0x20'

id(object)：

返回对象的“标识值”，该值是一个整数，在此对象的生命周期中保证是唯一且恒定。两个生命周期不重叠的对象可能具有相同的id()值。

input([prompt])：

如果存在prompt实参，则将其写入标准输出，末尾不带换行符。多在交互时使用。

>>> s = input('# ')
# Hello
>>> s
'Hello'

class int([x])：

返回一个使用数字或字符串x生成的整数对象，或者没有实参的时候返回0。

>>> int(12.34)
12
>>> int()
0

isinstance(object, classinfo)：

如果object实参是classinfo实参的实例，或者是子类的实例，则返回True。如果object不是给定类型的对象，函数始终返回False。

>>> class Person():
...     def __init__(self, name):
...         self.name = name
>>> zhangsan = Person('zhangsan')
>>> isinstance(zhangsan, Person)
True

issubclass(class, classinfo)：

如果class是classinfo的子类（直接、间接或虚拟的），则返回True。classinfo可以是类对象的元组，此时classinfo中的每个元素都会被检查。

iter(object[, sentinel])：

返回一个iterator对象。根据是否存在第二个实参，第一个实参的解释是非常不同的。如果没有第二个实参，object 必须是支持迭代协议（有__iter__()方法）的集合对象，或必须支持序列协议（有__getitem__()方法，且数字参数从 0 开始）。

class list([iterable])：

返回一个列表。list实际上是一种可变序列类型。

>>> a = list()
>>> a
[]
>>> a = list(range(1,6))
>>> a
[1, 2, 3, 4, 5]

locals()：

更新并返回表示当前本地符号表的字典。在函数代码块但不是类代码块中调用locals()时将返回自由变量。

map(function, iterable,…)：

返回一个将function应用于iterable中每一项并输出其结果的迭代器。如果传入额外的iterable参数，function必须接受相同个数的实参并被应用于从所有可迭代对象中并行获取的项。

>>> def f(x):
...     return x * x
>>> r = map(f,[1, 2, 3, 4, 5])
>>> list(r)
[1, 4, 9, 16, 25]

max(iterable, *[, key, default])：

返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的。

min(iterable, *[, key, default])：

返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。

next(iterable[,default])：

通过调用iterable的__next__()方法获取下一个元素。如果迭代器耗尽，则返回给定的default，如果没有默认值则触发StopIteration。

class object：

返回一个没有特征的新对象。object是所有类的基类，它具有所有python类实例的通用方法。

oct(x)：

将一个整数转变为一个前缀为0o的八进制字符串。结果是一个合法的python表达式。如果x不是python的int对象，那它需要定义__index__()方法返回一个整数。

>>> oct(8)
'0o10'
>>> oct(-55)
'-0o67'

open(file, mode=‘r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)：

打开file并返回对应的file object。如果文件不能打开，则触发OSError。

file是一个path-like object，表示将要打开的文件路径（绝对路径或相对路径）
mode是一个可选字符串，用于指定打开文件的模式。默认值是'r'
'r'     读取
'w'     写入，并先截断文件
'x'     排它性创建，如果文件已存在则失败
'a'     写入，如果文件存在则在末尾追加
'b'     二进制模式
't'     文本模式（默认）
'+'     更新磁盘文件（读取并写入）

默认的模式是’r’（打开并读取文件，同’rt’）。对于二进制写入，’w+b’模式打开并把文件截断成0字节；’r+b’则不会截断。

print(*objects, sep=’’, end=’\n’, file=sys.stdout, flush=False)：

将objects打印到file指定的文本流，以sep分隔并在末尾加上end。sep、end、file和flush如果存在，它们必须以关键字参数的形式给出。

class property(fget=None, fset=None, fdel=None, doc=None)：

返回property属性。fget是获取属性值得函数。fset是用于设置属性值的函数。fdel是用于删除属性值的函数。并且doc为属性对象创建文档字符串。

range(start,stop[,step])：

range实际上是一个不可变的序列类型。

>>> l = list(range(1,10,2))
>>> l
[1, 3, 5, 7, 9]

repr(object)：

返回包含一个对象的可打印表示形式的字符串。

reversed(seq)：

返回一个反向的iterator。seq必须具有一个__reversed__()方法的对象或支持该序列协议（具有从0开始的整数类型参数的__len__()方法和__getitem__()方法）。

round(number[,ndigits])：

返回number舍入到小数点后ndigits为精度的值，如果ndigits被省略或为None，则返回最接近输入值的整数。

>>> round(1.344, 2)
1.34
>>> round(-1.344213213, 3)
-1.344

class set([iterable])：

返回一个新的set对象，可以选择带有从iterable获取的元素。set是一个内置类型。

setattr(object, name, value)：

此函数与getattr()两相对应。其参数为一个对象、一个字符串和一个任意值。字符串指定一个现有属性或新增属性，函数会将值赋给该属性，只要对象允许该操作。例如，setattr(x, 'foobar', 123)等价于x.foobar = 123。

class slice(start, stop, [,step])：

返回一个表示由range(start, stop, step)所指定索引集的slice对象。其中start和stop参数默认为None。切片对象具有仅会返回对应参数值（或其默认值）的只读数据属性start，stop，和step。

>>> myslice = slice(5)
>>> myslice
slice(None, 5, None)
>>> L = list(range(1, 11)[myslice])
>>> L
[1, 2, 3, 4, 5]

sorted(iterable, *, key=None, reverse=False)：

根据iterable中的项返回一个新的已排序列表。具有两个可选参数，它们都必须指定为关键字参数。

key指定带有单个参数的函数，用于从iterable的每个元素中提取用于比较的键，默认值为None（直接比较元素）。

reverse为一个布尔值。如果设为True，则每个列表元素将按反向顺序比较进行排序。

>>> l = [3, -7, -12, 1, 15, -5, -32]
>>> sorted(l)
[-32, -12, -7, -5, 1, 3, 15]
>>> sorted(l, reverse=True)
[15, 3, 1, -5, -7, -12, -32]

sum(iterable[, start])：

从start开始自左向右对iterable中的项求和并返回总计值。start默认为0，iterable的项通常为数字，开始值不允许为字符串。

>>> l
[3, -7, -12, 1, 15, -5, -32]
>>> sum(l)
-37
>>> sum(l, 3)
-34
>>> sum(l, 6)
-31
>>> sum(l, 1)
-36

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

返回一个代理对象，它会将方法调用委托给type指定的父类或兄弟类。

super有两个典型用例。在具有单继承的类层级结构中，super可用来引用父类而不必显式地指定它们的名称，从而令代码更易维护。第二个用例是在动态执行环境中支持协作多重继承，此用例为python所独有。

tuple([iterable])：

tuple实际上是一个不可变的序列类型。它用于创建一个元组。

>>> l
[3, -7, -12, 1, 15, -5, -32]
>>> tuple(l)
(3, -7, -12, 1, 15, -5, -32)

class type(name, bases, dict)：

传入一个参数时，返回object的类型。返回值是一个type对象。传入三个参数时，返回一个新的type对象。

vars([object])：

返回模块、类、实例或任何其它具有__dict__属性的对象的__dict__属性。

不带参数时，vars()的行为类似locals()。需要注意的是，locals字典仅对读取起作用，对locals字典的更新会被忽略。

zip(*iterables)：

创建一个聚合了来自每个可迭代对象中的元素的迭代器。返回一个元组的迭代器，其中的第i个元组包含来自每个参数序列或可迭代对象的第i个元素。

L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> for index, name in zip(range(1, len(L) + 1), L):
...     print (index, '-', name)
... 
1 - Adam
2 - Lisa
3 - Bart
4 - Paul