前言

大家好，这里是 Charming讲Python编码小技巧 系列专栏。每天分享一个 30-seconds-of-python 仓库中的神级写法，助你告别"屎山"代码，写出让人眼前一亮的 Pythonic 风格！

小技巧内容描述

你是否遇到过需要判断一个列表中所有元素是否都相同的情况？比如检查数组是否全为0、判断用户输入是否一致、验证数据完整性等？

还在写这样的代码？

def check_all_equal(lst):
    if len(lst) == 0:
        return True
    first = lst[0]
    for item in lst:
        if item != first:
            return False
    return True

太长了！今天教你一个超优雅的技巧，一行代码搞定！

def all_equal(lst):
    return len(set(lst)) == 1

就这么简单！让我来解释一下为什么这么写。

为什么这么用？

核心原理：集合去重 + 长度判断

这个技巧利用了 Python 集合的两个特性：

1. set() 去重：集合会自动去除重复元素
2. len() 计数：如果所有元素相同，去重后集合长度就是 1

举个栗子

def all_equal(lst):
    return len(set(lst)) == 1

# 示例1：数字列表
print(all_equal([1, 1, 1, 1]))       # True - 所有元素都是1
print(all_equal([1, 2, 3, 4]))       # False - 元素各不相同
print(all_equal([5, 5, 5, 5, 5]))    # True - 所有元素都是5

# 示例2：字符串列表
print(all_equal(['a', 'a', 'a']))    # True - 所有元素都是'a'
print(all_equal(['a', 'b', 'c']))    # False - 元素各不相同

# 示例3：布尔值列表
print(all_equal([True, True, True])) # True - 所有元素都是True
print(all_equal([True, False]))      # False - 元素不同

# 示例4：空列表和单元素列表
print(all_equal([]))                 # True - 空列表视为相等
print(all_equal([42]))               # True - 只有一个元素，自然相等

解析代码执行过程

让我们以 all_equal([1, 1, 2, 1]) 为例：

第一步：输入 [1, 1, 2, 1]
第二步：set([1, 1, 2, 1]) → {1, 2}  (去重，集合中只保留唯一值)
第三步：len({1, 2}) → 2
第四步：2 == 1 → False
结果：False (列表中元素不完全相同)

再以 all_equal(['a', 'a', 'a']) 为例：

第一步：输入 ['a', 'a', 'a']
第二步：set(['a', 'a', 'a']) → {'a'}  (去重后只剩一个元素)
第三步：len({'a'}) → 1
第四步：1 == 1 → True
结果：True (列表中所有元素相同)

更多实用场景

场景一：验证用户输入一致性

def all_equal(lst):
    return len(set(lst)) == 1

# 用户投票场景
votes = ['同意', '同意', '同意', '同意']
if all_equal(votes):
    print("全票通过！")  # 全票通过！

# 验证密码确认
passwords = ['abc123', 'abc123', 'abc123']
if all_equal(passwords):
    print("密码确认成功，三次输入一致！")
else:
    print("密码输入不一致，请重新输入！")

场景二：数据质量检查

# 检查某列数据是否全部为空
def check_column_all_null(data, column_name):
    values = [row[column_name] for row in data if row[column_name] is not None]
    return len(values) == 0

# 检查评分是否全部满分
ratings = [5, 5, 5, 5, 5]
if all_equal(ratings) and ratings[0] == 5:
    print("这是一个满分作品！")

# 检查温度传感器读数是否异常（长时间不变）
temperature_readings = [25.0, 25.0, 25.0, 25.0, 25.0]
if all_equal(temperature_readings):
    print("警告：传感器可能卡住了，读数长时间未变化！")

场景三：游戏和算法

# 检查井字棋是否已有人获胜（一行/列/对角线全相同）
def check_winner(board, line):
    return all_equal([board[pos] for pos in line]) and board[line[0]] != ' '

board = ['X', 'O', 'X',
         'O', 'X', 'O',
         'X', ' ', ' ']

# 检查第一列
if check_winner(board, [0, 3, 6]):
    print("X获胜！")  # X获胜！

# 检查数组是否全为0（图像处理中的常见需求）
def is_blank_image(pixel_data):
    return all_equal(pixel_data) and pixel_data[0] == 0

blank_pixels = [0] * 1000
print(is_blank_image(blank_pixels))  # True

场景四：配置和状态管理

# 检查所有服务器状态是否一致
servers = [
    {'name': 'server1', 'status': 'running'},
    {'name': 'server2', 'status': 'running'},
    {'name': 'server3', 'status': 'running'}
]

statuses = [s['status'] for s in servers]
if all_equal(statuses):
    print(f"所有服务器状态一致：{statuses[0]}")

# 检查所有环境变量是否指向同一环境
envs = ['production', 'production', 'production']
if all_equal(envs):
    print("配置一致，指向生产环境")

# 检查所有测试用例是否通过
test_results = [True, True, True, True]
if all_equal(test_results) and test_results[0]:
    print("所有测试用例通过！")

对比其他方法

让我们看看如果不使用这个技巧，我们需要写多少代码：

方法1：传统循环（需要多行）

def all_equal_loop(lst):
    if len(lst) == 0:
        return True
    first = lst[0]
    for item in lst:
        if item != first:
            return False
    return True

# 测试
print(all_equal_loop([1, 1, 1]))  # True
print(all_equal_loop([1, 2, 3]))  # False

方法2：使用 all() 函数

def all_equal_all(lst):
    return all(x == lst[0] for x in lst) if lst else True

# 测试
print(all_equal_all([1, 1, 1]))  # True
print(all_equal_all([1, 2, 3]))  # False

方法3：使用 min() 和 max()

def all_equal_minmax(lst):
    return len(lst) == 0 or min(lst) == max(lst)

# 测试
print(all_equal_minmax([1, 1, 1]))  # True
print(all_equal_minmax([1, 2, 3]))  # False

我们的"一行代码"版本

def all_equal(lst):
    return len(set(lst)) == 1

对比总结：

• 传统循环：代码清晰，但需要6-7行
• all()函数：简洁，但需要额外处理空列表
• min/max：巧妙，但需要计算两次
• 一行代码：最简洁，最Pythonic，最易读

进阶技巧

技巧1：处理不可哈希元素

如果列表包含不可哈希元素（如列表、字典），set() 会报错。可以这样处理：

def all_equal_unhashable(lst):
    if not lst:
        return True
    first = lst[0]
    try:
        return len(set(lst)) == 1
    except TypeError:
        # 降级到循环方式
        return all(x == first for x in lst)

# 测试
print(all_equal_unhashable([[1, 2], [1, 2]]))  # True
print(all_equal_unhashable([[1, 2], [3, 4]]))  # False

技巧2：判断所有元素是否为特定值

def all_equal_to(lst, value):
    return all(x == value for x in lst)

# 或者使用 set
def all_equal_to_set(lst, value):
    return set(lst) == {value}

# 测试
print(all_equal_to([0, 0, 0], 0))  # True - 全为0
print(all_equal_to([0, 0, 1], 0))  # False

技巧3：判断列表是否只有两种值

def has_only_two_values(lst):
    return len(set(lst)) <= 2

# 测试
print(has_only_two_values([1, 2, 1, 2]))  # True
print(has_only_two_values([1, 2, 3]))     # False

注意事项

1. 空列表的处理

print(all_equal([]))  # True - 空列表被视为"所有元素相同"

如果需要空列表返回 False，可以这样修改：

def all_equal_not_empty(lst):
    return len(lst) > 0 and len(set(lst)) == 1

2. 性能考虑

对于超大型列表，创建集合会有额外内存开销。如果只想判断是否不全相同，可以用短路逻辑：

def not_all_equal(lst):
    if len(lst) < 2:
        return False
    first = lst[0]
    for item in lst[1:]:
        if item != first:
            return True
    return False

# 找到第一个不同元素就返回，更高效

3. 浮点数精度问题

# 注意浮点数精度！
print(all_equal([0.1 + 0.2, 0.3]))  # 可能是 False
# 因为 0.1 + 0.2 = 0.30000000000000004

# 解决方案：使用近似比较
from math import isclose

def all_equal_float(lst, tolerance=1e-9):
    if not lst:
        return True
    return all(isclose(x, lst[0], abs_tol=tolerance) for x in lst)

print(all_equal_float([0.1 + 0.2, 0.3]))  # True

总结

这个"判断列表元素是否全部相同"的技巧之所以如此优雅，是因为：

1. 代码简洁：一行代码搞定，可读性极强
2. 性能优秀：set() 去重是 O(n) 时间复杂度
3. Pythonic：充分利用了 Python 集合的特性
4. 通用性强：适用于任何可哈希的类型

下次遇到需要判断列表元素一致性的场景，不妨试试这个技巧，让你的代码既简洁又高效！

---

今日小技巧： all_equal - 一行代码判断列表元素是否全部相同

适用场景： 数据验证、用户输入检查、状态一致性判断、游戏逻辑等

点赞收藏，每天学一个Python神技巧！