Python每日一练 04

Python每日一练 04

一、前言

14天学习训练营导师课程：
杨鑫《Python 自学编程基础》
杨鑫《 Python 网络爬虫基础》
杨鑫《 Scrapy 爬虫框架实战和项目管理》

最近CSDN又出了一个活动，我看见了有关python的所以我就参加了，正好最近在进行python训练。
刚兴趣的朋友也可以去看看这个老师的课程。

二、常用数学运算函数

Python 内置了一系列与数字运算相关的函数可以直接使用，如下表所示：

函数	功能描述
abs(x)	返回 x的绝对值，x可以是整数或浮点数；当x为复数时返回复数的模
divmod(a, b)	(a // b, a % b)，以整数商和余数的二元组形式返回
pow(x, y[, z])	返回 x的y次幂，当z存在时，返回 x的y次幂对z取余
round(number[, n])	返回number舍入到小数点后n位精度的值。当小数点最后几位都是0时，输出其最短表示。
max(iterable)max(arg1,arg2,…)	从多个参数或一个可迭代对象中返回其最大值，有多个最大值时返回第一个。
min(iterable)min(arg1,arg2,…)	从多个参数或一个可迭代对象中返回其最小值，有多个最小值时返回第一个。
sum(iterable, start=0)	从 start 开始自左向右对 iterable 的项求和并返回总计值。 iterable 的项通常为数字，而 start 值则不允许为字符串。
eval(source)	计算指定表达式的值source：必选参数，可以是字符串，也可以是一个任意的代码对象实例。常用于将字符串转为数字
complex([real[, imag]])	返回值为 real + imag*1j 的复数，或将字符串或数字转换为复数。如果第一个形参是字符串，则它被解释为一个复数，并且函数调用时必须没有第二个形参。第二个形参不能是字符串。
int(x, base=10)	base缺省为10，当其省略时，当x为浮点数或整数字符串时返回整型数字，当x为浮点数字符串时会返回异常。当base为其他值时可将字符串x作为base进制字符串，并将其转成十进制数字。
float([x])	从一个数字或字符串x返回浮点数字

其中int()与float()函数前面已经讲解过，下面对其他函数进行说明。

1、abs(x)

返回一个数的绝对值。参数可以是整数、浮点数，返回值的类型与参数x的类型一致。

print(abs(3))        # 返回绝对值3
print(abs(-3.0))     # 返回绝对值3.0
print(abs(-3.45))    # 返回绝对值3.45

3
3.0
3.45

如果参数x是一个复数，则返回它的模。

print(abs(3 + 4j))  # 返回复数3+4j的模5.0

5.0

2、divmod(a, b)

参数a、b可以是整数、浮点数，返回以整数商和余数构成的二元组，相当于(a // b, a % b)

print(divmod(10, 3))        # 输出(3, 1)
print(divmod(10, -3))       # 输出(-4, -2)
print(divmod(-10, 3))       # 输出(-4, 2)
print(divmod(-10, -3))      # 输出(3, -1)

(3, 1)
(-4, -2)
(-4, 2)
(3, -1)

print(divmod(11.5, 3.5))    # 输出(3.0, 1.0)
print(divmod(11.5, -3.5))   # 输出(-4.0, -2.5)
print(divmod(-11.5, 3.5))   # 输出(-4.0, 2.5)
print(divmod(-11.5, -3.5))  # divmod()输出(3.0, -1.0)

(3.0, 1.0)
(-4.0, -2.5)
(-4.0, 2.5)
(3.0, -1.0)

3、pow(x, y[, z])

两参数形式 pow(x, y) 返回x的y次幂，等价于乘方运算：x ** y

print(pow(2, 3))      # 等价于2**3，返回8
print(pow(2, -3))      # 等价于2**-3，返回0.125
print(pow(2, 1/2))    # 等价于2**0.5，返回1.4142135623730951
print(pow(-9, 1/2))   # 等价于-9**0.5，返回复数1.8369701987210297e-16+3j，实部近似为0

8
0.125
1.4142135623730951
(1.8369701987210297e-16+3j)

如果z存在，则返回x的y次幂对z取余的结果， 比 pow(x, y) % z 更高效。此时三个参数均必须为整数。

print(pow(1999, 1998, 1997)) 
print(1999 ** 1998 % 1997) 

4
4

4、round(number[, n])

浮点数number保留n 位小的最短表示。

Python 中采用的末位取舍算法为：

四舍六入五考虑，

五后非零就进一，

五后为零看奇偶，

五前为偶应舍去，

五前为奇要进一。

四舍六入五考虑，五后非零就进一，

print(round(3.84, 1))      # 舍去，输出3.8
print(round(3.86, 1))      # 进位，输出3.9
print(round(3.125000001, 2))  # 五后非零应进一，输出3.13

3.8
3.9
3.13

五后为零看奇偶，五前为偶应舍去，五前为奇要进一。

print(round(3.12500000, 2))     # 五前为偶应舍去，输出3.12
print(round(3.11500000, 2))     # 五前为奇要进一，输出3.12

3.12
3.12

如果n被省略或为None,则返回最接近输入值的整数，即取整。

print(round(3.14))
print(round(-3.84))

3
-4

结果小数部分的末位为0 或n 超过小数位数时，返回该数的最短表示，舍弃浮点数末尾无意义的零。

print(round(3.000006, 2))       # 期望输出3.00，实际输出其浮点数的最短表示3.0
print(round(3.140000005, 4))    # 期望输出3.1400，实际输出3.14

3.0
3.14

需要注意的是，多数浮点数无法精确转为二进制，会导致部分数字取舍与期望不符。

print(round(3.1425, 3))  # 五前为偶应舍去，期望输出3.142，实际输出3.143
print(round(2.675, 2))   # 五前为奇应进一，期望输出2.68，实际输出2.67

3.143
2.67

使用decimal模块可观察浮点数的精确值，round()函数的舍入实际上是按照其精确值处理的。

import decimal  # 引入decimal模块
print(decimal.Decimal(3.1425))  
print(decimal.Decimal(2.675))

3.1425000000000000710542735760100185871124267578125
2.67499999999999982236431605997495353221893310546875

5、max(iterable)或max(arg1,arg2,…)

max(arg1,arg2,…) 从多个参数中返回其最大值。

print(max(80, 100, 1000))
print(max(32.7, 45.9, -100))

1000
45.9

max(iterable) 从一个可迭代对象中返回其最大值。

print(max([80, 100, 1000]))     # 返回列表中的最大值
print(max({32.7, 45.9, -100}))  # 返回集合中的最大值

1000
45.9

6、min(iterable)或min(arg1,arg2,…)

min(arg1,arg2,…) 从多个参数中返回其最小值

print(min(80, 100, 1000))
print(min(32.7, 45.9, -100))

80
-100

min(iterable) 从一个可迭代对象中返回其最小值

print(min([80, 100, 1000]))     # 返回列表中的最小值
print(min({32.7, 45.9, -100}))  # 返回集合中的最小值

80
-100

7、sum(iterable, start=0)

省略start时，将元素为数值的可迭代对象iterable中的元素累加。

print(sum(range(11)))      # 1+2+3+......+10，返回55
print(sum([1, 2, 3, 4]))   # 1+2+3+4，返回10

55
10

若给strat参数传值，将元素为数值的可迭代对象iterable中的元素累加到start上

print(sum(range(11), start=10))  # 10+1+2+3+......+10，返回65
print(sum([1, 2, 3, 4], 20))     # 20+1+2+3+4，返回30

65
30

start参数值非整数时的应用：列表降维

若一个二维列表包含 n 个一维列表元素，可使用sum()函数将这些子列表拼成一个新的一维列表，起到降维的效果。

ls=[[95, 96, 85, 63, 91], [75, 93, 66, 85, 88], [86, 76, 96, 93, 67], [88, 98, 76, 90, 89], [99, 96, 91, 88, 86]]
print(sum(ls,[]))

[95, 96, 85, 63, 91, 75, 93, 66, 85, 88, 86, 76, 96, 93, 67, 88, 98, 76, 90, 89, 99, 96, 91, 88, 86]

在某些使用场景时，不要用sum()。例如当以扩展精度对浮点数求和时，使用sum()可能无法得到精确结果，此时推荐使用 math.fsum()。

print(sum([0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]))   # 期望输出1.0，实际结果为0.9999999999999999

0.9999999999999999

import math  # 引入math模块
print(math.fsum([0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]))  # 可获得精确的结果，输出1.0

1.0

8、eval(source)

前面我们讲解过使用eval()进行数值类型转换。
实际上，source参数是一个字符串，python会将source当做一个python表达式（从技术上讲，是一个条件列表）进行解析和计算。

x = 1
y = 3
print(eval('x+1'))        # 计算表达式x+1，输出2
print(eval('pow(y, 2)'))  # 计算表达式pow(y, 2)，输出9

2
9

当eval()解析到表达式是不可以计算后，就会查找它是不是一个变量的名字，如果是一个变量的名字，那么它会输出这个变量的内容，否则就会抛异常。

s = 'abc'
print(eval('s'))  # 解析到s，将其当作变量名，输出其值'abc'
s = '"abc"'
print(eval(s))    # eval去除单引号后得到了字符串“abc”，直接输出。

abc
abc

s = 'abc'
print(eval(s))   # 解析到abcd，将其当作变量名，此时该变量名未定义，抛NameError异常

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

Input In [29], in ()
      1 s = 'abc'
----> 2 print(eval(s))


File :1, in 


NameError: name 'abc' is not defined

9、complex([real[, imag]])

如果第一个形参real是字符串，则它被解释为一个复数。此时函数调用时必须没有第二个形参，否则将抛异常。

print(complex('1'))     # 解释为复数，此时虚部为0，输出(1+0j)
print(complex('1+2j'))  # 解释为复数，输出(1+2j)

(1+0j)
(1+2j)

print(complex('1',2))        # 第一个参数为字符串，此时若设置第二个参数，将抛异常

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

Input In [38], in ()
----> 1 print(complex('1',2))


TypeError: complex() can't take second arg if first is a string

如果第一个形参real是数值型（整数、浮点数或复数），则函数调用时可以有第二个形参imag，返回值为 real + imag*1j 的复数。如果省略了imag，则默认值为零。

print(complex(1))           # 实部为1，此时虚部为默认值0，输出(1+0j)
print(complex(1, 2))        # 输出(1+2j)
print(complex(3.4, 5.6))    # 输出(3.4+5.6j)
print(complex(1+2j, 3+4j))  # 计算(1+2j)+(3+4j)*j，输出(-3+5j)

(1+0j)
(1+2j)
(3.4+5.6j)
(-3+5j)

第二个形参imag不能是字符串，否则将抛异常。

print(complex(1, '2'))        # 第二个参数为字符串，抛异常

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

Input In [43], in ()
----> 1 print(complex(1, '2'))


TypeError: complex() second arg can't be a string

+5.6j)
(-3+5j)

第二个形参imag不能是字符串，否则将抛异常。

print(complex(1, '2'))        # 第二个参数为字符串，抛异常

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

Input In [43], in ()
----> 1 print(complex(1, '2'))


TypeError: complex() second arg can't be a string