目录
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匹配。
2597
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
