【Python】 常见内置函数

目录

1  类型转换

2  数值运算

3  其他

---

Built-in Functions — Python 3.8.14 documentation

写在前面：

函数形参 (parameter) : 函数定义时的命名实体，指定函数所接受的实参类型

def func ( arg1, arg2, /, arg3, arg4, arg5, *, arg6, *arg7, **arg8 )

        位置参数：/  之前

        关键字参数：* 之后

        数量可变位置参数：参数前加 *

        数量可变关键字参数：参数前加 **

        默认参数：/ 之后，* 之前

1  类型转换

1.1  int()   float()   complex()

class int([x])  参数可以为空，若没有参数，返回0。

class int([x], base=10) 从数，串，字节或字节数组创建整形对象，若不是数，必须给定 base 。

print(int(3.5))                 # 获取实数的整数部分
print(int('119'))               # 把整数字符串转换为整数
print(int('1111', 2))           # 把1111看作二进制数，转换为十进制数
print(int('1111', 8))           # 把1111看作八进制数，转换为十进制数
print(int('1111', 16))          # 把1111看作十六进制数，转换为十进制数
print(int('  9\n'))             # 自动忽略字符串两个的空白字符
print(float('3.1415926'))       # 把字符串转换为实数
print(float('-inf'))            # 负无穷大
print(complex(3, 4))            # 复数
print(complex(6j))
print(complex('3'))

1.2   bin()   oct()   hex()

bin(x)  将整数转换为 “0b” 打头的二进制串
oct(x)  将整数转换为 “0o” 打头的八进制串
hex(x) 将整数转换为 “0x” 打头的十六进制串

print(bin(256))
print(oct(256))
print(hex(256))

1.3   ord()   chr()   str()

ord(c)  表示 Unicde 字符的一个串，返回字符 Unicde 码点所对应的整数

chr(i)  将 Uniced 码值为 i （0-1,114,111）的字符转换为串返回，ord() 的逆函数

class str(object='b', encoding='utf-8', errors='strict')

print(ord('江'))                # 返回字符的Unicode码
print(ord('画'))                # 返回汉字字符的Unicode编码
print(chr(27743))               # 返回指定ASCII码对应的字符
print(chr(30011))               # 返回指定Unicode编码对应的汉字
print(type(str([1, 2, 3, 4])))  # 把列表转换为字符串
print(str({1, 2, 3, 4}))        # 把集合转换为字符串

1.4   list()   tuple()   dict()   set()

print(list(), tuple(), dict(), set())  
s = {3, 2, 1, 4, 2}
print(s)
print(list(s), tuple(s))

list()  会把字符串中每一个字符转换为列表中的元素

tuple()  ,  set()  具有类似的特点

lst = [1, 3, 4, 6, 1, 4, 2]
print(list(str(lst)))
print(dict(name='江', sex='Male', age=14))

1.5.1   eval()

eval(expression[,globals[,locals]])

将 globals 和 locals 字典作为全局变量和局部名变量，将expression（必须是串），解析成Python表达式，并且求值返回。

a, b, c = 10, 20, 30
g = {'a': 6, 'b': 8}
t = {'b': 100, 'c': 10}
print(eval('a+b+c'))
# print(eval('a+b+c',g))    # 报错，NameError c未定义
# print(eval('a+b+c',t))    # 报错，NameError a未定义
print(eval('a+b+c', g, t))
print(eval('a+b+c', t, g))

eval()  函数在查找字典时，先局部后全局

1.5.2   globals()   locals()

globals() : 返回当前全局字符表字典，当前模块（定义调用 globals() 的函数或方法所在的模块）的符号表字典

locals() : 更新并返回表示当前局部符号表的字典。党在函数块中被调用时，返回自由变量，在模块locals() 和 globals() 返回相同字典。

2  数值运算

2.1.1   max()   min()

max( iterable, *[, key, default])   max(arg1, arg2, *args[, key])

返回 iterable 可迭代对象或多个参数中的最大值。可选关键字参数 key 指定一个单参数排列函数； default参数确定当 iterable 对象为空时的返回值，若没有，触发 ValueError 。

data = [12, 32, 6]
print(max(data))
print(min(data))
print(max(data, key=str))  # 返回转换成字符之后的最大的元素

data = ['123', '12', 'weird']
print(max(data, key=len))

 当判断条件的大小相同时，返回靠前的值。

data = ['ab', 'bc', 'bd']
print(max(data, key=str))
print(max(data, key=len))
print(min(data, key=str))

lis = [1, 1, 1, 2, 3, 4, 3, 2, 1]
print(list(set(lis)))
print(max(list(set(lis)), key=lis.count))
print(max(range(len(lis)), key=lis.__getitem__))

2.1.2   sum()

sum(iteable,/,start=0)

将 start 和可迭代对象元素从左到右进行 '+' 并返回；

可迭代对象通常是数，start 的值不能是串。

print(sum([72, 26, 98, 42])/len([72, 26, 98, 42]))
# print(sum([[1], [2], [3]]))     # 报错
print(sum([[1], [2], [3]], []))
print(''.join(['a', 'b', 'c']))   # 字符串加法

2.2   len()

len(s) : 返回对象 s 的长度，s 是序列（列表，元组，串，range()）或容器（字典，集合）

lis = [1, 2, 3, 4]
print(len(lis))
data = {'name': 'jiang', 'age': '14'}
print(len(data))

2.3   sorted()

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

对可迭代对象排序并返回新列表，不修改原对象。

lis = [4, 12, 432, 123, 231, 1, 4]
print(sorted(lis, key=lambda i: i % 4))

x = ['aaaa', 'bc', 'd', 'b', 'ba']
print(sorted(x, key=len))
print(sorted(x, key=lambda item: item))
print(sorted(x, key=lambda item: (len(item), item)))

tudent = [('jiang', '14'), ('hua', '12')]
print(sorted(student, key=lambda age: list(age)[1]))

2.4   reversed()

逆序对象，返回迭代器，所输出结果只能使用一次。

lis1 = list(range(10))
lis2 = reversed(lis1)
print(list(lis2))
[print(i) for i in lis2]
print('?')

3  其他

3.1   class range( stop )   class range(start, stop, [, step]

[print(i, end=' ') for i in range(9)]
print()
[print(i, end=' ') for i in range(0, 10, 3)]

3.2   zip()

zip(* iterables, strict=False)

在多个可迭代对象上并行迭代，产生有各个可迭代对象所构成的元素迭代器；

第 i 个元组包含所有可迭代对象的第 i 个元素；

strict 为 False 忽略因长度不同引起的 ValueError。

print(list(zip('1234', [1, 2, 3, 4, 5])))

3.3   map()

map( function, iterable, ...)

将 function 用于可迭代对象的每一个元素，返回迭代器。

print(sum(map(lambda x: x ** 2, [1, 2, 3, 4, 5])))
print(list(map(operator.add, [1, 2, 3, 4, 5], [10, 9, 8, 7, 6])))
print(list(map(operator.sub, [1, 2, 3, 4, 5], [10, 9, 8, 7, 6])))
print(list(map(operator.mul, [1, 2, 3, 4, 5], [10, 9, 8, 7, 6])))
print(list(map(operator.truediv, [1, 2, 3, 4, 5], [10, 9, 8, 7, 6])))

3.4   filter()

filter( function, iterable)

将 function 用于可迭代对象的为一个元素，返回值为 True 的元素构建迭代器并返回。

seq = ['abcd', '1234', '.,?!', '']
print(list(filter(str.isdigit, seq)))   # 只保留数字字符串
print(list(filter(str.isalpha, seq)))   # 只保留英文字母字符串
print(list(filter(str.isalnum, seq)))   # 只保留数字字符串和英文字符串
print(list(filter(None, seq)))          # 只保留等价于True的元素

3.5   enumerate()

enumerate(iterable, start=0)

返回枚举迭代器对象。通过迭代器 __next()__ 方法可迭代对象 iterable 中元素 value

的枚举（count，value），count 从 start 开始，默认为零。

print(list(enumerate(['jiang', 'hua'])))