Rabu , November 29 2023
Programming, News, and Technology
No Result
View All Result
  • Home
  • Troubleshoot
  • Social Media
  • Internet
  • Guide
  • Programming
  • Home
  • Troubleshoot
  • Social Media
  • Internet
  • Guide
  • Programming
No Result
View All Result
Programming, News, and Technology
No Result
View All Result
Home Programming Python

Understanding Bitwise Operators in Python

Maret 6, 2023
in Python
0
Bitwise Operators in Python
ADVERTISEMENT

Bitwise operators in python – If you’re new to Python programming, you might be wondering what bitwise operators are and how they work. Simply put, bitwise operators are used to perform operations on binary numbers.

These operators are represented by symbols like &, |, ^, and ~, and they work on individual bits of binary numbers.

In this article, we will explore bitwise operators in Python and how they can be used in programming. We will cover the following topics:

RELATED POSTS

Boolean Logic and Comparison Exercises in Python

Logical and Boolean Operations in Python

Python Comparison Operations, Calculation and Exercises

  1. What are Bitwise Operators?
  2. Types of Bitwise Operators
  3. AND Operator
  4. OR Operator
  5. XOR Operator
  6. NOT Operator
  7. Left Shift Operator
  8. Right Shift Operator
  9. Bitwise Operators in Python
  10. Practical Applications of Bitwise Operators

Let’s get started!

1. What are Bitwise Operators?

Bitwise operators are used to perform operations on binary numbers. In computing, everything is represented in binary form, which consists of only two digits – 0 and 1.

A binary digit is also called a bit. Bitwise operators are used to manipulate these bits to perform various operations.

2. Types of Bitwise Operators

There are six types of bitwise operators in Python:

  • AND (&)
  • OR (|)
  • XOR (^)
  • NOT (~)
  • Left Shift (<<)
  • Right Shift (>>)

3. AND Operator

The AND operator in Python is used to perform a bitwise AND operation on two numbers. The AND operator is represented by the symbol ‘&’. It returns 1 if both the bits are 1, otherwise it returns 0.

Let’s take a look at the truth table for the AND operator:

a b a & b
0 0 0
0 1 0
1 0 0
1 1 1

As you can see, the AND operator returns 1 only when both the bits are 1.

Now, let’s take a look at an example of using the AND operator in Python:

a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = a & b # 12 = 0000 1100
print("Result of bitwise AND: ", c)

Output:
Result of bitwise AND: 12

In this example, we are performing a bitwise AND operation on the values of a and b.

The binary representation of a is 0011 1100, and the binary representation of b is 0000 1101.

When we perform a bitwise AND operation on these two values, we get the value 0000 1100, which is equal to 12 in decimal.

Therefore, the output of the above code will be:

Result of bitwise AND: 12

4. OR Operator

The OR operator is a bitwise operator that takes two operands and performs a logical OR operation on each pair of corresponding bits. The symbol ‘|’ is used to represent the OR operator in Python.

It returns 1 if either of the bits is 1, otherwise it returns 0. Here’s the truth table for the OR operator. When we apply the OR operator to two bits, it returns 1 if either of the bits is 1, and 0 if both bits are 0. The truth table for the OR operator is as follows:

a b a OR b
0 0 0
0 1 1
1 0 1
1 1 1

Here’s an example of using the OR operator in Python:

a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = a | b # 61 = 0011 1101
print("Result of bitwise OR: ", c)

Output:
Result of bitwise OR: 61

As you can see from the truth table, the OR operator returns 1 only when at least one of the input bits is 1.

In the example provided, we have two variables ‘a’ and ‘b’ with the values 60 and 13 respectively. In binary, 60 is represented as 0011 1100 and 13 is represented as 0000 1101.

When we perform the bitwise OR operation between ‘a’ and ‘b’ using the ‘|’ operator, we get 0011 1101, which is equal to 61 in decimal.

So the final output of the program is:

Result of bitwise OR: 61

5. XOR Operator

The XOR operator, also known as the “exclusive or” operator, is used to perform a bitwise comparison of two values. It returns a value of 1 for each bit position where the corresponding bits of the operands are different, and 0 where they are the same. The XOR operator is represented by the symbol ‘^’.

Here’s the truth table for the XOR operator:

a b a ^ b
0 0 0
0 1 1
1 0 1
1 1 0

Here’s an example of using the XOR operator in Python:

a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = a ^ b # 49 = 0011 0001

print("Result of bitwise XOR: ", c)

Output:
Result of bitwise XOR: 49

In this example, the variable ‘a’ is assigned the value 60, which is equivalent to the binary number 0011 1100. The variable ‘b’ is assigned the value 13, which is equivalent to the binary number 0000 1101.

When we perform the XOR operation between ‘a’ and ‘b’, we get the result of 49, which is equivalent to the binary number 0011 0001. This is because the XOR operator returns 1 for each bit position where the corresponding bits of the operands are different, and 0 where they are the same.

Overall, the XOR operator is commonly used in computer programming for tasks such as encryption, error detection, and data validation.

6. NOT Operator

The NOT operator is represented by the symbol ‘~’. It inverts the value of a single bit. If the bit is 0, it returns 1 and if the bit is 1, it returns 0.

Here’s the truth table for the NOT operator:

a ~a
0 1
1 0

As you can see from the table, the NOT operator simply flips the value of the bit. For example, if the input is 0, the NOT operator returns 1. Similarly, if the input is 1, the NOT operator returns 0.

Here’s an example of how to use the NOT operator in Python:

a = 60 # 60 = 0011 1100
b = ~a # -61 = 1100 0011
print("Result of bitwise NOT: ", b)

Output:
Result of bitwise NOT: -61

In this example, we use the NOT operator to invert the value of the variable ‘a’, which is 60 in binary (0011 1100). The NOT operator inverts each bit in the binary representation of ‘a’, resulting in -61 in binary (1100 0011).

7. Left Shift Operator

The Left Shift Operator in Python is represented by the ‘<<‘ symbol. It is used to shift the bits of a number to the left by a specified number of positions. The left shift operation is equivalent to multiplying the number by 2 to the power of the number of positions shifted.

The general syntax for the left shift operator is as follows:

number << n

Here, ‘number’ is the number that you want to shift and ‘n’ is the number of positions you want to shift it by.

To understand the left shift operator, let’s take an example. Suppose we have a number 10 in binary form, which is 1010. Now, if we shift this number to the left by 2 positions, we get:

1010 << 2 = 101000

As you can see, the number has been shifted to the left by 2 positions and two 0’s have been added to the right end of the binary representation.

Here’s a truth table for the left shift operator:

Left Operand (x) Right Operand (y) x << y
0 n 0
n 0 n
n m n * 2^m

Let’s take an example to understand how to use the left shift operator in Python:

a = 5 # 5 in binary is 101
b = 2
c = a << b # 10100 in binary, which is 20 in decimal
print(c)

Output:
Result of bitwise left shift : 20

In the above example, we have a variable ‘a’ which is equal to 5 in decimal form, which is 101 in binary form. We also have a variable ‘b’ which is equal to 2.

Now, we shift the bits of ‘a’ to the left by 2 positions using the left shift operator and store the result in the variable ‘c’.

The result of the left shift operation is 10100 in binary form, which is equal to 20 in decimal form. Finally, we print the value of ‘c’, which is 20.

The left shift operator is commonly used in Python when working with binary numbers and bitwise operations.

8. Right Shift Operator

The right shift operator (>>) shifts the bits of a number to the right by a specified number of positions. The syntax for the right shift operator is as follows:

a >> n

where a is the number to be shifted and n is the number of positions to shift the bits. The right shift operator works by moving all the bits in a to the right by n positions. The leftmost n bits are discarded, and the rightmost n bits are filled with zeroes.

Here’s an example of using the right shift operator in Python:

a = 60      # 60 = 0011 1100
b = a >> 2  # 15 = 0000 1111
print("Result of bitwise right shift: ", b)

Output:
Result of bitwise right shift: 15

In this example, the variable a is assigned the value 60, which is represented in binary as 0011 1100. The right shift operator >> is used to shift the bits of a to the right by 2 positions, resulting in the binary value 0000 1111, which is equivalent to the decimal value 15.

Here’s a truth table for the right shift operator:

a n a >> n
0 n 0
1 n 0 or 1
0 0 0
1 0 1

In the table, a is the original bit value, n is the number of positions to shift the bits to the right, and a >> n is the result of the right shift operation. As you can see, the right shift operator always fills the vacated leftmost bits with zeroes.

9. Bitwise Operators in Python

Bitwise operators are used to manipulate the individual bits of binary numbers. Python supports six bitwise operators:

  1. Bitwise AND (&)
  2. Bitwise OR (|)
  3. Bitwise XOR (^)
  4. Bitwise NOT (~)
  5. Left shift (<<)
  6. Right shift (>>)

Let’s take a closer look at each one.

1. Bitwise AND (&)

The bitwise AND operator returns a 1 in each bit position where both corresponding bits are 1.

Here’s an example:

a = 0b1100
b = 0b1010
c = a & b  # 0b1000

In this example, a is binary for 12, and b is binary for 10. The result of a & b is binary for 8, which is the binary value where both a and b have a 1 in the same bit position.

2. Bitwise OR (|)

The bitwise OR operator returns a 1 in each bit position where at least one corresponding bit is 1.

Here’s an example:

a = 0b1100
b = 0b1010
c = a | b  # 0b1110

In this example, a is binary for 12, and b is binary for 10. The result of a | b is binary for 14, which is the binary value where either a or b have a 1 in the same bit position.

3. Bitwise XOR (^)

The bitwise XOR operator returns a 1 in each bit position where the corresponding bits are different.

Here’s an example:

a = 0b1100
b = 0b1010
c = a ^ b  # 0b0110

In this example, a is binary for 12, and b is binary for 10. The result of a ^ b is binary for 6, which is the binary value where a and b have a different bit in the same bit position.

4. Bitwise NOT (~)

The bitwise NOT operator returns the complement of a binary number, which is the inverse of each bit (1s become 0s and vice versa).

Here’s an example:

a = 0b1100
b = ~a  # -13

In this example, a is binary for 12. The result of ~a is binary for -13, which is the two’s complement of the binary number.

5. Left shift (<<)

The left shift operator shifts the bits of a binary number to the left by a specified number of positions. This is equivalent to multiplying the binary number by 2 raised to the power of the shift amount.

Here’s an example:

a = 0b1100
b = a << 2  # 0b110000

In this example, a is binary for 12. The result of a << 2 is binary for 48, which is a shifted to the left by 2 bits.

6. Right shift (>>)

The right shift operator shifts the bits of a binary number to the right by a specified number of positions. This is equivalent to dividing the binary number by 2 raised to the power of the shift amount.

Here’s an example:

a = 0b1100
b = a >> 2  # 0b0011

In this example, we start with the binary representation of the number 12, which is 0b1100. We then use the right shift operator >> to shift the bits in a two places to the right, resulting in 0b0011.

The two rightmost bits are dropped, and the two leftmost bits are set to 0. This is because we’re effectively dividing the value of a by 2^2, or 4. So, b has the decimal value 3.

It’s important to note that the right shift operator can also be used with a signed integer. In this case, the most significant bit (the leftmost bit) is used to determine the sign of the number.

For example:

a = -12 # -12 in two's complement is 0b11111100
b = a >> 2 # -3 in two's complement is 0b11111101

In this example, we start with the two’s complement representation of -12, which is 0b11111100. We then shift the bits two places to the right using the >> operator. The result is 0b11111101, which represents -3 in two’s complement notation.

This happens because the most significant bit is a 1, indicating a negative number. When we shift the bits to the right, we preserve the value of the most significant bit, resulting in a negative number with a different value.

In general, bitwise operators can be a powerful tool for performing low-level operations on binary data. However, they should be used with care, as they can be easy to misuse and can lead to subtle bugs if not used correctly.

10. Practical Applications of Bitwise Operators

Here are some practical applications of bitwise operators in Python, along with examples and tables:

Setting and clearing flags: Bitwise operators can be used to set or clear specific bits in a number to represent different flags or options.

For example, let’s say we want to represent four different options using the four least significant bits of a number, with 1 indicating that the option is selected and 0 indicating that it is not.

We can use the OR operator to set a bit and the AND operator with the NOT operator to clear a bit:

# Setting and clearing flags
option1 = 0b0001  # Select option 1
option2 = 0b0010  # Select option 2
option3 = 0b0100  # Select option 3
option4 = 0b1000  # Select option 4
options = 0b0000  # No options selected yet

# Set options 1 and 3
options |= option1 | option3
print(bin(options))  # 0b0101

# Clear option 1 and set option 2
options &= ~option1 | option2
print(bin(options))  # 0b0010

Here, we use the OR operator | to set the first and third bits of options to 1, which represents selecting options 1 and 3. Then we use the AND operator & with the NOT operator ~ to clear the first bit and set the second bit to 1, which represents clearing option 1 and selecting option 2.

Encoding and decoding data: Bitwise operators can also be used to encode and decode data by representing characters or data using their binary values.

For example, let’s say we want to encode the message “hello” as a series of binary values. We can use the ord() function to get the ASCII code for each character, then use the bitwise OR operator to combine the codes into a single number:

# Encoding data
message = "hello"
encoded = 0
for c in message:
    encoded <<= 8  # Shift left by 8 bits for each new character
    encoded |= ord(c)
print(bin(encoded))  # 0b110100001100101011011000110110001101111

Here, we shift the current value of encoded left by 8 bits for each new character, then use the OR operator | to combine the ASCII code for the current character with the previous value of encoded.

To decode the data, we can use the bitwise AND and right shift operators to extract the original values:

# Decoding data
decoded = ""
while encoded:
    c = encoded & 0xFF  # Extract the least significant 8 bits
    decoded = chr(c) + decoded
    encoded >>= 8  # Shift right by 8 bits to extract the next character
print(decoded)  # "hello"

Here, we extract the least significant 8 bits of encoded using the AND operator & and the mask 0xFF, which gives us the ASCII code for the last character. We then use the chr() function to convert the code back into a character and add it to the beginning of the decoded message. Finally, we shift the value of encoded right by 8 bits to extract the next character, repeating the process until all characters have been decoded.

Bit manipulation: Bitwise operators can also be used for various other bit manipulation tasks, such as swapping the values of two variables without using a temporary variable:

# Swapping values without a temporary variable

Another practical application of bitwise operators is swapping the values of two variables without using a temporary variable. This technique can be useful in cases where memory space is limited or when the temporary variable may cause performance issues.

Here’s how it works. Let’s say we have two variables, a and b, and we want to swap their values:

a = 10
b = 5

print("Before swapping: a =", a, "b =", b)

a = a ^ b
b = a ^ b
a = a ^ b

print("After swapping: a =", a, "b =", b)

Output:
Before swapping: a = 10 b = 5
After swapping: a = 5 b = 10

Let’s break it down step by step:

  1. a = a ^ b: This sets the value of a to the result of performing the XOR operation on a and b. This effectively sets a to the bitwise difference between a and b.
  2. b = a ^ b: This sets the value of b to the result of performing the XOR operation on a and b. Since a is now the bitwise difference between a and b, b will be set to the original value of a.
  3. a = a ^ b: This sets the value of a to the result of performing the XOR operation on a and b. Since b is now the original value of a, a will be set to the original value of b.

After these three steps, the values of a and b will have been swapped:

print(a) # Output: 5
print(b) # Output: 10

This technique works because the XOR operation is both commutative and associative. This means that the order in which we perform the operations does not matter, and we can safely use the same variables for both the inputs and outputs of each operation.

Using bitwise operators to swap values can be faster than using a temporary variable, especially in cases where memory access is slow. However, it can also make your code harder to read and understand, so use it judiciously.

ADVERTISEMENT

Conclusion

bitwise operators are an important feature of Python that allow us to manipulate individual bits of binary numbers. These operators can be used for a variety of tasks such as setting and clearing flags, performing logical operations, and bit manipulation.

Understanding bitwise operators is essential for anyone working with low-level programming, cryptography, or embedded systems. By using bitwise operators, we can write more efficient and optimized code, which is especially important when working with large datasets or complex algorithms.

With the help of examples and tables, this beginner’s guide to bitwise operators in Python should provide a solid foundation for anyone looking to learn this important concept.

Tags: Bitwise OperatorsBitwise Operators in Pythonpython
ShareTweetShareSendShare

RelatedPosts

Boolean Logic and Comparison Exercises in Python
Python

Boolean Logic and Comparison Exercises in Python

2023/03/06
Logical and Boolean Operations in Python
Python

Logical and Boolean Operations in Python

2023/03/06
Python Comparison Operations
Python

Python Comparison Operations, Calculation and Exercises

2023/03/04
Python Arithmetic Operations Exercises
Python

Python Arithmetic Operations Simple Calculation Exercises for Beginners

2023/03/04
Arithmetic Operations in Python: An Overview
Python

Arithmetic Operations in Python: An Overview

2023/03/04
Learn Python Language : Taking Input Data from the User
Python

Learn Python Language : Taking Input Data from the User

2023/03/04

Tinggalkan Balasan Batalkan balasan

Alamat email Anda tidak akan dipublikasikan. Ruas yang wajib ditandai *

Recommended Stories

Python Libraries

The Top 10 Python Libraries for Web Scraping

Maret 4, 2023
Tips to Boost Your Internet Speed

10 Simple Tips to Boost Your Internet Speed

Januari 6, 2023
How to Fix Gmail Spam

How to Fix Gmail Spam Filter Not Working

Januari 16, 2023
Machine Learning Model in Python

How to Build a Machine Learning Model in Python

Maret 4, 2023
Location Settings in Google Chrome

How to Change Your Location Settings in Google Chrome

Januari 7, 2023
ADVERTISEMENT

Popular Posts

  • understanding of insurance

    Understanding the Fundamentals of How Insurance Operates

    0 shares
    Share 0 Tweet 0
  • Easy Ways to Fix 5G Network Not Showing Up

    0 shares
    Share 0 Tweet 0
  • How to Change Your Location Settings in Google Chrome

    0 shares
    Share 0 Tweet 0
  • How to Fix Gmail Spam Filter Not Working

    0 shares
    Share 0 Tweet 0
  • Top Automation Tools for Web Testing

    0 shares
    Share 0 Tweet 0
  • 10 Simple Tips to Boost Your Internet Speed

    0 shares
    Share 0 Tweet 0
ADVERTISEMENT
Programming, News, and Technology

Bagopa.com is an online media that provides technology information to the public with a focus on providing critically balanced information on real-life events for general purpose only. The goal is to update current news as a form of contribution in the field of science and technology, and serve as a comparison and balance to mainstream media information.

Recent Posts

  • Understanding Bitwise Operators in Python
  • Boolean Logic and Comparison Exercises in Python
  • Logical and Boolean Operations in Python
  • How to Install C++ Sublime Text and MinGW on Windows
  • How to Install C++ Visual Studio Code on Windows

Category

  • C++
  • Guide
  • Insurance
  • Internet
  • Java
  • Programming
  • Python
  • Social Media
  • Tech
  • Troubleshoot
  • Windows
  • Privacy Policy

© 2023 Bagopa.com - Programming, News, and Technology.

No Result
View All Result
  • Home
  • Troubleshoot
  • Social Media
  • Internet
  • Guide
  • Programming

© 2023 Bagopa.com - Programming, News, and Technology.