比较运算符 #

# 数值相等
print(5 == 5)       # True
print(5 == 5.0)     # True（值相等）
print(5 == "5")     # False（类型不同）

# 字符串相等
print("hello" == "hello")  # True
print("Hello" == "hello")  # False（区分大小写）

# 列表相等
print([1, 2, 3] == [1, 2, 3])  # True
print([1, 2, 3] == [3, 2, 1])  # False（顺序重要）

# 字典相等
print({"a": 1} == {"a": 1})    # True
print({"a": 1} == {"a": 1.0})  # True（值相等）

# 数值不等于
print(5 != 3)       # True
print(5 != 5)       # False

# 字符串不等于
print("hello" != "world")  # True

# 使用 <>（Python 2语法，Python 3已移除）
# print(5 <> 3)  # SyntaxError in Python 3

# 数值比较
print(5 > 3)        # True
print(5 < 3)        # False
print(5 >= 5)       # True
print(5 <= 4)       # False

# 字符串比较（字典序）
print("apple" < "banana")   # True
print("apple" < "Apple")    # False（小写字母在大写字母之后）
print("abc" < "abcd")       # True（较短的字符串较小）

# 列表比较（逐元素比较）
print([1, 2, 3] < [1, 2, 4])  # True
print([1, 2] < [1, 2, 3])     # True

x = 5

# 传统写法
print(x > 1 and x < 10)  # True

# 链式比较
print(1 < x < 10)        # True
print(1 < x <= 5)        # True
print(0 <= x < 10)       # True

# 多个比较
print(1 < x < 10 > 5)    # True
print(1 < 5 < 10 < 20)   # True

# 可以混合使用不同运算符
x = 5
print(1 < x == 5)        # True
print(1 < x != 10)       # True
print(x > 0 < 10)        # True（x > 0 and 0 < 10）

x = 15

# 链式比较会短路求值
print(1 < x < 10)  # False（不计算中间部分）

# 实际执行过程
# 1 < 15 -> True，继续
# 15 < 10 -> False，停止

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

# == 比较值
print(a == b)       # True（值相等）

# is 比较身份（是否同一对象）
print(a is b)       # False（不同对象）
print(a is c)       # True（同一对象）

# is not
print(a is not b)   # True

# Python缓存了小整数（通常是-5到256）
a = 256
b = 256
print(a is b)       # True

c = 257
d = 257
print(c is d)       # False（超出缓存范围）

# 字符串也有类似缓存
s1 = "hello"
s2 = "hello"
print(s1 is s2)     # True

# 动态创建的字符串可能不被缓存
s3 = "hel" + "lo"
print(s1 is s3)     # True（编译时优化）

s4 = "".join(["h", "e", "l", "l", "o"])
print(s1 is s4)     # False

x = None

# 推荐：使用is检查None
print(x is None)       # True
print(x is not None)   # False

# 不推荐：使用==
print(x == None)       # True（但不推荐）

# 原因：==可能被重载
class MyNone:
    def __eq__(self, other):
        return True  # 总是返回True

obj = MyNone()
print(obj == None)     # True（被欺骗）
print(obj is None)     # False（正确的判断）

# True和False也是单例
print(True is True)    # True
print(False is False)  # True

# 但不推荐用is比较布尔值
flag = True
print(flag is True)    # True（可以工作）
print(flag == True)    # True（推荐）

# 更好的写法
if flag:
    print("flag为真")

fruits = ["apple", "banana", "orange"]

print("apple" in fruits)      # True
print("grape" in fruits)      # False
print("grape" not in fruits)  # True

s = "Hello World"

print("World" in s)       # True
print("world" in s)       # False（区分大小写）
print("xyz" not in s)     # True

# 单字符检查
print("e" in s)           # True

person = {"name": "Tom", "age": 25}

# 检查键
print("name" in person)       # True
print("Tom" in person)        # False（不检查值）
print("address" not in person) # True

# 检查值
print("Tom" in person.values())    # True
print(25 in person.values())       # True

# 检查键值对
print(("name", "Tom") in person.items())  # True

numbers = {1, 2, 3, 4, 5}

print(3 in numbers)       # True
print(6 in numbers)       # False

# 集合的成员检查效率很高（O(1)）

# 元组
coords = (10, 20, 30)
print(20 in coords)       # True

# range
print(5 in range(10))     # True
print(10 in range(10))    # False

# 整数和浮点数可以比较
print(5 == 5.0)       # True
print(5 > 4.9)        # True
print(5 < 5.1)        # True

# 复数只能比较相等
print(1+2j == 1+2j)   # True
# print(1+2j > 2+3j)  # TypeError

# 不同类型比较（Python 3）
# print(5 > "3")      # TypeError

# Python 2中可以比较，结果可能不符合预期
# Python 3中会抛出TypeError

# 列表和元组可以比较
print([1, 2, 3] == (1, 2, 3))  # False（类型不同）
print([1, 2] < [1, 2, 3])      # True

# 不同序列类型比较（Python 3）
# print([1, 2] < (1, 2))       # TypeError

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __eq__(self, other):
        return self.age == other.age
    
    def __lt__(self, other):
        return self.age < other.age
    
    def __le__(self, other):
        return self.age <= other.age

p1 = Person("Tom", 25)
p2 = Person("Jerry", 30)

print(p1 == p2)  # False
print(p1 < p2)   # True

from functools import total_ordering

@total_ordering
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __eq__(self, other):
        return self.age == other.age
    
    def __lt__(self, other):
        return self.age < other.age

# 只需定义 __eq__ 和 __lt__，其他比较自动生成
p1 = Person("Tom", 25)
p2 = Person("Jerry", 30)

print(p1 <= p2)  # True
print(p1 > p2)   # False

# 比较运算符总是返回True或False
result = 5 > 3
print(type(result))  # <class 'bool'>
print(result)        # True

# 可以直接用在条件中
if 5 > 3:
    print("5大于3")

# 比较结果可以赋值
is_adult = age >= 18

# 可以用在列表推导式
numbers = [1, 2, 3, 4, 5]
evens = [n for n in numbers if n % 2 == 0]

# 可以用在filter
filtered = filter(lambda x: x > 0, [-1, 0, 1, 2])

# 浮点数精度问题
a = 0.1 + 0.2
b = 0.3

print(a == b)  # False
print(a)       # 0.30000000000000004

# 解决方案：使用容差比较
def almost_equal(x, y, tolerance=1e-9):
    return abs(x - y) < tolerance

print(almost_equal(a, b))  # True

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

print(a == b)   # True（值相等）
print(a is b)   # False（不同对象）

# 什么时候用is？
# 1. 检查None
if x is None:
    pass

# 2. 检查哨兵值
SENTINEL = object()
if value is SENTINEL:
    pass

x = 5

# 注意这个表达式
print(x > 0 < 10)    # True（x > 0 and 0 < 10）

# 不是
# print((x > 0) < 10)  # 等价于 True < 10 = True

# 另一个例子
print(False == False in [False])  # True
# 等价于 False == False and False in [False]
# 即 True and True = True

import math

nan = float('nan')

print(nan == nan)      # False
print(nan != nan)      # True
print(math.isnan(nan)) # True（正确的检查方式）