что делает это? python --- & gt; печать (5 | 3) [дубликат]

В этом примере будут показаны операции для всех четырех двухбитовых значений:

10 | 12

1010 #decimal 10
1100 #decimal 12

1110 #result = 14

10 & 12

1010 #decimal 10
1100 #decimal 12

1000 #result = 8

Вот один пример использования:

x = raw_input('Enter a number:')
print 'x is %s.' % ('even', 'odd')[x&1]

Другим распространенным прецедентом является манипулирование / проверка прав доступа к файлам. См. Модуль stat Python: http://docs.python.org/library/stat.html .

Например, чтобы сравнить разрешения файла с желаемым набором разрешений, вы могли бы сделать что-то вроде:

import os
import stat

#Get the actual mode of a file
mode = os.stat('file.txt').st_mode

#File should be a regular file, readable and writable by its owner
#Each permission value has a single 'on' bit.  Use bitwise or to combine 
#them.
desired_mode = stat.S_IFREG|stat.S_IRUSR|stat.S_IWUSR

#check for exact match:
mode == desired_mode
#check for at least one bit matching:
bool(mode & desired_mode)
#check for at least one bit 'on' in one, and not in the other:
bool(mode ^ desired_mode)
#check that all bits from desired_mode are set in mode, but I don't care about 
# other bits.
not bool((mode^desired_mode)&desired_mode)

Я приводил результаты как логические значения, потому что я только забочусь об истине или ложности, но было бы целесообразным вывести значения bin () для каждого один.

Я думаю, что вторая часть вопроса:

Кроме того, для чего используются побитовые операторы? Я был бы признателен за некоторые примеры.

Был только частично рассмотрен. Это мои два цента по этому вопросу.

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

Во всех приложениях, которые должны отправлять данные между двумя узлами, такими как:

• компьютерные сети;
• телекоммуникационные приложения (сотовые телефоны, спутниковая связь , и т. д.).

На уровне связи нижнего уровня данные обычно отправляются в так называемых кадрах. Фреймы - это просто строки байтов, которые отправляются через физический канал. Эти кадры обычно содержат фактические данные плюс некоторые другие поля (закодированные в байтах), которые являются частью того, что называется заголовком. Заголовок обычно содержит байты, которые кодируют некоторую информацию, связанную с состоянием связи (например, с флагами (битами)), счетчики кадров, коды коррекции и обнаружения ошибок и т. Д. Чтобы получить переданные данные в кадре и построить кадры для отправки данных, вам понадобятся наверняка побитовые операции.

В общем, при работе с такими приложениями API доступен, поэтому вам не нужно разбираться со всеми этими деталями. Например, все современные языки программирования предоставляют библиотеки для соединений сокетов, поэтому на самом деле вам не нужно создавать кадры связи TCP / IP. Но подумайте о хороших людях, которые запрограммировали эти API для вас, им наверняка пришлось иметь дело с рамочной конструкцией; используя все виды побитовых операций для перехода от низкоуровневой связи к высокоуровневой связи.

Как конкретный пример, представьте, что кто-то дает вам файл, который содержит необработанные данные, которые были захвачены напрямую с помощью телекоммуникационного оборудования. В этом случае, чтобы найти кадры, вам нужно будет прочитать необработанные байты в файле и попытаться найти какие-то слова синхронизации, сканируя данные по частям. После определения слов синхронизации вам нужно будет получить фактические кадры и, если необходимо, SHIFT их (и это только начало истории), чтобы получить фактические данные, которые передаются.

Еще одна очень различное семейство приложений низкого уровня - это когда вам нужно управлять оборудованием, используя некоторые (древние) порты, такие как параллельные и последовательные порты. Эти порты управляются путем установки некоторых байтов, и каждый бит этих байтов имеет конкретное значение с точки зрения инструкций для этого порта (см., Например, http://en.wikipedia.org/wiki/Parallel_port ). Если вы хотите создать программное обеспечение, которое что-то делает с этим оборудованием, вам понадобятся побитовые операции для перевода инструкций, которые вы хотите выполнить, в байты, которые порт понимает.

Например, если у вас есть некоторые физические кнопки, подключенные к параллельному порту для управления другим устройством, это строка кода, которую вы можете найти в мягком приложении:

read = ((read ^ 0x80) >> 4) & 0x0f; 

Надеюсь, что это поможет.

следующие побитовые операторы: & amp; , | , ^ и ~ возвращаемые значения (основанные на их вход) аналогичным образом логические ворота влияют на сигналы. Вы можете использовать их для эмуляции цепей.

Я не видел, чтобы это упоминалось. Этот пример покажет вам (-) десятичную операцию для двух битовых значений: AB (только если A содержит B)

эта операция необходима, когда мы держим глагол в наша программа, представляющая биты. иногда нам нужно добавить биты (например, выше), и иногда нам нужно удалить биты (если глагол содержит тогда)

111 #decimal 7
-
100 #decimal 4
--------------
011 #decimal 3

с python: 7 & amp; ~ 4 = 3 (удалить из 7 битов, которые представляют 4)

001 #decimal 1
-
100 #decimal 4
--------------
001 #decimal 1

с python: 1 & amp; ~ 4 = 1 (удалить из 1 битов, которые представляют 4 - в этом случае 1 не «содержит» 4) ..

Я не видел упоминания выше, но вы также увидите, что некоторые люди используют левый и правый сдвиг для арифметических операций. Левый сдвиг на x эквивалентен умножению на 2 ^ x (пока он не переполняется), а правый сдвиг эквивалентен делению на 2 ^ x.

Недавно я видел людей, использующих x & lt; 1 и x >> 1 для удвоения и сокращения пополам, хотя я не уверен, что они просто стараются быть умными или действительно есть отличное преимущество над нормальными операторами.

Бит-представления целых чисел часто используются в научных вычислениях для представления массивов истинной-ложной информации, потому что побитовая операция выполняется намного быстрее, чем итерация через массив булевых. (Языки более высокого уровня могут использовать идею бит-массива.)

Приятным и довольно простым примером этого является общее решение игры Nim. Взгляните на код Python на странице на странице Википедии . Он сильно использует побитовое исключение или ^.

Хотя манипуляция битами целого числа полезна, часто для сетевых протоколов, которые могут быть указаны до бита, может потребоваться манипуляция более длинными байтовыми последовательностями (которые нелегко преобразовать в одно целое). В этом случае полезно использовать библиотеку bitstring , которая позволяет выполнять побитовые операции с данными - например, можно импортировать строку «ABCDEFGHIJKLMNOPQ» в виде строки или в виде шестнадцатеричного и битового сдвига (или выполнять другие побитовые операции):

>>> import bitstring
>>> bitstring.BitArray(bytes='ABCDEFGHIJKLMNOPQ') << 4
BitArray('0x142434445464748494a4b4c4d4e4f50510')
>>> bitstring.BitArray(hex='0x4142434445464748494a4b4c4d4e4f5051') << 4
BitArray('0x142434445464748494a4b4c4d4e4f50510')

Подумайте о 0 как false и 1 как истина. Затем побитовые и (& amp;) и / или (|) работают так же, как и обычные, и / или только за исключением того, что все биты в значении сразу. Как правило, вы увидите, что они используются для флагов, если у вас есть 30 параметров, которые можно установить (например, стили рисования в окне), которые вы не хотите передавать в 30 отдельных логических значениях, чтобы установить или отключить их, чтобы вы использовали | для объединения опций в одно значение, а затем вы используете & amp; чтобы проверить, установлена ​​ли каждая опция. Этот стиль прохождения флага сильно используется OpenGL. Поскольку каждый бит является отдельным флагом, вы получаете значения флага по степеням двух (или числа, которые имеют только один бит) 1 (2 ^ 0) 2 (2 ^ 1) 4 (2 ^ 2) 8 (2 ^ 3) мощность двух указывает, какой бит установлен, если флаг включен.

Также обратите внимание на 2 = 10, так что x | 2 равно 110 (6) не 111 (7) Если ни один из битов не перекрывается (что true в этом случае) | действует как дополнение.

Наборы

Наборы можно комбинировать с помощью математических операций.

• Объединенный оператор | объединяет два набора, чтобы сформировать новый, содержащий элементы в любом из них.
• Оператор пересечения & получает элементы только в обоих.
• Оператор разницы - получает элементы в первом наборе, но не во втором.
• Симметричный разностный оператор ^ получает элементы в любом наборе, но не оба.

Попробуйте сами:

first = {1, 2, 3, 4, 5, 6}
second = {4, 5, 6, 7, 8, 9}

print(first | second)

print(first & second)

print(first - second)

print(second - first)

print(first ^ second)

Результат :

{1, 2, 3, 4, 5, 6, 7, 8, 9}

{4, 5, 6}

{1, 2, 3}

{8, 9, 7}

{1, 2, 3, 7, 8, 9}

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

import numpy as np
a=np.array([1.2, 2.3, 3.4])
np.where((a>2) and (a<3))      
#Result: Value Error
np.where((a>2) & (a<3))
#Result: (array([1]),)

, для чего используются побитовые операторы? Я был бы признателен за некоторые примеры.

Одним из наиболее распространенных применений побитовых операций является разбор шестнадцатеричных цветов.

Например, здесь Python , которая принимает строку типа #FF09BE и возвращает кортеж ее значений красного, зеленого и синего.

def hexToRgb(value):
    # Convert string to hexadecimal number (base 16)
    num = (int(value.lstrip("#"), 16))

    # Shift 16 bits to the right, and then binary AND to obtain 8 bits representing red
    r = ((num >> 16) & 0xFF)

    # Shift 8 bits to the right, and then binary AND to obtain 8 bits representing green
    g = ((num >> 8) & 0xFF)

    # Simply binary AND to obtain 8 bits representing blue
    b = (num & 0xFF)
    return (r, g, b)

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