深入理解Python and 运算符：解析字符串逻辑表达式在排序中的陷阱

print('good' and 'morning')      # 输出: 'morning'
print('morning' and 'good')      # 输出: 'good'
print('' and 'test')             # 输出: ''
print('test' and '')             # 输出: ''

d = {'27': 'good morning', '14': 'morning', '23': 'good afternoon', '25': 'amazing'}
priority_1 = 'good'
priority_2 = 'morning'
priority_3 = 'afternoon'

new_d = sorted(d.items(), key=lambda c: [(priority_1 and priority_2) in c[1], priority_3 in c[1]])

lambda c: ['morning' in c[1], 'afternoon' in c[1]]

(priority_1 in c[1] and priority_2 in c[1])

d = {'27': 'good morning', '14': 'morning', '23': 'good afternoon', '25': 'amazing'}

priority_1 = 'good'
priority_2 = 'morning'
priority_3 = 'afternoon'

# 原始（错误）的排序键及其结果
# new_d_original = sorted(d.items(), key=lambda c: [(priority_1 and priority_2) in c[1], priority_3 in c[1]])
# print("原始代码的排序结果:")
# print(new_d_original)
# 实际输出: [('25', 'amazing'), ('23', 'good afternoon'), ('27', 'good morning'), ('14', 'morning')]

# 修正后的排序键，正确检查多个子字符串
# 排序规则：
# 1. 优先匹配同时包含 priority_1 和 priority_2 的项 (True 排在 False 之后，如果需要匹配项靠前，需要反转布尔值或使用 reverse=True)
# 2. 次优先匹配包含 priority_3 的项
# Python 默认升序排序，False < True。如果希望匹配项（True）排在前面，需要对布尔值进行处理，例如 `not (condition)` 或在排序时使用 `reverse=True`。
# 为了让“更匹配”的项（即条件为 True 的项）在前面，我们通常会让 True 对应的值更小，或者使用 `reverse=True`。
# 这里我们假设 True 代表更高的优先级，希望它们排在前面，所以我们将布尔值取反，让 True 变为 0，False 变为 1，或者直接使用 `reverse=True`。
# 为了与用户预期的“高优先级在前”的直觉保持一致，我们让 True 的条件排在前面。
# 默认排序是 False 在前，True 在后。所以，如果希望 True 的项在前，可以对布尔值取反，或者在最后对结果列表进行反转。
# 更好的做法是，如果 True 意味着“更重要”，那么让 True 对应一个较小的值。
# 或者直接使用 `reverse=True` 针对整个键列表。

# 让我们重新审视期望的排序行为。
# 假设我们希望：
# 1. 同时包含 priority_1 和 priority_2 的最高优先级。
# 2. 然后是包含 priority_3 的。
# 3. 然后是包含 priority_2 的（如果未被前两条覆盖）。
# 4. 最后是其他。

# 这种复杂的优先级需要更精细的键定义。
# 我们可以为每个条件定义一个优先级分数，或者一个元组，其中 True 对应的数值更小。
# 例如，如果 True 优先级更高，可以返回 `(not condition_1, not condition_2)`。

# 让我们先按照用户原意修正 `and` 运算符的问题，并观察结果。
# 这里的 lambda 返回一个布尔值元组。Python 默认排序会将 False 放在 True 之前。
# 如果我们希望匹配的项（即条件为 True 的项）排在前面，我们可以对布尔值取反，或者对整个排序结果使用 `reverse=True`。
# 假设我们希望 `(priority_1 in c[1] and priority_2 in c[1])` 为 True 的项排在前面，
# 并且 `priority_3 in c[1]` 为 True 的项次之。
# 我们可以让 True 对应一个更小的数字，比如 0，False 对应 1。

new_d_corrected = sorted(d.items(), key=lambda c: [
    not (priority_1 in c[1] and priority_2 in c[1]), # True -> False (0), False -> True (1)
    not (priority_3 in c[1])                          # True -> False (0), False -> True (1)
])

print("\n修正后的排序结果 (优先级：同时包含P1和P2 > 包含P3):")
print(new_d_corrected)

# 让我们分析修正后的键值和排序结果：
# d = {'27': 'good morning', '14': 'morning', '23': 'good afternoon', '25': 'amazing'}
# priority_1 = 'good', priority_2 = 'morning', priority_3 = 'afternoon'

# 1. ('27', 'good morning'):
#    - (P1 in c[1] and P2 in c[1]): ('good' in 'good morning' and 'morning' in 'good morning') -> True
#    - not True -> False (0)
#    - (P3 in c[1]): ('afternoon' in 'good morning') -> False
#    - not False -> True (1)
#    - Key: [0, 1]