目录
2.1 算术运算
Python支持的算术运算见表2.1.1。
运算符 | 功 能 |
+ | 加法 |
- | 减法(双操作数),取相反数(单操作数) |
* | 乘法 |
/ | 除法。结果一定是小数,就算能整除结果也是小数 |
// | //除法。结果如果不是整数,就往小里取整。计算结果有可能是整数,也有可能是2.0、3.0这样小数部分为0的小数。如果参与运算的两个操作数都是整数,那么结果就是整数。如果有一个操作数是小数,结果就是小数 |
% | 取模(求余数)。a%b称为“a模b”,即求a除以b的余数。操作数可以是小数 |
** | 求幂 |
算术运算符示例如下:
a = (3+2)*(6-3)/2
print(a) #>>7.5
print(10/8) #>>1.25
print(10%8) #>>2 10模8,即求10除以8的余数
print(15/4) #>>3.75
print(3.4/2.2) #>>1.5454545454545452
print(2**3) #>>8求2的3次方
print(15//4) #>>3
print(3.4//2.2) #>>1.0
print(-9//4) #>>-3往小里取整
print(4.5%2.1) #>>0.2999999999999998
第1行:在Python的运算表达式中,括号“()”起到的作用和在普通数学算式中一样,括号里的式子要先算。
第6行:输出一个小数的时候,如果没有指定保留小数点后面几位,那么到底会输出几位,没有明确的说法。如果对输出格式有要求,就应该用格式控制符“.nf”指明保留小数点后面几位。
第8行:15除以4是3.75。由于参与运算的都是整数,所以结果就是整数3。
第9行:3.4除以2.2得1.5454......,往小里取整,就是1。Python规定,有小数参与运算的算术表达式,计算结果一定是小数,因此,结果就是1.0。
第10行:这里的“−”是取相反数的意思。−9除以4,结果往小的方向取整,就是−3。第11行:结果不是0.3是因为小数计算总会有误差。
第11行:结果不是0.3是因为小数计算总会有误差。
需要强调一点,除法“/”的结果一定是小数,哪怕能整除。而且Python中只要算术运算表达式中出现了小数,那么整个表达式的计算结果就一定是小数。例如:
print(10//2) #>>5
z = 10/2
print(z) #>>5.0
z = 10.0-10
print(z) #>>0.0
print(2+0*4.5) #>>2.0
print(10/5) #>>2.0
print(2+10/5) #>>4.0
第2行:虽然10/2能整除,但是“/”的结果一定是小数,所以z就是小数5.0。
第4行:包含小数的算术表达式,结果一定是小数,所以z就是小数0.0。下面第6,7,8行都在表明这个规定。
常见错误:题目要求输出结果是整数,却输出了XXXX.0形式的小数。比如应该输出10,却输出了10.0。忘记除法"/"的结果一定是小数,以及含小数的算式结果一定是小数,就可能导致这个问题。根据实际情况,可以考虑用int(x)或round(x)将小数x转换成整数,就能解决这个问题。在后文“条件分支语句”一节的“温度转换”例题和“简单计算器”例题中会讲述这个问题。
常见错误:误把除法运算符“/”当分数线,导致计算顺序方面的错误。“/”是“÷”,不是分子分母之间的水平分数线。因此a/b*c是a÷b×c,不是a/(b*c)。
Python中的算术运算符是有优先级的。从高到低依次是:
第一级:**
第二级:−(求相反数)
第三级:*///%
第四级:+ -(减法)
记不清优先级就勤用“()”来写清楚计算顺序,如(a/b)**c,这样既保险,也易懂。就算你记得清优先级,读你程序的人未必记得,说不定他记错了,就会理解错你的程序。因此不妨自己麻烦点,多用括号,与人方便。
算术运算符后面还可加上赋值号“=”形成“算术赋值运算符”,在计算的同时进行赋值。例如,a+=b等价于a=a+b,a=b等价于a=ab。同理还有*=、/=、%=、**=。算术赋值运算符中的算术运算符和“=”之间不能有空格,而且和赋值运算符一样,其左边必须是个变量。例如:
a = 6
a /= 3
print(a) #>>2.0
a **= 3
print(a) #>>8.0
2.2 关系运算和 bool 类型
Python中的数(整数、小数)和字符串都可以比较大小。列表、元组在特定情况下也可以比较大小。有6种关系运算符用于比较大小:
== 是否相等
!= 是否不等
> 是否大于
= 是否大于等于
<= 是否小于等于
比较的结果是bool类型,成立则为True,反之则为False。bool类型数据只有两种值,True或False。示例如下:
print(3 < 5) #>>True
print(4 != 7) #>>True
a = 4
print(a == 5) #>>False
print(2 < a < 6 < 8) #>>True
print(2 < a == 4 < 6) #>>True
print(2 < a == 5 < 6) #>>False
print((2 < a) == (7 < 8)) #>>True
print(2 < a > 5) #>>False
b = a <= 6 #b的值是True
print(b) #>>True
第5行:2小于a,a小于6,6小于8,因此结果是True。
第6行:2小于a,a等于4,4小于6,因此结果是True。
第7行:a不等于5,因此结果是False。
第8行:2<6 和 7<8这两个表达式的值都是True,相等。因此结果为True。
第10行:将表达式a<=6的值赋给b。因此b的值是True。
字符串可以通过关系运算符比较大小。字符串里的每个字符都由2个字节的Unicode编码表示,编码就是一个整数。两个字符串比大小,就是逐个字符的编码比大小,直到分出胜负。因为大小写字母编码不一样,因此字符串比大小时,大小写是有区别的:
a = "k"
print(a == "k") #>>True
a = "abc"
print(a == "abc") #>>True
print(a == "Abc") #>>False
print("abc" < "acd") #>>True
print("abc" < "abcd") #>>True
print("abc" > "Abc") #>>True,因为′a′的编码大于′A′的编码
英文字符串比大小,规则类似于在英文词典里,排前面的单词就比排在后面的小。但是汉字的Unicode编码是按《康熙字典》的偏旁部首和笔画数来排序的,所以两个汉字字符串比较大小,很难看出规律。在Python中,True和1等价,False和0等价,可以互换使用:
b = 3 < 4 #b的值为True
print(b == 1) #>>True
print(b == 2) #>>False
print(b + 3) #>>4 因b等于1
print(False == 0) #>>True
print(False + 2) #>>2 因False等于0
print(3 + (2 < 4)) #>>4 2 < 4为True,即1
6个关系运算符的优先级是一样的,一起运算时,按从左到右的顺序进行。
2.3 逻辑运算
逻辑运算有and、or、not三种,运算的结果都是True或False。
2.3.1 and
and,即与运算,形式为exp1andexp2。当且仅当exp1和exp2的值都为True(或相当于True),运算的结果为True(或相当于True)。其他情况,运算结果为False(或相当于False)。
在Python中,1和True等价,0和False等价。非0的数、非空的字符串、非空的列表、非空的元组、非空的字典、非空的集合,都相当于True,可以参与逻辑运算,但它们并不等于True。空字符串""、空列表[]、空元组、空字典、空集合,都相当于False,也可以参与逻辑运算,但它们并不等于False:
print(1 < 2 and 1 < 3) #True
print(1 < 2 and 1 > 3) #False
n = 4
print(n >= 2 and n < 5 and n%2 == 0) #>>True
print(n >= 2 and n < 5 and n%2 == 1) #>>False
print("" == False) #>>False
print([] == False) #>>False
print(2 == True) #>>False
print([2,3] == True) #>>False
print("ok" == True) #>>False
print(0 and "ok") #>>0
print(True and 8) #8
第4、5行:可以有任意多个表达式参与and运算。当且仅当所有表达式的值都为True(或相当于True),结果才为True(或相当于True)。
从第6行到第10行我们可以看出,空字符串、空列表都不等于False。1以外的非0的数、非空字符串、非空列表都不等于True。
第11、12行:"ok"、8都相当于True,因而都可以参与逻辑运算。只需要理解0and"ok"的值相当于False,Trueand8的值相当于True即可,至于这两行的输出结果为什么会是那样,虽然是可以讲清楚的,但我们并不需要掌握这样的细节—因为这种细节容易记错且没多大意义。
为叙述简便,今后提到表达式值为真,说的就是表达式的值为True或相当于True;提到表达式值为假,说的就是表达式值为False或相当于False。“相当于True”和“相当于False”这两个概念的作用,在后面学习“条件分支语句”的时候就会明白。
2.3.2 or
or,即或运算,形式为exp1 or exp2。
当且仅当exp1和exp2的值都为假时,结果为假,其他情况结果为真:
n = 4
print(n > 4 or n < 5) #>>True
print(0 or "ok") #>>"ok"
print("" or [ ]) #>>[ ]
print(4 > 5 or 4 >= 2 or 4%2 == 1) #>>True
2.3.3 not
not,即非运算,形式为not exp。exp值为真时,结果为False;exp值为假时,结果为True:
print(not 4 < 5) #>>False
print(not 5) #>>False
print(not 0) #>>True
print(not "abc") #>>False
print(not "") #>>True
print(not [ ]) #>>True
print(not [1]) #>>False
逻辑运算符的优先级,是not最高,and其次,or最低。逻辑运算表达式中同样可以用()来指定其中的内容是一个整体,要先算:
1. print(3 < 4 or 4 < 5 and 1 > 2) #>>True
2. print((3 < 4 or 4 < 5) and 1 > 2) #>>False
3. print(not 4 < 5 and 4 > 6) #>>False
第1行:and优先,因此等价于3 < 4 or (4 > 5 and 1 > 2)。
第3行:not比and优先,因此等价于(not 4 < 5) and 4 > 6,而非not(4 < 4 and 4 > 6)。
逻辑表达式是短路计算的,即对逻辑表达式的计算,在整个表达式的值已经能够断定的时候即会停止。对于exp1 and exp2,如果已经算出表达式exp1为假,那么整个表达式的值肯定为假,于是表达式exp2就不需要计算。对于exp1 or exp2,如果已经算出exp1为真,那么整个表达式必定为真,于是exp2就不必计算。短路计算可以节省计算表达式的时间。
2.4 运算符的优先级
Python中各类运算符,优先级从高到低依次是:
算术运算符:− (取相反数) ** * / // % + −(减法)
关系运算符:< > == != <= >=
逻辑运算符:not and or
赋值运算符:=
程序示例如下:
print(3 + 2 < 5) #>>False
print(3 + (2 < 5)) #>>4 因2<5 等于1
n = 4
a = 7 < n + 3 and n < 5 #n+3 先算,<、> 都比and先算
print(a) #>>False
再次强调,勤用()避免搞错优先级是个利人利己的好习惯。
2.5 条件分支语句
程序是从上到下顺序执行的。有时,并非所有的程序语句都应该被执行,会希望满足某种条件就执行一部分语句,满足另一条件就执行另一部分语句。这就需要“条件分支语句”,也叫“if语句”。if语句格式如下:
if 表达式1:
语句组1
elif 表达式2:
语句组2
......
elif 表达式n:
语句组n
else:
语句组n+1
elif是elseif的缩写。
if语句的执行过程是:依次计算表达式1、表达式2……只要碰到一个表达式i值为真,则执行语句组i(前面为假的表达式对应的语句组都不会被执行),且后面的表达式都不再计算,后面的语句组也都不会被执行。若表达式1至表达式n都为假,则执行语句组n+1。
if语句中的语句组由一条或多条语句组成,必须向右缩进至少1个空格。同一个语句组里的多条语句,缩进的程度必须一样,即它们应该左对齐。通常缩进4个空格会比较美观易读。在Python开发环境里,按Tab键进行缩进会比较方便。如果一个语句组里,有的语句缩进4个空格,有的语句缩进1个制表符,即使看上去是左对齐,也是不行的,PyCharm会用红线提示错误。要么都用空格缩进,要么都用制表符缩进。
Python程序有个规律:如果下一行要缩进,那么本行必须以“:”结尾。初学者经常忘记写这个“:”,开发环境就会在行末画红线提示错误。if语句可以没有else,形式如下:
if 表达式1:
语句组1
elif 表达式2:
语句组2
......
elif 表达式n:
语句组n
上面这种情况,如果所有表达式的值都是假,则所有语句组都不会被执行。if语句中的elif可以有任意多个,也可以没有:
if 表达式1:
语句组1
else:
语句组2
上面这种情况,如果表达式1的值为真,就执行语句组1,否则就执行语句组2。
if语句也可以elif和else都没有:
if 表达式1:
语句组1
上面这种情况,如果表达式1值为真,就执行语句组1,否则就不执行。下面是几个示例:
if int(input()) == 5: #输入5才会执行下面两行
print("a", end="")
print("b", end="")
print("c")
输入:5 输出:abc
输入:4 输出:c
第4行没有缩进,因此不是if语句组的一部分。它一定会被顺序执行到。
if int(input()) == 5:
print("a", end="")
print("b")
上面程序出错!第3行既没有和第2行对齐,也没有和第1行对齐,这个尴尬的位置让Python搞不清它到底是不是if语句组的一部分。下面的程序能说明什么是“相当于True”和“相当于False”。
if "ok": #"ok"相当于True,即是真
print("ok") #>>ok此句会被执行
if "": #""相当于False,即是假
print("null string") #此句不会执行
a = [4,2]
if a: #非空列表是真
print(a) #>>[4,2]
if 20: #非0的数是真
print(20) #>>20
if 0: #0就是False
print(0)此句不会执行
在一条if语句的某个分支(语句组)里,还可以再写if语句,称为if语句的嵌套:
a = int(input())
if a > 0:
if a % 2:
print("good")
else:
print("bad")
输入:4 输出:bad
输入:3 输出:good
输入:−1 无输出
在if语句的嵌套中,通过对齐来判断语句与哪个if匹配。