Bit-level Operatörler: Permission Flags, RGB Manipülasyon ve Düşük-Seviye Hızın Dünyası

6 Bit Operatörü#

a = 0b1100   # 12
b = 0b1010   # 10

# AND
print(bin(a & b))   # 0b1000  (8) — sadece her ikisinde 1 olan bit
print(a & b)        # 8

# OR
print(bin(a | b))   # 0b1110  (14) — en az birinde 1 olan
print(a | b)        # 14

# XOR
print(bin(a ^ b))   # 0b110   (6) — sadece birinde 1 olan
print(a ^ b)        # 6

# NOT (-(x+1) gibi davranır — two's complement)
print(~12)          # -13
print(bin(~12))     # -0b1101 (negatif gösterim Python-spesifik)

# Shift
print(0b0001 << 3)  # 0b1000 (8) — sola 3 bit
print(0b1000 >> 2)  # 0b0010 (2) — sağa 2 bit

x = 5

# Sola shift = 2'nin kuvvetiyle çarpma
print(x << 1)    # x * 2 = 10
print(x << 3)    # x * 8 = 40

# Sağa shift = 2'nin kuvvetiyle bölme (floor)
print(40 >> 1)   # 40 / 2 = 20
print(40 >> 3)   # 40 / 8 = 5

Binary representation — sayıları görselleştirmek#

# Pozitif sayılar
print(bin(0))        # 0b0
print(bin(1))        # 0b1
print(bin(5))        # 0b101
print(bin(255))      # 0b11111111
print(bin(256))      # 0b100000000

# Negatif (Python — sign-magnitude)
print(bin(-5))       # -0b101 (Python rep)

# Format kontrolü
print(f"{255:08b}")  # 11111111 (8-bit padding)
print(f"{5:08b}")    # 00000101
print(f"{255:016b}") # 0000000011111111 (16-bit)

# Hex (genelde okuması kolay)
print(hex(255))      # 0xff
print(f"{255:02x}")  # ff
print(f"{255:#04x}") # 0xff (prefix dahil)

# Octal
print(oct(8))        # 0o10

# Tersine dönüşüm
print(int("11111111", 2))  # 255
print(int("ff", 16))        # 255
print(int("0xff", 16))      # 255
print(int("0b1111", 2))     # 15

Pratik 1: Permission flags (Unix-style)#

rwx rwx rwx
421 421 421

# Permission constants
READ = 0b100      # 4
WRITE = 0b010     # 2
EXECUTE = 0b001   # 1

# Birleştirme (OR)
rwx = READ | WRITE | EXECUTE              # 0b111 (7)
rw_ = READ | WRITE                         # 0b110 (6)
r__ = READ                                  # 0b100 (4)
__x = EXECUTE                               # 0b001 (1)

print(f"rwx = {rwx} = 0b{rwx:03b} = 0o{rwx:o}")  # 7 = 0b111 = 0o7
print(f"rw_ = {rw_} = 0b{rw_:03b} = 0o{rw_:o}")  # 6 = 0b110 = 0o6

# Kontrol (AND)
permissions = rwx
has_read = bool(permissions & READ)         # True (sıfır olmayan = truthy)
has_execute = bool(permissions & EXECUTE)   # True

permissions = rw_
has_execute = bool(permissions & EXECUTE)   # False

# Bit kapatma (AND with NOT)
permissions = rwx
permissions = permissions & ~WRITE          # write'i kapat → r_x (5)
print(f"After remove write: 0b{permissions:03b}")  # 0b101

# Bit toggle (XOR)
permissions ^= EXECUTE                      # execute'u tersine çevir
print(f"After toggle execute: 0b{permissions:03b}")  # 0b100 (sadece read)


# Tam Linux permission (9-bit, 3 grup)
def parse_permissions(perm_int):
    """0o755 (493) → 'rwxr-xr-x'."""
    flags = "rwxrwxrwx"
    result = []
    for i in range(9):
        bit_pos = 8 - i   # en yüksek bit'ten başla
        if perm_int & (1 << bit_pos):
            result.append(flags[i])
        else:
            result.append("-")
    return "".join(result)

print(parse_permissions(0o755))   # 'rwxr-xr-x'
print(parse_permissions(0o644))   # 'rw-r--r--'
print(parse_permissions(0o777))   # 'rwxrwxrwx'

Modern alternatif:

enum.IntFlag

#

from enum import IntFlag, auto

class Permission(IntFlag):
    READ = 4
    WRITE = 2
    EXECUTE = 1

# Veya auto() ile (sırayla 1, 2, 4, 8...)
class Permission(IntFlag):
    READ = auto()
    WRITE = auto()
    EXECUTE = auto()
    # 1, 2, 4 otomatik

# Birleştirme
rwx = Permission.READ | Permission.WRITE | Permission.EXECUTE
print(rwx)
# Permission.READ|WRITE|EXECUTE  ← güzel repr

# Kontrol — 'in' kullanımı (3.11+)
if Permission.READ in rwx:
    print("Okunabilir")

# Klasik AND
if rwx & Permission.WRITE:
    print("Yazılabilir")

# Iteration (3.11+)
for p in rwx:
    print(p)   # READ, WRITE, EXECUTE

# Bit kapatma
no_exec = rwx & ~Permission.EXECUTE
print(no_exec)   # Permission.READ|WRITE

• Type safety: 'Permission.READ' net, '4' magic number değil.
• Repr: 'Permission.READ|WRITE|EXECUTE' okunabilir.
• 'in' desteği (3.11+): 'Permission.READ in flags'.
• IDE autocomplete: değerleri biliyor.
• Validation: int + IntFlag karışıklığı zorlanmıyor.

Re-pythonic API ile#

from enum import IntFlag, auto

class FilePermission(IntFlag):
    NONE = 0
    READ = auto()
    WRITE = auto()
    EXECUTE = auto()
    ALL = READ | WRITE | EXECUTE

p = FilePermission.READ | FilePermission.EXECUTE
print(p)                          # FilePermission.READ|EXECUTE
print(FilePermission.READ in p)    # True (Python 3.11+)
print(p == FilePermission.READ | FilePermission.EXECUTE)  # True

# Tüm
all_perm = FilePermission.ALL
print(all_perm == FilePermission.READ | FilePermission.WRITE | FilePermission.EXECUTE)  # True

Pratik 2: RGB Color Manipulation#

# Hex notation
WHITE = 0xFFFFFF
BLACK = 0x000000
RED = 0xFF0000
GREEN = 0x00FF00
BLUE = 0x0000FF
ORANGE = 0xFF8800

# Bileşenleri ayır
def rgb_split(color):
    r = (color >> 16) & 0xFF    # üst 8 bit
    g = (color >> 8) & 0xFF     # orta 8 bit
    b = color & 0xFF             # alt 8 bit
    return r, g, b

print(rgb_split(0xFF8800))    # (255, 136, 0)
print(rgb_split(0x123456))    # (18, 52, 86)


# Bileşenleri birleştir
def rgb_combine(r, g, b):
    return (r << 16) | (g << 8) | b

print(hex(rgb_combine(255, 136, 0)))    # 0xff8800
print(hex(rgb_combine(0, 0, 0)))         # 0x0


# Renk operations
def lighten(color, amount=20):
    r, g, b = rgb_split(color)
    r = min(255, r + amount)
    g = min(255, g + amount)
    b = min(255, b + amount)
    return rgb_combine(r, g, b)

def invert(color):
    return color ^ 0xFFFFFF    # XOR ile tersle

print(hex(lighten(0xFF8800)))   # 0xffa414
print(hex(invert(0xFF0000)))    # 0xffff (== 0x00FFFF, cyan — kırmızının tersi)

RGBA — alpha channel#

def rgba_split(color):
    r = (color >> 24) & 0xFF
    g = (color >> 16) & 0xFF
    b = (color >> 8) & 0xFF
    a = color & 0xFF
    return r, g, b, a

print(rgba_split(0xFF880080))    # (255, 136, 0, 128) — half-transparent orange

Pratik 3: IPv4 adres manipülasyonu#

def ip_to_int(ip):
    """'192.168.1.1' → 3232235777"""
    parts = [int(p) for p in ip.split(".")]
    return (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8) | parts[3]

def int_to_ip(n):
    """3232235777 → '192.168.1.1'"""
    return f"{(n >> 24) & 0xFF}.{(n >> 16) & 0xFF}.{(n >> 8) & 0xFF}.{n & 0xFF}"


# Test
ip = "192.168.1.1"
n = ip_to_int(ip)
print(n)              # 3232235777
print(hex(n))         # 0xc0a80101
print(int_to_ip(n))   # 192.168.1.1


# Subnet mask kontrolü
def in_subnet(ip, network, prefix_len):
    """IP, /prefix CIDR network'unda mı?"""
    mask = (0xFFFFFFFF << (32 - prefix_len)) & 0xFFFFFFFF
    return (ip_to_int(ip) & mask) == (ip_to_int(network) & mask)

print(in_subnet("192.168.1.50", "192.168.1.0", 24))    # True
print(in_subnet("192.168.2.1", "192.168.1.0", 24))     # False
print(in_subnet("10.0.0.5", "10.0.0.0", 8))             # True

import ipaddress

ip = ipaddress.IPv4Address("192.168.1.50")
network = ipaddress.IPv4Network("192.168.1.0/24")

print(ip in network)    # True
print(int(ip))          # 3232235826 (otomatik)

Bit manipulation klasikleri#

Tek bit kontrol/set/clear/toggle#

def get_bit(num, pos):
    """Pozisyondaki bit 1 mi 0 mı?"""
    return (num >> pos) & 1

def set_bit(num, pos):
    """Pozisyona 1 yaz."""
    return num | (1 << pos)

def clear_bit(num, pos):
    """Pozisyona 0 yaz."""
    return num & ~(1 << pos)

def toggle_bit(num, pos):
    """Pozisyondaki bit'i tersle."""
    return num ^ (1 << pos)


x = 0b1010   # 10
print(get_bit(x, 1))     # 1
print(get_bit(x, 0))     # 0

print(bin(set_bit(x, 0)))    # 0b1011 (11)
print(bin(clear_bit(x, 1)))  # 0b1000 (8)
print(bin(toggle_bit(x, 3))) # 0b10 (2 — bit 3 silindi)

Bit count (popcount)#

# Python 3.10+: int.bit_count
print((0b11010110).bit_count())   # 5

# 3.10 öncesi
def popcount(n):
    count = 0
    while n:
        count += n & 1
        n >>= 1
    return count

print(popcount(0b11010110))   # 5

# Veya bin() ile
print(bin(0b11010110).count("1"))   # 5

En sağdaki 1 bit'i bul#

# x'in en sağ 1 bit'i (lowest set bit)
def lowest_bit(x):
    return x & (-x)

print(bin(lowest_bit(0b1010_1100)))    # 0b100 (en sağ 1, pozisyon 2)

Power of 2 kontrolü#

def is_power_of_2(n):
    """n iki'nin kuvveti mi? (1, 2, 4, 8, 16, ...)"""
    return n > 0 and (n & (n - 1)) == 0

# Mantık: 2^k binary'de tek bir 1 var (örn 8 = 1000)
# 2^k - 1 = 0111 (tüm bitler dolu)
# AND → 0

print(is_power_of_2(16))    # True
print(is_power_of_2(15))    # False
print(is_power_of_2(0))     # False

Swap without temp#

a, b = 5, 3

# Klasik (temp ile)
temp = a
a = b
b = temp

# Pythonic (tuple unpacking)
a, b = b, a

# XOR swap (eski C trick)
a = a ^ b
b = a ^ b
a = a ^ b

bool'larda bit operatörleri#

print(True & False)      # 0 (False ile aynı semantic)
print(True | False)      # 1 (True ile aynı)
print(True ^ True)       # 0

# Ama dikkat — bool dönmüyor, int dönüyor
print(type(True & False))   # <class 'int'>
print(True & 1)             # 1

# and/or — short-circuit, son değer döner
True and False     # False
0 or "x"           # 'x'
None and 5         # None

# &/| — bit-level, her zaman number döner, no short-circuit
True & False       # 0
0 | 1              # 1
None & 5           # TypeError! (NoneType bit op desteklemez)

import numpy as np

a = np.array([True, False, True])
b = np.array([True, True, False])

# 🚫 a and b — ValueError (truth value of array ambiguous)
# ✅ a & b — element-wise AND
print(a & b)    # [True, False, False]
print(a | b)    # [True, True, True]

Yaygın tuzaklar#

1. Python int sınırsız — bit gösterimi#

# C/Java: ~5 = 0xFFFFFFFA (32-bit, two's complement)
# Python: ~5 = -6 (sign-magnitude, sınırsız bit)

# 32-bit unsigned olmasını istersen mask uygula
print(~5 & 0xFFFFFFFF)   # 4294967290 (= 0xFFFFFFFA)

2. Operator precedence#

# 🚫
if x & 0b100 == 0b100:
    ...
# Aslında: x & (0b100 == 0b100) = x & True = x & 1 — yanlış!

# ✅
if (x & 0b100) == 0b100:
    ...

# Veya
if x & 0b100:    # truthy check yeter
    ...

3.

&

/

|

ile boolean#

# 🚫
if x and y == z:    # and short-circuit — OK
    ...

# 🚫
if x & (y == z):    # bit AND — y == z bool → 0 veya 1, ama (x & 0) veya (x & 1)
    ...             # x'in en sağ bit'ine bağlı — yanlış!

# Pandas/NumPy'da:
mask = (df.age > 18) & (df.country == "TR")    # ✅ element-wise

4. Shift overflow (yok!)#

# C/Java: int 32-bit, shift fazla → undefined / 0
# Python: sınırsız precision

x = 1 << 100   # OK
print(x)        # 1267650600228229401496703205376

5. Negatif shift#

1 << -1    # ValueError: negative shift count

6.

~

ile bool#

~True         # -2
~False        # -1

# bool'ları "ters çevirmek" istiyorsan
not True      # False
not False     # True

7. IntFlag yerine raw int#

# 🚫
permissions = 7   # ne anlama geliyor? 7 magic number
if permissions & 4:    # 4 = read?
    ...

# ✅
permissions = Permission.READ | Permission.WRITE | Permission.EXECUTE
if Permission.READ in permissions:    # net
    ...

Bu derste neler kazandın?#