លំហាត់៖ ការប្រើប្រតិបត្តិករ Bitwise ក្នុង Python

១. សេចក្ដីផ្ដើម

កុំព្យូទ័ររក្សាទុក និងដំណើរការទិន្នន័យជាទម្រង់គោលពីរ ដែលមានតែប៊ីត 0 និង 1។ ទោះបីយើងសរសេរចំនួនដូចជា 5, 10 ឬ 20 ក៏ដោយ កុំព្យូទ័របម្លែងចំនួនទាំងនេះទៅជាទម្រង់គោលពីរ មុនពេលធ្វើប្រតិបត្តិការ។

Python ផ្ដល់ ប្រតិបត្តិករ Bitwise សម្រាប់ធ្វើការដោយផ្ទាល់លើប៊ីតនីមួយៗនៃចំនួនគត់។ ប្រតិបត្តិករទាំងនេះមានប្រយោជន៍ក្នុងការគ្រប់គ្រង Hardware, IoT, Network, Permissions, Flags, Encryption និងប្រព័ន្ធដែលត្រូវការគ្រប់គ្រងទិន្នន័យកម្រិតប៊ីត។

ប្រតិបត្តិករ Bitwise ក្នុង Python រួមមាន៖

• & — Bitwise AND
• | — Bitwise OR
• ^ — Bitwise XOR
• ~ — Bitwise NOT
• << — Left Shift
• >> — Right Shift

២. និយមន័យប៊ីត

Bit គឺជាឯកតាតូចបំផុតនៃទិន្នន័យក្នុងកុំព្យូទ័រ ហើយមានតម្លៃតែពីរគឺ៖

0
1

ឧទាហរណ៍ ចំនួនគត់ 5 ក្នុងគោលដប់ អាចសរសេរជាគោលពីរថា៖

5 = 0101

ចំនួន 3 ក្នុងគោលពីរគឺ៖

3 = 0011

ប្រតិបត្តិករ Bitwise នឹងប្រៀបធៀប ឬកែប្រែប៊ីតនីមួយៗនៅទីតាំងដូចគ្នា។

៣. បម្លែងចំនួនទៅជាគោលពីរ

Python មានមុខងារ bin() សម្រាប់បម្លែងចំនួនគត់ទៅជាទម្រង់គោលពីរ។

number = 10

print(bin(number))

លទ្ធផល៖

0b1010

អក្សរ 0b បញ្ជាក់ថា តម្លៃខាងក្រោយជាចំនួនគោលពីរ។

ឧទាហរណ៍៖

print(bin(5))
print(bin(8))
print(bin(15))

លទ្ធផល៖

0b101
0b1000
0b1111

៤. តារាងប្រតិបត្តិករ Bitwise

៥. ប្រតិបត្តិករ Bitwise AND &

៥.១ និយមន័យ

ប្រតិបត្តិករ & ប្រៀបធៀបប៊ីតពីរនៅទីតាំងដូចគ្នា។ លទ្ធផលជាប៊ីត 1 លុះត្រាតែប៊ីតទាំងពីរជា 1។

តារាងតម្លៃពិត៖

ឧទាហរណ៍៖

a = 6
b = 3

result = a & b

print(result)

ទម្រង់គោលពីរ៖

6 = 0110
3 = 0011
---------
    0010

0010 ស្មើនឹង 2។

លទ្ធផល៖

2

៥.២ កូដបង្ហាញទាំងគោលដប់ និងគោលពីរ

a = 6
b = 3

print("a =", a, "Binary:", bin(a))
print("b =", b, "Binary:", bin(b))
print("a & b =", a & b, "Binary:", bin(a & b))

លទ្ធផល៖

a = 6 Binary: 0b110
b = 3 Binary: 0b11
a & b = 2 Binary: 0b10

៦. ប្រតិបត្តិករ Bitwise OR |

៦.១ និយមន័យ

ប្រតិបត្តិករ | ផ្ដល់ប៊ីត 1 ប្រសិនបើប៊ីតណាមួយក្នុងចំណោមប៊ីតទាំងពីរជា 1។

តារាងតម្លៃពិត៖

ឧទាហរណ៍៖

a = 6
b = 3

result = a | b

print(result)

ទម្រង់គោលពីរ៖

6 = 0110
3 = 0011
---------
    0111

0111 ស្មើនឹង 7។

លទ្ធផល៖

7

៧. ប្រតិបត្តិករ Bitwise XOR ^

៧.១ និយមន័យ

ប្រតិបត្តិករ ^ ផ្ដល់ប៊ីត 1 នៅពេលប៊ីតទាំងពីរខុសគ្នា។ ប្រសិនបើប៊ីតទាំងពីរដូចគ្នា លទ្ធផលគឺ 0។

តារាងតម្លៃពិត៖

ឧទាហរណ៍៖

a = 6
b = 3

result = a ^ b

print(result)

ទម្រង់គោលពីរ៖

6 = 0110
3 = 0011
---------
    0101

0101 ស្មើនឹង 5។

លទ្ធផល៖

5

៧.២ លក្ខណៈសំខាន់របស់ XOR

ចំនួនណាមួយធ្វើ XOR ជាមួយខ្លួនឯង ផ្ដល់លទ្ធផល 0៖

x = 10

print(x ^ x)

លទ្ធផល៖

0

ចំនួនណាមួយធ្វើ XOR ជាមួយ 0 ផ្ដល់តម្លៃដើម៖

x = 10

print(x ^ 0)

លទ្ធផល៖

10

៨. ប្រតិបត្តិករ Bitwise NOT ~

៨.១ និយមន័យ

ប្រតិបត្តិករ ~ ប្រើសម្រាប់បញ្ច្រាសប៊ីត៖

• 0 ប្រែទៅជា 1
• 1 ប្រែទៅជា 0

ឧទាហរណ៍៖

a = 5

result = ~a

print(result)

លទ្ធផល៖

-6

ក្នុង Python លទ្ធផលរបស់ ~x អាចគណនាតាមរូបមន្ត៖

~x = -(x + 1)

ដូច្នេះ៖

~5 = -(5 + 1)
   = -6

ឧទាហរណ៍បន្ថែម៖

print(~0)
print(~1)
print(~10)

លទ្ធផល៖

-1
-2
-11

ចំណាំ

លទ្ធផលអវិជ្ជមានកើតឡើងដោយសារកុំព្យូទ័រប្រើទម្រង់ Two’s Complement សម្រាប់តំណាងចំនួនអវិជ្ជមាន។

៩. ប្រតិបត្តិករ Left Shift <<

៩.១ និយមន័យ

ប្រតិបត្តិករ << រំកិលប៊ីតទៅខាងឆ្វេងតាមចំនួនទីតាំងដែលបានកំណត់។ រាល់ការរំកិលទៅឆ្វេងមួយទីតាំង ជាទូទៅស្មើនឹងការគុណនឹង 2។

ឧទាហរណ៍៖

a = 5

result = a << 1

print(result)

ទម្រង់គោលពីរ៖

5 = 0101

រំកិលទៅឆ្វេងមួយទីតាំង៖

1010

1010 ស្មើនឹង 10។

លទ្ធផល៖

10

៩.២ រំកិលច្រើនទីតាំង

a = 5

print(a << 1)
print(a << 2)
print(a << 3)

លទ្ធផល៖

10
20
40

អាចយល់តាមរូបមន្ត៖

a << n = a × 2ⁿ

ឧទាហរណ៍៖

5 << 2 = 5 × 2²
       = 5 × 4
       = 20

១០. ប្រតិបត្តិករ Right Shift >>

១០.១ និយមន័យ

ប្រតិបត្តិករ >> រំកិលប៊ីតទៅខាងស្ដាំ។ សម្រាប់ចំនួនវិជ្ជមាន ការរំកិលទៅស្ដាំមួយទីតាំងជាទូទៅស្មើនឹងការចែកយកផលចែកគត់នឹង 2។

ឧទាហរណ៍៖

a = 20

result = a >> 1

print(result)

ទម្រង់គោលពីរ៖

20 = 10100

រំកិលទៅស្ដាំមួយទីតាំង៖

01010

01010 ស្មើនឹង 10។

លទ្ធផល៖

10

១០.២ រំកិលច្រើនទីតាំង

a = 20

print(a >> 1)
print(a >> 2)
print(a >> 3)

លទ្ធផល៖

10
5
2

អាចយល់តាមរូបមន្តសម្រាប់ចំនួនវិជ្ជមាន៖

a >> n = a // 2ⁿ

ឧទាហរណ៍៖

20 >> 2 = 20 // 4
        = 5

១១. ប្រៀបធៀបលទ្ធផលប្រតិបត្តិករទាំងអស់

កំណត់៖

a = 6
b = 3

ទម្រង់គោលពីរ៖

a = 0110
b = 0011

លទ្ធផល៖

១២. កូដលំហាត់ពេញលេញ

# Python Bitwise Operators Exercise

a = int(input("Enter the first integer: "))
b = int(input("Enter the second integer: "))

print("\n=== Original Values ===")
print("a =", a, "Binary:", bin(a))
print("b =", b, "Binary:", bin(b))

and_result = a & b
or_result = a | b
xor_result = a ^ b
not_a_result = ~a
not_b_result = ~b
left_shift_a = a << 1
right_shift_a = a >> 1

print("\n=== Bitwise Results ===")

print("a & b =", and_result)
print("Binary:", bin(and_result))

print("\na | b =", or_result)
print("Binary:", bin(or_result))

print("\na ^ b =", xor_result)
print("Binary:", bin(xor_result))

print("\n~a =", not_a_result)
print("~b =", not_b_result)

print("\na << 1 =", left_shift_a)
print("Binary:", bin(left_shift_a))

print("\na >> 1 =", right_shift_a)
print("Binary:", bin(right_shift_a))

print("\n=== Simple Explanations ===")

print("AND keeps bits that are 1 in both numbers.")
print("OR keeps bits that are 1 in either number.")
print("XOR keeps bits that are different.")
print("NOT reverses the bits.")
print("Left shift moves bits to the left.")
print("Right shift moves bits to the right.")

១៣. ការពន្យល់កូដតាមបន្ទាត់

បន្ទាត់មតិយោបល់

# Python Bitwise Operators Exercise

បន្ទាត់នេះជាមតិយោបល់ ដែលប្រាប់ថា កម្មវិធីនេះជាលំហាត់អំពីប្រតិបត្តិករ Bitwise។

ទទួលចំនួនទីមួយ

a = int(input("Enter the first integer: "))

បន្ទាត់នេះ៖

1. ប្រើ input() ដើម្បីទទួលទិន្នន័យពីអ្នកប្រើ។
2. ប្រើ int() ដើម្បីបម្លែងទិន្នន័យទៅជាចំនួនគត់។
3. រក្សាទុកតម្លៃក្នុងអញ្ញតិ a។

ទទួលចំនួនទីពីរ

b = int(input("Enter the second integer: "))

បន្ទាត់នេះទទួលចំនួនគត់ទីពីរ ហើយរក្សាទុកក្នុងអញ្ញតិ b។

បង្ហាញតម្លៃដើម

print("a =", a, "Binary:", bin(a))
print("b =", b, "Binary:", bin(b))

មុខងារ bin() បម្លែងចំនួនគត់ទៅជាទម្រង់គោលពីរ។

គណនា Bitwise AND

and_result = a & b

បន្ទាត់នេះអនុវត្ត AND លើប៊ីតនីមួយៗរបស់ a និង b ហើយរក្សាទុកលទ្ធផលក្នុង and_result។

គណនា Bitwise OR

or_result = a | b

បន្ទាត់នេះអនុវត្ត OR លើប៊ីតរបស់ចំនួនទាំងពីរ។

គណនា Bitwise XOR

xor_result = a ^ b

បន្ទាត់នេះអនុវត្ត XOR ហើយផ្ដល់ប៊ីត 1 នៅទីតាំងដែលប៊ីតទាំងពីរខុសគ្នា។

គណនា Bitwise NOT

not_a_result = ~a
not_b_result = ~b

បន្ទាត់ទាំងនេះបញ្ច្រាសប៊ីតរបស់ a និង b។

រំកិលប៊ីតទៅឆ្វេង

left_shift_a = a << 1

បន្ទាត់នេះរំកិលប៊ីតរបស់ a ទៅឆ្វេងមួយទីតាំង។ សម្រាប់ចំនួនវិជ្ជមាន វាស្មើនឹងការគុណនឹង 2។

រំកិលប៊ីតទៅស្ដាំ

right_shift_a = a >> 1

បន្ទាត់នេះរំកិលប៊ីតរបស់ a ទៅស្ដាំមួយទីតាំង។ សម្រាប់ចំនួនវិជ្ជមាន វាស្រដៀងនឹងការចែកយកផលចែកគត់នឹង 2។

១៤. ឧទាហរណ៍នៃការដំណើរការ

អ្នកប្រើបញ្ចូល៖

Enter the first integer: 6
Enter the second integer: 3

លទ្ធផល៖

=== Original Values ===
a = 6 Binary: 0b110
b = 3 Binary: 0b11

=== Bitwise Results ===
a & b = 2
Binary: 0b10

a | b = 7
Binary: 0b111

a ^ b = 5
Binary: 0b101

~a = -7
~b = -4

a << 1 = 12
Binary: 0b1100

a >> 1 = 3
Binary: 0b11

១៥. ការប្រើ Bitwise សម្រាប់សិទ្ធិ

ប្រតិបត្តិករ Bitwise អាចប្រើសម្រាប់រក្សាទុកសិទ្ធិច្រើនក្នុងចំនួនតែមួយ។

ឧទាហរណ៍៖

READ = 1       # 001
WRITE = 2      # 010
DELETE = 4     # 100

ផ្ដល់សិទ្ធិអាន និងសរសេរ៖

permission = READ | WRITE

print(permission)

ការគណនា៖

001
010
---
011

លទ្ធផលគឺ 3។

ពិនិត្យសិទ្ធិអាន៖

if permission & READ:
    print("Read permission is allowed.")

ពិនិត្យសិទ្ធិលុប៖

if permission & DELETE:
    print("Delete permission is allowed.")
else:
    print("Delete permission is not allowed.")

១៦. កូដឧទាហរណ៍សិទ្ធិអ្នកប្រើ

# Permission Flags Example

READ = 1
WRITE = 2
DELETE = 4

user_permission = READ | WRITE

print("User permission value:", user_permission)

if user_permission & READ:
    print("Read: Allowed")
else:
    print("Read: Denied")

if user_permission & WRITE:
    print("Write: Allowed")
else:
    print("Write: Denied")

if user_permission & DELETE:
    print("Delete: Allowed")
else:
    print("Delete: Denied")

លទ្ធផល៖

User permission value: 3
Read: Allowed
Write: Allowed
Delete: Denied

១៧. Bitwise Assignment Operators

ប្រតិបត្តិករ Bitwise អាចប្រើជាមួយ Assignment Operators បានផងដែរ។

ឧទាហរណ៍៖

x = 6
x &= 3

print(x)

លទ្ធផល៖

2

ឧទាហរណ៍ Left Shift Assignment៖

x = 5
x <<= 2

print(x)

លទ្ធផល៖

20

១៨. ភាពខុសគ្នារវាង Logical និង Bitwise Operators

ឧទាហរណ៍ Logical៖

print(True and False)

លទ្ធផល៖

False

ឧទាហរណ៍ Bitwise៖

print(6 & 3)

លទ្ធផល៖

2

កុំច្រឡំរវាង៖

and

និង៖

&

ព្រោះវាមានគោលបំណងប្រើប្រាស់ខុសគ្នា។

១៩. កំហុសដែលតែងតែកើតមាន

១៩.១ ច្រឡំ and ជាមួយ &

a = 6
b = 3

print(a and b)
print(a & b)

លទ្ធផលអាចខុសគ្នា៖

3
2

and ជាប្រតិបត្តិករតក្កវិទ្យា ខណៈ & ជាប្រតិបត្តិករ Bitwise។

១៩.២ ច្រឡំ or ជាមួយ |

print(6 or 3)
print(6 | 3)

លទ្ធផល៖

6
7

១៩.៣ មិនយល់លទ្ធផលរបស់ ~

print(~5)

លទ្ធផលគឺ -6 មិនមែន 2 ឬតម្លៃប៊ីតបញ្ច្រាសធម្មតាទេ ព្រោះ Python តំណាងចំនួនគត់តាមគោលការណ៍ Two’s Complement។

១៩.៤ ប្រើជាមួយចំនួនទសភាគ

កូដខាងក្រោមមិនត្រឹមត្រូវ៖

print(5.5 & 2.0)

ប្រតិបត្តិករ Bitwise ត្រូវប្រើជាមួយចំនួនគត់ int។

១៩.៥ រំកិលប៊ីតដោយចំនួនអវិជ្ជមាន

កូដខាងក្រោមបង្កើតកំហុស៖

print(5 << -1)

ចំនួនទីតាំងដែលត្រូវរំកិលមិនអាចជាចំនួនអវិជ្ជមានបានទេ។

២០. លំហាត់អនុវត្តបន្ថែម

លំហាត់ទី១៖ សាកល្បង AND

ទទួលចំនួនគត់ពីរពីអ្នកប្រើ ហើយគណនា a & b។ បង្ហាញលទ្ធផលជាគោលដប់ និងគោលពីរ។

លំហាត់ទី២៖ សាកល្បង OR និង XOR

ទទួលលេខពីរ ហើយបង្ហាញលទ្ធផល a | b និង a ^ b។

លំហាត់ទី៣៖ រំកិលប៊ីត

ទទួលចំនួនគត់មួយ និងចំនួនទីតាំងដែលត្រូវរំកិល។ បង្ហាញលទ្ធផលនៃ << និង >>។

លំហាត់ទី៤៖ គ្រប់គ្រងសិទ្ធិ

កំណត់៖

VIEW = 1
EDIT = 2
DELETE = 4

បង្កើតសិទ្ធិអ្នកប្រើដោយប្រើ | ហើយពិនិត្យសិទ្ធិនីមួយៗដោយប្រើ &។

លំហាត់ទី៥៖ បង្ហាញទម្រង់គោលពីរ

ទទួលចំនួនពីអ្នកប្រើ ហើយបង្ហាញ៖

• តម្លៃគោលដប់
• តម្លៃគោលពីរ
• តម្លៃក្រោយ ~
• តម្លៃក្រោយ << 1
• តម្លៃក្រោយ >> 1

២១. សំណួរត្រួតពិនិត្យការយល់ដឹង

1. តើ Bit គឺជាអ្វី?
2. តើប្រតិបត្តិករ Bitwise ក្នុង Python មានអ្វីខ្លះ?
3. តើ & ផ្ដល់ប៊ីត 1 នៅពេលណា?
4. តើ | ផ្ដល់ប៊ីត 0 នៅពេលណា?
5. តើ ^ ផ្ដល់ប៊ីត 1 នៅពេលណា?
6. តើ ~5 មានលទ្ធផលប៉ុន្មាន?
7. តើ 5 << 1 មានលទ្ធផលប៉ុន្មាន?
8. តើ 20 >> 2 មានលទ្ធផលប៉ុន្មាន?
9. តើ and និង & ខុសគ្នាយ៉ាងដូចម្ដេច?
10. តើមុខងារ bin() ប្រើសម្រាប់អ្វី?
11. តើ Bitwise Operators អាចប្រើជាមួយ float បានដែរឬទេ?
12. តើ Bitwise Operators មានប្រយោជន៍អ្វីក្នុងការគ្រប់គ្រងសិទ្ធិ?

២២. សន្និដ្ឋាន

ប្រតិបត្តិករ Bitwise ក្នុង Python ប្រើសម្រាប់ធ្វើប្រតិបត្តិការលើប៊ីត 0 និង 1 នៃចំនួនគត់ ដោយ & ប្រើសម្រាប់ Bitwise AND, | សម្រាប់ Bitwise OR, ^ សម្រាប់ Bitwise XOR, ~ សម្រាប់បញ្ច្រាសប៊ីត, << សម្រាប់រំកិលប៊ីតទៅឆ្វេង និង >> សម្រាប់រំកិលប៊ីតទៅស្ដាំ។ ប្រតិបត្តិករទាំងនេះខុសពីប្រតិបត្តិករតក្កវិទ្យា and, or និង not ព្រោះវាធ្វើការដោយផ្ទាល់លើប៊ីត និងផ្ដល់លទ្ធផលជាចំនួនគត់។ Bitwise Operators ត្រូវបានប្រើក្នុងការគ្រប់គ្រងសិទ្ធិ Hardware, IoT, Network, Flags និងកម្មវិធីកម្រិតទាបផ្សេងៗ។