Python(五) 基础语法：身份运算符和成员运算符

一、为什么要学习身份运算符和成员运算符

在 Python 中，我们经常需要判断两类问题：

第一类问题是：

某个值在不在一组数据里面？

例如：

students = ["小明", "小红", "小刚"]

if "小明" in students:
    print("小明在学生名单中")

这里用到的是成员运算符 in。

第二类问题是：

两个变量是不是指向同一个对象？

例如：

a = [1, 2, 3]
b = a

if a is b:
    print("a 和 b 指向同一个列表")

这里用到的是身份运算符 is。

成员运算符和身份运算符在代码中很常见，但初学者容易把它们和比较运算符 == 混淆。

本节重点讲清楚：

in 和 not in 是什么。
is 和 is not 是什么。
in、is、== 之间有什么区别。
在实际写代码时应该注意什么。

二、成员运算符的定义

成员运算符用于判断一个值是否属于某个对象。

更通俗地说：

成员运算符用来判断“某个东西在不在里面”。

Python 中有两个成员运算符：

运算符	含义
`in`	判断某个值是否在指定对象中
`not in`	判断某个值是否不在指定对象中

成员运算符的结果是布尔值：

True

或者：

False

例子：

numbers = [1, 2, 3, 4, 5]

print(3 in numbers)
print(8 in numbers)

输出：

True
False

解释：

3 in numbers 的意思是：数字 3 是否在列表 numbers 中。
8 in numbers 的意思是：数字 8 是否在列表 numbers 中。

三、成员运算符 in 的使用方法

1. 在字符串中使用 in

字符串可以看成由一个个字符组成的序列。

所以可以用 in 判断某个字符或某段文字是否在字符串中。

text = "I love Python"

print("Python" in text)
print("Java" in text)

输出：

True
False

这里：

"Python" in text 表示 "Python" 是否出现在字符串 text 中。
"Java" in text 表示 "Java" 是否出现在字符串 text 中。

再看一个中文例子：

message = "我正在学习 Python 编程"

if "Python" in message:
    print("这句话和 Python 有关")

输出：

这句话和 Python 有关

2. 判断单个字符是否在字符串中

word = "hello"

print("h" in word)
print("a" in word)

输出：

True
False

说明：

"h" 是字符串 "hello" 中的字符。
"a" 不在字符串 "hello" 中。

3. in 对大小写敏感

Python 中的字符串判断区分大小写。

text = "Python"

print("Python" in text)
print("python" in text)

输出：

True
False

因为 "Python" 和 "python" 不是同一个字符串。

如果想忽略大小写，可以先统一转换成小写或大写。

text = "Python"

print("python" in text.lower())

输出：

True

这里：

text.lower()

会把 "Python" 转成 "python"。

4. 在列表中使用 in

列表是成员运算符最常见的使用场景之一。

students = ["小明", "小红", "小刚"]

print("小明" in students)
print("小李" in students)

输出：

True
False

可以用于判断某个人是否在名单中。

students = ["小明", "小红", "小刚"]
name = input("请输入学生姓名：")

if name in students:
    print("该学生在名单中")
else:
    print("该学生不在名单中")

5. 在元组中使用 in

元组和列表类似，也可以使用 in。

weekends = ("Saturday", "Sunday")

print("Saturday" in weekends)
print("Monday" in weekends)

输出：

True
False

6. 在集合中使用 in

集合也可以使用 in。

allowed_roles = {"admin", "teacher", "student"}

role = "teacher"

if role in allowed_roles:
    print("角色有效")
else:
    print("角色无效")

集合的特点是查找速度通常很快，适合用来判断某个值是否在一组允许值中。

例如：

valid_codes = {"A", "B", "C"}
code = input("请输入等级 A/B/C：")

if code in valid_codes:
    print("等级有效")
else:
    print("等级无效")

7. 在字典中使用 in

字典由键和值组成。

对字典使用 in 时，默认判断的是键，不是值。

student = {
    "name": "小明",
    "age": 18,
    "score": 95
}

print("name" in student)
print("小明" in student)

输出：

True
False

解释：

"name" 是字典的键，所以结果是 True。
"小明" 是字典的值，不是键，所以 "小明" in student 的结果是 False。

如果要判断某个值是否在字典的值里面，可以使用 values()。

student = {
    "name": "小明",
    "age": 18,
    "score": 95
}

print("小明" in student.values())

输出：

True

如果要判断某个键是否存在，常见写法是：

if "score" in student:
    print("字典中有 score 这个键")

四、成员运算符 not in 的使用方法

not in 用来判断某个值“不在”某个对象中。

例子：

students = ["小明", "小红", "小刚"]

print("小李" not in students)
print("小明" not in students)

输出：

True
False

解释：

"小李" not in students 的结果是 True，因为小李不在列表中。
"小明" not in students 的结果是 False，因为小明在列表中。

1. 用 not in 判断用户名是否可用

forbidden_names = ["admin", "root", "test"]

username = input("请输入用户名：")

if username not in forbidden_names:
    print("用户名可以使用")
else:
    print("用户名不能使用")

这里的逻辑是：

如果用户名不在禁止名单中，就可以使用。
如果用户名在禁止名单中，就不能使用。

2. 用 not in 判断关键词是否不存在

message = "今天学习 Python"

if "错误" not in message:
    print("没有发现错误提示")

五、成员运算符的常见应用场景

1. 判断输入是否合法

choice = input("请选择 A/B/C：")

if choice in ["A", "B", "C"]:
    print("选择有效")
else:
    print("选择无效")

这个例子非常适合课堂教学，因为它简单、直观，也贴近日常程序设计。

2. 判断名单中是否存在某个元素

names = ["小明", "小红", "小刚"]

name = input("请输入要查找的姓名：")

if name in names:
    print("找到了")
else:
    print("没有找到")

3. 判断字符串中是否包含某个关键词

content = "Python 是一种简单易学的编程语言"

if "简单" in content:
    print("这段文字提到了简单")

4. 判断字典中是否有某个键

student = {
    "name": "小明",
    "score": 95
}

if "score" in student:
    print("可以读取成绩")
else:
    print("没有成绩信息")

这种写法可以避免直接读取不存在的键时报错。

六、成员运算符的注意事项

1. in 判断的是“完整成员”，不是模糊相似

在列表中，in 判断的是某个元素是否完整存在。

names = ["小明", "小红", "小刚"]

print("小" in names)

输出：

False

虽然每个名字里都有“小”，但列表中的成员是 "小明"、"小红"、"小刚"，并没有单独的 "小"。

如果是字符串，就不一样：

text = "小明"

print("小" in text)

输出：

True

因为字符串中确实包含字符 "小"。

教学时可以这样提醒：

在字符串中，in 判断的是子字符串是否出现。
在列表中，in 判断的是某个元素是否完整存在。

2. 字典中 in 默认判断键

student = {"name": "小明", "age": 18}

print("name" in student)
print("小明" in student)

输出：

True
False

如果要判断值，应该写：

print("小明" in student.values())

3. 注意大小写问题

valid = ["yes", "no"]
answer = input("请输入 yes 或 no：")

if answer in valid:
    print("输入有效")
else:
    print("输入无效")

如果用户输入：

YES

结果是无效，因为 "YES" 和 "yes" 不一样。

可以改成：

valid = ["yes", "no"]
answer = input("请输入 yes 或 no：").lower()

if answer in valid:
    print("输入有效")
else:
    print("输入无效")

4. 注意输入内容前后的空格

用户输入时可能不小心输入空格。

valid = ["A", "B", "C"]
choice = input("请选择 A/B/C：")

if choice in valid:
    print("选择有效")
else:
    print("选择无效")

如果用户输入：

后面多了一个空格，判断可能失败。

可以使用 strip() 去掉前后空白。

valid = ["A", "B", "C"]
choice = input("请选择 A/B/C：").strip()

if choice in valid:
    print("选择有效")
else:
    print("选择无效")

七、身份运算符的定义

身份运算符用于判断两个变量是否引用同一个对象。

Python 中有两个身份运算符：

运算符	含义
`is`	判断两个变量是否引用同一个对象
`is not`	判断两个变量是否不是引用同一个对象

身份运算符的结果也是布尔值：

True

或者：

False

这里最关键的是理解“对象”和“引用”。

可以先用一个生活化说法：

变量就像标签，对象就像真正的物品。

一个对象可以有多个标签贴在上面。

如果两个变量是贴在同一个对象上的两个标签，那么 is 的结果就是 True。

八、is 的使用方法

1. 两个变量引用同一个对象

a = [1, 2, 3]
b = a

print(a is b)

输出：

True

解释：

b = a

并没有创建一个新列表，而是让 b 也指向 a 指向的那个列表。

所以 a 和 b 是同一个列表对象的两个名字。

可以验证：

a = [1, 2, 3]
b = a

b.append(4)

print(a)
print(b)

输出：

[1, 2, 3, 4]
[1, 2, 3, 4]

因为 a 和 b 指向同一个列表，修改 b，a 看到的内容也变了。

2. 两个变量内容相同，但不是同一个对象

a = [1, 2, 3]
b = [1, 2, 3]

print(a == b)
print(a is b)

输出通常是：

True
False

解释：

a == b 判断内容是否相等。
a is b 判断是否是同一个对象。

虽然两个列表内容一样，但它们是分别创建出来的两个列表，所以不是同一个对象。

可以这样理解：

a 和 b 像两本内容完全一样的书。
内容一样，所以 == 是 True。
但它们不是同一本书，所以 is 是 False。

3. 使用 id() 观察对象身份

Python 中可以用 id() 查看对象的身份标识。

a = [1, 2, 3]
b = a
c = [1, 2, 3]

print(id(a))
print(id(b))
print(id(c))

通常会看到：

id(a) 和 id(b) 相同。
id(c) 不同。

说明：

a is b

等价于判断：

id(a) == id(b)

不过实际写代码时，一般不需要直接比较 id()，使用 is 就可以。

九、is not 的使用方法

is not 用于判断两个变量不是同一个对象。

a = [1, 2, 3]
b = [1, 2, 3]

print(a is not b)

输出：

True

因为 a 和 b 是两个不同的列表对象。

再看：

a = [1, 2, 3]
b = a

print(a is not b)

输出：

False

因为 a 和 b 指向同一个对象。

十、is 最常见、最推荐的使用场景：判断 None

在实际写 Python 代码时，is 最常见的使用场景是判断一个变量是否为 None。

None 表示“没有值”或“空值”。

推荐写法：

result = None

if result is None:
    print("目前没有结果")

判断不是 None：

result = "查询成功"

if result is not None:
    print("有结果")

为什么推荐用 is None，而不是 == None？

因为 None 在 Python 中是一个特殊的单例对象。判断是否为 None，本质上就是判断变量是否指向这个唯一的 None 对象。

所以推荐：

if result is None:
    print("没有结果")

不推荐：

if result == None:
    print("没有结果")

后者通常也能运行，但不符合 Python 常见规范。

十一、身份运算符和 == 的区别

这是本节最重要的内容。

运算符	判断内容	通俗理解
`==`	两个对象的值是否相等	内容是不是一样
`is`	两个变量是否引用同一个对象	是不是同一个东西

例子：

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)
print(a is b)
print(a is c)

输出通常是：

True
False
True

解释：

a == b 是 True：两个列表内容一样。
a is b 是 False：两个列表不是同一个对象。
a is c 是 True：c 和 a 指向同一个对象。

教学时可以让学生记住：

== 比内容，is 比身份。

十二、为什么不要用 is 判断普通数值或字符串是否相等

初学者有时会这样写：

a = 1000
b = 1000

if a is b:
    print("相等")

这不是推荐写法。

如果只是想判断两个数字是否相等，应该使用 ==：

a = 1000
b = 1000

if a == b:
    print("相等")

字符串也是一样。

不推荐：

name = "小明"

if name is "小明":
    print("名字是小明")

十三、身份运算符的常见应用场景

1. 判断变量是否为 None

user = None

if user is None:
    print("用户不存在")
else:
    print("用户存在")

2. 判断函数是否没有返回有效结果

def find_student(name):
    students = ["小明", "小红", "小刚"]

    if name in students:
        return name
    return None


result = find_student("小李")

if result is None:
    print("没有找到学生")
else:
    print("找到了学生")

3. 理解列表引用关系

a = [1, 2, 3]
b = a
c = a.copy()

print(a is b)
print(a is c)
print(a == c)

输出通常是：

True
False
True

解释：

b = a：b 和 a 指向同一个列表。
c = a.copy()：c 是复制出来的新列表。
a == c：虽然不是同一个对象，但内容相同。

这个例子适合帮助学生理解“值相等”和“对象相同”的区别。

十四、成员运算符和身份运算符的区别

成员运算符和身份运算符解决的问题完全不同。

类型	运算符	解决的问题
成员运算符	`in`、`not in`	某个值在不在某个对象中
身份运算符	`is`、`is not`	两个变量是不是同一个对象

例子：

students = ["小明", "小红", "小刚"]
name = "小明"

print(name in students)

这是成员判断：name 的值是否在 students 这个列表中。

再看：

a = students

print(a is students)

这是身份判断：a 和 students 是否指向同一个列表对象。

十五、in、is、== 的区别总结

这三个运算符很容易混淆，可以放在一起讲。

运算符	读法	判断内容	例子
`in`	在里面	某个值是否属于某个对象	`"小明" in students`
`is`	是同一个对象	两个变量是否引用同一个对象	`a is b`
`==`	等于	两个值是否相等	`a == b`

示例：

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(1 in a)
print(a == b)
print(a is b)
print(a is c)

输出通常是：

True
True
False
True

解释：

1 in a：数字 1 在列表 a 中。
a == b：两个列表内容相等。
a is b：两个列表不是同一个对象。
a is c：a 和 c 是同一个对象。

十六、结合条件判断使用

成员运算符和身份运算符经常和 if 一起使用。

1. 成员运算符配合 if

valid_levels = ["A", "B", "C"]

level = input("请输入等级：").strip().upper()

if level in valid_levels:
    print("等级有效")
else:
    print("等级无效")

这里使用了：

strip() 去掉前后空白。
upper() 把输入转换成大写。
in 判断输入是否在允许等级中。

2. 身份运算符配合 if

result = None

if result is None:
    print("还没有查询结果")
else:
    print("查询成功")

十七、综合示例：学生名单查询

下面是一个适合课堂演示的小程序。

students = ["小明", "小红", "小刚"]

name = input("请输入要查询的学生姓名：").strip()

if name in students:
    print(f"{name} 在学生名单中")
else:
    print(f"{name} 不在学生名单中")

这个程序中：

students 是学生名单。
input() 接收用户输入。
strip() 去掉输入前后的空格。
name in students 判断学生是否在名单里。
根据判断结果输出不同提示。

十八、综合示例：查找学生并判断结果是否为空

def find_student(name):
    students = ["小明", "小红", "小刚"]

    if name in students:
        return name
    return None


name = input("请输入学生姓名：").strip()
result = find_student(name)

if result is None:
    print("没有找到这个学生")
else:
    print(f"找到了学生：{result}")

这段代码同时使用了成员运算符和身份运算符。

分析：

name in students 判断姓名是否在学生列表中。
如果在，函数返回这个姓名。
如果不在，函数返回 None。
result is None 判断函数是否没有找到结果。

十九、常见错误和改正方法

1. 用 is 判断两个值是否相等

不推荐：

a = 1000
b = 1000

if a is b:
    print("两个数字相等")

2. 用 is 判断字符串内容

不推荐：

answer = input("请输入 yes：")

if answer is "yes":
    print("输入正确")

3. 误以为 in 会自动忽略大小写

错误理解：

text = "Python"

print("python" in text)

输出：

False

正确处理：

text = "Python"

print("python" in text.lower())

输出：

True

4. 误以为列表中的 in 是模糊查找

names = ["小明", "小红"]

print("小" in names)

输出：

False

因为列表中没有单独的 "小" 这个元素。

如果想判断列表中是否有名字包含 "小"，可以使用循环：

names = ["小明", "小红"]

found = False

for name in names:
    if "小" in name:
        found = True

print(found)

输出：

True

5. 误以为字典中的 in 判断值

student = {"name": "小明", "age": 18}

print("小明" in student)

输出：

False

因为对字典使用 in 时，默认判断键。

判断值要写：

print("小明" in student.values())

6. 忘记处理用户输入中的空格

valid = ["A", "B", "C"]
choice = input("请选择 A/B/C：")

if choice in valid:
    print("有效")
else:
    print("无效")

如果用户输入 " A "，程序会判断为无效。

可以使用：

choice = input("请选择 A/B/C：").strip().upper()

二十、课堂讲解建议

教学时可以按照这个顺序讲：

先讲成员运算符，因为它更直观。
用字符串、列表、字典分别演示 in。
再讲 not in，让学生理解它就是“不在里面”。
然后讲身份运算符，用“变量是标签，对象是物品”的比喻。
最后重点比较 == 和 is。

可以给学生一个简短口诀：

in 看在不在，is 看是不是同一个，== 看值相不相等。

再配合例子：

students = ["小明", "小红"]
name = "小明"

print(name in students)

这是判断姓名在不在名单中。

a = [1, 2]
b = [1, 2]

print(a == b)
print(a is b)

这是判断内容是否相等，以及是否是同一个对象。

二十一、课堂练习

练习 1：判断字符是否存在

请判断字符串 "python" 中是否包含字母 "y"。

参考答案：

word = "python"

print("y" in word)

输出：

True

练习 2：判断学生是否在名单中

请让用户输入学生姓名，判断是否在名单中。

名单如下：

["小明", "小红", "小刚"]

参考答案：

students = ["小明", "小红", "小刚"]

name = input("请输入学生姓名：").strip()

if name in students:
    print("学生在名单中")
else:
    print("学生不在名单中")

练习 3：判断用户名是否可用

禁止使用的用户名如下：

["admin", "root", "test"]

如果用户输入的用户名不在禁止名单中，就输出“可以使用”。

参考答案：

forbidden_names = ["admin", "root", "test"]

username = input("请输入用户名：").strip()

if username not in forbidden_names:
    print("可以使用")
else:
    print("不能使用")

练习 4：判断字典中是否有某个键

给定字典：

student = {"name": "小明", "score": 95}

请判断字典中是否有 "score" 这个键。

参考答案：

student = {"name": "小明", "score": 95}

if "score" in student:
    print("有成绩")
else:
    print("没有成绩")

练习 5：判断变量是否为 None

请判断变量 result 是否为 None。

参考答案：

result = None

if result is None:
    print("没有结果")
else:
    print("有结果")

练习 6：比较 == 和 is

阅读下面代码，判断输出结果。

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)
print(a is b)
print(a is c)

参考答案通常是：

True
False
True

原因：

a 和 b 内容相同，所以 a == b 是 True。
a 和 b 不是同一个列表对象，所以 a is b 是 False。
c = a 让 c 指向 a 的列表，所以 a is c 是 True。

练习 7：修正错误代码

下面代码有什么问题？请改正。

answer = input("请输入 yes：")

if answer is "yes":
    print("输入正确")

参考答案：

问题是：判断字符串内容是否相等应该使用 ==，不应该使用 is。

正确写法：

answer = input("请输入 yes：").strip().lower()

if answer == "yes":
    print("输入正确")

练习 8：判断输入等级是否有效

有效等级为：

["A", "B", "C"]

要求用户输入时可以输入小写，也可以在前后带空格。

参考答案：

valid_levels = ["A", "B", "C"]

level = input("请输入等级 A/B/C：").strip().upper()

if level in valid_levels:
    print("等级有效")
else:
    print("等级无效")

二十二、常见错误对照表

错误现象	常见原因	修改方法
用 `is` 判断两个数字是否相等	混淆了身份和相等	判断值相等用 `==`
用 `is` 判断字符串内容	`is` 判断对象身份，不判断内容	字符串内容比较用 `==`
`"小" in ["小明", "小红"]` 得到 `False`	列表中判断完整元素	如果要查名字中是否包含“小”，需要遍历列表
`"小明" in student` 得到 `False`	字典中 `in` 默认判断键	判断值使用 `student.values()`
`"python" in "Python"` 得到 `False`	字符串判断区分大小写	使用 `.lower()` 或 `.upper()` 统一大小写
用户输入明明对却判断失败	输入中可能有空格或大小写不同	使用 `.strip()`、`.lower()`、`.upper()`
不知道何时使用 `is`	把 `is` 当作普通相等判断	常见场景是 `is None` 和 `is not None`

二十三、总结

成员运算符和身份运算符都是 Python 中常见的判断工具。

成员运算符包括：

in：判断某个值是否在某个对象中。
not in：判断某个值是否不在某个对象中。

它常用于字符串、列表、元组、集合和字典。

身份运算符包括：

is：判断两个变量是否引用同一个对象。
is not：判断两个变量是否不是引用同一个对象。

它最常见的使用场景是判断 None。

本节最重要的区别是：

in 判断“在不在里面”。
is 判断“是不是同一个对象”。
== 判断“值是否相等”。

教学时可以让学生记住一句话：

查名单用 in，比身份用 is，比内容用 ==。

掌握这几个运算符后，学生在写条件判断、输入校验、列表查询、字典检查和函数返回值判断时，都会更加清楚、准确。