Stop Learning Binary with Silly Calculator Examples
Right, so you’ve got arithmetic operators working and you understand how Python handles basic maths operations. Now we’re moving into python bitwise operators territory, which is where networking gets really interesting.
Python for Network Engineers Blog 16: Logical Operators
Now here’s where most Python courses completely lose the plot again. They’ll have you doing binary arithmetic with random numbers or calculating weird bit patterns that mean nothing. I’m sitting there thinking, that’s lovely mate but I’ve got VLAN configurations to manage, subnet masks to work with, and access control lists to manipulate. How’s calculating whether 42 & 57 equals 40 going to help me configure my switches then?
Look, I made this exact mistake when I started. About three years back, trying to learn bitwise operations from some generic programming course. Spent ages working through examples about flipping individual bits in abstract numbers. Made no sense whatsoever. Complete waste of time.
Few months later, needed to work out some subnet calculations programmatically. Had to figure out network addressing, wildcard masks, that sort of thing. Thought there’s got to be a better way than manually converting everything to binary.
Found someone who explained it properly using actual networking examples. Made much more sense straight away. Instead of working with meaningless numbers, I’m manipulating IP addresses, subnet masks, and network ranges.
So let’s cover python bitwise operators properly using network stuff that matters.
What Bitwise Operators Actually Do
Right so python bitwise operators work directly on the binary representation of numbers. That means they manipulate individual bits rather than treating numbers as whole values. Simple enough concept.
These are your six bitwise operators:
# The six bitwise operators with network examples
network_address = 192 # 11000000 in binary
subnet_mask = 255 # 11111111 in binary
# Bitwise AND (&)
result_and = network_address & subnet_mask
print("Bitwise AND:", result_and) # 192
# Bitwise OR (|)
result_or = network_address | 63
print("Bitwise OR:", result_or) # 255
# Bitwise XOR (^)
result_xor = network_address ^ 63
print("Bitwise XOR:", result_xor) # 63
# Bitwise NOT (~)
result_not = ~network_address
print("Bitwise NOT:", result_not) # -193
# Left shift (<<)
result_left = network_address << 1
print("Left shift:", result_left) # 384
# Right shift (>>)
result_right = network_address >> 1
print("Right shift:", result_right) # 96See? Working with actual network values. Not abstract meaningless numbers.
Now here’s something quite clever about python bitwise operators that I didn’t appreciate when I started. They work at the bit level, which means you can manipulate individual parts of network addresses without having to convert everything manually. Perfect for subnet calculations, wildcard masks, access lists.
Actually had this come up last year. Was working on some automated subnet planning and needed to calculate network boundaries efficiently. Python bitwise operators made it straightforward once I understood how they mapped to networking concepts.
Why This Matters for Network Engineers
Look, networking’s absolutely stuffed with binary operations, isn’t it? IP addresses, subnet masks, VLAN IDs stored as bits, access control lists. Everything’s got binary representation attached.
Understanding python bitwise operators properly means you can manipulate network addresses directly. Makes your subnet calculations much more efficient.
# Basic subnet calculation using bitwise AND
ip_address = 3232235776 # 192.168.1.0 as integer
subnet_mask = 4294967040 # 255.255.255.0 as integer
# Calculate network address
network_address = ip_address & subnet_mask
print("Network address as integer:", network_address)
# Convert back to readable format manually
octet1 = (network_address >> 24) & 255
octet2 = (network_address >> 16) & 255
octet3 = (network_address >> 8) & 255
octet4 = network_address & 255
print("Network address:", octet1, ".", octet2, ".", octet3, ".", octet4)Brilliant for automating network planning tasks.
But here’s where people get confused. When do you use bitwise operators versus regular arithmetic operators?
Understanding Each Bitwise Operator
This catches people out constantly. Which operator does what, and when would you actually use each one?
Simple rule I use. If you’re working with individual bits or binary patterns, use bitwise operators. If you’re doing normal maths, use arithmetic operators.
# Bitwise AND - both bits must be 1 to get 1
vlan_permissions = 240 # 0b11110000 - VLANs 4,5,6,7 allowed
user_request = 160 # 0b10100000 - Requesting VLANs 5,7
allowed = vlan_permissions & user_request
print("Allowed VLANs (binary):", bin(allowed)) # 0b10100000
print("Allowed VLANs (decimal):", allowed) # 160
# Bitwise OR - either bit can be 1 to get 1
current_vlans = 15 # 0b00001111 - VLANs 0,1,2,3 active
new_vlans = 240 # 0b11110000 - Adding VLANs 4,5,6,7
all_vlans = current_vlans | new_vlans
print("All VLANs (binary):", bin(all_vlans)) # 0b11111111
print("All VLANs (decimal):", all_vlans) # 255
# Bitwise XOR - bits must be different to get 1
original_config = 170 # 0b10101010
updated_config = 204 # 0b11001100
changes = original_config ^ updated_config
print("Configuration changes (binary):", bin(changes)) # 0b01100110
print("Configuration changes (decimal):", changes) # 102
Got caught out by this early on actually. Had a script that was trying to check interface permissions using arithmetic instead of bitwise operations, couldn’t work out why the logic wasn’t working. Spent ages debugging before I realised I needed bitwise AND, not regular addition.
Bitwise AND for Network Masking
Right so here’s something that confused the hell out of me when I started. The bitwise AND operator only returns 1 when both corresponding bits are 1. Otherwise it returns 0.
This is absolutely perfect for subnet calculations because that’s exactly how subnet masks work.
# Subnet mask examples using bitwise AND
host_ip = 3232235828 # 192.168.1.52
subnet_24 = 4294967040 # 255.255.255.0 (/24)
subnet_25 = 4294967168 # 255.255.255.128 (/25)
subnet_26 = 4294967232 # 255.255.255.192 (/26)
# Calculate network addresses with different masks
network_24 = host_ip & subnet_24
network_25 = host_ip & subnet_25
network_26 = host_ip & subnet_26
print("Host IP: 192.168.1.52")
print("With /24 mask, network is:", network_24) # Same as original
print("With /25 mask, network is:", network_25) # Different network
print("With /26 mask, network is:", network_26) # Different again
# Check which subnet the host belongs to
if (host_ip & subnet_24) == (3232235776 & subnet_24):
print("Host is in 192.168.1.0/24 network")
if (host_ip & subnet_26) == (3232235792 & subnet_26):
print("Host is in 192.168.1.48/26 network")When you’d use this in practice.
Port Access Control:
Use AND to check permissions against allowed resources.
# Simple port access control using bitwise AND
allowed_ports = 240 # 0b11110000 - Ports 4,5,6,7 allowed
requested_port = 32 # 0b00100000 - Requesting port 5
# Check if request is allowed
if allowed_ports & requested_port:
print("Port 5 access: GRANTED")
else:
print("Port 5 access: DENIED")
# Check multiple ports at once
requested_ports = 176 # 0b10110000 - Requesting ports 4,5,7
valid_requests = allowed_ports & requested_ports
print("Binary allowed:", bin(allowed_ports))
print("Binary requested:", bin(requested_ports))
print("Binary granted:", bin(valid_requests))
print("Granted ports value:", valid_requests)Much cleaner than checking each port individually.
Bitwise OR for Configuration Building
The OR operator returns 1 when either bit is 1. Only returns 0 when both bits are 0.
Perfect for building up configurations by combining different settings.
# Building VLAN configurations using bitwise OR
sales_vlans = 3 # 0b00000011 - VLANs 0,1
engineering_vlans = 12 # 0b00001100 - VLANs 2,3
management_vlans = 240 # 0b11110000 - VLANs 4,5,6,7
# Combine department VLANs
sales_eng = sales_vlans | engineering_vlans
print("Sales + Engineering VLANs:", sales_eng) # 15 (0b00001111)
all_departments = sales_vlans | engineering_vlans | management_vlans
print("All department VLANs:", all_departments) # 255 (0b11111111)
# Add new VLAN to existing configuration
existing_config = 15 # 0b00001111 - VLANs 0,1,2,3
new_vlan = 16 # 0b00010000 - VLAN 4
updated_config = existing_config | new_vlan
print("Updated configuration:", updated_config) # 31 (0b00011111)
print("Binary before:", bin(existing_config))
print("Binary after:", bin(updated_config))
Interface Feature Flags:
Enable multiple features simultaneously.
# Interface feature management using bitwise OR
FEATURE_NONE = 0 # 0b00000000
FEATURE_STP = 1 # 0b00000001 - Spanning Tree
FEATURE_VLAN = 2 # 0b00000010 - VLAN support
FEATURE_QOS = 4 # 0b00000100 - Quality of Service
FEATURE_SECURITY = 8 # 0b00001000 - Port Security
# Build interface configuration
interface_config = FEATURE_NONE
interface_config = interface_config | FEATURE_STP # Enable STP
interface_config = interface_config | FEATURE_VLAN # Enable VLAN
interface_config = interface_config | FEATURE_QOS # Enable QoS
print("Interface features enabled:", interface_config) # 7
print("Binary representation:", bin(interface_config)) # 0b00000111
# Check if specific feature is enabled
if interface_config & FEATURE_SECURITY:
print("Security: ENABLED")
else:
print("Security: DISABLED")
if interface_config & FEATURE_QOS:
print("QoS: ENABLED")
else:
print("QoS: DISABLED")Much more efficient than managing separate boolean variables.
Bitwise XOR for Change Detection
XOR returns 1 when bits are different, 0 when they’re the same. Perfect for detecting what’s changed between configurations.
# Configuration change detection using XOR
original_ports = 240 # 0b11110000 - Ports 4,5,6,7 originally active
current_ports = 195 # 0b11000011 - Ports 6,7,0,1 currently active
# Find what changed
changes = original_ports ^ current_ports
print("Changed ports (binary):", bin(changes)) # 0b00110011
print("Changed ports (decimal):", changes) # 51
# Work out what was added vs removed
added_ports = current_ports & changes
removed_ports = original_ports & changes
print("Added ports:", added_ports) # 3 (ports 0,1)
print("Removed ports:", removed_ports) # 48 (ports 4,5)
print("Added binary:", bin(added_ports))
print("Removed binary:", bin(removed_ports))Useful for audit trails and change tracking.
Simple Data Scrambling:
XOR provides basic data obfuscation.
# Simple configuration scrambling using XOR
config_value = 100 # VLAN 100
scramble_key = 42 # Arbitrary key
# Scramble the value
scrambled = config_value ^ scramble_key
print("Original VLAN:", config_value)
print("Scrambled value:", scrambled)
# Unscramble it (XOR with same key)
unscrambled = scrambled ^ scramble_key
print("Unscrambled VLAN:", unscrambled)
# Verify it's back to original
if unscrambled == config_value:
print("XOR scrambling works both ways!")Basic but effective for hiding configuration details from casual viewing.
Bit Shifting for Powers of Two
Left shift (<<) multiplies by powers of 2. Right shift (>>) divides by powers of 2 (and rounds down).
Absolutely brilliant for network calculations involving powers of two.
# Calculate subnet sizes using bit shifts
prefix_24 = 24
prefix_25 = 25
prefix_26 = 26
prefix_27 = 27
# Calculate host bits and addresses
host_bits_24 = 32 - prefix_24 # 8 host bits
host_bits_25 = 32 - prefix_25 # 7 host bits
host_bits_26 = 32 - prefix_26 # 6 host bits
host_bits_27 = 32 - prefix_27 # 5 host bits
# Total addresses = 2^host_bits
addresses_24 = 1 << host_bits_24 # 2^8 = 256
addresses_25 = 1 << host_bits_25 # 2^7 = 128
addresses_26 = 1 << host_bits_26 # 2^6 = 64
addresses_27 = 1 << host_bits_27 # 2^5 = 32
# Usable addresses (subtract network and broadcast)
usable_24 = addresses_24 - 2 # 254
usable_25 = addresses_25 - 2 # 126
usable_26 = addresses_26 - 2 # 62
usable_27 = addresses_27 - 2 # 30
print("Subnet sizes:")
print(f"/{prefix_24}: {usable_24} usable addresses")
print(f"/{prefix_25}: {usable_25} usable addresses")
print(f"/{prefix_26}: {usable_26} usable addresses")
print(f"/{prefix_27}: {usable_27} usable addresses")Much faster than doing the arithmetic manually.
VLAN ID Extraction:
Use shifts to extract VLAN IDs from 802.1Q tags.
# 802.1Q VLAN tag format: 3 bits priority + 1 bit CFI + 12 bits VLAN ID
vlan_tag = 25700 # Example VLAN tag (16-bit value)
# Extract VLAN ID (bottom 12 bits)
vlan_id = vlan_tag & 4095 # 4095 = 0xFFF = 12 bits of 1s
print("VLAN ID:", vlan_id)
# Extract priority (top 3 bits)
priority = (vlan_tag >> 13) & 7 # Shift right 13, mask to 3 bits
print("Priority:", priority)
# Extract CFI bit (bit 12)
cfi = (vlan_tag >> 12) & 1 # Shift right 12, mask to 1 bit
print("CFI:", cfi)
print("Original tag:", vlan_tag)
print("Binary representation:", bin(vlan_tag))
print("VLAN breakdown - Priority:", priority, "CFI:", cfi, "VLAN:", vlan_id)
Essential for packet processing and VLAN management.
Bitwise NOT for Wildcard Masks
The NOT operator (~) flips all bits. Perfect for creating wildcard masks from subnet masks.
# Wildcard mask calculation using bitwise NOT
subnet_255_255_255_0 = 4294967040 # 255.255.255.0
subnet_255_255_255_128 = 4294967168 # 255.255.255.128
subnet_255_255_255_192 = 4294967232 # 255.255.255.192
subnet_255_255_255_224 = 4294967264 # 255.255.255.224
# Calculate wildcard masks using bitwise NOT
wildcard_0 = ~subnet_255_255_255_0 & 4294967295 # Mask to 32 bits
wildcard_128 = ~subnet_255_255_255_128 & 4294967295
wildcard_192 = ~subnet_255_255_255_192 & 4294967295
wildcard_224 = ~subnet_255_255_255_224 & 4294967295
print("Subnet mask to wildcard mask conversions:")
print("255.255.255.0 ->", wildcard_0) # Should be 255 (0.0.0.255)
print("255.255.255.128 ->", wildcard_128) # Should be 127 (0.0.0.127)
print("255.255.255.192 ->", wildcard_192) # Should be 63 (0.0.0.63)
print("255.255.255.224 ->", wildcard_224) # Should be 31 (0.0.0.31)
# Convert wildcard back to dotted decimal manually
wc_octet4 = wildcard_0 & 255
wc_octet3 = (wildcard_0 >> 8) & 255
wc_octet2 = (wildcard_0 >> 16) & 255
wc_octet1 = (wildcard_0 >> 24) & 255
print("255.255.255.0 wildcard as IP:", wc_octet1, ".", wc_octet2, ".", wc_octet3, ".", wc_octet4)Saves time when configuring access lists or OSPF.
Took me ages to figure this out actually. Was manually calculating wildcard masks for OSPF configurations, couldn’t work out why some weren’t working. Turns out I was getting the binary inversion wrong. Once I started using bitwise NOT properly, ACL configuration became much more reliable.
Common Mistakes with Bitwise Operators
Let me tell you about mistakes I see constantly when people start working with python bitwise operators. Made most of these myself at some point.
Mixing Up Logical and Bitwise Operators:
Using & instead of and, | instead of or.
# Wrong approach - mixing logical and bitwise
interface_up = True
vlan_configured = True
# This produces unexpected results
wrong_result = interface_up & vlan_configured # Bitwise AND on booleans
print("Wrong bitwise result:", wrong_result) # Might work but not intended
# Right approach - use logical operators for boolean values
correct_result = interface_up and vlan_configured # Logical AND
print("Correct logical result:", correct_result)
# When to use each type
port_status = 240 # Binary data - use bitwise operators
admin_enabled = True # Boolean data - use logical operators
# Bitwise for binary data
active_ports = port_status & 192 # Extract specific bits
print("Active ports:", active_ports)
# Logical for boolean conditions
if admin_enabled and (active_ports > 0):
print("System is operational")Different operators for different data types.
Forgetting Operator Precedence:
Bitwise operators have lower precedence than arithmetic operators.
# Wrong way - precedence confusion
vlan_base = 100
vlan_offset = 5
vlan_mask = 255
# This doesn't do what you think!
wrong_result = vlan_base + vlan_offset & vlan_mask # Addition happens first
print("Wrong result:", wrong_result)
# Right way - use parentheses for clarity
correct_result = (vlan_base + vlan_offset) & vlan_mask
print("Correct result:", correct_result)
# Another precedence example
value = 8
shift_amount = 2
addition = 4
# Wrong precedence
wrong_shift = value << shift_amount + addition # Addition first, then shift
print("Wrong shift result:", wrong_shift)
# Correct precedence
correct_shift = value << (shift_amount + addition) # Explicit grouping
print("Correct shift result:", correct_shift)Always use parentheses to make precedence explicit.
Got caught by this one badly last month. Had a subnet calculation that wasn’t working properly, spent hours debugging the network logic. Turns out it was just operator precedence causing the wrong calculations. Simple brackets fixed it.
Sign Extension with NOT Operator:
Python’s NOT operator can produce negative numbers with large values.
# Potential issue with bitwise NOT
subnet_mask = 4278190080 # 255.0.0.0 as 32-bit integer
# NOT operator produces negative number in Python
inverted = ~subnet_mask
print("NOT result:", inverted) # Negative number!
# Solution - mask to desired bit width
wildcard = ~subnet_mask & 4294967295 # Mask to 32 bits (0xFFFFFFFF)
print("Wildcard result:", wildcard) # Positive number
# Convert to readable format
octet1 = (wildcard >> 24) & 255
octet2 = (wildcard >> 16) & 255
octet3 = (wildcard >> 8) & 255
octet4 = wildcard & 255
print("Wildcard mask:", octet1, ".", octet2, ".", octet3, ".", octet4)Always mask the result when using NOT to avoid negative numbers.
Actually Useful Applications
Once you get python bitwise operators sorted, loads of networking tasks become much easier. Let me show you some practical applications.
Network Address Validation:
Check if IP addresses belong to specific networks.
# Check if IP address is in specified network
host_ip = 3232235572 # 192.168.1.20
network_addr = 3232235520 # 192.168.1.0
subnet_mask = 4294967040 # 255.255.255.0
# Calculate network portion of host IP
host_network = host_ip & subnet_mask
print("Host network portion:", host_network)
print("Expected network:", network_addr)
# Check if host is in network
if host_network == network_addr:
print("Host 192.168.1.20 is in 192.168.1.0/24 network")
else:
print("Host is NOT in specified network")
# Test with different host
other_host = 3232235828 # 192.168.1.52
other_network = other_host & subnet_mask
if other_network == network_addr:
print("Host 192.168.1.52 is in 192.168.1.0/24 network")
# Test with host outside network
outside_host = 3232236032 # 192.168.2.0
outside_network = outside_host & subnet_mask
if outside_network == network_addr:
print("Host 192.168.2.0 is in 192.168.1.0/24 network")
else:
print("Host 192.168.2.0 is NOT in 192.168.1.0/24 network")Essential for network planning and security policies.
Port Security Status Tracking:
Use bitmaps to track port security violations efficiently.
# Port security using bitmaps (24 ports for example)
violations = 0 # Bitmap for tracking violations
enabled_ports = 0 # Bitmap for security-enabled ports
# Enable security on specific ports (1, 3, 5, 7)
enabled_ports = enabled_ports | 2 # Port 1 (bit 1)
enabled_ports = enabled_ports | 8 # Port 3 (bit 3)
enabled_ports = enabled_ports | 32 # Port 5 (bit 5)
enabled_ports = enabled_ports | 128 # Port 7 (bit 7)
print("Security enabled ports (binary):", bin(enabled_ports))
print("Security enabled ports (decimal):", enabled_ports)
# Record violations on ports 1 and 5
violations = violations | 2 # Port 1 violation
violations = violations | 32 # Port 5 violation
print("Violation ports (binary):", bin(violations))
print("Violation ports (decimal):", violations)
# Check specific port status
port_to_check = 1
port_bit = 1 << port_to_check # Calculate bit position
if enabled_ports & port_bit:
print(f"Port {port_to_check}: Security ENABLED")
if violations & port_bit:
print(f"Port {port_to_check}: VIOLATION detected")
else:
print(f"Port {port_to_check}: Operating normally")
else:
print(f"Port {port_to_check}: Security DISABLED")
# Check port 3
port_to_check = 3
port_bit = 1 << port_to_check
if enabled_ports & port_bit:
print(f"Port {port_to_check}: Security ENABLED")
if violations & port_bit:
print(f"Port {port_to_check}: VIOLATION detected")
else:
print(f"Port {port_to_check}: Operating normally")Much more efficient than managing separate variables for each port.
Subnet Boundary Calculations:
Calculate broadcast addresses and address ranges.
# Calculate subnet boundaries using bitwise operations
network_192_168_1_0 = 3232235520 # 192.168.1.0
mask_24 = 4294967040 # 255.255.255.0 (/24)
mask_25 = 4294967168 # 255.255.255.128 (/25)
mask_26 = 4294967232 # 255.255.255.192 (/26)
# Calculate broadcast addresses using OR with inverted mask
broadcast_24 = network_192_168_1_0 | (~mask_24 & 4294967295)
broadcast_25 = network_192_168_1_0 | (~mask_25 & 4294967295)
broadcast_26 = network_192_168_1_0 | (~mask_26 & 4294967295)
print("Subnet boundary calculations:")
print(f"192.168.1.0/24 broadcast: {broadcast_24}") # Should be 192.168.1.255
print(f"192.168.1.0/25 broadcast: {broadcast_25}") # Should be 192.168.1.127
print(f"192.168.1.0/26 broadcast: {broadcast_26}") # Should be 192.168.1.63
# Convert broadcast addresses back to dotted decimal
def int_to_dotted(ip_int):
octet1 = (ip_int >> 24) & 255
octet2 = (ip_int >> 16) & 255
octet3 = (ip_int >> 8) & 255
octet4 = ip_int & 255
return f"{octet1}.{octet2}.{octet3}.{octet4}"
print("Readable format:")
print(f"192.168.1.0/24 broadcast: {int_to_dotted(broadcast_24)}")
print(f"192.168.1.0/25 broadcast: {int_to_dotted(broadcast_25)}")
print(f"192.168.1.0/26 broadcast: {int_to_dotted(broadcast_26)}")
# Calculate usable address ranges
first_usable_24 = network_192_168_1_0 + 1
last_usable_24 = broadcast_24 - 1
print(f"192.168.1.0/24 usable range: {int_to_dotted(first_usable_24)} to {int_to_dotted(last_usable_24)}")Perfect for network planning and IP address management.
PCEP Requirements for Bitwise Operators
The PCEP exam covers specific aspects of python bitwise operators that you need to understand properly.
You need to know all six bitwise operators and what they do:
# All bitwise operators the exam might test
a = 12 # 1100 in binary
b = 10 # 1010 in binary
# Bitwise AND (&)
result_and = a & b # 8 (1000 in binary)
# Bitwise OR (|)
result_or = a | b # 14 (1110 in binary)
# Bitwise XOR (^)
result_xor = a ^ b # 6 (0110 in binary)
# Bitwise NOT (~)
result_not_a = ~a # -13 (complement)
result_not_b = ~b # -11 (complement)
# Left shift (<<)
result_left = a << 2 # 48 (shift left by 2 positions)
# Right shift (>>)
result_right = a >> 2 # 3 (shift right by 2 positions)
print("Bitwise operator results:")
print(f"{a} & {b} = {result_and}")
print(f"{a} | {b} = {result_or}")
print(f"{a} ^ {b} = {result_xor}")
print(f"~{a} = {result_not_a}")
print(f"~{b} = {result_not_b}")
print(f"{a} << 2 = {result_left}")
print(f"{a} >> 2 = {result_right}")The exam will test these operations with various number combinations.
Understanding operator precedence with bitwise operators:
# Precedence examples the exam might test
result1 = 8 | 4 & 2 # AND has higher precedence than OR
result2 = (8 | 4) & 2 # Parentheses change the order
result3 = 16 >> 2 << 1 # Shifts have same precedence, left-to-right
result4 = 3 + 2 << 1 # Addition before shift
print("Precedence examples:")
print(f"8 | 4 & 2 = {result1}") # 8 (not 4)
print(f"(8 | 4) & 2 = {result2}") # 0
print(f"16 >> 2 << 1 = {result3}") # 8
print(f"3 + 2 << 1 = {result4}") # 10The exam tests whether you understand how operators combine.
Binary number representation and conversion:
# Binary representations the exam covers
decimal_value = 42
binary_string = bin(decimal_value) # '0b101010'
hex_string = hex(decimal_value) # '0x2a'
octal_string = oct(decimal_value) # '0o52'
print(f"Decimal {decimal_value}:")
print(f"Binary: {binary_string}")
print(f"Hexadecimal: {hex_string}")
print(f"Octal: {octal_string}")
# Working with different number bases
binary_literal = 0b101010 # 42 in decimal
hex_literal = 0x2a # 42 in decimal
octal_literal = 0o52 # 42 in decimal
print("All represent the same value:")
print(f"0b101010 = {binary_literal}")
print(f"0x2a = {hex_literal}")
print(f"0o52 = {octal_literal}")Understanding different number bases is part of the PCEP syllabus.
Why This All Actually Matters
Understanding python bitwise operators properly is fundamental to network automation and any programming that deals with binary data. Without them, you’ll struggle with subnet calculations, VLAN management, access control configuration.
The key thing is using bitwise operators for actual binary network data. IP addresses, subnet masks, VLAN bitmaps, port configurations. Not abstract programming exercises that don’t help anyone.
When you’re working with network protocols, configurations, address planning, all the binary manipulation becomes much easier once you’re comfortable with bitwise operations.
Got caught out by not understanding these properly early on. Kept trying to do subnet calculations with arithmetic operators and string manipulation. Everything became much simpler once I learned to work directly with the binary representations using bitwise operators.
That’s python bitwise operators sorted properly. You understand what they are, how they work with network data, common mistakes to avoid, and practical applications for real network engineering tasks. Much more useful than learning about theoretical bit manipulation problems that have nothing to do with your actual job.
External Link: IEEE 802.1Q Standard – official IEEE standard for VLAN tagging that uses bitwise operations extensively