Битовая операция и использование
Вы попытались использовать транзакции?
Из того, что Вы описываете, имея сервер, передающий 100% времени к диску, кажется, что Вы отправляете, каждая строка данных в атомарном предложении SQL, таким образом вынуждая сервер фиксировать (запишите в диск), каждая строка.
при использовании транзакций вместо этого, сервер только фиксировал бы однажды в конце транзакции.
Для дальнейшей справки: Какой метод Вы используете для вставки данных к серверу? Обновление DataTable с помощью DataAdapter, или исполняя каждый приговор с помощью строки?
5 ответов
Bitwise operators are operators that work on multi-bit values, but conceptually one bit at a time.
ANDis 1 only if both of its inputs are 1, otherwise it's 0.ORis 1 if one or both of its inputs are 1, otherwise it's 0.XORis 1 only if exactly one of its inputs are 1, otherwise it's 0.NOTis 1 only if its input is 0, otherwise it's 0.
These can often be best shown as truth tables. Input possibilities are on the top and left, the resultant bit is one of the four (two in the case of NOT since it only has one input) values shown at the intersection of the inputs.
AND | 0 1 OR | 0 1 XOR | 0 1 NOT | 0 1
----+----- ---+---- ----+---- ----+----
0 | 0 0 0 | 0 1 0 | 0 1 | 1 0
1 | 0 1 1 | 1 1 1 | 1 0
One example is if you only want the lower 4 bits of an integer, you AND it with 15 (binary 1111) so:
201: 1100 1001
AND 15: 0000 1111
------------------
IS 9 0000 1001
The zero bits in 15 in that case effectively act as a filter, forcing the bits in the result to be zero as well.
In addition, >> and << are often included as bitwise operators, and they "shift" a value respectively right and left by a certain number of bits, throwing away bits that roll of the end you're shifting towards, and feeding in zero bits at the other end.
So, for example:
1001 0101 >> 2 gives 0010 0101
1111 1111 << 4 gives 1111 0000
Note that the left shift in Python is unusual in that it's not using a fixed width where bits are discarded - while many languages use a fixed width based on the data type, Python simply expands the width to cater for extra bits. In order to get the discarding behaviour in Python, you can follow a left shift with a bitwise and such as in an 8-bit value shifting left four bits:
bits8 = (bits8 << 4) & 255
With that in mind, another example of bitwise operators is if you have two 4-bit values that you want to pack into an 8-bit one, you can use all three of your operators (left-shift, and and or):
packed_val = ((val1 & 15) << 4) | (val2 & 15)
- The
& 15operation will make sure that both values only have the lower 4 bits. - The
<< 4is a 4-bit shift left to moveval1into the top 4 bits of an 8-bit value. - The
|simply combines these two together.
If val1 is 7 and val2 is 4:
val1 val2
==== ====
& 15 (and) xxxx-0111 xxxx-0100 & 15
<< 4 (left) 0111-0000 |
| |
+-------+-------+
|
| (or) 0111-0100
Надеюсь, это проясняет эти два:
x | 2
0001 //x
0010 //2
0011 //result = 3
x & 1
0001 //x
0001 //1
0001 //result = 1
для чего на самом деле используются побитовые операторы? Я был бы признателен за несколько примеров.
Одним из наиболее распространенных способов использования побитовых операций является анализ шестнадцатеричных цветов.
Например, вот функция Python , которая принимает строку типа # FF09BE и возвращает кортеж его значений Red, Green и Blue.
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)
Я знаю, что есть более эффективные способы добиться этого, но я считаю, что это действительно краткий пример, иллюстрирующий как сдвиги, так и побитовые логические операции.
Типичное использование:
| используется для установки определенного бита в 1
и используется для проверки или сброса определенного бита
Установить бит (где n - номер бита, а 0 - младший значащий бит):
unsigned char a | = (1 << n);Очистить бит:
unsigned char b & = ~ (1 << n);Переключить бит:
unsigned char c ^ = (1 << n);Проверить бит:
unsigned char e = d & (1 << n );
Возьмем, к примеру, случай вашего списка:
x | 2 используется для установки бита 1 x в 1
x & 1 используется для проверки, является ли бит 0 x 1 или 0
Считайте 0 ложным, а 1 истинным. Затем побитовое и (&) и или (|) работают так же, как и обычные и, за исключением того, что они обрабатывают все биты в значении одновременно. Обычно вы увидите, что они используются для флагов, если у вас есть 30 параметров, которые можно установить (скажем, как стили рисования в окне), вы не хотите передавать 30 отдельных логических значений для установки или отключения каждого из них, поэтому вы используете | для объединения параметров в одно значение, а затем вы используете &, чтобы проверить, установлена ли каждая опция. Этот стиль передачи флагов широко используется OpenGL. Поскольку каждый бит является отдельным флагом, вы получаете значения флагов по степени двойки (например, числа, у которых установлен только один бит) 1 (2 ^ 0) 2 (2 ^ 1) 4 (2 ^ 2) 8 (2 ^ 3) степень двойки сообщает вам, какой бит установлен, если флаг установлен.
Также обратите внимание, что 2 = 10, поэтому x | 2 равно 110 (6), а не 111 (7) Если ни один из битов не перекрывается (что в данном случае верно) | действует как сложение.