内置函数_数学运算

abs-绝对值

abs(x)

1. 返回数字的绝对值，参数可以是整数、浮点数或者复数。
2. 如果参数是一个复数，此方法返回此复数的绝对值。

# 整数
print(abs(1)) # 1
print(abs(-1)) # 1
print(abs(0)) # 0
# 浮点数
print(abs(-2.3)) # 2.3
print(abs(2.3)) # 2.3
# 复数
print(abs(complex(2,3))) # 3.605551275463989
print(abs(complex(-2,-3))) # 3.605551275463989

divmod-返回商和余数

divmod(a, b)

1. 接受两个数值(非复数)，返回两个数值的相除得到的商，和余数组成的元组
2. 如果参数都是整数，执行的是地板除，相当于 (a//b,a%b)

print(divmod(9,4)) # (2, 1)
print(9//4) # 2
print(9%4) # 1

3. 如果参数时浮点数，相当于( a//b,a%b)

print(divmod(10,3.0)) # (3.0, 1.0)
print(10%3.0) # 1.0
print(10/3.0) # 3.0

max-返回可迭代对象最大值 / min-返回可迭代对象最小值

max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])
mix(iterable, *[, key, default])
mix(arg1, arg2, *args[, key]) —max和min的运用是一样的。

1. 函数功能为取传入的多个参数中的最大值，或者传入的可迭代对象元素中的最大值。默认数值型参数，取值大者；字符型参数，取字母表排序靠后者。还可以传入命名参数key，其为一个函数，用来指定取最大值的方法。default命名参数用来指定最大值不存在时返回的默认值、

# 传入多个参数
print(max(1,2,3,5,4)) # 5
# 传入可迭代对象
print(max(tuple((1,2,3,8,6,7)))) # 8
# 传入字符型参数
print(max('abcdes')) # s

2. 函数至少传入两个参数，但是有只传入一个参数的例外，此时参数必须为可迭代对象，返回的是可迭代对象中的最大元素。

# 传入一个参数
print(max(1)) # TypeError: 'int' object is not iterable
# 传入二个参数
print(max(5,1)) # 5
# 传入可迭代对象
print(max(list((1,2,6,4,8)))) # 8

3. 当传入参数为数据类型不一致时，传入的所有参数将进行隐式数据类型转换后再比较，如果不能进行隐式数据类型转换，则会报错。

max_1 = max(1,1.3,1.3E1)
print(max_1) # 13.0

# '5'是字符串，不能隐式进行数据转换
#  max(1,2,'5') # TypeError: '>' not supported between instances of 'str' and 'int'

max_2 = max([1, 4],[2, 6])
print(max_2) [2, 6]

4. 当存在多个相同的最大值时，返回的是最先出现的那个最大值。

a = ['a', 'a']
b = ['c', 'b']
c = ['c', 'b']
print(id(a)) # 1744744702536
print(id(b)) # 1744744702600
print(id(c)) # 1744776500104

print(max(a,b,c)) # ['c', 'b']
print(id(max(a,b,c))) # 1744744702600

5. 默认数值型参数，取值大者；字符型参数，取字母表排序靠后者；序列型参数，则依次按索引位置的值进行比较取最大者。还可以通过传入命名参数key，指定取最大值方法。

print(max(1,2,3)) # 3
print(max('a','b','c')) # c
print(max('ab','ac','ad')) # ad

print(max('5',3,2,key=int)) # 5

6. 当只传入的一个可迭代对象时，而且可迭代对象为空，则必须指定命名参数default，用来指定最大值不存在时，函数返回的默认值。

# print(max(())) # ValueError: max() arg is an empty sequence
print(max((),default=0)) # 0

pow-幂乘

pow(x, y[, z])

1. 函数有两个必需参数x,y和一个可选参数z，结果返回x的y次幂乘(相当于x**y)，如果可选参数z有传入值，则返回幂乘之后再对z取模(相当于pow(x,y)%z)。

print(pow(2,3)) # 8

print(pow(2,3,5)) # 3
print(2**3%5) # 3

2. 所有的参数必须是数值类型。

# pow('2',3) # TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'

# pow(2,'3') TypeError: unsupported operand type(s) for ** or pow(): 'int' and 'str'

3. 如果x,y有一个是浮点数，则结果将转换成浮点数。

print(pow(2,0.1)) # 1.0717734625362931
print(pow(0.2,4)) # 0.0016000000000000003

4. 如果x,y都是整数，则结果也是整数，除非y是负数；如果y是负数，则结果返回的是浮点数，浮点数不能取模，所有可选参数z不能传入值。

print(pow(2,4)) # 16
print(pow(2,-4)) # 0.0625

# print(pow(2,-4,5)) # ValueError: pow() 2nd argument cannot be negative when 3rd argument specified

5. 如果可选参数z传入了值，x,y必须为整数，且y不能为负数。

print(pow(2,4,5)) # 1
# print(pow(2,-4,5)) # ValueError: pow() 2nd argument cannot be negative when 3rd argument specified

round-对浮点数进行四舍五入求值

round(number[, ndigits])
　1. round函数用于对浮点数进行四舍五入求值，具体保留几位小数，以传入的ndigits参数来控制。

print(round(3.1415926,2)) # 3.14
print(round(3.1415926,4)) # 3.1416

2. ndigits参数为可选参数，当不传入时，即以默认保留0位小数进行取整，返回的是整数。ndigits参数传入0时，虽然与不传入ndigits参数一样保留0位小数进行四舍五入，但是返回的值是浮点型。

print(round(3.1415926)) # 3
print(round(3.1415926,0)) # 3.0

3. ndigits参数小于0时，对整数部分进行四舍五入，ndigits参数控制了对浮点数的整数部分的后几位进行四舍五入，小数部分全部清0，返回类型是浮点数。如果传入的浮点数的整数部分位数小于ndigits参数绝对值，则返回0.0.

print(round(3146.5, -1)) # 3150.0
print(round(3141.5, -2)) # 3100.0
print(round(3146.5, -3)) # 3000.0
print(round(3141.5, -4)) # 0.0

4. round四舍五入时是遵循靠近0原则，所以-0.5和0.5进行0位四舍五入，返回的都是0.

print(round(0.5)) # 0
print(round(-0.5)) # 0

5. 对于浮点数求四舍五入有一个陷阱，有些四舍五入结果不像预期那样，比如round(2.675, 2) 的结果是2.67 而不是预期的 2.68，这不是bug，而是浮点数在存储的时候因为位数有限，实际存储的值和显示的值有一定误差。

print(round(2.675, 2)) # 2.67

6. 对整数也能进行round操作，返回值也是整形。

print(round(31415)) # 31415
print(round(31415, 0)) # 31415
print(round(31415, 1)) # 31415
print(round(31415, 2)) # 31415
print(round(31415, -1)) # 31420
print(round(31415, -2)) # 31400

sum-对元素类型是数值的可迭代对象中的每个元素求和

sum(iterable[, start])

1. 函数功能是对可迭代类型进行求和。要求：① 接收对象是可迭代类型。② 可迭代对象所有元素类型是数值型。

print(sum((1,2,3,4))) # 10

print(sum((1.1,1.2,1.2,0.5))) # 4.0

print(sum((complex(1,-1),complex(2,-2)))) # (3-3j)
# print(sum((1,2,3,'4'))) # TypeError: unsupported operand type(s) for +: 'int' and 'str'

2. 可以传入一个可选参数start，表示求和前的初始化值，如果传入空的可迭代数据类型，则返回初始值。

print(sum((1,2,3,4),2)) # 12