Assurez-vous que tous les éléments de la liste sont les mêmes en Python

J'étais réticent à continuer à divulguer des informations incorrectes, alors je les ai réécrites. J'ai essayé d'écrire de plusieurs façons tout en reflétant les points que j'ai reçus.

la mise en oeuvre

Jugez en frappant le premier élément avec un autre élément

def map_all(es):
    return all([e == es[0] for e in es[1:]]) if es else False

Jugez par le nombre d'éléments lorsque les éléments en double sont supprimés

def set_list(es):
    return len(list(set(es))) == 1

• ʻEs` est une liste de listes qui entraînera une erreur d'exécution
• TypeError: unhashable type: 'list'

Jugement en frappant le premier élément avec un autre élément (récursif)

def recursive(es):
    return _rec(es, es[0], True) if es else False

def _rec(es, head, acc):
    return _rec(es[1:], head, acc and head == es[0]) if es else acc

• J'ai écrit de force ce que j'ai essayé de faire dans le précédent réduire
• Je ne l'ai pas fait car la reconnaissance de la queue est gênante

Dupliquer le premier élément et comparer pour juger

def multi_diff(es):
    return es == [es[0]] * len(es) if es else False

• J'ai trouvé pendant le test

tester

La dernière fois, c'était tellement bon que je l'ai testé dans une certaine mesure cette fois ...

def tests(expected, elements):
    assert map_all(elements) == expected
    assert set_list(elements) == expected
    assert recursive(elements) == expected
    assert multi_diff(elements) == expected

T, F, N = True, False, None

tests(True, [-1])
tests(True, [0])
tests(True, [1])
tests(True, [2])
tests(True, ['T'])
tests(True, [T])
tests(True, [N])

tests(True, [-1, -1])
tests(True, [0, 0])
tests(True, [1, 1])
tests(True, [2, 2])
tests(True, ['T', 'T'])
tests(True, [T, T])
tests(True, [F, F])
tests(True, [N, N])

tests(True, [-1, -1, -1])
tests(True, [0, 0, 0])
tests(True, [1, 1, 1])
tests(True, [2, 2, 2])
tests(True, ['T', 'T', 'T'])
tests(True, [T, T, T])
tests(True, [F, F, F])
tests(True, [N, N, N])


tests(False, [])

tests(False, [0, 1])
tests(False, [1, 0])
tests(False, [0, 2])
tests(False, [1, 2])
tests(False, ['T', 'F'])
tests(False, ['F', 'T'])
tests(False, [T, F])
tests(False, [F, T])
tests(False, [T, N])
tests(False, [N, F])
tests(False, [N, 0])
tests(False, [0, N])

tests(False, [0, 0, 1])
tests(False, [0, 1, 0])
tests(False, [T, F, F])
tests(False, [F, T, F])
tests(False, [F, F, T])
tests(False, [F, T, T])
tests(False, [T, F, T])
tests(False, [T, T, F])
tests(False, [T, T, N])


tests(True, [[]])
tests(True, [[], []])
tests(True, [[], [], []])
tests(True, [[5]])
tests(True, [[5], [5]])
tests(True, [[5], [5], [5]])

tests(False, [[],  [5]])
tests(False, [[3], [5]])
tests(False, [[3], [3, 3]])

en conclusion

La dernière fois que j'ai dit ceci, oh embarrassant ...