Рубрики
Без рубрики

Определение Если все элементы в списке одинаковы в Python

Получите практические, реальные навыки Python на наших ресурсах и пути

Автор оригинала: Mike Driscoll.

Примечание редактора: на этой неделе у нас есть гостевой пост от Алекса, генеральный директор Репутация

В жизни у нас всегда есть варианты, знаете ли мы о них или нет. Это то же самое с кодированием. Существует справедливое количество различных способов, которыми мы можем приблизиться к определенной задаче. Мы могли бы не считать этими способами или не иметь никакого ключа о них, но там они есть. Быть кодером – не только знание языка и процесса написания кода. Очень часто являющимся кодером, значит быть самым креативным вариантом себя, учитывая то, что вы никогда раньше не рассматривали. И на эту записку я хотел бы представиться. Привет! Алекс мое зовут, я генеральный директор в Checkio, и я имел дело с творческими аспектами этого проекта на некоторое время.

Наши пользователи имеют различные уровни и опыт знаний кодирования, поэтому я часто вижу стандартные и более очевидные подходы к решению задач. Но время от времени я сталкиваюсь с такими уникальными и необычными решениями, которые делают меня снова изучать новые тонкости языка.

В этой статье я хочу провести некоторые из решений одной из очень простых задач, которые, на мой взгляд, являются самыми интересными. Миссия требует от вас, чтобы написать функцию, которая будет определять, имеют ли все элементы массива одинаковое значение.

1. Одним из первых решений, которые приходят к уму, состоит в том, чтобы сравнить длину списка входных элементов с количеством раз, когда первый элемент входит в список. Если эти значения равны, то список состоит из тех же элементов. Список также должен быть проверен, будь то пустым, так как в этом случае необходимо и вернуть истину.

def all_the_same(elements):
   if len(elements) < 1:
       return True
   return len(elements) == elements.count(elements[0])

Или несколько более коротких версий:

def all_the_same(elements):
   return len(elements) < 1 or len(elements) ==
elements.count(elements[0])

2. В этом решении была использована полезная функция Python – возможность сравнения списков с лишь оператором сравнения – == (В отличие от некоторых других языков программирования, где это не так просто). Давайте посмотрим, как это работает:

>>>[1, 1, 1] == [1, 1, 1]
True
>>> [1, 1, 0] == [0, 1, 1]
False

Этот язык имеет еще одну отличную функцию – она обеспечивает возможность умножить список по номеру и в результате этой операции у нас будет список, когда все элементы скопированы указанное количество раз. Позвольте мне показать вам несколько примеров:

>>> [1] * 3
[1, 1, 1]
>>> [1] * 5
[1, 1, 1, 1, 1]
>>> [1] * 0
[]
>>> [1, 2] * 3
[1, 2, 1, 2, 1, 2]

Таким образом, вы можете придумать простое решение – если вы умножаете на массив одного элемента, который является первым элементом входного массива, по длине этого входного массива, затем в результате вы должны снова вернуть этот входной массив, Если все элементы этого массива действительно одинаковы.

def all_the_same(elements):
    if not elements:
        return True
    return [elements[0]] * len(elements) == elements

Здесь тоже решение может быть сокращено:

def all_the_same(elements):
    return not elements or [elements[0]] * len(elements) == elements

3. В этом решении было использовано стандарт set () Функция Отказ Эта функция преобразует объект в набор, в котором все элементы по определению должны быть уникальными. Похоже, это выглядит:

>>> elements = [1, 2, 5, 1, 5, 3, 2]
>>> set(elements)
{1, 2, 3, 5}

Если результирующий набор состоит из 1 или 0 элементов, то входной список имел все те же элементы или было пустым. Решение может выглядеть так:

def all_the_same(elements):
    return len(set(elements)) in (0, 1)

Или, как это:

def all_the_same(elements):
    return len(set(elements)) <= 1

Этот подход можно использовать с Numpy Модуль, который имеет Уникальная () Функция Это работает следующим образом:

>>> from numpy import unique
>>> a = [1, 2, 1, 2, 3, 1, 1, 1, 1]
>>> unique(a)
[1 2 3]

Как видите, его работа очень похожа на функцию SET () с единственной разницей, что в этом случае тип объекта не изменяется – список остается список. Решение с этой функцией выглядит так:

from numpy import unique

def all_the_same(elements):
    return len(unique(elements)) <= 1

4. Вот пример очень оригинального решения, в котором стандарт использованного Python All () Функция это игра на имя этой задачи. Функция All () вернет True, если все элементы передаваемого списка верны. Например:

>>> all([1, 2, 0, True])
False
#(0 isn't true)
>>> all([1, 2, None, True])
False
#(None isn't true)
>>> all([1, 2, False, True])
False
>>> all([1, 2, 0.1, True])
True

В первую очередь переменная первая присваивается значение первого элемента списка, а остальное является список всех других элементов, кроме первого. Тогда в Toot_same CUPLE добавляются истинные или ложные значения, в зависимости от того, будет ли следующий элемент списка отдыха равен первым элементе списка ввода. После этого функция All () вернет True, если TEUPLE TUPLE будет состоять только из «True» элементов, и False – если в кортеже есть хотя бы один «ложный» элемент.

def all_the_same(elements):
    try:
        first, *rest = elements    
    except ValueError:
        return True
    the_same = (x == first for x in rest)
    return all(the_same)

Исключение ValueError будет повышено только в том случае, если массив пуст. Но мы можем запустить более знакомый тест:

def all_the_same(elements):
    if not elements:
        return True
    first, *rest = elements
    the_same = (x == first for x in rest)
    return all(the_same)

5. Следующее решение очень похоже на предыдущее. В нем есть только одна небольшая поправка – первый элемент входного списка, а остальные из них разделены итератором. Функция ITER () Создает итератор из перенесенного списка и Далее () Функция берет следующий элемент от него (то есть первого – на первый звонок). Если вы распечатаете элементы, перечисленные в EL и сначала, вы увидите следующее:

>>> el = iter([1, 2, 3])
>>> first = next(el, None)
>>> print(first)
1
>>> for i in el:
>>>     print(i)
2
3

Для остальных, это решение напоминает предыдущий с исключением, что нам не нужно проверять, пуст ли список или нет.

def all_the_same(elements):
    el = iter(elements)
    first = next(el, None)
    return all(element == first for element in el)

6. Один из креативных подходов к решению этой задачи – переставить элементы. Мы изменяем места элементов и проверьте, изменился ли список из-за этого. Это говорит нам, что все элементы в списке одинаковы. Вот несколько примеров этого подхода:

def all_the_same(elements):
    return elements[1:] == elements[:-1]

или же

def all_the_same(elements):
    return elements == elements[1:] + elements[:1]

Следует также признать, что сравнение массивов может быть сделано элемент элементами, используя ZIP () Функция Отказ Давайте рассмотрим следующие решения.

7. ZIP () Функция Сочетает в себе каждый I-T-й элемент одного объекта с i-го элемента объектов остальных до тех пор, пока короткий объект не заканчивается.

>>> x = [1, 2, 3]
>>> y = [10, 11]
>>> list(zip(x, y))
[(1, 10), (2, 11)]

Как видите, несмотря на то, что X состоит из трех элементов, использовались только два, потому что кратчайший объект (в этом случае y) состоит только из 2 элементов.

Решение ниже работает следующим образом: Прежде всего, второй список создан (элементы [1:]), который равен списку ввода, но без первого элемента. Затем элементы из этих двух списков сравниваются в свою очередь, и в результате каждого такого сравнения мы получаем истинное или ложное. После этого функция All () возвращает результат обработки этого истинного и ложного набора.

def all_the_same(elements):
    return all(x == y for x, y in zip(elements, elements[1:]))

Скажем, наш входной список – это элементы = [2, 2, 2, 3]. Затем используя ZIP (), мы объединяем полный список ([2, 2, 2, 2, 3]) и список без первого элемента ([2, 2, 3]) следующим образом: [(2, 2), (2 2), (2, 3)]. Сравнение элементов между собой пройдет к функции All () на множестве [True, True, false], и в результате мы получаем false, что является правильным ответом, поскольку не все элементы в списке ввода одинаковы.

8. Следующее решение, где Groupby () итератор был использован, чтобы быть очень интересным. The Groupby () итератор работает так: он сравнивает каждый I-й элемент с (I-1)-местом, и если элементы равны – перемещаются дальше, если они не равны – оставляет (I-1) элемент в сводном списке и продолжает сравнение с следующим элементом. На практике это выглядит так:

>>> from itertools import groupby
>>> elements = [1, 1, 1, 2, 1, 1, 1, 2]
>>> for key, group in groupby(elements):
>>>     print(key)
1
2
1
2

Как видите, остались только те элементы, которые отличаются от элемента на следующей позиции (элементы [0], элементы [1], элементы [4] и элементы [5] были исключены).

В этом решении функция с помощью итератора Groupby () добавляет одну (1) в список каждый раз, когда следующий элемент ввода-списка отличается от предыдущего. Таким образом, если входной список содержит 0 элементов или все элементы равны, сумма (сумма (1 для _ в группе (элементы))) будет 0 или 1, что в любом случае меньше 2, как указано в решении Отказ

from itertools import groupby

def all_the_same(elements):
    return sum(1 for _ in groupby(elements)) < 2

9. Еще одно творческое решение, где один из стандартных модулей Python – Коллекции – имеет пользуюсь. Счетчик Создает словарь, в котором он хранит информацию о количестве каждого элемента в списке ввода. Посмотрим, как это работает:

>>> from collections import Counter
>>> a = [1, 1, 1, 2, 2, 3]
>>> Counter(a)
Counter({1: 3, 2: 2, 3: 1})

Следовательно, если длина этого словаря 2 или более, есть как минимум 2 различных элемента в входном списке, а не все они одинаковы.

def all_the_same(elements):
    from collections import Counter
    return not len(list(Counter(elements))) > 1

10. Это решение построено на той же логике, что и решение № 7, но используемые функции являются eq () и Starmap () Отказ Давайте выясним, как они работают:

>>> from operator import eq
>>> eq(1, 2)
False

В основном функция EQ () делает то же самое, что и «==» – сравнивает два объекта и возвращает true, если они равны, и false, если иным образом (эквивалентные). Однако обратите внимание, что функция является объектом, и она может, например, быть передан в качестве аргумента другой функции, которая была сделана в решении, описанном в дальнейшем.

Функция Starmap () создает итератор, который применяет другую функцию к списку объектов. Используется, когда объекты уже сгруппированы на кортежи. Например:

>>> import math
>>> from itertools import starmap
>>> list(starmap(math.pow, [(1, 2), (3, 4)]))
[1.0, 81.0]

Как вы можете видеть, однажды указанная функция Math.POW () благодаря функции Starmap () была применена дважды – для обоих наборов объектов.0 .0).

Более просто функция Starmap () для этого примера может быть представлена как цикла:

import math

elements = [(1, 2), (3, 4)]
result = []
for i in elements:
    result.append(math.pow(i[0], i[1]))

Решение, где используются ранее описанные функции, выглядит так:

from operator import eq
from itertools import starmap

def all_the_same(elements):
    return all(starmap(eq, zip(elements, elements[1:])))

Заключение

Итак, здесь мы проходили некоторые из творческих решений, которые все должны делать с одним из простейших головоломков кодирования. Я даже не могу начать описывать сумму уникальных подходов, которые поделились нашими пользователями из-за борьбы с другими интересными и сложными проблемами. Я надеюсь, что вам понравилось читать эту статью столько же, сколько мне нравится писать. Я с нетерпением жду ваших отзывов. Пожалуйста, скажите. Это было полезно для вас? Как бы вы решили эту задачу?