Python3中的内置函数（1）

abs(x)

返回数字x的绝对值，如果x是一个复数，则返回该复数的模

>>> abs(2.5)
2.5
>>> abs(-4.7)
4.7
>>> abs(True)
1
>>> abs(False)
0
>>> abs(3 + 4j)
5.0

pow(x, y[, z])

返回x的y次幂的值。若指定了第三个参数，则返回x的y次幂对z取模的结果。

除非前两个参数都是整数，否则，不能指定第三个参数.

>>> pow(2, 3)
8
>>> pow(2, 3, 5)
3
>>> pow(4, 1.5)
8.0
>>> pow(4, -1.5)
0.125
>>> pow(-4, 2, 5)
1
>>> pow(-3, 3, 5)
3
>>> pow(-3, 1.5, 5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: pow() 3rd argument not allowed unless all arguments are integers

all(iterableObj)

判断给定的可迭代对象中的每一个元素是否都为True，若是，返回True，否则返回False。

>>> all([0, 1, 2, 3])
False
>>> all([1, 2, 3])
True
>>> all(range(5, 2))
True

注意，当可迭代对象iterableObj为空时，该函数的返回值将为True。

>>> all(b'')
True
>>> all('')
True

any(iterableObj)

判断给定的可迭代对象中的每一个元素是否都为False，若是，则返回False，否则返回True。

>>> any([0, False, None, ''])
False
>>> any([0, False, None, True])
True

ascii(obj)

返回一个仅由ascii字符组成的用来表示给定对象的字符串。

与repr函数的作用类似，但是会使用\x、\\U、\\u对repr()返回的字符串中的非ascii字符进行转义。

>>> ascii('x010')
16
>>> ascii('我喜欢Python')
"'\\u6211\\u559c\\u6b22Python'"

bin(n)

返回一个整数的二进制表示形式的字符串。参数n必须是int类型

>>> bin(4)
'0b100'
>>> bin(0x09)
'0b1001'

oct(n)

返回一个整数的八进制表示形式的字符串。参数n必须是int类型

>>> oct(10)
'0o12'
>>> oct(0x10)
'0o20'

hex(n)

返回一个整数的十六进制表示形式的字符串。参数n必须是int类型

>>> hex(10)
'0xa'
>>> hex(16)
'0x10'

int(x, base=10)

将给定的数字类型或字符串类型的参数x转化为十进制整数。

如果未指定任何参数，则返回整数0，如果x是一个浮点数，则返回这个浮点数的整数部分。

当位置参数 x 是一个数字时，不能显示指定默认参数 base 的值，否则会引发 TypeError 异常。

如果x不是一个数字或者显示指定了base参数，那么x必须是一个表示*base*进制整数字面量的字符串、bytes或bytearray对象。这个整数字面量可以有一个+或-作为前缀并且可以被空格包围。

base的默认值是10，允许的取值范围为[0, 2-36]。若 base 取 0，则表示从 x 的字面量推断其进制。例如， '0x24' 会被当作一个表示十六进制整数的字符串，b'0b101' 会被当作一个表示2进制整数的字节字符串，而对于字符串 'c2'，由于无法根据其字面量推断其进制，则会引发 ValueError 异常。

>>> int()  # 未指定任何参数时将返回0
0
>>> int(7.6)  # 截取整数部分
7
>>> int(-1.7)  # 截取整数部分
-1
>>> int(0x16)  # 将16进制整数转为10进制整数
22
>>> int('  -0x25 ', base=16)  # 表示16进制整数的字符串字面量，前面和后面带有空格
-37
>>> int(b'0b111')  # 将表示2进制整数的字节字符串转为十进制整数
7
>>> int('12')  # 将表示十进制整数的字符串转为十进制整数
12
>>> int('15', base=8)  # 将表示8进制整数的字符串转为10进制整数
13
>>> int('0x24', base=16)  # 将表示16进制整数的字符串转为10进制整数
36
>>> int('11', base=0)  # 由其字面量推断其进制为10进制，等价于 int('11')
11
>>> int('0xe2', base=0)  # 由其字面量推断其进制为16进制，等价于 int('0xe2', base=16)
226
>>> int('0b101', base=0)  # 由其字面量推断其进制为2进制，等价于 int('0b101', base=2)
5
>>> int('0o777', base=0)  # 由其字面量推断其进制为8进制，等价于 int('0o777', base=8)
511
>>> int('c2', base=16)  # ‘c2’看起来不像一个有效的16进制数，但是仍然可以通过指定进制来进行转换
194
>>> int('c2', base=0) # 由于无法根据其字面量推断其进制，所以引发异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 0: 'c2'
>>> int(24, base=10)  # 当第一个参数是数字时，显示指定默认参数的值将会引发异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: int() can't convert non-string with explicit base

bool([x])

用于将给定的参数x转换为布尔类型，如果没有指定参数，则返回False。

>>> bool(0)
False
>>> bool(1)
True
>>> bool('')
False
>>> bool(b'')
False
>>> bool(None)
False```

***`chr(n)`***

指定一个表示Unicode字符代码点的整数，返回这个整数代表的Unicode字符。其中，0 <= n <= 0x10ffff。

```python
>>> chr(97)
a
>>> chr(126)
'~'
>>> chr(992)
'Ϡ'
>>> chr(9999)
'✏'

ord(char)

指定一个表示单个Unicode字符的字符串，返回表示这个字符的Unicode代码点的整数。

>>> ord('~')
126
>>> ord('\U0010ffff')
111411
>>> ord('Ϡ')
992
>>> ord('✏')
9999

callable(obj)

如果 obj 是可调用的，返回 True，否则返回 False。即使返回 True，调用仍然可能会失败；但如果返回假，则调用肯定会失败。注意类是可调用的（调用类会返回一个新的实例）。如果实例的类有 __call__() 方法，则它是可调用的。

>>>callable(0)
False
>>> callable("list()")
False
>>> callable(sum)             # 函数返回 True
True
>>> class A:                  # 未实现__call__方法的类
...     def method(self):
...             return 0
... 
>>> callable(A)               # 类返回 True
True
>>> a = A()
>>> callable(a)               # 由于类A未实现 __call__方法,故而其实例是不可调用的
False
>>> class B:                  # 实现了__call__方法的类
...     def __call__(self):
...             return 0
... 
>>> callable(B)
True
>>> b = B()
>>> callable(b)               # 由于类B实现 __call__方法,故而其实例是可调用的
True

classmethod(function)

将类中的一个方法转化为类方法。

class Test:
    def func1(cls):
        print('this is a class method')
    
    func1 = classmethod(func1)
    

Test.func1()

# 以下为输出
# 'this is a class method'

但更一般的用法是将其作为一个装饰器：

class Test:
    @classmethod
    def func1(cls):
        print('this is a class method')
        

Test.func1()

# 以下为输出
# 'this is a class method'

staticmethod(function)

将类中的一个方法转化为静态方法。

class Test:
    def func1(cls):
        print('this is a static method')
    
    func1 = staticmethod(func1)
    

Test.func1()

# 以下为输出
# 'this is a static method'

但更一般的用法是将其作为一个方法装饰器。

class Test:
    @staticmethod
    def func1(cls):
        print('this is a static method')
        

Test.func1()

# 以下为输出
# 'this is a static method'

两种使用方法的效果是一样的。

delattr(obj, attr)

删除给定对象obj的attr的属性。 其中参数attr必须是一个字符串类型，代表对象obj的某个属性的名称。

若对象obj不存在名称为attr的属性，则抛出AttributeError异常。

若attr不是字符串类型，则抛出TypeError异常。

>>> class Foo:
...     var1 = 'a class variable'
...     @classmethod
...     def cls_meth(cls):
...         print('a class method')
...     def __init__(self, name):
...         self.name = name
... 
>>> Foo.var1
'a class variable'
>>> delattr(Foo, 'var1')  # 删除类Foo的var1属性
>>> Foo.var1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: type object 'Foo' has no attribute 'var1'
>>> Foo.cls_meth()
a class method
>>> delattr(Foo, 'cls_meth')  # 删除类Foo的cls_meth方法
>>> Foo.cls_meth()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: type object 'Foo' has no attribute 'cls_meth'
>>> foo = Foo('bob')
>>> foo.name
'bob'
>>> delattr(foo, 'name')  # 删除类Foo的实例对象foo的name属性
>>> foo.name
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Foo' object has no attribute 'name'

getattr(obj, attr, default=None)

获取对象obj的名为attr的属性。其中attr必须是字符串类型，表示对象obj的某个属性的名称。

若提供了default参数，则default参数的值将作为对象obj不存在名为attr的属性时，该方法的返回值；

若未提供default参数，并且对象obj不存在名为attr的属性，则抛出AttributeError异常。

>>> class Foo:
...     bar = 1
... 
>>> getattr(Foo, 'bar')
1
>>> getattr(Foo, 'foo')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: type object 'Foo' has no attribute 'foo'
>>> getattr(Foo, 'foo', 'hello')
'hello'
>>> getattr(Foo, 'bar', 'hello')
1

setattr(obj, attr, value)

为给定的对象obj绑定一个属性attr，并将其值设置为value；或者将给定的对象obj的属性attr的值设置为value。其中attr必须是字符串类型，表示对象obj的某个属性的名称，value可以是一个具体的值，也可以是一个函数、类或者某个类的实例。并且，通过这种动态绑定的方式设置的属性是支持继承的。

若对象obj已存在名称为attr的属性，则将其属性attr的值设置为value；

若对象obj不存在名称为attr的属性，则为其绑定一个名为attr的属性，并将值设置为value；

>>> class Person:
...     def __init__(self, name):
...         self.name = name
... 
>>> bob = Person('bob')
>>> setattr(bob, 'age', 16)  # 给bob动态绑定一个属性age
>>> bob.age
16
>>> def capitalize_name(self):
...     return self.name.capitalize()
... 
>>> setattr(Person, 'capitalize_name', capitalize_name)  # 给Person类动态绑定一个实例方法
>>> bob.capitalize_name()
'Bob'
>>> class Student(Person):
...     def __init__(self, s_name, s_age):
...         super().__init__(s_name)
...         self.age = s_age
... 
>>> stu1 = Student('tim', 16)
>>> stu1.capitalize_name()  # 调用上面给Person类动态绑定的实例方法
'Tim'

hasattr(obj, attr)

判断给定的对象obj是否存在属性attr。 其中参数attr必须是字符串类型，表示属性名称。

>>> hasattr(Foo, 'name')
True
>>> hasattr(Foo, 'age')
False

len(obj)

返回数据对象（字符串、列表、元组等）内的项目个数。

该方法其实是调用给定对象obj的__len__魔术方法来进行计算的，所以，只要是实现了__len__方法的类的实例对象均可使用该方法。

>>> len('abcd')
4
>>> len(list('hello'))
5
>>> class Data:
...     def __init__(self, data):
...         self.data = data
...     def __len__(self):
...         count = 0
...         for i in self.data:
...             count += 1
...         return count
... 
>>> d = Data('abcd')
>>> len(d)
4

min(iterable, *[, default=obj, key=func])

min(arg1, arg2, *arg[, key=func])

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

如果只指定了一个位置参数，则这个参数必须是一个可迭代对象，返回值为这个可迭代对象中最小的一个元素。如果指定了两个或者两个以上的位置参数，则返回这些位置参数中最小的一个。

有两个可选的仅限关键字参数key和default，其中key可以是一个单参数函数，default是当可迭代对象为空时的返回值。

若给定的可迭代对象或多个参数中有多个相同的最小值，则返回第一个。

注意：

1. 指定的可迭代对象中的每一个元素或者多个位置参数必须均可与其他元素比较大小，否则将抛出TypeError异常。
2. 若指定的可迭代对象为空，且未指定可选关键字参数default，则抛出ValueError异常。

>>> min(1, 4, -3, 5)
-3
>>> min('abcde')
'a'
>>> min([9, 8, 7, 6], key=lambda x: x % 5)
6
>>> min([], key=lambda x: x % 5, default=0)
0
>>> min([12, 9, 8, 7], key=lambda x: x % 5)  # 由于12和7对5取余的结果都是2，但是12排在前面，所以返回12
12
>>> min('a', 35, b'hello')  # 给出的元素之间不能比较大小
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'int' and 'str'
>>> min([])  # 指定了一个空列表但是未指定可选的default关键字参数
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: min() arg is an empty sequence

max(iterable, *[, key=func, default=obj])

max(arg1, arg2, *arg[, key=func])

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

如果只指定了一个位置参数，则这个参数必须是一个可迭代对象，返回值为这个可迭代对象中最大的一个元素。如果指定了两个或者两个以上的位置参数，则返回这些位置参数中最大的一个。

有两个可选的仅限关键字参数key和default，其中key可以是一个单参数函数，default是当可迭代对象为空时的返回值。

若给定的可迭代对象或多个参数中有多个相同的最大值，则返回第一个。

注意：

1. 指定的可迭代对象中的每一个元素或者多个位置参数必须均可与其他元素比较大小，否则将抛出TypeError异常。
2. 若指定的可迭代对象为空，且未指定可选关键字参数default，则抛出ValueError异常。

>>> max(1, 4, -3, 5)
5
>>> max('abcde')
'e'
>>> max([9, 8, 7, 6], key=lambda x: x % 5)
9
>>> max([], key=lambda x: x % 5, default=0)
0
>>> max([14, 10, 9, 7], key=lambda x: x % 5)  # 由于14和9对5取余的结果都是4，但是14排在前面，所以返回14
14
>>> max('a', 35, b'hello')  # 给出的元素之间不能比较大小
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '>' not supported between instances of 'int' and 'str'
>>> max([])  # 指定了一个空列表但是未指定可选的default关键字参数
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: max() arg is an empty sequence

id(obj)

获取给定对象obj的内存地址

>>> id(str)
4468605024
>>> id('a')
4471358272
>>> class Foo: pass
... 
>>> id(Foo)
140707344948120

sum(iterable_obj, start=0)

返回给定的可迭代对象中所有元素之和再加上初始值。其中，默认的初始值为0，并且可迭代对象中的每个元素必须都是数值。

>>> sum([1, 2, 3, 4])
10
>>> sum((1, 2, 3, ))
6
>>> sum([1, 2, 3, 4], 5)
15
>>> def number_generator(n):
...     while n > 0:
...         yield n
...         n -= 1
... 
>>> sum(number_generator(5))
15

该函数一般用来计算一个序列中元素的和，但是也可以做一些有趣的事情，例如下面的例子中，将一个多维列表扁平化处理成一个一维的列表：

>>> nested_list = [list(range(i)) for i in [4, 5, 6]]
>>> nested_list
[[0, 1, 2, 3], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4, 5]]
>>> sum(nested_list, [])
[0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5]

range(stop)

range(start, stop[, step])

根据给定的初始值，结束值和步长，返回一个可迭代对象。

默认的初始值为0;

若只指定一个参数，则将被解释为结束值；

若指定两个参数，则依次解释为初始值和结束值；结束值必须大于等于初始值，否则返回长度为0的可迭代对象；

若指定三个参数，则依次解释为初始值、结束值和步长；若结束值小于等于初始值且步长为正数或结束值大于等于初始值且步长为负数，则返回长度为0的可迭代对象。 step 参数必须是不为0的整数。

若返回的可迭代对象长度不为0，则可迭代对象中包含初始值但是不包含结束值。

>>> [i for i in range(5)]
[0, 1, 2, 3, 4]
>>> [i for i in range(1, 5)]
[1, 2, 3, 4]
>>> [i for i in range(1, 10, 2)]
[1, 3, 5, 7, 9]
>>> [i for i in range(10, -4, -3)]
[10, 7, 4, 1, -2]
>>> [i for i in range(10, 5)]
[]
>>> [i for i in range(10, 5, 1)]
[]
>>> [i for i in range(4, 9, -1)]
[]

enumerate(sequence, start=0)

将一个可迭代的数据对象（如list、tuple或str）组合成一个索引序列，这个索引序列的每一个元素均是一个二元组，二元组中包含数据索引和数据，索引默认从0开始，可以通过 start 参数指定索引的起始值。

>>> e = enumerate('abcde')
>>> e
<enumerate object at 0x10a88a6c0>
>>> for i in e:
...     print(i)
... 
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(4, 'e')
>>> e1 = enumerate('ghijk', start=1)
>>> for index, data in e1:
...     print('the index of "{0}" is {1}'.format(data, index))
... 
the index of "g" is 1
the index of "h" is 2
the index of "i" is 3
the index of "j" is 4
the index of "k" is 5

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

将给定的可迭代对象 iterable 中的元素进行排序并返回由这些元素组成的已排序的列表。

可选的关键字参数 key 可以指定为带有单个参数的函数，用于从可迭代对象中提取出用于比较的键（例如，str.lower）。默认值为 None，表示直接比较可迭代对象中的元素；

可选的关键字参数reversed用于指定排序为升序或降序，其值必须是一个布尔值。如果为 True，则为降序，如果为 False，则为升序。默认值为 False，表示升序。

注意：

该方法的排序结果是稳定的，也就是说，如果序列中的多个元素有相同的键，那么排序结果将保留这些元素的原有顺序。

>>> emp_info = [ {'name': 'Bob', 'salary': 8000}, {'name': 'Tim', 'salary': 7500}, {'name': 'Christina', 'salary': 9500}]
>>> sorted(emp_info, key=lambda e: e['salary'])
[{'name': 'Tim', 'salary': 7500}, {'name': 'Bob', 'salary': 8000}, {'name': 'Christina', 'salary': 9500}]
>>> sorted(emp_info, key=lambda e: e['salary'], reverse=True)
[{'name': 'Christina', 'salary': 9500}, {'name': 'Bob', 'salary': 8000}, {'name': 'Tim', 'salary': 7500}]

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

将 source 编译成代码或 AST 对象，并且生成的代码可以被 eval 函数或者 exec 函数执行。

source 可以是表示Python模块、表达式或者语句的常规字符串或者字节字符串。

filename 参数指定读取代码的文件，如果不需要从文件中读取代码，那么可以传入可辨识的值，用于运行时的错误消息。

mode 参数指定编译时使用的模式。如果 source 是单一表达式，那么应该指定为 eval，如果 source 是单个交互式语句，那么应该指定为 single，如果 source 是语句序列或者模块，那么应该指定为 exec。

可选的 flags 参数将决定编译过程中要启用哪些可选功能（与 __feature__ 模块相关，可以使用该模块中定义的按位或标志来指定这些功能）。如果未指定 flags 参数或将其设为0，则使用当前有效的任意功能来编译。如果提供了 flags 参数，则将指定的功能添加到那些已有效的功能中。如果设置了 dont_inherit 参数，则只启用 flags 参数中指定的那些功能（其他已启用的功能将会被忽略）

optimize 参数用来指定编译器的优化级别。默认值 -1 表示选择与解释器的 -O 选项相同的优化级别。也可显式指定为级别为 0 （没有优化；__debug__为真）、1 （断言被删除， __debug__ 为假）或 2 （文档字符串也被删除）。

>>> func_str = """
... def nums(n):
...     while n > 0:
...         print(n)
...         n -= 1
... nums(5)
... """
>>> func = compile(func_str, '<string>', 'exec')
>>> func
<code object <module> at 0x100d7edb0, file "<string>", line 2>
>>> exec(func)
5
4
3
2
1

eval(source, globals=None, locals=None)

该方法用来解析和执行表示Python表达式的字符串或者表示 compile() 函数返回值的代码对象。

位置参数 source 参数必须是一个字符串或者一个代码对象。如果该参数是一个字符串，那么这个字符串只能是一个单一的表达式。

globals 参数必须是一个字典，locals 参数可以是任何映射对象。这两个参数用来提供解析和执行 source 时的全局和本地命名空间。如果提供了 globals 参数但是不包含键为 __builtins__ 的项，则会在解析 source 之前插入以 __builtins__ 为键的对内置模块 builtins 的字典的引用。如果未提供 locals 参数，则其默认值将会取 globals 的值。如果 globols 参数和 locals 参数都未提供，那么 source 将会在该方法被调用的环境中执行，返回值为 source 执行的结果。如果 source 中有语法错误，那么将引发异常。

注意：如果 source 是代码对象，并且编译该对象时的 mode 参数的值是 exec，那么 eval() 方法的返回值将为 None。

>>> eval('5 * 6')
30
>>> eval("print('{} is {} years old'.format(name, age))", {'name': 'bob', 'age': 16})
bob is 16 years old
>>> c = compile('int("5")', '<string>', 'eval')  # compile()方法的mode参数是eval或single时，使用eval执行得到的代码对象的返回值不是None
>>> result = eval(c)  # eval 方法的返回值不为空
>>> print(result)
5 
>>> c = compile('int("5")', '<string>', 'exec')
>>> result = eval(c)  # eval 方法的返回值为空
>>> print(result)
None

exec(source, globals=None, locals=None)

这个函数支持动态执行 Python 代码。source 参数必须是常规字符串、字节字符串或者代码对象。如果是常规字符串或字节字符串，那么该字符串将被解析为一系列 Python 语句并执行（除非发生语法错误）。如果是代码对象，它将被直接执行。在任何情况下，被执行的代码都需要和文件输入一样是有效的。请注意即使在传递给 exec() 函数的代码的上下文中，return 和 yield 语句也不能在函数定义之外使用。

该函数返回值是 None。

无论哪种情况，如果省略了可选参数，代码将在当前范围内执行。如果提供了 globals 参数，就必须是字典类型，而且会被用作全局和本地变量。如果同时提供了 globals 和 locals 参数，它们分别被用作全局和本地变量。如果提供了 locals 参数，则它可以是任何映射类型的对象。请记住，在模块层级，全局和本地变量是相同的字典。如果 exec 函数的 globals 参数和 locals 参数的值不同，代码就像嵌入在类定义中一样执行。

如果 globals 字典不包含键为 __builtins__ 的项，则将为该键插入对内建 builtins 模块字典的引用。因此，在将执行的代码传递给 exec() 之前，可以通过将自己的 __builtins__ 字典插入到 globals 中来控制可以使用哪些内置代码。

注解:
内置 globals() 和 locals() 函数各自返回当前的全局和本地字典，因此可以将它们传递给 exec() 的第二个和第三个参数。
默认情况下，locals 的行为如 locals() 函数描述的一样：不要试图改变默认的 locals 字典。如果想在 exec() 函数返回时知道代码对 locals 的变动，请明确地传递 locals 字典。

>>> s = """
... def say_hello(name):
...     print('hello ', name)
... say_hello(your_name)
... """
>>> exec(s, {'your_name': 'bob'})
hello  bob

globals()

返回包含当前范围的全局变量的字典。

注意：如果在另一个名为 func 的函数或者方法内调用该方法，返回的则是定义 func 的模块的全局命名空间的字典，而不是调用 func 方法的模块的全局命名空间的字典。

注意：更新这个字典会影响当前全局范围的名称查找。

locals()

返回包含当前范围的本地变量的字典。

注意：在模块层级，locals() 和 globals() 是同一个字典。在函数代码块但不是类代码块中调用 locals() 时返回自由变量的字典。

注意：不要更改此字典的内容；更改不会影响解释器使用的局部变量或自由变量的值。