有时候，一个简单的条件判断能让你的代码看起来更聪明。但如何真正“理解”用户的意图？我们来看看两种处理方式的差异。
你有没有遇到过这样的场景：用户输入一句话，你希望根据这句话的内容做出不同的响应？比如，当用户输入“Good!”或“Great!”时，你希望程序做出积极的反馈。听起来简单，但如果你不仔细思考，可能会写出一堆啰嗦的代码。
你可能已经写过这样的代码：
weather = input("How's the weather? ")
if weather == "Good!" or weather == "Great!":
print("That's awesome!")
这段代码确实能工作，但有没有更优雅的方式？让我们来聊一聊。
Python的字符串方法，比如lower()和strip()，可以帮助我们更灵活地处理输入。比如，你可以把用户的输入统一转为小写，并去掉前后空格，这样就能避免大小写不一致的问题。
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这样写是不是更简洁？而且更健壮。你不需要担心用户输入了“GOOD!”或“Great ”这样的变种形式。
不过，有时候你可能希望保留用户的原始输入，比如在记录日志时。这时候，你可能会想，是否还有其他方式可以处理这种情况？
有没有想过使用正则表达式？虽然它可能有点复杂，但能让你的代码更具扩展性。比如，如果你希望匹配任何包含“good”或“great”的输入，可以这样做：
import re
weather = input("How's the weather? ")
if re.search(r'\b(good|great)\b', weather, re.IGNORECASE):
print("That's awesome!")
这段代码使用了正则表达式，可以匹配“good”和“great”这两个单词，并且不区分大小写。这在处理用户输入时非常有用，尤其是当用户可能用不同的方式表达相同的意思。
但正则表达式有时候会让代码变得难以理解。所以，有没有一种折中的方法？
我们可以结合使用lower()和split()方法。比如：
weather = input("How's the weather? ").strip().lower()
if any(word in ["good", "great"] for word in weather.split()):
print("That's awesome!")
这样写的好处是，它不仅处理了“good”和“great”这两个单词，还能处理任何包含这些词的输入，比如“Great day!”或“Good weather today!”。
你是不是觉得，有时候“简单”并不等于“好”？代码的可读性和健壮性同样重要。在实际开发中，你可能会遇到各种输入形式，这时候一个灵活的条件判断就显得尤为重要。
有没有想过，除了这些方法，还有其他方式可以处理用户输入？比如使用枚举（Enum）来定义可接受的输入值？
from enum import Enum
class WeatherResponse(Enum):
GOOD = "Good!"
GREAT = "Great!"
NEUTRAL = "Okay"
BAD = "Bad"
weather = input("How's the weather? ").strip()
if weather in [response.value for response in WeatherResponse]:
print("That's awesome!")
这样写的好处是，你可以更清晰地定义可接受的输入值，并且代码的可维护性更好。当然，如果你只是想匹配“good”或“great”，这种方法可能有点小题大做，但如果你需要处理更多情况，它就非常有用。
有没有一种方式，既能保持代码简洁，又能处理更多输入情况？这时候，你可能会想到使用集合（Set）。比如：
weather = input("How's the weather? ").strip().lower()
if weather in {"good", "great"}:
print("That's awesome!")
这样写是不是更直观？而且集合的查找效率更高，尤其是在处理大量输入时。
你有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if "good" in weather or "great" in weather:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
weather = input("How's the weather? ").strip().lower()
if weather in ["good", "great"]:
print("That's awesome!")
这种方法虽然能工作，但可能不如前面的方式那么优雅。因为in操作符在字符串中查找的是子字符串，而不是完整的单词。如果你希望匹配完整的单词，就需要使用split()或正则表达式。
有没有一种方式，能让你的代码既简洁又健壮？这时候，你可能会想到使用函数封装。比如：
def is_positive_feedback(input_text):
input_text = input_text.strip().lower()
return input_text in {"good", "great"}
weather = input("How's the weather? ")
if is_positive_feedback(weather):
print("That's awesome!")
这样写的好处是，你可以将条件判断封装成一个函数，这样不仅代码更清晰，而且更容易复用。
有没有想过，为什么有时候我们不直接使用in操作符？比如：
```python weather = input("How's the weather? ").strip().lower() if weather in ["good", "great"]: print("That's awesome