一、运算符是什么
学运算符之前,先记住一句话:运算符就是“动作”,它两边的值就是“被动作的东西”。
比如 3 + 5 里,3 和 5 是要处理的对象(叫操作数),+ 是动作(叫运算符)。这一整句叫表达式——表达式算完之后,一定会得到一个结果。
Python 的运算符按用途可以分成五大类,先看一眼全貌,后面每一类都会单独讲:
| 类别 | 主要符号 | 一句话用途 |
|---|---|---|
| 算术运算符 | + - * / // % ** | 做数学计算 |
| 比较运算符 | == != > < >= <= | 比大小、问“是不是” |
| 赋值运算符 | = += -= *= /= //= %= **= | 把值存进变量 |
| 逻辑运算符 | and or not | 把多个条件连起来 |
| 成员 / 身份运算符 | in not in is is not | 判断“在不在”“是不是同一个” |
这五类里,算术和赋值每天都在用;比较和逻辑是写判断(if)的左右手;成员和身份是判断“在不在”“是不是同一个”的小工具。
x += 1 其实就是 x = x + 1 的简写)。二、算术运算符:做数学计算
算术运算符就是计算器上那几个键,一共 7 个。先看总表:
| 运算符 | 名称 | 作用 | 例子 | 结果 |
|---|---|---|---|---|
+ | 加法 | 把两个数加起来 | 3 + 5 | 8 |
- | 减法 | 相减 | 10 - 4 | 6 |
* | 乘法 | 相乘 | 6 * 7 | 42 |
/ | 除法 | 相除,结果一定是小数 | 10 / 3 | 3.3333333333333335 |
// | 整除 | 相除,只保留整数部分(向下取整) | 10 // 3 | 3 |
% | 取模 | 求除法的余数 | 10 % 3 | 1 |
** | 幂运算 | 求一个数的几次方 | 2 ** 3 | 8 |
下面把它们放在一段代码里跑一遍(# 里的内容就是程序的输出):
print(3 + 5) # 8 加法
print(10 - 4) # 6 减法
print(6 * 7) # 42 乘法
print(10 / 3) # 3.3333333333333335 除法(结果一定是小数)
print(10 // 3) # 3 整除(只留整数部分)
print(10 % 3) # 1 取模(求余数)
print(2 ** 3) # 8 幂(2 的 3 次方)
要特别注意 / 和 // 这一对,它们看着像,结果完全不同:
print(10 / 3) # 3.3333333333333335 除不尽,是小数
print(10 // 3) # 3 只留整数部分
print(10 / 2) # 5.0 ← 能整除,结果还是小数!
print(10 // 2) # 5 ← 整除,结果才是整数
print(type(10 / 2)) # <class 'float'> 小数
print(type(10 // 2)) # <class 'int'> 整数
10 // 3 是“向下取整”而不是“四舍五入”?10 // 3 得到 3 很好理解,但负数会反直觉:print(10 // 3) # 3
print(-10 // 3) # -4 ← 注意!不是 -3
“向下”指的是往数轴上更小的方向走:-10 ÷ 3 ≈ -3.33,比它小的整数是 -4。如果误以为是“去掉小数部分”,就会错答成 -3。
%(取余)是新手最容易忽略、却最有用的一位。它算的是一次除法之后剩下来的余数,最大的用途就是判断奇偶和分组:
n = 7
print(n % 2) # 1 7 除以 2 余 1
print(n % 2 == 1) # True → 余数是 1,说明是奇数
print(8 % 2 == 0) # True → 余数是 0,说明是偶数
print(9 % 2 == 0) # False
# 取余还常用来分组:第 n 件包裹放到第 n % 4 号柜格
for n in range(1, 7):
print(f"第 {n} 件 → {n % 4} 号柜")
顺手一招:用取余算生肖
十二生肖 12 年一轮,正好对应「除以 12 取余数」。用 (年份 - 4) % 12 的余数去查一串生肖,就能算出某一年属什么:0 鼠、1 牛、2 虎、3 兔、4 龙、5 蛇、6 马、7 羊、8 猴、9 鸡、10 狗、11 猪。
year = 2026
animals = "鼠牛虎兔龙蛇马羊猴鸡狗猪"
print(animals[(year - 4) % 12])
输出:
马
2026 年正好是马年。取余的本质是「转圈圈」:余数就是转完整数圈之后,停在第几个位置。
另外,+ 和 * 还有一份“兼职”:当两边不是数字而是文字、列表时,它们会变成拼接和重复。
print("Py" + "thon") # Python 两个字符串拼起来
print("ha" * 3) # hahaha 字符串重复 3 次
print([1, 2] + [3, 4]) # [1, 2, 3, 4] 两个列表接起来
/ 的结果一定是小数,哪怕能整除(4 / 2 得到 2.0);② 想要整数就写 //,但要知道它是向下取整,不是四舍五入。课程思政|工匠精神与严谨求实 · 差一位就是错
算术运算符里有一对最容易被忽略:/ 算出来永远是小数,// 只管整数部分,还是「向下取整」。10 / 2 得到 5.0 而不是 5,很多人第一眼就放过。差不多的结果,往往差着一位——跟数据打交道,差一位可能就是一笔账、一份报表的事。先看清规则再动手,比事后返工省得多。
三、比较运算符:问一句话,答 True 或 False
比较运算符的作用是“问一句话”,而这类问题的答案只有两个:True(对)或者 False(不对)。
| 运算符 | 名称 | 作用 | 例子 | 结果 |
|---|---|---|---|---|
== | 等于 | 问左右两边是否相等 | 5 == 5 / 5 == '5' | True / False |
!= | 不等于 | 问左右两边是否不相等 | 5 != 3 / 5 != 5 | True / False |
> | 大于 | 左边是否大于右边 | 8 > 5 / 3 > 5 | True / False |
< | 小于 | 左边是否小于右边 | 2 < 7 / 9 < 5 | True / False |
>= | 大于等于 | 左边是否大于或等于右边 | 6 >= 6 / 4 >= 7 | True / False |
<= | 小于等于 | 左边是否小于或等于右边 | 3 <= 5 / 8 <= 2 | True / False |
跑一遍看结果:
print(5 == 5) # True 相等
print(5 != 3) # True 不相等
print(8 > 5) # True 大于
print(2 < 7) # True 小于
print(6 >= 6) # True 大于或等于
print(3 <= 5) # True 小于或等于
print(3 > 5) # False
print(type(3 > 5)) # <class 'bool'> 真假值
print(5 == '5') # False 一个是数字,一个是文字,不相等
请注意:比较运算的结果不是数字,而是 True / False 这种“真假值”(类型叫 bool)。这正是下一章 if 判断的基础——if 后面跟的就是这种真假值。
Python 还支持连着写的比较,读起来跟数学课本一样:
age = 20
print(18 <= age < 60) # True 这就是“18 到 60 之间”的写法
score = 85
print(60 <= score < 90) # True 分数在 [60, 90) 区间内
# 上面第一句完全等价于下面这句,但更短更好读:
print(18 <= age and age < 60) # True
print('a' < 'b') # True 按字母顺序,a 在 b 前面
print('10' < '9') # True ← 坑!按字典顺序逐位比,'1' 比 '9' 小
print(10 < 9) # False ← 数字比较才是我们习惯的结果
print(int('10') < int('9')) # False 先转换再比,就对了
所以 "10" 和 "9" 比较时,比的是第一个字符 "1" 和 "9","1" 更小,结果就是 True。要按数值比较,得先转成数字。
== 是两条等号,= 是一条(下一节讲区别);③ 数字和文字不能直接比大小,先 int() 转换。四、赋值运算符:把值存进变量
赋值运算符负责把值“存进”变量。最重要的一句话:= 不是“等于”,而是“放进去”。
x = 5 读作“把 5 放进 x 这个盒子”,它不产生 True / False,只是完成一次存放动作。
除了最简单的 =,Python 还提供了一组组合写法,把“算一算”和“存回去”合并成一步:
| 运算符 | 等价写法 | 说明 |
|---|---|---|
= | — | 把右边的值赋给左边的变量 |
+= | x = x + y | 在原来的基础上加 |
-= | x = x - y | 在原来的基础上减 |
*= | x = x * y | 在原来的基础上乘 |
/= | x = x / y | 除以(结果变成小数) |
//= | x = x // y | 整除(向下取整) |
%= | x = x % y | 对结果取余 |
**= | x = x ** y | 取若干次方 |
用一段代码把上面这些逐个走一遍:
x = 3
print(x) # 3 先把 3 放进 x
x += 2 # 等价于 x = x + 2
print(x) # 5
x -= 1 # 等价于 x = x - 1
print(x) # 4
x *= 5 # 等价于 x = x * 5
print(x) # 20
x /= 4 # 等价于 x = x / 4
print(x) # 5.0 ← 从这一步开始变成小数了
x //= 2 # 5.0 // 2
print(x) # 2.0
x **= 3 # 2.0 的 3 次方
print(x) # 8.0
x %= 3 # 8.0 除以 3 的余数
print(x) # 2.0
组合写法的价值就两个字:省事。少打一遍变量名,也就少一次写错的机会:
count = 0
count = count + 1 # 老写法:变量名写了两遍
count += 1 # 简写:意思完全一样,更清爽
print(count) # 2
不只是数字,字符串也能这样累加:
s = "Py"
s += "thon" # 等价于 s = s + "thon"
print(s) # Python
/=,变量就会变成小数,后面再算都会带着小数点。上面那段代码最后输出 2.0 而不是 2,就是这个原因。+= 理解成“在原来的基础上再加”,读代码时就不会卡住。count += 1 是程序中最高频的一行代码(数数、计数、循环累加全靠它)。五、逻辑运算符:把多个条件串起来
逻辑运算符只有三个:and、or、not。它们的作用是把好几个条件连成一个条件。
先用最直白的话理解:and 要求“两个都对”,or 只要“有一个对”,not 是“反过来说”。
| A | B | A and B |
A or B |
not A |
|---|---|---|---|---|
| True | True | True | True | False |
| True | False | False | True | False |
| False | True | False | True | True |
| False | False | False | False | True |
把真值表里的每一行都跑一遍:
print(3 > 2 and 5 < 6) # True 两个都对
print(3 > 2 and 5 > 6) # False 有一个不对,结果就不对
print(3 > 2 or 5 > 6) # True 至少一个对,结果就对
print(3 < 2 or 5 > 6) # False 两个都不对
print(not (3 > 2)) # False 把 True 反过来
print(not (3 < 2)) # True 把 False 反过来
真实场景——判断一个年龄是否有效,必须同时满足两个条件:
age = 19
name = "小满"
# 两个条件都得成立:既要有名字,年龄也要在合理范围
if name != "" and 0 < age < 150:
print("报名信息有效")
else:
print("报名信息有问题")
and 如果左边已经是 False,右边根本不会执行;or 如果左边已经是 True,右边也不会执行。这既省时间,也常被用来避免报错。def hello():
print("[hello 被执行了]")
return True
print(False and hello()) # 输出 False,右边没执行
print(True or hello()) # 输出 True,右边也没执行
上面这段代码只输出 False 和 True,没有出现 [hello 被执行]——因为 and 的左边已经是“假”,右边的函数压根没被调用。
Python 有一个自己的特点:and 和 or 交出来的不是 True / False,而是参与运算的那个值本身。
print(6 and 3) # 3 ← 不是 True!两个都“真”,交出后面那个
print(0 and 3) # 0 ← 前面是“假”,直接交出它,后面不看了
print(6 or 3) # 6 ← 前面已经“真”,直接交出它
print(0 or 3) # 3 ← 前面是“假”,只好交后面那个
print('a' and 'b') # b
利用这一点,可以写出很简洁的代码。比如下面的写法,用户直接回车时用默认值顶替:
name = input("请输入名字:") or "匿名用户"
print("你好,", name)
# 直接回车(输入空字符串)时,结果就是:你好, 匿名用户
0、空字符串 ""、空列表 []、None 都算“假”,其余算“真”;② not 只对一个条件取反,写了多个条件要加括号;③ 判断范围优先用链式比较 0 < age < 150,比 and 更清楚。AI 助手小贴士|and / or 的短路行为是隐藏考点,让 AI 用会「翻车」的例子演示。
打开任意 AI 对话工具(网页版或 App 都可以),试试这样问:and 和 or 的短路行为是什么?用两个「条件顺序不同、结果就不同」的表达式例子演示,并解释原因
课程思政|数据安全与法治素养 · 两个条件都对了才放行
and 要求两边都对,or 只要一边对——一词之差,意义完全不同。落到现实里,这类判断常常就是「门禁」:核查一条记录该不该被访问,必须两个条件都成立才放行,写成 or 就等于把门敞开大半。用 or 图省事的那一下,可能就是安全的口子。条件怎么写,等于把底线画在哪里。
六、成员与身份运算符:在不在、是不是
这两类运算符在别处不太见到,但 Python 里非常好用。它们回答的是两个不同的问题:“在不在里面”和“是不是同一个”。
6.1 成员运算符:在不在里面
| 运算符 | 含义 | 例子 | 结果 |
|---|---|---|---|
in | 在……里面 | 'a' in 'abc' | True |
in | 在……里面 | 4 in [1, 2, 3] | False |
not in | 不在……里面 | 'x' not in 'abc' | True |
not in | 不在……里面 | 3 not in [1, 2, 3] | False |
常见的“容器”有字符串、列表、元组、字典的键、集合:
print('a' in 'abc') # True 单个字母在字符串里
print('thon' in 'Python') # True 连续的片段也算
print('A' in 'abc') # False 区分大小写
print(4 in [1, 2, 3]) # False 4 不在列表里
print(3 in [1, 2, 3]) # True
print('x' not in 'abc') # True x 确实不在
print(3 not in [1, 2, 3]) # False 3 在里面,所以“不在”不成立
# 实际用法:检查一条外卖备注里有没有关键词
note = "珍珠奶茶,少冰,不要椰果"
print('椰果' in note) # True
print('加糖' in note) # False
in 在字符串里判断的是连续的片段,所以 "thon" in "Python" 是 True。另外它区分大小写,"A" in "abc" 是 False。6.2 身份运算符:是不是同一个
is 和 is not 比较的是“这两个名字是不是指向同一个对象”。先看一段最容易说明问题的代码:
a = [1, 2]
b = a # b 和 a 指向同一个东西
print(a == b) # True 内容一样
print(a is b) # True 就是同一个对象
c = [1, 2] # 另做了一个内容相同的新列表
print(a == c) # True 内容一样,所以相等
print(a is c) # False ← 但不是同一个对象
为什么 a == c 是 True,但 a is c 是 False?关键在于:b = a 是“给同一个东西再贴一个标签”;而 c = [1, 2] 是“另做了一个内容一样的新东西”。
| 写法 | 比较的是什么 | 什么时候是 True |
|---|---|---|
a == c | 内容(值) | 两边内容一样就为 True |
a is c | 身份(内存地址) | 两边是同一个对象才为 True |
6.3 什么时候真的需要用 is
日常判断“值是否相等”一律用 ==;is 最好只用在判断 None 上:
result = None
print(result is None) # True 推荐这样写
print(result == None) # True 能用,但不推荐
== 问“内容一样吗”,is 问“是同一个东西吗”。判断 None 用 is None,其余情况默认用 ==。七、最容易搞混的几组对比
运算符本身不难,难的是长得像的符号。这一节把最容易混淆的几组放在一起对照,看完基本就不会错了。
7.1 = 与 ==:赋值 vs 比较
这两个是最常见的笔误来源,区别只有一条等号还是两条等号:
| 写法 | 名称 | 动作 | 结果 |
|---|---|---|---|
x = 5 | 赋值 | 把 5 存进变量 x | 不产生 True/False,只是存放 |
x == 5 | 比较 | 问“x 是否等于 5” | True 或 False |
x = 5 # 赋值:把 5 放进 x
print(x == 5) # 比较:x 是不是等于 5 → True
# if x = 5: # ✗ 语法错误 SyntaxError
if x == 5: # ✓ 正确写法
print("x 就是 5")
if x = 5: 会直接报语法错误 SyntaxError,因为 = 是赋值,放进判断条件里是不合法的。看到这个报错,先检查是不是少写了一个等号。7.2 == 与 is:值相等 vs 同一个对象
| 写法 | 问的问题 | 例子 | 结果 |
|---|---|---|---|
a == c | 内容一样吗 | [1,2] == [1,2] | True |
a is c | 是同一个对象吗 | [1,2] is [1,2] | False |
判断 None 用 is,判断其它一律用 ==。
7.3 / 与 //:一个得到小数,一个得到整数
| 表达式 | 结果 | 说明 |
|---|---|---|
10 / 2 | 5.0 | 除以:结果一定是小数,即使能整除 |
10 // 2 | 5 | 整除:结果是整数 |
10 / 4 | 2.5 | 除不尽时保留小数 |
10 // 4 | 2 | 整除只留整数部分(向下取整) |
7.4 同一个 +,一会儿加法一会儿拼接
+ 到底做什么,取决于两边是什么类型:
print(3 + 5) # 8 数字 + 数字 = 加法
print("3" + "5") # 35 文字 + 文字 = 拼接
print("3" * 3) # 333 文字 * 数字 = 重复
# print(3 + "5") # ✗ TypeError 一个数字一个文字,加不了
3 + "5" 会报 TypeError,因为一个是数字、一个是文字,Python 不知道该做加法还是拼接。类型混搭是新手报错的头号原因,看到 TypeError 就检查两边的类型。7.5 运算符的优先级
当一个表达式里有多个运算符,Python 按下面的顺序算(越上面越先算):
| 优先级 | 运算符 | 说明 |
|---|---|---|
| 1(最高) | ** | 幂 |
| 2 | +x -x | 正负号 |
| 3 | * / // % | 乘除类 |
| 4 | + - | 加减 |
| 5 | == != > < >= <= | 比较运算 |
| 6 | in not in is is not | 成员、身份 |
| 7 | not | 逻辑非 |
| 8 | and | 逻辑与 |
| 9(最低) | or | 逻辑或 |
print(2 + 3 * 4) # 14 先乘后加
print((2 + 3) * 4) # 20 括号优先
print(2 ** 3 ** 2) # 512 幂是“从右往左”算:2 ** (3 ** 2)
print(1 + 2 == 3) # True == 比 + 低,先算 1 + 2
print(not 1 == 2) # True 相当于 not (1 == 2)
not:它比比较运算低,所以 not 1 == 2 其实是 not (1 == 2),结果是 True。八、把运算符串起来:三个小例子
运算符单独看都很简单,难的是组合使用。下面三个小例子把前面几节的内容串起来,建议照着敲一遍。
例 1:判断闰年(比较 + 逻辑 + 取余)
规则:能被 4 整除但不能被 100 整除,或者能被 400 整除。
year = int(input("请输入年份:"))
# 能被 4 整除(%4==0) 且 不能被 100 整除,或者 能被 400 整除
if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
print(f"{year} 年是闰年")
else:
print(f"{year} 年不是闰年")
运行结果:
请输入年份:2024
2024 年是闰年
请输入年份:2023
2023 年不是闰年
上面这串 %4 %100 %400 是闰年的「原理」,得会写。但真写程序时不用自己算——Python 标准库 calendar 里有个现成的函数 calendar.isleap()(isleap 就是 is leap year),把年份交给它,它直接回你 True 或 False。
import calendar
for year in [2024, 2023, 1900, 2000]:
if calendar.isleap(year):
print(f"{year} 年是闰年")
else:
print(f"{year} 年不是闰年")
运行结果:
2024 年是闰年
2023 年不是闰年
1900 年不是闰年
2000 年是闰年
or 串起来的长条件是练「运算符怎么组合成条件」;等原理懂了,实际就写 calendar.isleap(year) 这种现成的函数——少写一行,也少一次算错的机会。标准库里这类现成工具还有一大堆,见《28-常用标准库》。例 2:判断成绩等级(链式比较 + 逻辑 + 赋值)
score = int(input("请输入分数:"))
if score < 0 or score > 100:
print("分数要在 0 到 100 之间")
elif 90 <= score <= 100: # 链式比较 + 比较运算
print("优秀")
elif 80 <= score < 90:
print("良好")
elif 60 <= score < 80:
print("及格")
else:
print("不及格")
运行结果:
请输入分数:85
良好
请输入分数:102
分数要在 0 到 100 之间
例 3:奶茶团购折扣(算术 + 逻辑 + 赋值组合)
price = float(input("奶茶单价:"))
count = int(input("杯数:"))
total = price * count # 算术运算
# 满 100 元 并且 买 3 杯以上,打九折
if total >= 100 and count >= 3: # 逻辑运算
total *= 0.9 # 赋值运算:等于 total = total * 0.9
print("已享受九折优惠")
print(f"应付金额:{total:.2f} 元")
运行结果:
奶茶单价:15
杯数:8
已享受九折优惠
应付金额:108.00 元
AI 助手小贴士|优先级是运算符的隐形规则,出题检验最有效。
打开任意 AI 对话工具(网页版或 App 都可以),试试这样问:出 5 道运算符优先级判断题(要包含 / // % 和 and or),我答完逐题讲解为什么
课程思政|诚信与职业操守 · 别人的分数,别动手脚
例子里判断成绩等级时,改一改阈值,出来的等级就会变。这段小代码其实很像真实场景:将来你手里会有别人的成绩、收入、业绩,只要动一行判断条件,数字就能「好看」一点。算出来的结果,要如实呈现——统计数字骗不了人,但人会;能守住不改动的那一下,才是这份专业最该有的底色。
九、常见坑与排错
下面这些是新同学在运算符上最常遇到的问题,逐条对照排查。
| 现象 / 报错 | 原因 | 怎么改 |
|---|---|---|
SyntaxError(if x = 5:) | 把赋值 = 写在了判断条件里 | 改成比较 == |
TypeError(3 + "5") | 数字和文字混在一起运算 | 先统一类型:int("5") 或 str(3) |
10 / 2 得到 5.0 不是 5 | / 的结果一定是小数 | 要整数就用 10 // 2 |
-10 // 3 得到 -4 不是 -3 | // 是向下取整,不是去掉小数部分 | 记住“往数轴更小的方向走”即可 |
2 and 3 得到 3 不是 True | Python 的 and / or 交出的是操作数本身 | 想强制转成真假值就套 bool() |
Age 报 NameError | Python 区分大小写,变量名大小写不一致 | 检查大小写是否与定义时完全一致 |
"10" < "9" 是 True | 字符串按字典顺序逐位比较 | 先 int() 转成数字再比 |
2 + 3 * 4 得到 14 而不是 20 | 乘号优先级高于加号 | 想先加就写 (2 + 3) * 4 |
None 用 == 判断 | 能用,但不是推荐写法 | 改成 result is None |
SyntaxError: invalid syntax(含中文符号) | 输入法把 ()、,、"" 打成了全角 | 切回英文输入法重打标点 |
SyntaxError 多半是符号写错,TypeError 多半是类型混搭,NameError 是变量名拼错或没定义。ValueError 是用 int() 转换时内容不是数字。看懂最后一行,排查速度会快很多。AI 助手小贴士|/、//、% 长得像、含义差很多,是最容易混的一组。让 AI 用生活例子讲一遍,再出题检验自己是不是真懂了。
打开任意 AI 对话工具(网页版或 App 都可以),试试这样问:用分苹果、数人数这样的生活例子解释 Python 里 /、//、% 的区别,讲完出 3 道题考我,我答完再对答案
十、随堂自测(10 题)
点击选项即可判分,答错的题会立刻显示解析。全部答完会给出正确率和错题清单,可以点“重新答题”再来一遍。
1下面哪个运算符的作用是“求余数”?
- A.
% - B.
// - C.
/ - D.
**
% 是取模,求一次除法之后剩下来的余数,如 10 % 3 得 1。// 是整除(只留整数部分),/ 的结果一定是小数,** 是幂运算。2print(-10 // 3) 的输出是什么?
- A.
3 - B.
-3 - C.
-4 - D.
-3.3333333333333335
// 是“向下取整”,也就是往数轴上更小的方向走:-10 ÷ 3 ≈ -3.33,向下取整得 -4。如果按“去掉小数部分”理解就会错答成 -3。3x = 5 和 x == 5 的区别是什么?
- A. 两者完全一样,怎么写都行
- B. 前者是判断,后者是赋值
- C. 前者报错,后者才是赋值
- D. 前者是赋值(把 5 存进 x),后者是判断(问 x 是否等于 5)
= 是赋值,把右边的值存进左边的变量,不产生 True / False;两条等号 == 是比较,结果是 True 或 False。写成 if x = 5: 会直接报 SyntaxError。4下面哪个写法是把 5 存进变量 x 里?
- A.
x == 5 - B.
x = 5 - C.
x != 5 - D.
5 = x
= 才是赋值,作用是把右边的值存进左边的变量。x == 5 是比较(问 x 是不是等于 5),x != 5 是判断不相等,而 5 = x 会报语法错误——赋值号左边必须是变量名,不能是数字。5print(6 and 3) 的结果是?
- A. 3
- B. True
- C. 2
- D. False
and 交出的是参与运算的值本身,不是 True / False。6 为“真”,所以继续看后面,直接交出 3。这是 Python 比较特别的地方,别以为结果一定是 True。6判断变量 name 是不是空值,推荐写法是?
- A.
name == None - B.
name is None - C.
name = None - D.
name != None
is 比较的是“是不是同一个对象”,而 None 全程序只有一个,所以 is None 最准也最快。注意 name = None 是赋值,会把 name 的值改掉。7print("3" + "5") 的输出是?
- A. 8
- B. 报错 TypeError
- C.
35.0 - D. 35
+ 做的是“拼接”,把两段文字接起来,所以得到 35 而不是 8。想要 8,得先转成数字:int("3") + int("5")。8print(2 ** 3 ** 2) 的结果是?
- A. 64
- B. 12
- C. 512
- D. 36
** 是从右往左结合的,先算 3 ** 2 得 9,再算 2 ** 9 得 512。64 是按从左往右(2**3=8,8**2=64)算出来的错误结果。9print(10 % 3 == 1) 这样写,是在判断什么?
- A. 10 除以 3 的余数是不是 1(判断奇偶这类场景常用)
- B. 10 能不能被 3 整除
- C. 10 和 3 哪个更大
- D. 10 乘以 3 的结果是不是 1
% 算出 10 除以 3 的余数 1,再用 == 问“是不是 1”,结果得 True。判断奇偶就是看 n % 2 == 0 是否成立。10执行 s = "Py" 之后再执行 s += "thon",print(s) 会输出什么?
- A. 报错 TypeError
- B. Py
- C. Python
- D. Pythonthon
+= 是加法赋值的简写,s += "thon" 等价于 s = s + "thon"。两边都是字符串,+ 做的是拼接,所以把两段文字接起来得到 Python,而不是重复。