python section python section modulus

返回一个数的绝对值。 参数可以是整数、浮点数或实现了 __abs__() 的对象。 若参数是一个复数，则返回它的模。

print(abs(12))     # 12
print(abs(-1.2))   # 1.2

# 参数是复数，返回模
print(abs(-3+4j))    # 5.0
print(abs(-1.2+1.6j))     # 2.0

# 参数是实现了 __abs__() 的对象
class TestClass:
    def __abs__(self):
        return 123
print('abs(TestClass()) = ',abs(TestClass()))     # abs(TestClass()) =  123

divmod()

division（求商）和modulus（取余数）两个单词的缩写，将两个数字（非复数）作为实参，返回值一个包含商和余数的元组，即结果为(a//b , a%b)。

a = 10  # 被除数
b = 2   # 除数
print('divmod(a, b) = ',divmod(a, b))  # divmod(a, b) =  (3, 1)
print('(a//b, a%b) = ',(a//b, a%b))    # (a//b, a%b) =  (3, 1)

a = 2.0  # 被除数
b = 0.3  # 除数
print(f' divmod(a, b) = ',divmod(a, b))  # divmod(a, b) =  (6.0, 0.20000000000000007)
print('(a//b, a%b) = ',(a//b, a%b))      # (a//b, a%b) =  (6.0, 0.20000000000000007)

# 由于浮点数存在误差，有时结果并非尽如人意
# 2.0并不能被0.4整除
a = 2.0  # 被除数
b = 0.4  # 除数
print(f' divmod(a, b) = ',divmod(a, b))  # divmod(a, b) =  (4.0, 0.3999999999999999)
print('(a//b, a%b) = ',(a//b, a%b))      # (a//b, a%b) =  (4.0, 0.3999999999999999)

max()

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

如果只提供了一个位置参数，它必须是非空可迭代对象，返回可迭代对象中最大的元素；如果提供了两个及以上的位置参数，则返回最大的位置参数。

max()还有两个可选的关键字参数。key 参数指定排序函数用的参数；default 参数是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会报 ValueError。

# 一个位置参数，返回可迭代对象中最大的元素
print(f'{ max([1,2,4,5,3]) = }')                 # max([1,2,4,5,3]) = 5
# 两个及以上的位置参数，则返回最大的位置参数。
print(f'{ max(1,2,4,5,3) = }')                   # max(1,2,4,5,3) = 5
# 关键字参数key，指定排序规律，可以是list.sort,abs等等
print(f'{ max([3, 9, -20, 15], key=abs) = }')    # max([1, 2, -3, 2], key=abs) = -3
# 关键字default，用于可迭代对象为空           
print(f'{ max([], default=None) = }')            # max([], default=None) = None
# 如果可迭代对象为空，并且没有给 default ，则会报ValueError。
# print(f'{ max([]) = }')
# 如果有多个最大元素，则此函数将返回第一个找到的
print(f'{ max([1, 2, -3, 2, 3], key=abs) = }')   # max([1, 2, -3, 2, 3], key=abs) = -3

print(f'{ max([1,2,4,5,3]) = }')这种写法在python 3.6中亲测并没有得到支持，但是在3.8版本中可用。

min()

min()和max()结构一样，只是返回最小值。可以参考max()来理解。

pow()

格式：pow(base, exp[, mod])

功能：返回 base 的 exp 次幂；如果 mod 存在，则返回 base 的 exp 次幂对 mod 取余（比 pow(base, exp) % mod 高效）。

# 返回 base 的 exp 次幂；
print(f'{ pow(10, 2) = }')         # pow(10, 2) = 100

# 如果 mod 存在，则返回 base 的 exp 次幂对 mod 取余（比 pow(base, exp) % mod 更高效）
print(f'{ pow(12, 34, 56) = }')    # pow(12, 34, 56) = 16

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

# 参数必须具有数值类型
# 对于混用的操作数类型，则将应用双目算术运算符的类型强制转换规则。
print(f'{ pow(2.0, 3) = }')        # pow(2.0, 3) = 8.0

# 对于 int 操作数，结果具有与操作数相同的类型（强制转换后），除非第二个参数为负值；在这种情况下，所有参数将被转换为浮点数并输出浮点数结果。
print(f'{ pow(2, 3) = }')          # pow(2, 3) = 8
print(f'{ pow(2, -3) = }')         # pow(2, -3) = 0.125

# 对于 int 操作数 base 和 exp，如果给出 mod，则 mod 必须为整数类型并且 mod 必须不为零。 如果给出 mod 并且 exp 为负值，则 base 必须相对于 mod 互质(不含1以外的公因数)。

# 下面的例子是 20 的倒数对 47 取余:
print(pow(20, -1, mod=47))         # 40
print(40 * 20 % 47 == 1)           # True
# 关于分数求模的方法可以参考：https://wenku.baidu.com/view/6f2879cca1c7aa00b52acb5f.html

# 在 3.8 版更改: (1)对于 int 操作数,三参数形式的 pow 现在允许第二个参数为负值,即可以计算倒数的余数。(2)允许关键字参数,之前只支持位置参数。

round()

格式：round(number[, ndigits])

功能：返回 number 舍入到小数点后 ndigits 位精度的值。 如果 ndigits 被省略或为 None，则返回最接近输入值的整数。如果与两个倍数的距离相等，则选择偶数 (因此，round(0.5) 和 round(-0.5) 均为 0 而round(1.5) 为2)。 任何整数值都可作为有效的 ndigits (正数、零或负数)。 如果 ndigits 被省略或为 None 则返回值将为整数。 否则返回值与 number 的类型相同。

# 返回 number 舍入到小数点后 ndigits 位精度的值。
print(f'{ round(123.456, 2) = }')

# 如果 ndigits 被省略或为 None，则返回最接近输入值的整数。
print(f'{ round(123.456) = }')               # round(123.456, 2) = 123.46
print(f'{ round(123.456, None) = }')         # round(123.456, None) = 123

# 如果与两个倍数的距离相等，则选择偶数 (因此，round(0.5) 和 round(-0.5) 均为 0 而 round(1.5)为2)。
numbers = [-0.5, 0.5, 1.5, 2.5, 3.5]
for num in numbers:
    print(f'{ num = } { round(num) = }')
# 输出为：
# num = -0.5  round(num) = 0
# num = 0.5  round(num) = 0
# num = 1.5  round(num) = 2
# num = 2.5  round(num) = 2
# num = 3.5  round(num) = 4
# 也就是说，round()内置函数不是使用四舍五入的规则，而是根据距离远近的规则来取近似值，四舍六入五考虑（趋偶）

# 任何整数值都可作为有效的 ndigits (正数、零或负数)。
print(f'{ round(123.456, 2) = }')        # round(123.456, 2) = 123.46
print(f'{ round(123.456, 0) = }')        # round(123.456, 0) = 123.0
print(f'{ round(123.456, -2) = }')       # round(123.456, -2) = 100.0
print(f'{ round(193.456, -2) = }')       # round(193.456, -2) = 200.0

# 如果 ndigits 被省略或为 None 则返回值将为整数。 否则返回值与 number 的类型相同。
print(f'{ round(123.456) = }')           # round(123.456) = 123
print(f'{ round(123.456, None) = }')     # round(123.456, None) = 123
print(f'{ round(123.456, 2) = }')        # round(123.456, 2) = 123.46

# 对于一般的 Python 对象 number, round 将委托给 number.__round__。
print(f'{ round(123.456, 2) = }')        # round(123.456, 2) = 123.46
print(f'{ 123.456.__round__(2) = }')     # 123.456.__round__(2) = 123.46

# 对浮点数执行 round() 的行为可能会令人惊讶：例如，round(2.675, 2) 将给出 2.67 而不是期望的 2.68。 这不算是程序错误：这一结果是由于大多数十进制小数实际上都不能以浮点数精确地表示。
print(f'{ round(2.675, 2) = }')          # round(2.675, 2) = 2.67
print(f'{ round(0.125, 2) = }')          # round(0.125, 2) = 0.12

sum()

格式：sum(iterable,start)

功能：从 start 开始自左向右对 iterable 的项求和并返回总计值。 iterable 的项通常为数字，而 start 值则不允许为字符串。

# 从start 开始自左向右对 iterable 的项求和并返回总计值。
print(f'{ sum([1, 2, 3]) = }')                      # sum([1, 2, 3]) = 6
print(f'{ sum([1, 2, 3], 10) = }')                  # sum([1, 2, 3], 10) = 16
print(f'{ sum([1, 2, 3], 100) = }')                 # sum([1, 2, 3], 100) = 106
print(f'{ sum([1, 2, 3], start=100) = }')           # sum([1, 2, 3], start=100) = 106
# 注：iterable只能是位置参数，不能是关键字参数

# 对某些用例来说，存在 sum() 的更好替代。 拼接字符串序列的更好更快方式是调用 ''.join(sequence)。 要以扩展精度对浮点值求和，请参阅 math.fsum()。 要拼接一系列可迭代对象，请考虑使用 itertools.chain()。

# 在 3.8 版更改: start 形参可用关键字参数形式来指定。

# 拼接字符串序列的更好更快方式是调用 ''.join(sequence)。
print(f'{ "a" + "b" + "c" = }')                     # "a" + "b" + "c" = 'abc'
# print(f'{ sum(["a", "b", "c"]) = }')
print(f'{ "".join(["a", "b", "c"]) = }')            # "".join(["a", "b", "c"]) = 'abc'