លំហសិក្សាធិការកម្ពុជា
V1.0
លំហសិក្សាធិការកម្ពុជា
V1.0
មេរៀនបន្ថែមនេះគ្របដណ្ដប់ចំណុចសំខាន់ៗដែលនៅសល់ក្នុង Python រួមមាន Conditional Expression សម្រាប់ជ្រើសរើសតម្លៃតាមលក្ខខណ្ឌក្នុងបន្ទាត់តែមួយ, Unary Operators ដូចជា +, -, ~ និង not ដែលធ្វើការលើតម្លៃតែមួយ, ប្រតិបត្តិករគុណម៉ាទ្រីស @ សម្រាប់ Object ឬ Library ដែលគាំទ្រ, Walrus Operator := សម្រាប់កំណត់ និងប្រើតម្លៃក្នុងកន្សោមតែមួយ និង Operator Precedence ដែលកំណត់លំដាប់នៃការគណនា។ ការយល់ចំណុចទាំងនេះជួយឱ្យអ្នកសិក្សាសរសេរកូដបានខ្លី ច្បាស់ ត្រឹមត្រូវ និងជៀសវាងកំហុសក្នុងការគណនា និងការសម្រេចចិត្តតាមលក្ខខណ្ឌ។
មេរៀនមុនៗបានគ្របដណ្ដប់ប្រតិបត្តិករសំខាន់ៗក្នុង Python ស្ទើរតែទាំងអស់ រួមមាន ប្រតិបត្តិករនព្វន្ត ប្រតិបត្តិករកំណត់តម្លៃ ប្រតិបត្តិករប្រៀបធៀប ប្រតិបត្តិករតក្កវិទ្យា ប្រតិបត្តិករសមាជិកភាព ប្រតិបត្តិករបញ្ជាក់អត្តសញ្ញាណ និងប្រតិបត្តិករលើប៊ីត។ ទោះជាយ៉ាងណា នៅមានចំណុចបន្ថែមមួយចំនួនដែលអ្នកសិក្សាគួរយល់ ដើម្បីអាចសរសេរកូដបានខ្លី ច្បាស់ និងមានប្រសិទ្ធភាពជាងមុន។
ចំណុចទាំងនេះរួមមាន៖
if–else@:=ចំណាំថា ចំណុចមួយចំនួនខាងលើមិនមែនជាប្រភេទប្រតិបត្តិករដាច់ដោយឡែកទាំងស្រុងទេ ប៉ុន្តែវាជាទម្រង់កន្សោម ឬគោលការណ៍សំខាន់សម្រាប់ការប្រើប្រតិបត្តិករក្នុង Python។
កន្សោមលក្ខខណ្ឌប្រើសម្រាប់ជ្រើសរើសតម្លៃមួយក្នុងចំណោមតម្លៃពីរ ដោយផ្អែកលើលក្ខខណ្ឌ។ វាត្រូវបានគេហៅផងដែរថា Ternary Expression ព្រោះវាមានផ្នែកសំខាន់បី៖
ទម្រង់ទូទៅ៖
value_if_true if condition else value_if_falsePython វាយតម្លៃលក្ខខណ្ឌជាមុន។ បើលក្ខខណ្ឌពិត វាផ្ដល់តម្លៃនៅខាងឆ្វេង if; បើមិនពិត វាផ្ដល់តម្លៃនៅខាងក្រោយ else។
score = 75
result = "Pass" if score >= 50 else "Fail"
print(result)លទ្ធផល៖
Passការពន្យល់៖
score >= 50 ជាលក្ខខណ្ឌ។"Pass" ត្រូវបានដាក់ក្នុងអញ្ញតិ result។"Fail" ត្រូវបានដាក់ក្នុង result។កូដធម្មតា៖
score = 75
if score >= 50:
result = "Pass"
else:
result = "Fail"កូដខ្លីដោយប្រើ Conditional Expression៖
result = "Pass" if score >= 50 else "Fail"កូដទាំងពីរផ្ដល់លទ្ធផលដូចគ្នា។
number = 8
result = "Even" if number % 2 == 0 else "Odd"
print(result)លទ្ធផល៖
Evena = 20
b = 15
greater_number = a if a > b else b
print("Greater number:", greater_number)លទ្ធផល៖
Greater number: 20Conditional Expression សមស្របសម្រាប់លក្ខខណ្ឌខ្លីៗដែលជ្រើសរើសតម្លៃតែមួយ។
ឧទាហរណ៍ល្អ៖
status = "Active" if is_active else "Inactive"មិនគួរប្រើវាសម្រាប់លក្ខខណ្ឌវែង ឬមានការងារច្រើនជំហាន ព្រោះអាចធ្វើឱ្យកូដពិបាកអាន។
ប្រតិបត្តិករឯកធាតុ គឺជាប្រតិបត្តិករដែលធ្វើការលើតម្លៃ ឬអញ្ញតិតែមួយ។ ពាក្យ Unary មានន័យថា “មានធាតុចូលតែមួយ”។
ប្រតិបត្តិករឯកធាតុសំខាន់ៗរួមមាន៖
| ប្រតិបត្តិករ | ឈ្មោះ | ឧទាហរណ៍ |
|---|---|---|
+ | Unary Positive | +x |
- | Unary Negative | -x |
~ | Bitwise NOT | ~x |
not | Logical NOT | not condition |
Python ដាក់ +x, -x និង ~x ក្នុងក្រុមប្រតិបត្តិការឯកធាតុនព្វន្ត និង Bitwise។
+សញ្ញា + នៅខាងមុខតម្លៃ បញ្ជាក់ថាតម្លៃនោះជាតម្លៃវិជ្ជមាន។
number = 10
positive_number = +number
print(positive_number)លទ្ធផល៖
10Unary Positive ជាទូទៅមិនផ្លាស់ប្ដូរតម្លៃរបស់ចំនួនទេ។
-សញ្ញា - នៅខាងមុខតម្លៃ បញ្ច្រាសសញ្ញារបស់ចំនួន។
number = 10
negative_number = -number
print(negative_number)លទ្ធផល៖
-10បើតម្លៃដើមអវិជ្ជមាន វានឹងក្លាយជាវិជ្ជមាន៖
number = -10
print(-number)លទ្ធផល៖
10~~ បញ្ច្រាសប៊ីតរបស់ចំនួនគត់។
number = 5
print(~number)លទ្ធផល៖
-6រូបមន្តដែលអាចប្រើដើម្បីយល់លទ្ធផលគឺ៖
~x = -(x + 1)notnot បញ្ច្រាសតម្លៃតក្កវិទ្យា៖
is_logged_in = False
print(not is_logged_in)លទ្ធផល៖
Truenot True → Falsenot False → Truenumber = 8
is_active = True
print("Original number:", number)
print("Unary positive:", +number)
print("Unary negative:", -number)
print("Bitwise NOT:", ~number)
print("Logical NOT:", not is_active)Python ប្រើសញ្ញា @ សម្រាប់ប្រមាណវិធីគុណម៉ាទ្រីស និងប្រើ @= សម្រាប់គុណម៉ាទ្រីសរួចកំណត់លទ្ធផលត្រឡប់ទៅអញ្ញតិដើម។
ទម្រង់៖
result = matrix_a @ matrix_bនិង៖
matrix_a @= matrix_bប្រតិបត្តិករ @ ត្រូវបានបន្ថែមក្នុង Python 3.5។ ប្រភេទទិន្នន័យស្រាប់របស់ Python ដូចជា List មិនអនុវត្តប្រតិបត្តិករនេះដោយផ្ទាល់ទេ។ Object ឬ Library ដែលចង់គាំទ្រវា ត្រូវអនុវត្តវិធីសាស្ត្រពិសេសដូចជា __matmul__()។
កូដខាងក្រោមមិនដំណើរការទេ៖
a = [[1, 2], [3, 4]]
b = [[5, 6], [7, 8]]
result = a @ bList ធម្មតាមិនគាំទ្រ @ ទេ។
NumPy ផ្ដល់ Array ដែលគាំទ្រប្រតិបត្តិករ @ សម្រាប់គុណម៉ាទ្រីស។ numpy.matmul() ក៏អនុវត្តអត្ថន័យដូចប្រតិបត្តិករ @ ផងដែរ។
ដំឡើង NumPy៖
pip install numpyកូដឧទាហរណ៍៖
import numpy as np
matrix_a = np.array([
[1, 2],
[3, 4]
])
matrix_b = np.array([
[5, 6],
[7, 8]
])
result = matrix_a @ matrix_b
print(result)លទ្ធផល៖
[[19 22]
[43 50]]ម៉ាទ្រីសទីមួយ៖
1 2
3 4ម៉ាទ្រីសទីពីរ៖
5 6
7 8ការគណនាធាតុទីមួយ៖
(1 × 5) + (2 × 7) = 19ធាតុទីពីរ៖
(1 × 6) + (2 × 8) = 22ជួរទីពីរ៖
(3 × 5) + (4 × 7) = 43
(3 × 6) + (4 × 8) = 50* និង @ជាមួយ NumPy៖
matrix_a * matrix_bធ្វើការគុណធាតុតាមទីតាំង។
ចំណែក៖
matrix_a @ matrix_bធ្វើការគុណតាមច្បាប់ម៉ាទ្រីស។
:= (Walrus Operator)សញ្ញា := ត្រូវបានគេហៅថា Assignment Expression, Named Expression ឬ Walrus Operator។ វាអាចកំណត់តម្លៃទៅក្នុងអញ្ញតិ និងផ្ដល់តម្លៃនោះត្រឡប់មកប្រើក្នុងកន្សោមតែមួយ។ វាត្រូវបានបន្ថែមក្នុង Python 3.8។
ទម្រង់ទូទៅ៖
(variable := expression)numbers = [10, 20, 30, 40]
if (count := len(numbers)) > 3:
print("The list has", count, "items.")លទ្ធផល៖
The list has 4 items.ក្នុងបន្ទាត់៖
count := len(numbers)កម្មវិធី៖
count3:=numbers = [10, 20, 30, 40]
count = len(numbers)
if count > 3:
print("The list has", count, "items.")កូដទាំងពីរផ្ដល់លទ្ធផលដូចគ្នា ប៉ុន្តែ := អាចកាត់បន្ថយការសរសេរដដែល។
while (text := input("Enter text or type quit: ")) != "quit":
print("You entered:", text)ដំណើរការ៖
text"quit"Assignment Expression ត្រូវបានប្រើជាញឹកញាប់ក្នុង if និង while នៅពេលតម្លៃមួយត្រូវគណនា ពិនិត្យ និងប្រើឡើងវិញ។
កុំប្រើ := ច្រើនពេកនៅក្នុងបន្ទាត់តែមួយ ព្រោះវាអាចធ្វើឱ្យកូដពិបាកអាន។
កូដងាយយល់៖
if (length := len(message)) > 20:
print("Message is too long:", length)កូដពិបាកយល់៖
if (x := len(a)) > 5 and (y := sum(a)) > 100 and (z := max(a)) > 50:
print(x, y, z)ក្នុងករណីស្មុគស្មាញ គួរបែងចែកជាច្រើនបន្ទាត់។
នៅពេលកន្សោមមានប្រតិបត្តិករច្រើន Python ត្រូវសម្រេចថា ប្រតិបត្តិករណាត្រូវអនុវត្តមុន។ ច្បាប់នេះហៅថា លំដាប់អាទិភាពប្រតិបត្តិករ។
ឧទាហរណ៍៖
result = 2 + 3 * 4Python គុណជាមុន៖
3 × 4 = 12
2 + 12 = 14លទ្ធផល៖
14បើចង់ឱ្យបូកមុន ត្រូវប្រើវង់ក្រចក៖
result = (2 + 3) * 4លទ្ធផល៖
20Python កំណត់លំដាប់ប្រតិបត្តិករពីអាទិភាពខ្ពស់ទៅទាប ហើយប្រតិបត្តិករភាគច្រើនដែលមានអាទិភាពដូចគ្នា ត្រូវបានវាយតម្លៃពីឆ្វេងទៅស្ដាំ។ ស្វ័យគុណ និង Conditional Expression មានការចងពីស្ដាំទៅឆ្វេង។
តារាងខាងក្រោមរៀបពីអាទិភាពខ្ពស់ទៅទាប៖
| លំដាប់ | ប្រតិបត្តិករ | អត្ថន័យ |
| 1 | () | វង់ក្រចក |
| 2 | ** | ស្វ័យគុណ |
| 3 | +x, -x, ~x | Unary Operators |
| 4 | *, @, /, //, % | គុណ ចែក ម៉ាទ្រីស និងសំណល់ |
| 5 | +, - | បូក និងដក |
| 6 | <<, >> | រំកិលប៊ីត |
| 7 | & | Bitwise AND |
| 8 | ^ | Bitwise XOR |
| 9 | | | Bitwise OR |
| 10 | <, <=, >, >=, ==, !=, in, is | ប្រៀបធៀប |
| 11 | not | Logical NOT |
| 12 | and | Logical AND |
| 13 | or | Logical OR |
| 14 | x if condition else y | Conditional Expression |
| 15 | := | Assignment Expression |
លំដាប់នេះផ្អែកលើតារាង Operator Precedence របស់ Python Language Reference។
result = 10 + 2 * 3 ** 2លំដាប់គណនា៖
3 ** 2 = 9
2 * 9 = 18
10 + 18 = 28លទ្ធផល៖
28result = True or False and Falseand មានអាទិភាពខ្ពស់ជាង or៖
False and False = False
True or False = Trueលទ្ធផល៖
Trueទោះបីអ្នកចងចាំលំដាប់អាទិភាពក៏ដោយ ការប្រើវង់ក្រចកជួយឱ្យកូដងាយយល់។
eligible = (age >= 18) and (score >= 50)កូដនេះងាយអានជាង៖
eligible = age >= 18 and score >= 50ទោះបីលទ្ធផលដូចគ្នាក៏ដោយ។
រក្សាទុកឯកសារជា៖
additional_operators.py# Additional Python Operators and Expressions
print("=== 1. Conditional Expression ===")
score = float(input("Enter your score: "))
status = "Pass" if score >= 50 else "Fail"
print("Result:", status)
print("\n=== 2. Unary Operators ===")
number = int(input("Enter an integer: "))
is_active = True
print("Original number:", number)
print("Unary positive:", +number)
print("Unary negative:", -number)
print("Bitwise NOT:", ~number)
print("Logical NOT of is_active:", not is_active)
print("\n=== 3. Assignment Expression ===")
numbers = [10, 20, 30, 40, 50]
if (count := len(numbers)) >= 5:
print("The list contains", count, "items.")
else:
print("The list contains fewer than five items.")
print("\n=== 4. Operator Precedence ===")
result1 = 2 + 3 * 4
result2 = (2 + 3) * 4
result3 = 2 + 3 * 2 ** 2
result4 = True or False and False
result5 = (True or False) and False
print("2 + 3 * 4 =", result1)
print("(2 + 3) * 4 =", result2)
print("2 + 3 * 2 ** 2 =", result3)
print("True or False and False =", result4)
print("(True or False) and False =", result5)
print("\n=== 5. Matrix Multiplication ===")
try:
import numpy as np
matrix_a = np.array([
[1, 2],
[3, 4]
])
matrix_b = np.array([
[5, 6],
[7, 8]
])
matrix_result = matrix_a @ matrix_b
print("Matrix A:")
print(matrix_a)
print("\nMatrix B:")
print(matrix_b)
print("\nMatrix A @ Matrix B:")
print(matrix_result)
except ImportError:
print("NumPy is not installed.")
print("Install it by running: pip install numpy")
print("\n=== Exercise Completed ===")score = float(input("Enter your score: "))
status = "Pass" if score >= 50 else "Fail"បន្ទាត់ទីមួយទទួលពិន្ទុពីអ្នកប្រើ។ បន្ទាត់ទីពីរពិនិត្យថា ពិន្ទុចាប់ពី ៥០ ឡើងទៅដែរឬទេ។
print("Unary positive:", +number)
print("Unary negative:", -number)
print("Bitwise NOT:", ~number)
print("Logical NOT of is_active:", not is_active)បន្ទាត់ទាំងនេះបង្ហាញការប្រើប្រតិបត្តិករឯកធាតុជាមួយតម្លៃតែមួយ។
if (count := len(numbers)) >= 5:បន្ទាត់នេះគណនាចំនួនធាតុ រក្សាទុកក្នុងអញ្ញតិ count និងប្រៀបធៀបជាមួយ 5 ក្នុងពេលតែមួយ។
result1 = 2 + 3 * 4
result2 = (2 + 3) * 4result1 ផ្ដល់ 14 ព្រោះគុណមុនបូក។ result2 ផ្ដល់ 20 ព្រោះវង់ក្រចកត្រូវបានគណនាមុន។
matrix_result = matrix_a @ matrix_bបន្ទាត់នេះប្រើ @ ដើម្បីគុណម៉ាទ្រីស NumPy ទាំងពីរ។
ផ្នែក៖
try:និង៖
except ImportError:ការពារកម្មវិធីមិនឱ្យឈប់ដំណើរការ ប្រសិនបើកុំព្យូទ័រមិនទាន់បានដំឡើង NumPy។
ប្រសិនបើអ្នកប្រើបញ្ចូល៖
Enter your score: 75
Enter an integer: 8លទ្ធផលសំខាន់ៗ៖
=== 1. Conditional Expression ===
Result: Pass
=== 2. Unary Operators ===
Original number: 8
Unary positive: 8
Unary negative: -8
Bitwise NOT: -9
Logical NOT of is_active: False
=== 3. Assignment Expression ===
The list contains 5 items.
=== 4. Operator Precedence ===
2 + 3 * 4 = 14
(2 + 3) * 4 = 20
2 + 3 * 2 ** 2 = 14
True or False and False = True
(True or False) and False = False
=== 5. Matrix Multiplication ===
Matrix A:
[[1 2]
[3 4]]
Matrix B:
[[5 6]
[7 8]]
Matrix A @ Matrix B:
[[19 22]
[43 50]]កូដមិនត្រឹមត្រូវ៖
result = if score >= 50 "Pass" else "Fail"កូដត្រឹមត្រូវ៖
result = "Pass" if score >= 50 else "Fail"@ ជាមួយ Listកូដខាងក្រោមមិនដំណើរការ៖
a = [[1, 2], [3, 4]]
b = [[5, 6], [7, 8]]
print(a @ b)ត្រូវប្រើប្រភេទទិន្នន័យដែលគាំទ្រ @ ដូចជា NumPy Array។
:= ជាមួយ =x = 10ប្រើសម្រាប់កំណត់តម្លៃធម្មតា។
if (x := get_value()) > 10:ប្រើសម្រាប់កំណត់តម្លៃ និងប្រើតម្លៃក្នុងកន្សោម។
average = score1 + score2 + score3 / 3កូដនេះចែកតែ score3 នឹង 3។
កូដត្រឹមត្រូវ៖
average = (score1 + score2 + score3) / 3កូដខាងក្រោមពិបាកអាន៖
result = "A" if score >= 90 else "B" if score >= 80 else "C" if score >= 70 else "F"គួរប្រើ if, elif និង else សម្រាប់លក្ខខណ្ឌច្រើនកម្រិត។
ទទួលអាយុពីអ្នកប្រើ ហើយប្រើ Conditional Expression ដើម្បីបង្ហាញ៖
"Adult" បើអាយុចាប់ពី ១៨ ឆ្នាំឡើងទៅ"Minor" បើអាយុតិចជាង ១៨ ឆ្នាំទទួលចំនួនមួយ ហើយបង្ហាញ៖
បង្កើត List មួយ ហើយប្រើ := ដើម្បីរក្សាទុកចំនួនធាតុ ខណៈពេលពិនិត្យថា List មានធាតុច្រើនជាង ៥ ឬអត់។
ព្យាករណ៍លទ្ធផលមុនពេលដំណើរការកូដ៖
result = 5 + 2 * 3 ** 2បន្ទាប់មកប្រើវង់ក្រចកដើម្បីធ្វើឱ្យការបូកដំណើរការមុន។
បង្កើតម៉ាទ្រីសទំហំ 2 × 2 ចំនួនពីរ ហើយប្រើ NumPy និង @ ដើម្បីគណនាផលគុណ។
-x មានឥទ្ធិពលអ្វីលើតម្លៃ x?@ ប្រើសម្រាប់អ្វី?@ ដែរឬទេ?:= ខុសពី = ដូចម្ដេច?2 + 3 * 4 មានលទ្ធផលប៉ុន្មាន?(2 + 3) * 4 មានលទ្ធផលប៉ុន្មាន?and និង or មួយណាមានអាទិភាពខ្ពស់ជាង?** និង *?ចំណុចបន្ថែមសំខាន់ៗក្នុងការប្រើប្រតិបត្តិករ Python រួមមាន Conditional Expression ដែលប្រើទម្រង់ value_if_true if condition else value_if_false ដើម្បីជ្រើសរើសតម្លៃក្នុងបន្ទាត់តែមួយ ប្រតិបត្តិករឯកធាតុ +, -, ~ និង not ដែលធ្វើការលើតម្លៃតែមួយ ប្រតិបត្តិករគុណម៉ាទ្រីស @ ដែលប្រើជាមួយ Object ឬ Library ដែលគាំទ្រការគុណម៉ាទ្រីស Assignment Expression := ដែលអាចកំណត់ និងប្រើតម្លៃក្នុងកន្សោមតែមួយ និងលំដាប់អាទិភាពប្រតិបត្តិករ ដែលកំណត់ថាប្រតិបត្តិករណាត្រូវអនុវត្តមុន។ ការយល់ដឹងពីចំណុចទាំងនេះជួយឱ្យអ្នកសិក្សាអាចសរសេរកូដបានខ្លី ច្បាស់ ត្រឹមត្រូវ និងជៀសវាងកំហុសក្នុងការគណនា និងការវាយតម្លៃលក្ខខណ្ឌ។
មិនទាន់មានមតិយោបល់ — ក្លាយជាអ្នកដំបូង!