ビット演算の基本と実用例|AND・OR・XOR・シフトとフラグ・マスクの使い方
プログラムを読んでいると、「flags & 0x04」「mode |= WRITE」「n >> 1」のような書き方に出会います。これはビット演算といって、数を 0 と 1 の並び(ビット)として見て、1 桁ずつ計算する方法です。設定のオン・オフをまとめて持つ「フラグ」、値の一部だけを取り出す「マスク」、2 倍・半分にする「シフト」などで使われます。
この記事では、ビット演算の 6 つの演算子を 1 つずつ説明し、仕事でよく使うパターンと、つまずきやすいポイントを紹介します。例はすべて Python 3.12・PowerShell 5.1・Microsoft Edge 155(ヘッドレスモード)の JavaScript で実際に実行し、その結果を載せています。
この記事で分かること:
- AND・OR・XOR・NOT・左シフト・右シフトの動きと使いどころ
- Python で ~5 が -6 になる理由(2 の補数との関係)
- 算術シフトと論理シフトの違い、JavaScript の >> と >>> の違い
- フラグの操作、偶数判定、2 のべき乗判定、ビットを数える方法、enum.Flag
- 「&」と「==」の優先順位のような、言語ごとの落とし穴
2 進数・16 進数の読み方そのものは「2進数・16進数の基本」で解説しています。数を 2 進数に変換して確かめたいときは「基数変換ツール」が便利です。
ビット演算とは
ふつうの足し算は「12 + 10 = 22」のように数全体で計算しますが、ビット演算は数を 2 進数に直し、同じ位置のビットどうしを 1 桁ずつ計算します。桁の繰り上がりはありません。使う演算子は言語によって書き方が少し違います。
| 演算 | Python | JavaScript | PowerShell | 一言でいうと |
|---|---|---|---|---|
| AND(論理積) | a & b | a & b | a -band b | 両方 1 なら 1 |
| OR(論理和) | a | b | a | b | a -bor b | どちらかが 1 なら 1 |
| XOR(排他的論理和) | a ^ b | a ^ b | a -bxor b | 違っていれば 1 |
| NOT(反転) | ~a | ~a | -bnot a | 0 と 1 を入れ替える |
| 左シフト | a << n | a << n | a -shl n | 左に n 桁ずらす |
| 右シフト | a >> n | a >> n(符号あり)、a >>> n(符号なし) | a -shr n | 右に n 桁ずらす |
Python の「&」と「and」は別物です。「and」は真偽の判定に使う論理演算子で、12 and 10 は 10(右側の値)を返しますが、12 & 10 はビットごとの AND で 8 になります。
AND・OR・XOR:2 つの数をビットごとに比べる
縦に並べて計算する
12(2 進数で 1100)と 10(1010)を例にします。2 つの数を縦に並べ、列ごとに 0 と 1 を比べるだけです。
12 = 1100
10 = 1010
------------------
AND(&) = 1000 = 8 両方 1 の列だけ 1
OR (|) = 1110 = 14 どちらかが 1 の列は 1
XOR(^) = 0110 = 6 違う列だけ 1

AND・OR・XOR・NOT の考え方は論理演算と同じです。1 ビット分の動きを真理値表で確かめたいときは「論理演算・真理値表ツール」を使ってください。
3 つの言語で確かめる
Python で次のコードを実行すると、1 行目に「8 14 6」、2 行目に 4 桁の 2 進数で「1000 1110 0110」と表示されます。format の ’04b’ は「0 で埋めて 4 桁の 2 進数」という指定です。
a, b = 0b1100, 0b1010
print(a & b, a | b, a ^ b)
print(format(a & b, '04b'), format(a | b, '04b'), format(a ^ b, '04b'))
PowerShell では -band・-bor・-bxor を使います。次のコマンドを実行すると「8」と表示されます(-bor なら 14、-bxor なら 6)。
0xC -band 0xA
JavaScript は Python と同じ記号です。ブラウザの開発者ツールのコンソール(F12 キーで開く画面の「Console」)で次の式を入力すると「8」と表示されます。
12 & 10
使いどころの覚え方
- AND は「取り出す・調べる」:1 にした場所だけが残り、0 にした場所は必ず 0 になる。この「残したい場所だけ 1 にした数」をマスクと呼ぶ
- OR は「立てる」:1 にした場所は必ず 1 になり、それ以外はそのまま
- XOR は「反転する・違いを見つける」:1 にした場所だけ 0 と 1 が入れ替わる。同じ数どうしの XOR は 0 になる
NOT(~)と 2 の補数:~5 が -6 になる理由
NOT はすべてのビットの 0 と 1 を入れ替える演算です。ところが Python で print(~5) を実行すると、250 のような正の数ではなく「-6」と表示されます。JavaScript の ~5 も、PowerShell の -bnot 5 も、同じく -6 です。
理由は、マイナスの数を2 の補数という形で表しているためです。8 ビットで考えると、次のようになります。
5 = 00000101
~5 = 11111010 ← 最上位ビットが 1 なので「マイナスの数」として読む
-6 = 11111010 (6 = 00000110 を反転して 1 を足したもの)
2 の補数では「ビットを反転して 1 を足す」と符号が逆になります。つまり「反転だけ」は「符号を逆にして 1 を引く」ことと同じで、~x は -(x+1) になります。Python の公式リファレンスにも「x のビット反転は -(x+1) と定義される」と書かれています。2 の補数の求め方や、ビット数ごとの表せる範囲は「基数変換ツール」のページで詳しく説明しています。
Python の整数には決まったビット数がなく、公式ドキュメントでは「符号ビットが無限に続く 2 の補数」として計算すると説明されています。そのため ~5 は「…11111010」と 1 が左に無限に続く数、つまり -6 になります。8 ビットの範囲で反転した値がほしいときは、0xFF との AND で下の 8 ビットだけを残します。次のコードを実行すると「250 11111010」と表示されます。
print(~5 & 0xFF, format(~5 & 0xFF, '08b'))
JavaScript では、ビット演算の結果は 32 ビットの符号付き整数です。ビットの並びを見たいときは「>>> 0」で符号なしにしてから 2 進数の文字列にします。次の式は「11111111111111111111111111111010」(1 が 30 個のあとに 010)を返します。
(~5 >>> 0).toString(2)
PowerShell 5.1 では、次のコマンドで同じ 32 ビットの並びが表示されます。
[Convert]::ToString((-bnot 5), 2)
シフト演算:ビットを左右にずらす
左シフト:n 桁ずらすと 2n 倍
左シフトは、ビット全体を左にずらし、空いた右端に 0 を入れます。2 進数で 1 桁左にずらすと 2 倍、n 桁なら 2n 倍です。たとえば 5(101)を 1 桁ずらすと 1010(10)、1 を 3 桁ずらすと 1000(8)です。「1 << n」は「n 番目のビットだけが 1 の数」を作る定番の書き方で、フラグの定義によく使われます。

右シフト:算術シフトと論理シフト
右シフトは、ビット全体を右にずらし、右端からはみ出したビットは捨てます。問題は空いた左端に何を入れるかで、2 種類あります。
- 算術シフト:左端に元の最上位ビット(符号)と同じ値を入れる。マイナスの数はマイナスのまま、ほぼ「2n で割る」になる
- 論理シフト:左端に必ず 0 を入れる。ビットの並びをそのまま動かしたいときに使う。マイナスの数は大きな正の数になる
JavaScript には両方があり、「>>」が算術シフト、「>>>」が論理シフト(MDN では「ゼロ埋め右シフト」)です。Edge で確かめた結果は次のとおりです。
| JavaScript の式 | 結果 | 説明 |
|---|---|---|
| -16 >> 2 | -4 | 符号を保ったまま 4 で割った値 |
| -16 >>> 2 | 1073741820 | 左端に 0 が入り、大きな正の数になる |
| -1 >>> 0 | 4294967295 | ずらさずに「符号なし 32 ビット」として読み直す |
| (-16 >>> 0).toString(2) | 11111111111111111111111111110000 | マイナスの数のビットの並びを確認する |

Python と PowerShell の右シフトは算術シフトです。Python の公式ドキュメントでは、n ビットの右シフトは「pow(2, n) での切り捨て除算」と定義されています。そのため -7 >> 1 は -3.5 を小さい方向に切り捨てた -4 になり、-7 // 2 と同じ結果です。PowerShell 5.1 でも -5 -shr 1 は -3 になりました。
PowerShell 5.1 には >>> にあたる演算子がありません。論理シフトをしたいときは、符号なしの型([uint32])にしてからシフトします。次のコマンドを実行すると「268435455」(0x0FFFFFFF)と表示されます。
[uint32]4294967280 -shr 4
なお、[uint32]0xFFFFFFF0 と 16 進数で書くとエラーになります。PowerShell 5.1 は 0xFFFFFFF0 を Int32(符号付き)の -16 として読むため、符号なしの型に変換できないからです。
JavaScript は 32 ビットに切り詰める
JavaScript の数(Number)は小数も扱える 64 ビットの浮動小数点数ですが、ビット演算をするときだけ32 ビットの整数に変換されます。そのため、次のような結果になります。
| JavaScript の式 | 結果 | 理由 |
|---|---|---|
| 1 << 31 | -2147483648 | 32 ビット目(最上位ビット)が 1 になり、マイナスとして読まれる |
| 1 << 32 | 1 | シフト量は 32 で割った余りが使われるので、0 桁のシフトになる |
| 0xFFFFFFFF | 0 | -1 | 32 ビットすべて 1 は、符号付きでは -1 |
| 2 ** 40 & 1 | 0 | 32 ビットより上の桁は捨てられる |
| 3.7 | 0、-3.7 | 0 | 3、-3 | 小数点以下が捨てられる(0 の方向に切り捨て) |
32 ビットを超える整数でビット演算をしたいときは、数の後ろに n を付けた BigInt を使います。1n << 40n は 1099511627776 になります。ただし BigInt には >>> がなく、1n >>> 0n は「TypeError: BigInts have no unsigned right shift, use >> instead」というエラーになりました。BigInt と普通の数を混ぜた 1n & 1 もエラーです。
Python の int は桁あふれしない
Python の整数には上限がないため、シフトしても桁があふれません。print(1 << 100) は 1267650600228229401496703205376 と、2100 をそのまま表示します。他の言語の 32 ビットの計算を再現したいときは、0xFFFFFFFF との AND で 32 ビットに切りそろえます。次のコードを実行すると「68719476720」と「4294967280」が表示されます。
x = 0xFFFFFFFF << 4
print(x)
print(x & 0xFFFFFFFF)
シフト量にマイナスを指定すると、Python では「ValueError: negative shift count」というエラーになります。JavaScript の 5 >> -1 はエラーにならず 0 でした(-1 が 32 で割った余りの 31 として扱われるため)。言語によって扱いが違うので、シフト量は 0 以上にしましょう。
実用例:よく使うパターン
フラグを立てる・調べる・下ろす・反転する
1 ビットに 1 つの「オン・オフ」を割り当て、1 つの数にまとめて持つ方法をフラグと呼びます。ファイルの権限(読み・書き・実行)がその代表です。基本の 4 つの操作を Python で書くと次のようになります。
READ, WRITE, EXEC = 1, 2, 4
perm = READ | WRITE
perm |= EXEC
print(perm, format(perm, '03b'))
print(perm & WRITE != 0)
print(perm & (WRITE | EXEC) == (WRITE | EXEC))
perm &= ~WRITE
print(perm, format(perm, '03b'))
perm ^= READ
print(perm, format(perm, '03b'))
実行結果は次のとおりです。
7 111
True
True
5 101
4 100
| やりたいこと | 書き方 | 考え方 |
|---|---|---|
| 立てる | perm |= EXEC | OR で EXEC のビットを 1 にする |
| 1 つ調べる | perm & WRITE != 0 | AND の結果が 0 でなければ立っている |
| 全部立っているか調べる | perm & mask == mask | mask のビットがすべて残っていれば True |
| 下ろす | perm &= ~WRITE | WRITE 以外を 1 にしたマスク(~WRITE)と AND |
| 反転する | perm ^= READ | XOR で READ のビットだけ入れ替える |
この表の「調べる」の書き方は、Python ではそのまま動きますが、JavaScript では同じように書くと間違った結果になります。理由は後の「& と == の優先順位」で説明します。JavaScript では (perm & WRITE) !== 0 のように、必ずかっこで囲みます。Linux の権限(755 など)の数値と記号の変換は「chmod 計算ツール」で確かめられます。
偶数・奇数の判定:n & 1
2 進数の一番右のビット(最下位ビット)は、奇数なら 1、偶数なら 0 です。そのため n & 1 が 0 なら偶数、1 なら奇数と判定できます。
この書き方は、マイナスの数でも同じように動くのが利点です。JavaScript の余りの演算子「%」は割られる数の符号を受け継ぐため、-3 % 2 は -1 になり、「n % 2 === 1 なら奇数」という判定は -3 で失敗します。一方、-3 & 1 は 1 です(Python では -3 % 2 も 1 になります)。
2 のべき乗の判定:n & (n – 1)
n – 1 を計算すると、n の一番右にある 1 が 0 になり、その右側の 0 がすべて 1 になります。たとえば 12(1100)から 1 を引くと 11(1011)です。そのため n & (n – 1) は「一番右の 1 を消した数」になります。
2 のべき乗(1、2、4、8…)は 1 が 1 個だけなので、それを消すと 0 になります。次のコードは 1〜69 のうち n & (n – 1) が 0 になる数を集めます。実行すると「[1, 2, 4, 8, 16, 32, 64]」と表示されます。
print([n for n in range(1, 70) if n & (n - 1) == 0])
0 も 0 & (-1) で 0 になってしまうので、実際の判定では n > 0 and n & (n – 1) == 0 のように 0 を除きます。反対に n & -n と書くと「一番右の 1 だけを残した数」になり、40(101000)なら 8(1000)です。
マスクとシフトで値の一部を取り出す
複数の値を 1 つの数に詰めて持つ形式では、「必要な位置まで右にシフトして、マスクで AND を取る」のが定番です。カラーコード 0x1E90FF から赤・緑・青を取り出し、もう一度組み立てる例です。
color = 0x1E90FF
r = (color >> 16) & 0xFF
g = (color >> 8) & 0xFF
b = color & 0xFF
print(r, g, b)
print(hex((r << 16) | (g << 8) | b))
実行すると「30 144 255」と「0x1e90ff」が表示されます。取り出すときは「>> と &」、組み立てるときは「<< と |」と、逆の組み合わせになっている点に注目してください。IP アドレスとサブネットマスクの AND も同じ考え方で、ネットワークアドレスをすぐに求めたいときは「サブネット計算ツール」が使えます。
1 のビットを数える:int.bit_count()
立っているフラグの数を知りたいときなど、1 になっているビットの数(ポピュレーションカウントと呼びます)を数えるには、Python 3.10 で追加された int.bit_count() を使います。次のコードを実行すると「8 2 2」と表示されます。
print((255).bit_count(), (12).bit_count(), (-12).bit_count())
公式ドキュメントのとおり、数えるのは絶対値の 2 進数の 1 の数なので、-12 も 12 と同じ 2 になります。2 の補数で表した 32 ビットの 1 を数えたいときは、(-12 & 0xFFFFFFFF).bit_count() のように先に切りそろえます。Python 3.9 以前では bin(n).count(‘1’) で同じ結果が得られます。なお、PowerShell 5.1 では .NET の [System.Numerics.BitOperations] は「型が見つからない」というエラーになり、使えませんでした。
XOR で 2 つの値を入れ替える(実用では使わない)
XOR には「同じ値で 2 回 XOR すると元に戻る」という性質があり、これを使うと一時変数なしで 2 つの値を入れ替えられます。x = 12、y = 25 に対して x ^= y、y ^= x、x ^= y の順に実行すると、x が 25、y が 12 になります。
ただし、実際のコードでは使わないことをおすすめします。理由は次の 3 つです。
- 同じ場所どうしだと 0 になる:リストの a[i] と a[j] を入れ替えるとき、i と j が同じだと 1 回目の XOR で値が 0 になり、元に戻りません。a = [5, 9]、i = j = 0 で試すと、結果は [0, 9] になりました
- 読みにくい:何をしているのか、読む人がすぐに分からない
- もっと簡単な書き方がある:Python なら x, y = y, x、JavaScript なら [x, y] = [y, x] と書ける
XOR の性質そのものは、データの差分を調べる、誤り検出のパリティを計算するなどの場面で役に立ちます。「入れ替えのテクニック」としてではなく、「同じなら 0、2 回で元に戻る」という性質として覚えておきましょう。
Python の enum.Flag でフラグに名前を付ける
フラグをただの数で持つと、print しても「3」としか表示されず、どのフラグが立っているのか分かりません。Python では、標準ライブラリの enum.Flag を使うと、名前付きのフラグとして扱えます。auto() は 1、2、4…と、ビットが重ならない値を自動で割り当てます。
from enum import Flag, auto
class Perm(Flag):
READ = auto()
WRITE = auto()
EXEC = auto()
p = Perm.READ | Perm.WRITE
print(p)
print(p.value)
print(Perm.WRITE in p, Perm.EXEC in p)
p &= ~Perm.WRITE
print(p)
print(list(Perm.READ | Perm.EXEC))
print(Perm(7))
実行結果は次のとおりです。
Perm.READ|WRITE
3
True False
Perm.READ
[<Perm.READ: 1>, <Perm.EXEC: 4>]
Perm.READ|WRITE|EXEC
- 表示が「Perm.READ|WRITE」となり、どれが立っているか一目で分かる
- 「in」で調べられるので、& と != 0 を書かずに済み、優先順位の間違いも起きない
- list() で立っているフラグを 1 つずつ取り出せる(Python 3.11 から)
定義にない値を変換しようとすると、エラーで知らせてくれます。この例で Perm(8) を実行すると「ValueError: <flag ‘Perm’> invalid value 8」になりました。公式ドキュメントによると、範囲外の値をエラーにする STRICT が Flag の既定の動きです(Python 3.11 から)。ファイルや通信で受け取った数をそのまま int で扱うより、おかしな値に早く気付けます。整数として計算にも使いたい場合は IntFlag という種類もあり、こちらは範囲外の値もそのまま保持するのが既定です。
よくある間違い・落とし穴
& と == の優先順位が言語で違う
ビット演算でいちばん多い間違いが、演算子の優先順位(どちらを先に計算するか)です。「12 & 6 == 4」(12 と 6 の AND は 4 か?)という同じ式でも、言語によって結果が変わります。
| 言語 | 式 | 結果 | どう計算されたか |
|---|---|---|---|
| Python 3.12 | 12 & 6 == 4 | True | (12 & 6) == 4。& が先 |
| JavaScript(Edge) | 12 & 6 == 4 | 0 | 12 & (6 == 4) → 12 & false → 0。== が先 |
| PowerShell 5.1 | 12 -band 6 -eq 4 | 0 | 12 -band (6 -eq 4)。-eq が先 |
公式の資料でも確認しました。Python の言語リファレンスには「C と違い、Python の比較演算はすべて同じ優先順位で、算術・シフト・ビット演算のどれよりも低い」と書かれています。一方、MDN の JavaScript の優先順位表では、等価演算子(==)が 8、ビット AND(&)が 7 で、== の方が先に計算されます。PowerShell 5.1 の about_Operator_Precedence でも、-eq などの比較演算子が -band などより先に並んでいます。
特に危ないのが JavaScript の偶数判定です。n & 1 == 0 と書くと n & (1 == 0) つまり n & false となり、どんな n でも 0 になります。エラーにならないので気付きにくい間違いです。言語にかかわらず、ビット演算と比較を組み合わせるときは (n & 1) === 0 のように必ずかっこを付けるのが安全です。
シフトは足し算より後に計算される
「1 + 2 << 3」は、1 + (2 << 3) の 17 ではなく、(1 + 2) << 3 の 24 になります。Python・JavaScript・PowerShell(1 + 2 -shl 3)のどれでも 24 でした。シフトを「掛け算の代わり」として足し算と混ぜると、意図と違う結果になります。ここでもかっこを付けましょう。
~ の結果をそのまま表示してマイナスに驚く
Python で ~0 は -1、~5 は -6 です。これは間違いではなく、前に説明したとおり 2 の補数の仕組みによるものです。「8 ビットの反転」がほしいなら ~x & 0xFF、「32 ビットの反転」なら ~x & 0xFFFFFFFF のように、ビット数をマスクで決めてから使います。なお、フラグを下ろす perm & ~WRITE は、相手の perm が正の数なので、マスクで切りそろえなくても正しく動きます。
JavaScript で大きな数にビット演算を使う
JavaScript のビット演算は 32 ビットに切り詰めるため、ID やタイムスタンプ(ミリ秒)のような大きな数に使うと、上の桁が黙って捨てられます。2 ** 40 & 1 が 0、(2 ** 40 + 5) & 0xFF が 5 になるように、エラーにはなりません。32 ビットを超える数は BigInt にするか、ビット演算を使わない方法にしましょう。また、「x | 0」で小数を整数にする書き方も、231 以上の数では壊れます(2 ** 32 | 0 は 0)。整数にしたいときは Math.trunc を使う方が安全です。
論理演算子(and・&&)と取り違える
if の条件で「A かつ B」と書きたいときは、Python なら and、JavaScript なら &&、PowerShell なら -and を使います。ビット演算の & を使っても動くように見える場合がありますが、Python の 12 and 10 が 10、12 & 10 が 8 になるように、意味が違います。とくに PowerShell では、論理演算の -and と、ビット演算の -band を 1 文字違いで取り違えやすいので注意してください。
よくある質問
掛け算や割り算をシフトに書き換えると速くなりますか?
「2 倍するなら << 1」のような書き換えは、まず読みやすさを損ないます。さらに Python の >> は切り捨て除算、JavaScript は 32 ビットへの切り詰め、と結果が普通の割り算と変わる場合もあります。計算として 2 倍・半分にしたいなら * や // を使い、速度が気になるときは実際に測ってから判断しましょう。シフトは「ビットの位置を動かしたい」ときに使うのが基本です。
ビット演算の結果を 2 進数で表示するには?
Python では format(x, ’08b’) や f 文字列の f'{x:08b}’ で 0 埋めの 2 進数にできます(書式指定は「Pythonのf文字列(f-string)の使い方」で解説しています)。JavaScript は x.toString(2)、マイナスの数のビットを見たいときは (x >>> 0).toString(2) です。PowerShell 5.1 は [Convert]::ToString(x, 2) を使います。
フラグは数でまとめるのと、真偽値を別々に持つのと、どちらがよいですか?
ファイルの権限やライブラリの設定値のように、決まった形式(数)で受け渡しが必要な場合はビットのフラグが向いています。自分のプログラムの中だけで使う設定なら、真偽値を別々に持つ方が読みやすいことも多いです。Python でビットのフラグを使うなら、enum.Flag で名前を付けると両方の良いところを取れます。
まとめ
AND は取り出す、OR は立てる、XOR は反転する、NOT は -(x+1)、シフトはビットを動かす、と役割で覚えると、コードの意味が読めるようになります。言語ごとの違い(Python は桁あふれしない、JavaScript は 32 ビット、& と == の優先順位)でつまずきやすいので、比較と組み合わせるときはかっこを付けましょう。
関連する記事・ツール
- 基数変換ツール(2 進数・8 進数・10 進数・16 進数の相互変換、2 の補数対応)
- 論理演算・真理値表ツール
- chmod 計算ツール
- サブネット計算ツール
- 2進数・16進数の基本|0xFF・カラーコード・IPアドレスなど仕事で出会う場面を解説
- Pythonのf文字列(f-string)の使い方|書式指定・桁区切り・ゼロ埋めを実例で解説
- 浮動小数点数の誤差とは?0.1+0.2が0.3にならない理由と対処法