python内置函数【A-C】

内置函数

abs（x ）

返回一个数字的绝对值。参数可能是整数或浮点数。如果参数是一个复数，则返回其大小。

In [33]: abs(-1)Out[33]: 1

all（iterable）

如果的所有元素迭代是真实的（或者如果可迭代为空）返回True。相当于：

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

In [30]: all([1,2,3])Out[30]: TrueIn [31]: all([1,2,False])Out[31]: FalseIn [32]: all([])Out[32]: True

ascii(object)

这个函数跟repr()函数一样，返回一个可打印的对象字符串方式表示。当遇到非ASCII码时，就会输出\x，\u或\U等字符来表示。与Python 2版本里的repr()是等效的函数。

In [34]: print(ascii(10), ascii(9000000), ascii('b\31'), ascii('0x\1000'))10 9000000 'b\x19' '0x@0'In [35]: type(ascii(10))Out[35]: str

bin（x ）

将整数转换为以“0b”为前缀的二进制字符串。结果是一个有效的Python表达式。

In [36]: bin(3)Out[36]: '0b11'In [37]: type(bin(3))Out[37]: strIn [38]: bin(-10)Out[38]: '-0b1010'In [39]: type(bin(-10))Out[39]: str

bool（[ x ] ）

返回一个布尔值，即一个True或False。 如果x为假或者省略，则返回False; 否则返回True。
bool类是int类的子类。

In [40]: bool()Out[40]: FalseIn [41]: bool([])Out[41]: FalseIn [42]: bool([1,2])Out[42]: TrueIn [43]: bool(1)Out[43]: TrueIn [44]: bool(0)Out[44]: False

bytearray([source [, encoding [, errors]]])

A bytearray与普通的python字符串非常相似（str在python2.x中，bytes在python3中），但有一个重要的区别，而字符串是不可变的，bytearrays是可变的，有点像list单个字符串。

这是有用的，因为一些应用程序使用不可变字符串执行较差的字节序列。如果在数据库引擎或图像库中，在大块内存中进行大量小改动，则字符串性能会很差;
因为你必须复制整个（可能是大的）字符串。 bytearray它的优点是可以在不复制记忆的情况下做出这种改变。

但是这个特例实际上更多的是例外，而不是规则。大多数用途涉及比较字符串或字符串格式。对于后者，无论如何通常都有一个副本，所以可变类型不会提供任何优势。对于前者，由于不可变的字符串不能更改，因此可以计算一个hash字符串，并将其作为比较每个字节顺序的快捷方式，这几乎总是一个很大的胜利;
所以它是不可变的类型（str或bytes），这是默认的; 并且bytearray是例外，当你需要它的特殊功能。

中文说明：

bytearray([source [, encoding [, errors]]])返回一个byte数组。Bytearray类型是一个可变的序列，并且序列中的元素的取值范围为 [0 ,255]。

参数source:

如果source为整数，则返回一个长度为source的初始化数组；

如果source为字符串，则按照指定的encoding将字符串转换为字节序列；

如果source为可迭代类型，则元素必须为[0 ,255]中的整数；

如果source为与buffer接口一致的对象，则此对象也可以被用于初始化bytearray.。

版本：在python2.6后新引入，在python3中同样可以使用！

In [45]: bytearray()Out[45]: bytearray(b'')In [46]: a = bytearray(3)In [47]: aOut[47]: bytearray(b'\x00\x00\x00')In [48]: a[0]Out[48]: 0In [49]: a[1]Out[49]: 0In [50]: a[2]Out[50]: 0In [51]: b = bytearray("abc")---------------------------------------------------------------------------TypeError                                 Traceback (most recent call last)<ipython-input-51-f477c68d28a2> in <module>()----> 1 b = bytearray("abc")TypeError: string argument without an encodingIn [52]: b = bytearray("abc", encoding='utf-8')In [53]: bOut[53]: bytearray(b'abc')In [54]: b[0]Out[54]: 97In [55]: b[1]Out[55]: 98In [56]: b[2]Out[56]: 99In [57]: c = bytearray([1,2,3])In [58]: c[0]Out[58]: 1In [59]: c[1]Out[59]: 2In [60]: c[2]Out[60]: 3In [61]: d = bytearray(buffer("abc"))---------------------------------------------------------------------------NameError                                 Traceback (most recent call last)<ipython-input-61-40665c074d88> in <module>()----> 1 d = bytearray(buffer("abc"))NameError: name 'buffer' is not defined

bytes([source[, encoding[, errors]]])

返回一个“bytes”对象, 是一个范围在0 <= x < 256的一个不变的整数序列。bytes 是一个不可变版本的 bytearray – 它具有相同的非变异方法和相同的索引和切片行为。
bytes和bytearray

Python 3 特有的，Python2是不区分bytes和str。

bytes是不可变的。

Python 2 中：

type(b'xxxx')<type 'str'>>>> type('xxxx')<type 'str'>

Python 3 中：

In [1]: type(b'xxxx')Out[1]: bytesIn [3]: type('xxxx')Out[3]: str

bytes 和 str 的区别在于，bytes是byte的序列，而str是unicode的序列。
str可使用encode的方法转化为bytes。
bytes使用decode的方法转化为str。

(默认的encode和decode的编码方式为utf-8）。

In [4]: s = '于龙君'In [5]: b = s.encode()In [6]: bOut[6]: b'\xe4\xba\x8e\xe9\xbe\x99\xe5\x90\x9b'In [7]: b.decode()Out[7]: '于龙君'In [8]: for x in s: ...:     print(x) ...: 于龙君In [9]: for x in b: ...:     print(x) ...: 228186142233190153229144155

bytearray和bytes不一样的地方在于，bytearray是可变的。

In [10]: s = '于龙君'In [11]: ba = bytearray(s.encode())In [12]: baOut[12]: bytearray(b'\xe4\xba\x8e\xe9\xbe\x99\xe5\x90\x9b')In [13]: ba.decode()Out[13]: '于龙君'In [14]: ba[:3] = bytearray('王'.encode())In [15]: baOut[16]: bytearray(b'\xe7\x8e\x8b\xe9\xbe\x99\xe5\x90\x9b')In [17]: ba.decode()Out[17]: '王龙君'

callable(object)

中文说明：检查对象object是否可调用。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。

注意：类是可调用的，而类的实例实现了__call__()方法才可调用。

版本：该函数在python2.x版本中都可用。但是在python3.0版本中被移除，而在python3.2以后版本中被重新添加。

In [15]: callable(0)Out[15]: FalseIn [16]: callable("my_string")Out[16]: FalseIn [17]: def add(a,b):    ...:     return a+b    ...:In [18]: callable(add)Out[18]: TrueIn [19]: class A:    ...:     def method(self):    ...:         return 0    ...:In [20]: callable(A)Out[20]: TrueIn [21]: a = A()In [23]: callable(a)Out[23]: FalseIn [24]: class B():    ...:     def __call__(self):    ...:         return 0    ...:In [25]: callable(B)Out[25]: TrueIn [27]: b = B()In [28]: callable(b)Out[28]: True

cmp（x，y ）(python3去除)

中文说明：比较两个对象x和y，如果x < y ,返回负数；x == y, 返回0；x > y,返回正数。
版本：该函数只有在python2中可用，而且在python2所有版本中都可用。但是在python3中该函数已经被删减掉，这点要特别注意。

Python 2.7.14 (v2.7.14:84471935ed, Sep 16 2017, 20:25:58) [MSC v.1500 64 bit (AMD64)] on win32Type "help", "copyright", "credits" or "license" for more information.>>> cmp(1,2)-1>>> exit()Python 3.6.3 (v3.6.3:2c5fed8, Oct  3 2017, 18:11:49) [MSC v.1900 64 bit (AMD64)] on win32Type "help", "copyright", "credits" or "license" for more information.>>> cmp(1,2)Traceback (most recent call last):  File "<stdin>", line 1, in <module>NameError: name 'cmp' is not defined>>>

compile(source, filename, mode[, flags[, dont_inherit]])

中文说明：将source编译为代码或者AST对象。代码对象能够通过exec语句来执行或者eval()进行求值。
参数source：字符串或者AST（Abstract Syntax Trees）对象。
参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
参数model：指定编译代码的种类。可以指定为 ‘exec’,’eval’,’single’。
参数flag和dont_inherit：这两个参数暂不介绍，可选参数。

版本：在python2.3、2.6、2.7、3.2中均有不同，使用时要引起注意，兼容python3

>>> code = "for i in range(0, 10): print(i)">>> code = compile(code, '', 'exec')>>> exec(code)0123456789>>> str = "3 * 4 + 5">>> a = compile(str,'','eval')>>> eval(a)17>>>

complex([real[, imag]])

中文说明：
创建一个值为real + imag * j的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。
参数real: int, long, float或字符串；
参数imag: int, long, float。

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

替换cmp的新函数

>>> import operator>>> a ,b = 0,1>>> operator.lt(a,b)True>>> operator.le(a,b)True>>> operator.eq(a,b)False>>> operator.ne(a,b)True>>> operator.ge(a,b)False>>> operator.gt(a,b)False>>>operator.__lt__(a, b) operator.__le__(a, b) operator.__eq__(a, b) operator.__ne__(a, b) operator.__ge__(a, b) operator.__gt__(a, b) lt(a, b) 相当于 a < ble(a,b) 相当于 a <= beq(a,b) 相当于 a == bne(a,b) 相当于 a != bgt(a,b) 相当于 a > bge(a, b)相当于 a>= b