python – самая низкая стоимость проверки сразу нескольких равенств

Я начинаю с списка, полного False элементов.
Затем эти элементы переключаются на True независимо в течение итераций.
Мне нужно знать, когда список полностью прав.

Скажем, у меня есть 3 элемента, они начинаются как

 [False, False, False] 

то я проверяю их по итерациям вроде:

 elements == [True, True, True] 

Список элементов фиксирован и не должен расти (или сокращаться). Вы можете думать об этих элементах как о переключателях, вход определяет, сколько их есть, и все они отключены. Единственное, что может случиться со временем, это то, что отдельные переключатели включаются (True) событиями, происходящими на итерации.

Как python выполняет проверку и какова стоимость?
Каков наилучший способ с точки зрения стоимости проверить это?
Есть ли способ с битовыми операциями или что-либо, что проверяет все элементы одновременно?

3 Solutions collect form web for “python – самая низкая стоимость проверки сразу нескольких равенств”

Вы можете использовать битовые операции для использования числа в качестве массива бит флагов. Чтобы заставить это работать, мы должны закодировать True в качестве очищенного бита, но False как установленный бит. Таким образом, число становится равным нулю, если все биты очищаются.

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

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

Замечания по этому вопросу предлагали сохранить счет и список. Когда одно из значений становится истинным, счетчик либо доходит до конечного значения длины списка, либо уменьшается от длины списка до нуля. Это сработает, но это будет лишним, поскольку один и тот же факт дважды кодируется как счетчик и один раз, как количество Trues.

Это объединяет счет и список. Он не содержит избыточности.

Начните с 5 битов:

 >>> bin((1<<5)-1) '0b11111' 

Затем очистите их. Это очищает 4-й бит:

 >>> bin(((1<<5)-1) & ~(1 << 3)) '0b10111' 

Это позволит вашему циклу иметь такое состояние, как следующий цикл:

 flags = (1<<5)-1 n = 0 while flags: flags &= ~(1<<n) print bin(flags) n += 1 

Этот цикл начинается с 5 битов и очищает их по одному.

 >>> flags = (1<<5)-1 >>> n = 0 >>> while flags: ... flags &= ~(1<<n) ... print bin(flags) ... n += 1 ... 0b11110 0b11100 0b11000 0b10000 0b0 

Используйте all ,

 >>> l = [True, True, True] >>> all(l) True 

Обратите внимание, что если итерабельный пуст, он также вернет True .

 >>> all([]) True 

Вы можете создать свой собственный класс флагов, который реализует идею @StefanPochmann и отслеживает, сколько флагов было установлено.

Доказательство концепции:

 class flags: def __init__(self,n): self.__flags = [False]*n self.__ntrue = 0 def flags(self): return self.__flags[:] #so read only def __len__(self): return len(self.__flags) def check(self,i): return self.__flags[i] def on(self,i): if not self.check(i): self.__ntrue +=1 self.__flags[i] = True def off(self,i): if self.check(i): self.__ntrue -=1 self.__flags[i] = False def toggle(self,i): if self.check(i): self.off(i) else: self.on(i) def ntrue(self): return self.__ntrue 

Протестировано, как:

 import random i = 0 f = flags(5) while f.ntrue() != len(f): i +=1 f.toggle(random.randint(0,4)) print(i,f.flags()) 

Типичный выход:

 19 [True, True, True, True, True] 
  • Обратный список чисел в python
  • Как получить список индексов ненулевых элементов в списке?
  • Создание списка из списка списков в Python
  • Инициализировать список до определенной длины в Python
  • Итерация по всем двум элементам в списке
  • pythonic способ связать элементы списка с их индексами
  • Преобразовать список в список кортежей python
  • различный размер элемента в массиве numpy и список
  • Python - лучший язык программирования в мире.