今天你 AI 赋能了吗?打开浏览器,在地址栏输入 xuefulu.ai ,按下 Enter 即可访问学府路1号!
2026年10月14日 星期三 10:40:05
常用网址: | | 学府路1号 https://xuefulu.ai | 下载 Python https://xuefulu.ai/Python.html | 下载 TRAE https://xuefulu.ai/Trae.html

一、运算符是什么

学运算符之前,先记住一句话:运算符就是“动作”,它两边的值就是“被动作的东西”。

比如 3 + 5 里,3 和 5 是要处理的对象(叫操作数),+ 是动作(叫运算符)。这一整句叫表达式——表达式算完之后,一定会得到一个结果。

打个比方:算式就像做菜。操作数是食材,运算符是“切、炒、煮”这些动作,表达式就是这道菜,最后端出来的那盘就是结果。

Python 的运算符按用途可以分成五大类,先看一眼全貌,后面每一类都会单独讲:

类别 主要符号 一句话用途
算术运算符+ - * / // % **做数学计算
比较运算符== != > < >= <=比大小、问“是不是”
赋值运算符= += -= *= /= //= %= **=把值存进变量
逻辑运算符and or not把多个条件连起来
成员 / 身份运算符in not in is is not判断“在不在”“是不是同一个”

这五类里,算术和赋值每天都在用;比较和逻辑是写判断(if)的左右手;成员和身份是判断“在不在”“是不是同一个”的小工具。

别被“五大类”吓住。真正需要背下来的符号只有十来个,其余都是变体(比如 x += 1 其实就是 x = x + 1 的简写)。

二、算术运算符:做数学计算

算术运算符就是计算器上那几个键,一共 7 个。先看总表:

运算符 名称 作用 例子 结果
+加法把两个数加起来3 + 58
-减法相减10 - 46
*乘法相乘6 * 742
/除法相除,结果一定是小数10 / 33.3333333333333335
//整除相除,只保留整数部分(向下取整)10 // 33
%取模求除法的余数10 % 31
**幂运算求一个数的几次方2 ** 38

下面把它们放在一段代码里跑一遍(# 里的内容就是程序的输出):

Python
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 次方)

要特别注意 / 和 // 这一对,它们看着像,结果完全不同:

Python
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 很好理解,但负数会反直觉:
Python
print(10 // 3)    # 3
print(-10 // 3)   # -4     ← 注意!不是 -3

“向下”指的是往数轴上更小的方向走:-10 ÷ 3 ≈ -3.33,比它小的整数是 -4。如果误以为是“去掉小数部分”,就会错答成 -3。

%(取余)是新手最容易忽略、却最有用的一位。它算的是一次除法之后剩下来的余数,最大的用途就是判断奇偶和分组:

Python
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 猪。

Python
year = 2026
animals = "鼠牛虎兔龙蛇马羊猴鸡狗猪"
print(animals[(year - 4) % 12])

输出:

输出
马

2026 年正好是马年。取余的本质是「转圈圈」:余数就是转完整数圈之后,停在第几个位置。

另外,+ 和 * 还有一份“兼职”:当两边不是数字而是文字、列表时,它们会变成拼接和重复。

Python
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 != 5True / False
>大于左边是否大于右边8 > 5 / 3 > 5True / False
<小于左边是否小于右边2 < 7 / 9 < 5True / False
>=大于等于左边是否大于或等于右边6 >= 6 / 4 >= 7True / False
<=小于等于左边是否小于或等于右边3 <= 5 / 8 <= 2True / False

跑一遍看结果:

Python
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 还支持连着写的比较,读起来跟数学课本一样:

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
容易踩的坑:字符串比较是按“字典顺序”逐位比的,不是按数值大小。
Python
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。要按数值比较,得先转成数字。

记住三条:① 比较的结果只有 True / False;② == 是两条等号,= 是一条(下一节讲区别);③ 数字和文字不能直接比大小,先 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取若干次方

用一段代码把上面这些逐个走一遍:

Python
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

组合写法的价值就两个字:省事。少打一遍变量名,也就少一次写错的机会:

Python
count = 0
count = count + 1     # 老写法:变量名写了两遍
count += 1            # 简写:意思完全一样,更清爽

print(count)          # 2

不只是数字,字符串也能这样累加:

Python
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
TrueTrueTrueTrueFalse
TrueFalseFalseTrueFalse
FalseTrueFalseTrueTrue
FalseFalseFalseFalseTrue

把真值表里的每一行都跑一遍:

Python
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 反过来

真实场景——判断一个年龄是否有效,必须同时满足两个条件:

Python
age = 19
name = "小满"

# 两个条件都得成立:既要有名字,年龄也要在合理范围
if name != "" and 0 < age < 150:
    print("报名信息有效")
else:
    print("报名信息有问题")
短路求值:and 如果左边已经是 False,右边根本不会执行;or 如果左边已经是 True,右边也不会执行。这既省时间,也常被用来避免报错。
Python
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,而是参与运算的那个值本身。

Python
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

利用这一点,可以写出很简洁的代码。比如下面的写法,用户直接回车时用默认值顶替:

Python
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

常见的“容器”有字符串、列表、元组、字典的键、集合:

Python
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 比较的是“这两个名字是不是指向同一个对象”。先看一段最容易说明问题的代码:

Python
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 上:

Python
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
Python
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 / 25.0除以:结果一定是小数,即使能整除
10 // 25整除:结果是整数
10 / 42.5除不尽时保留小数
10 // 42整除只留整数部分(向下取整)

7.4 同一个 +,一会儿加法一会儿拼接

+ 到底做什么,取决于两边是什么类型:

Python
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== != > < >= <=比较运算
6in not in is is not成员、身份
7not逻辑非
8and逻辑与
9(最低)or逻辑或
Python
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 整除。

Python
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。

Python
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:判断成绩等级(链式比较 + 逻辑 + 赋值)

Python
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:奶茶团购折扣(算术 + 逻辑 + 赋值组合)

Python
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 不是 TruePython 的 and / or 交出的是操作数本身想强制转成真假值就套 bool()
Age 报 NameErrorPython 区分大小写,变量名大小写不一致检查大小写是否与定义时完全一致
"10" < "9" 是 True字符串按字典顺序逐位比较先 int() 转成数字再比
2 + 3 * 4 得到 14 而不是 20乘号优先级高于加号想先加就写 (2 + 3) * 4
None 用 == 判断能用,但不是推荐写法改成 result is None
SyntaxError: invalid syntax(含中文符号)输入法把 ()、,、"" 打成了全角切回英文输入法重打标点
报错先看最后一行。Python 的报错信息最后一行才是结论:SyntaxError 多半是符号写错,TypeError 多半是类型混搭,NameError 是变量名拼错或没定义。ValueError 是用 int() 转换时内容不是数字。看懂最后一行,排查速度会快很多。

AI 助手小贴士|/、//、% 长得像、含义差很多,是最容易混的一组。让 AI 用生活例子讲一遍,再出题检验自己是不是真懂了。

打开任意 AI 对话工具(网页版或 App 都可以),试试这样问:用分苹果、数人数这样的生活例子解释 Python 里 /、//、% 的区别,讲完出 3 道题考我,我答完再对答案

十、随堂自测(10 题)

点击选项即可判分,答错的题会立刻显示解析。全部答完会给出正确率和错题清单,可以点“重新答题”再来一遍。

已答 0 / 10 · 正确 0 —

1下面哪个运算符的作用是“求余数”?

  • A. %
  • B. //
  • C. /
  • D. **
答案:A。% 是取模,求一次除法之后剩下来的余数,如 10 % 3 得 1。// 是整除(只留整数部分),/ 的结果一定是小数,** 是幂运算。

2print(-10 // 3) 的输出是什么?

  • A. 3
  • B. -3
  • C. -4
  • D. -3.3333333333333335
答案:C。// 是“向下取整”,也就是往数轴上更小的方向走:-10 ÷ 3 ≈ -3.33,向下取整得 -4。如果按“去掉小数部分”理解就会错答成 -3。

3x = 5 和 x == 5 的区别是什么?

  • A. 两者完全一样,怎么写都行
  • B. 前者是判断,后者是赋值
  • C. 前者报错,后者才是赋值
  • D. 前者是赋值(把 5 存进 x),后者是判断(问 x 是否等于 5)
答案:D。一条等号 = 是赋值,把右边的值存进左边的变量,不产生 True / False;两条等号 == 是比较,结果是 True 或 False。写成 if x = 5: 会直接报 SyntaxError。

4下面哪个写法是把 5 存进变量 x 里?

  • A. x == 5
  • B. x = 5
  • C. x != 5
  • D. 5 = x
答案:B。一条等号 = 才是赋值,作用是把右边的值存进左边的变量。x == 5 是比较(问 x 是不是等于 5),x != 5 是判断不相等,而 5 = x 会报语法错误——赋值号左边必须是变量名,不能是数字。

5print(6 and 3) 的结果是?

  • A. 3
  • B. True
  • C. 2
  • D. False
答案:A。Python 的 and 交出的是参与运算的值本身,不是 True / False。6 为“真”,所以继续看后面,直接交出 3。这是 Python 比较特别的地方,别以为结果一定是 True。

6判断变量 name 是不是空值,推荐写法是?

  • A. name == None
  • B. name is None
  • C. name = None
  • D. name != None
答案:B。is 比较的是“是不是同一个对象”,而 None 全程序只有一个,所以 is None 最准也最快。注意 name = None 是赋值,会把 name 的值改掉。

7print("3" + "5") 的输出是?

  • A. 8
  • B. 报错 TypeError
  • C. 35.0
  • D. 35
答案:D。两边都是字符串,+ 做的是“拼接”,把两段文字接起来,所以得到 35 而不是 8。想要 8,得先转成数字:int("3") + int("5")。

8print(2 ** 3 ** 2) 的结果是?

  • A. 64
  • B. 12
  • C. 512
  • D. 36
答案:C。** 是从右往左结合的,先算 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
答案:A。先由 % 算出 10 除以 3 的余数 1,再用 == 问“是不是 1”,结果得 True。判断奇偶就是看 n % 2 == 0 是否成立。

10执行 s = "Py" 之后再执行 s += "thon",print(s) 会输出什么?

  • A. 报错 TypeError
  • B. Py
  • C. Python
  • D. Pythonthon
答案:C。+= 是加法赋值的简写,s += "thon" 等价于 s = s + "thon"。两边都是字符串,+ 做的是拼接,所以把两段文字接起来得到 Python,而不是重复。