python内置函数

1. 数学运算

1. abs()

返回数字的绝对值。参数可以是整数、浮点数或任何实现了 abs() 的对象。 如果参数是一个复数，则返回它的模。

# 参数可以是整数
print(f'{ abs(123) = }')
print(f'{ abs(-123) = }')
print(f'{ abs(0) = }')
# 参数可以是浮点数
print(f'{ abs(1.23) = }')
print(f'{ abs(-1.23) = }')
print(f'{ abs(0.0) = }')
# 参数可以任何实现了 __abs__() 的对象。
class TestClass:
    def __abs__(self):
        return 123
print(f'{ abs(TestClass()) = }')
# 如果参数是一个复数，则返回它的模
# 复数是实数+虚数
# 注意点：复数的绝对值返回值一定是浮点数
print(f'{ abs(3+4j) = }')
print(f'{ abs(-3-4j) = }')

2. pow()

• 格式：pow(base, exp[, mod])
• 返回值：int

返回 base 的 exp 次幂；如果 mod 存在，则返回 base 的 exp 次幂对 mod 取余（比 pow(base, exp) % mod 更高效）。 两参数形式 pow(base, exp) 等价于乘方运算符: base**exp

# 返回 base 的 exp 次幂；
print(f'{ pow(2, 3) = }')
print(f'{ pow(10, 2) = }')
# 两参数形式 pow(base, exp) 等价于乘方运算符: base**exp。
print(f'{ 2**3 = }')
print(f'{ 10**2 = }')
# 如果 mod 存在，则返回 base 的 exp 次幂对 mod 取余（比 pow(base, exp) % mod 更高效）

# 参数必须具有数值类型。 对于混用的操作数类型，则将应用双目算术运算符的类型强制转换规则。 对于 int 操作数，结果具有与操作数相同的类型（强制转换后），除非第二个参数为负值；在这种情况下，所有参数将被转换为浮点数并输出浮点数结果。 例如，10**2 返回 100，但 10**-2 返回 0.01。

# 参数必须具有数值类型
# print(f'{ pow(2, "3") = }')
# 对于混用的操作数类型，则将应用双目算术运算符的类型强制转换规则。
print(f'{ pow(2.0, 3) = }')
# 对于 int 操作数，结果具有与操作数相同的类型（强制转换后），除非第二个参数为负值；在这种情况下，所有参数将被转换为浮点数并输出浮点数结果。
print(f'{ pow(2, 3) = }')
print(f'{ pow(2, -3) = }')

# 对于 int 操作数 base 和 exp，如果给出 mod，则 mod 必须为整数类型并且 mod 必须不为零。 
# 如果给出 mod 并且 exp 为负值，则 base 必须相对于 mod 不可整除。 在这种情况下，将会返回 pow(inv_base, -exp, mod)，其中 inv_base 为 base 的倒数对 mod 取余。

# print(f'{ pow(2, 3, 0) = }')

# 下面的例子是 38 的倒数对 97 取余:
# >>> pow(38, -1, mod=97)
# 23
# >>> 23 * 38 % 97 == 1
# True

3. divmod()

• 格式：divmod(a, b)
• 返回值：一个包含商和余数的元组

它将两个（非复数）数字作为实参，并在执行整数除法时返回一对商和余数。对于混合操作数类型，适用双目算术运算符的规则。对于整数，结果和 (a // b, a % b) 一致。对于浮点数，结果是 (q, a % b) ，q 通常是 math.floor(a / b) 但可能会比 1 小。在任何情况下， q * b + a % b 和 a 基本相等；如果 a % b 非零，它的符号和 b 一样，并且 0 <= abs(a % b) < abs(b) 。

# 对于整数，结果和 (a // b, a % b) 一致。
a = 20  # 被除数
b = 3   # 除数
print(f'{ divmod(a, b) = }')#(6,2)
print(f'{ (a//b, a%b) = }')
# 对于浮点数，结果是 (q, a % b) ，q 通常是 math.floor(a / b)
import math
a = 2.0  # 被除数
b = 0.3  # 除数
q = math.floor(a/b)
print(f'{ divmod(a, b) = }')
print(f'{ (q, a%b) = }')
# 在任何情况下， q * b + a % b 和 a 基本相等

4. max()

• 格式：max(iterable, *[, key, default])
  max(arg1, arg2, *args[, key])
• 返回值：可迭代对象中最大的元素，或者返回两个及以上实参中最大的序列。

如果只提供了一个位置参数，它必须是非空 iterable（单序列），返回可迭代对象中最大的元素；如果提供了两个及以上的位置参数（多序列），则返回最大的位置参数（序列）。
单序列入参，返回序列中最大的一个数值。多序列入参, 按索引顺序，逐一对比各序列的当前索引位的 “值”，直到遇见最大值立即停止对比，并返回最大值所在的序列（也就是说，多序列入参，返回值依旧是一个序列，而不是数值）

>>> max([1,2,3])
3
>>> max(1,2,4)
4
>>> max(-1, -0.5, 0)
0
>>> max((1,2,3))
3
>>> max([2,4], [3,6])
[3, 6]
>>> max([2,4], [1,5])
[2, 4]
>>> max([2,4], [1,5], [3,1], [2,5],[0,7])
[3, 1]
>>> max((1,2,3), (3,3,0))
(3, 3, 0)
>>> max((1,-1,0), (True,False,0)) #布尔喔
(True, False, 0)
>>> max((1,-1,0), (True,False,2,0),(1, 0, 0, 2))
(True, False, 2, 0)
>>> max((1,-1,0), (True,),(1,))
(1, -1, 0)
>>> max((-1,-1,0), (True,),(1,))
(True,)
>>> max([1,3,2],3,4) #非法入参
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '>' not supported between instances of 'int' and 'list'
>>> max((1,2,3), [2,4,1]) #非法入参

有两个可选只能用关键字的实参。key 实参指定排序函数用的参数，如传给 list.sort() 的。default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触发 ValueError。
如果有多个最大元素，则此