Python内置函数（1）— abs()、all()、any()、ascii()、bin()、bool()、breakpoint()、bytearray()、bytes()、callable()。
Python内置函数（2）— chr()、classmethod()、compile()、complex()、delattr()、dict()、dir()、divmod()、enumerate()、eval()。
Python内置函数（3）— exec()、filter()、float()、format()、frozenset()、getattr()、globals()、hasattr()、hash()、help()。
Python内置函数（4）— hex()、id()、input()、int()、isinstance()、issubclass、iter()、len()、list()、locals()。
Python内置函数（5）— map()、max()、memoryview()、min()、next()、object()、oct()、open()、ord()、pow()。
Python内置函数（6）— print()、property()、range()、repr()、reversed()、round()、set()、setattr()、slice()、sorted()。
Python内置函数（7）— staticmethod()、str()、sum()、super()、tuple()、type()、vars()、zip()、__import__()。
Python内置函数.png
41、map()
a）描述
原文：
map(func, *iterables) --> map object
Make an iterator that computes the function using arguments from each of the iterables. Stops when the shortest iterable is exhausted.
中文：
map(func, *iterables) --> map object
创建一个迭代器，使用每个迭代器的参数来计算函数。
诠释：
map() 会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
b）语法
map() 函数语法：map(function, iterable, ...)
c）参数
function：函数
iterable：一个或多个序列
d）返回值
返回迭代器。
e）实例
实例1：
def square(x): # 计算平方数
return x ** 2
print("map(square, [1, 2, 3, 4, 5])：",map(square, [1, 2, 3, 4, 5])) # 计算列表各个元素的平方
print("map(lambda x: x ** 2, [1, 2, 3, 4, 5])：",map(lambda x: x ** 2, [1, 2, 3, 4, 5])) # 使用 lambda 匿名函数
print("map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])：",map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])) # 提供了两个列表，对相同位置的列表数据进行相加
运行结果：
map(square, [1, 2, 3, 4, 5])： <map object at 0x000002A4C49E0A00>
map(lambda x: x ** 2, [1, 2, 3, 4, 5])： <map object at 0x000002A4C49E0580>
map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])： <map object at 0x000002A4C4A894C0>
实例2（如果函数有多个参数, 但每个参数的序列元素数量不一样, 会根据最少元素的序列进行）：
listx = [1,2,3,4,5,6,7] # 7 个元素
listy = [2,3,4,5,6,7] # 6 个元素
listz = [100,100,100,100] # 4 个元素
list_result = map(lambda x,y,z : x**2 + y + z,listx, listy, listz)
print("list_result：",list_result)
print("list(list_result):",list(list_result))
运行结果：
list_result： <map object at 0x000001A2D43CB790>
list(list_result): [103, 107, 113, 121]
# 明显可以看出是由于 lambda 中的 z 参数,实际是使用了 listz, 而 listz 里面只有 4 个元素, 所以即使 listx 有 7 个元素, listy 有 6 个元素,也不会继续执行了，只执行了 4 个元素的的计算。
实例3（除了计算幂函数，还可利用 map 函数的映射功能完成其他任务，例如规范名字格式）：
name_list = {'tony','cHarLIE','rachAEl'}
def format_name(s):
ss=s[0:1].upper()+s[1:].lower()
return ss
print("list(map(format_name,name_list))：",list(map(format_name,name_list)))
print("type(name_list)：",type(name_list))
运行结果：
list(map(format_name,name_list))： ['Rachael', 'Tony', 'Charlie']
type(name_list)： <class 'set'>
实例4（filter是通过生成 True 和 False 组成的迭代器将可迭代对象中不符合条件的元素过滤掉；而 map返回的则是 True 和 False 组成的迭代器）：
res1 = map(lambda n: n > 5, range(10))
lt1 = list(res1)
print("lt1：",lt1)
res2 = filter(lambda n: n > 5, range(10))
lt = list(res2)
print("lt：",lt)
运行结果：
lt1： [False, False, False, False, False, False, True, True, True, True]
lt： [6, 7, 8, 9]
实例5：
如果 zip(array) 不经过 x,y,z=zip(array)拆分成 x,y,z 三个变量，那么 [[1,4,7],[2,5,8],[3,6,9]]被 zip(*array) 之后的结果恰好是 [(1, 2, 3), (4, 5, 6), (7, 8, 9)]，刚好形成一个转置的关系，这对于所有 array=[[1,2,3],[4,5,6],[7,8,9]]的二维数组都是一样的。
当然 [(1, 2, 3), (4, 5, 6), (7, 8, 9)] 还不是我们需要的最后的结果。
因为只是一个存放 tuple 的 list，我们要保持原来 list 是存 list 的一致性，所以要应用到上方的 map 函数。
array = [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
print("map(list, zip(*array))：",map(list, zip(*array)))
print("list(map(list, zip(*array)))：",list(map(list, zip(*array))))
print("list(zip([1, 3, 5, 7, 9], [2, 4, 6, 8, 10]))：",list(zip([1, 3, 5, 7, 9], [2, 4, 6, 8, 10])))
print("list(map(lambda x,y : [x,y], [1,3,5,7,9], [2,4,6,8,10]))：",list(map(lambda x,y : [x,y], [1,3,5,7,9], [2,4,6,8,10])))
运行结果：
map(list, zip(*array))： <map object at 0x0000020CD31306D0>
list(map(list, zip(*array)))： [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
list(zip([1, 3, 5, 7, 9], [2, 4, 6, 8, 10]))： [(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]
list(map(lambda x,y : [x,y], [1,3,5,7,9], [2,4,6,8,10]))： [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]
42、max()
a）描述
原文：
max(iterable, *[, default=obj, key=func]) -> value
max(arg1, arg2, *args, *[, key=func]) -> value
With a single iterable argument, return its biggest item. The default keyword-only argument specifies an object to return if the provided iterable is empty.
With two or more arguments, return the largest argument.
中文：
max(iterable, *[, default=obj, key=func]) -> value
max(arg1, arg2, *args, *[, key=func]) -> value
使用单个可迭代参数，返回其最大的项。默认的关键字参数指定了当提供的iterable为空时返回的对象。
使用两个或多个参数，返回最大的参数。
b）语法
max() 方法的语法：max( x, y, z, .... )
c）参数
x：数值表达式。
y：数值表达式。
z：数值表达式。
d）返回值
返回给定参数的最大值。
e）实例
print("max(80, 100, 1000)：", max(80, 100, 1000))
print("max(-20, 100, 400)：", max(-20, 100, 400))
print("max(-80, -20, -10)：", max(-80, -20, -10))
print("max(0, 100, -400)：", max(0, 100, -400))
运行结果：
max(80, 100, 1000)： 1000
max(-20, 100, 400)： 400
max(-80, -20, -10)： -10
max(0, 100, -400)： 100
43、memoryview()
a）描述
memoryview() 函数返回给定参数的内存查看对象(Momory view)。
所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
b）语法
memoryview 语法：memoryview(obj)
c）参数
obj：对象
d）返回值
返回元组列表。
e）实例
v = memoryview(bytearray("abcefg", 'utf-8'))
print("v[1]：",v[1])
print("v[-1]：",v[-1])
print("v[1:4]：",v[1:4])
print("v[1:4].tobytes()：",v[1:4].tobytes())
运行结果：
v[1]： 98
v[-1]： 103
v[1:4]： <memory at 0x00000243E4D42580>
v[1:4].tobytes()： b'bce'
44、min()
a）描述
原文：
min(iterable, *[, default=obj, key=func]) -> value
min(arg1, arg2, *args, *[, key=func]) -> value
With a single iterable argument, return its smallest item. The default keyword-only argument specifies an object to return if the provided iterable is empty.
With two or more arguments, return the smallest argument.
中文：
min(iterable, *[, default=obj, key=func]) -> value
min(arg1, arg2, *args, *[, key=func]) -> value
使用单个可迭代参数，返回其最小的项。默认的关键字参数指定了当提供的iterable为空时返回的对象。
带两个或多个参数，返回最小的参数。
b）语法
min() 方法的语法：min( x, y, z, .... )
c）参数
x：数值表达式。
y：数值表达式。
z：数值表达式。
d）返回值
返回给定参数的最小值。
e）实例
print("min(80, 100, 1000)：", min(80, 100, 1000))
print("min(-20, 100, 400)：", min(-20, 100, 400))
print("min(-80, -20, -10)：", min(-80, -20, -10))
print("min(0, 100, -400)：", min(0, 100, -400))
运行结果：
min(80, 100, 1000)： 80
min(-20, 100, 400)： -20
min(-80, -20, -10)： -80
min(0, 100, -400)： -400
45、next()
a）描述
原文：
next(iterator[, default])
Return the next item from the iterator. If default is given and the iterator is exhausted, it is returned instead of raising StopIteration.
中文：
next(iterator[, default]
从迭代器返回下一项。如果提供了默认值，并且迭代器已耗尽，则返回它而不是引发StopIteration。
b）语法
next 语法：next(iterator[, default])
c）参数
iterator：可迭代对象
default：可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。
d）返回值
返回对象帮助信息。
e）实例
实例1：
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
try:
# 获得下一个值:
x = next(it)
print(x)
except StopIteration:
# 遇到StopIteration就退出循环
break
运行结果：
1
2
3
4
5
实例2（如果传入第二个参数, 获取最后一个元素之后, 下一次next返回该默认值, 而不会抛出 StopIteration）：
it = iter([1, 2, 5, 4, 3])
while True:
x = next(it, 'a')
print(x)
if x == 'a':
break
运行结果：
1
2
5
4
3
a
46、object()
暂略
a）描述
原文：
中文：
b）语法
c）参数
d）返回值
e）实例
47、oct()
a）描述
原文：
Return the octal representation of an integer.
中文：
返回整数的八进制表示形式。
b）语法
oct 语法：oct(x)
c）参数
x：整数。
d）返回值
返回8进制字符串。
e）实例
print("oct(10)：",oct(10))
print("oct(20)：",oct(20))
print("oct(15)：",oct(15))
运行结果：
oct(10)： 0o12
oct(20)： 0o24
oct(15)： 0o17
48、open()
a）描述
原文：
Open file and return a stream. Raise OSError upon failure.
file is either a text or byte string giving the name (and the path if the file isn't in the current working directory) of the file to be opened or an integer file descriptor of the file to be wrapped. (If a file descriptor is given, it is closed when the returned I/O object is closed, unless closefd is set to False.)
中文：
打开文件并返回一个流。失败时提出OSError。
文件是文本或字节字符串，给出要打开的文件的名称(和路径，如果文件不在当前工作目录)或要包装的文件的整数文件描述符。(如果给出了一个文件描述符，它在返回的I/O对象关闭时关闭，除非将closefd设置为False)。
诠释：
open() 函数用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。
注意：使用 open() 函数一定要保证关闭文件对象，即调用 close() 函数。
open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)：open(file, mode='r')
b）语法
open 语法：open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
c）参数
file：必需，文件路径（相对或者绝对路径）。
mode：可选，文件打开模式
buffering：设置缓冲
encoding：一般使用utf8
errors：报错级别
newline：区分换行符
closefd：传入的file参数类型
opener：
| 模式 | 描述 |
|---|---|
| t | 文本模式 (默认)。 |
| x | 写模式，新建一个文件，如果该文件已存在则会报错。 |
| b | 二进制模式。 |
| + | 打开一个文件进行更新(可读可写)。 |
| U | 通用换行模式（不推荐）。 |
| r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
| rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。 |
| r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |
| rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。 |
| w | 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 |
| w+ | 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 |
| a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| ab | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| a+ | 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 |
| ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 |
默认为文本模式，如果要以二进制模式打开，加上 b 。
d）返回值
无
e）实例
f = open('test.txt')
print(f.read())
运行结果：
I'm Kevin.
I love you.
49、ord()
a）描述
原文：
Return the Unicode code point for a one-character string.
中文：
返回一个单字符字符串的Unicode编码点。
诠释：
ord() 函数是 chr() 函数（对于 8 位的 ASCII 字符串）的配对函数，它以一个字符串（Unicode 字符）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值。
b）语法
ord() 方法的语法：ord(c)
c）参数
c：字符。
d）返回值
返回值是对应的十进制整数。
e）实例
print("ord('a')：",ord('a'))
print("ord('€')：",ord('€'))
运行结果：
ord('a')： 97
ord('€')： 8364
50、pow()
a）描述
原文：
Equivalent to xy (with two arguments) or xy % z (with three arguments)
Some types, such as ints, are able to use a more efficient algorithm when invoked using the three argument form.
中文：
与xy(有两个参数)或xy % z(有三个参数)
有些类型，如int，在使用三个参数形式调用时能够使用更有效的算法。
b）语法
math 模块 pow() 方法的语法:
import math
math.pow( x, y )
内置pow() 方法的语法：pow(x, y[, z])
函数是计算x的y次方，如果z存在，则再对结果进行取模，其结果等效于pow(x,y) %z。
注意：pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。
c）参数
x：数值表达式。
y：数值表达式。
z：数值表达式。
d）返回值
返回 xy或xy % z的值。
e）实例
import math # 导入 math 模块
print("math.pow(100, 2) : ", math.pow(100, 2))
# 使用内置，查看输出结果区别
print("pow(100, 2) : ", pow(100, 2))
print("math.pow(100, -2) : ", math.pow(100, -2))
print("math.pow(2, 4) : ", math.pow(2, 4))
print("math.pow(3, 0) : ", math.pow(3, 0))
运行结果：
math.pow(100, 2) : 10000.0
pow(100, 2) : 10000
math.pow(100, -2) : 0.0001
math.pow(2, 4) : 16.0
math.pow(3, 0) : 1.0
网友评论