Mga Operator sa Python

Ang artikulong ito ay nagpapaliwanag ng mga operator sa Python.

YouTube Video

Mga Operator sa Python

Ang Python ay may iba't ibang mga operator, na maaaring malawakang maiuri tulad ng sumusunod. Ipapaliwanag namin ang mga kinatawan na operator para sa bawat kategorya.

Mga Operator ng Aritmetika

Ang mga arithmetic operator ay mga operator na ginagamit upang magsagawa ng mga kalkulasyon sa mga numero.

 1a = 10
 2b = 3
 3
 4print(f"{a} + {b} = {a + b}")     # Addition
 5print(f"{a} - {b} = {a - b}")     # Subtraction
 6print(f"{a} * {b} = {a * b}")     # Multiplication
 7print(f"{a} / {b} = {a / b}")     # Division (float)
 8print(f"6 / 3 = {6 / 3}")         # Division (float)
 9print(f"{a} // {b} = {a // b}")   # Floor Division
10print(f"{a} % {b} = {a % b}")     # Modulo (remainder)
11print(f"{a} ** {b} = {a ** b}")   # Exponentiation

• Bukod sa apat na pangunahing operasyon sa aritmetika, naglalaman ang Python ng mga operator para sa paghahati (/), integer division (//), modulus (%), at exponentiation (**). Ang paghahati ay nagbabalik ng floating-point na numero kahit na integers ang hinati.

Mga Operator ng Assignment

Ang mga assignment operator ay ginagamit upang magtalaga ng mga halaga sa mga variable.

 1x = 5           # x = 5
 2
 3x += 3          # x = x + 3
 4x -= 2          # x = x - 2
 5x *= 4          # x = x * 4
 6x /= 3          # x = x / 3
 7x //= 2         # x = x // 2
 8x %= 5          # x = x % 5
 9x **= 3         # x = x ** 3
10
11x = 0b1100      # x = 0b1100 (12)
12
13x &= 0b1010     # x = x & 0b1010
14x |= 0b0011     # x = x | 0b0011
15x ^= 0b0101     # x = x ^ 0b0101
16x <<= 2         # x = x << 2
17x >>= 1         # x = x >> 1
18
19print(bin(x))   # Display in binary
20print(x)        # Display in decimal
21
22# Walrus operator
23if (n := len("hello")) > 3:
24    print(f"Length is {n}")

• Pinapayagan ng assignment operators ang pagsasama ng karaniwang assignment sa iba't ibang mga operator upang maitalaga ang resulta.
• Ang walrus operator (:=) ay isang assignment expression na available simula Python 3.8 at pataas.
• Bagaman ang karaniwang assignment ay magagamit lamang bilang statement, pinapayagan ng walrus operator ang assignment sa loob ng isang expression.

Mga Operator ng Paghahambing

Ikinukumpara ng mga comparison operator ang mga halaga at nagbabalik ng True o False.

 1a = 10
 2b = 20
 3
 4# Equal to (==)
 5print(f"{a} == {b} -> {a == b}")      # False: a and b are not equal
 6print(f"3 == 3.0 -> {3 == 3.0}")      # True: int and float with the same value are equal
 7print(f"3 == '3' -> {3 == '3'}")      # False: different types (int vs str)
 8print(f"True == 1 -> {True == 1}")    # True: True is equivalent to 1
 9print(f"False == 0 -> {False == 0}")  # True: False is equivalent to 0
10print(f"None == 0 -> {None == 0}")    # False: None is not equal to 0
11
12# Not equal to (!=)
13print(f"{a} != {b} -> {a != b}")      # True: a and b are not equal
14
15# Greater than (>)
16print(f"{b} > {a} -> {b > a}")        # True: 20 > 10
17
18# Less than (<)
19print(f"{a} < {b} -> {a < b}")        # True: 10 < 20
20
21# Greater than or equal to (>=)
22print(f"{a} >= 10 -> {a >= 10}")      # True: a is greater than or equal to 10
23
24# Less than or equal to (<=)
25print(f"{a} <= 10 -> {a <= 10}")      # True: a is less than or equal to 10

• Ikinukumpara ng comparison operators ang dalawang halaga para sa pagkakasunod-sunod o pagkakapantay at nagbabalik ng True o False bilang resulta.
• Sa Python, kailangang mag-ingat kapag naghahambing ng iba’t ibang uri ng data. May ilang uri na maaaring paghambingin, ngunit maaaring hindi maging inaasahan ang resulta.

Mga Lohikal na Operator

Ang mga logical operator ay ginagamit upang pagsamahin ang mga logical expression.

1x = 10
2print(x > 5 and x < 20)  # True
3print(x < 5 or x > 20)   # False
4print(not x == 10)       # False

• Ang and ay isang logical operator na nagbabalik ng True lamang kung parehong True ang kondisyon sa kaliwa at kanan.
• Ang or ay isang logical operator na nagbabalik ng True kung alinman sa kaliwa o kanang kondisyon ay True.
• Ang not ay isang logical operator na nagbabaligtad ng truth value ng isang kondisyon. Kung ito ay Totoo, nagiging Mali; at kung ito ay Mali, nagiging Totoo.

Prayoridad ng mga lohikal na operator

May prayoridad ang mga operator. Ito ang patakaran na tumutukoy kung aling operator ang uunahin sa pagbibigay halaga sa isang ekspresyon. Ang mga lohikal na operator ay sinusuri ayon sa pagkakasunod: not, and, saka or.

1result = True or False and False
2print(result)  # True
3
4result = (True or False) and False
5print(result)  # False

たとえば、

Sa unang halimbawa, unang sinusuri ang and, kaya ang False and False ay nagiging False, at bilang resulta, ang True or False ay nagiging True. Maaari mo rin baguhin ang pagkakasunod ng pagsusuri gamit ang mga panaklong, gaya ng ipinapakita sa ikalawang halimbawa.

Mga Operator ng Bitwise

Ang mga bitwise operator ay nagsasagawa ng mga operasyon sa antas ng bit.

 1# Sample code for bitwise operators
 2
 3# Define two integers
 4a = 5  # Binary: 0101
 5b = 3  # Binary: 0011
 6
 7# Bitwise AND
 8result_and = a & b  # Binary: 0001 -> Decimal: 1
 9print(f"{a} & {b} = {result_and}")
10
11# Bitwise OR
12result_or = a | b  # Binary: 0111 -> Decimal: 7
13print(f"{a} | {b} = {result_or}")
14
15# Bitwise XOR
16result_xor = a ^ b  # Binary: 0110 -> Decimal: 6
17print(f"{a} ^ {b} = {result_xor}")
18
19# Bitwise NOT (inverting bits)
20result_not = ~a  # Binary: -(0101 + 1) -> Decimal: -6
21print(f"~{a} = {result_not}")
22
23# Left shift
24shift_left = a << 1  # Binary: 1010 -> Decimal: 10
25print(f"{a} << 1 = {shift_left}")
26
27# Right shift
28shift_right = a >> 1  # Binary: 0010 -> Decimal: 2
29print(f"{a} >> 1 = {shift_right}")

• Maaari kang magsagawa ng bitwise AND, OR, XOR, NOT operations, pati na rin ng bit shift operations. Maaari mo ring pagsamahin ang mga ito gamit ang assignment operators tulad ng &=.

Mga Operator ng Miyembro

Ang mga membership operator ay ginagamit sa mga koleksyon tulad ng mga listahan at mga diksyunaryo.

 1x = [1, 2, 3]
 2y = 2
 3z = 4
 4
 5print("y in x : ", y in x)  # Result is True
 6print("z in x : ", z in x)  # Result is False
 7
 8print("y not in x : ", y not in x)  # Result is False
 9print("z not in x : ", z not in x)  # Result is True
10
11text = "hello world"
12print("'world' in 'hello world' : ",      "world" in text)      # True
13print("'python' not in 'hello world' : ", "python" not in text) # True

• Ang operator na in ay ginagamit upang matukoy kung ang isang tinukoy na halaga ay nakapaloob sa isang hanay kagaya ng listahan o string, o isang koleksyon kagaya ng diksyunaryo.
• Ang operator na not in ay ginagamit upang matukoy kung ang isang tinukoy na halaga ay hindi nakapaloob sa isang hanay o koleksyon.

Mga Operator ng Identidad

Tsinitsyek ng mga identity operator ang pagkakakilanlan ng mga bagay.

 1x = [1, 2, 3]
 2y = x
 3z = x.copy()
 4
 5print("x is y : ", x is y)  # Result is True
 6print("x is z : ", x is z)  # Result is False
 7
 8print("x is not y : ", x is not y)  # Result is False
 9print("x is not z : ", x is not z)  # Result is True
10
11print("x == y : ", x == y)  # Result is True
12print("x == z : ", x == z)  # Result is True

• Ang operator na is ay sumusuri kung ang dalawang object ay iisa (ibig sabihin, tumutukoy sa parehong memory location).
• Ang operator na is not ay sumusuri kung ang dalawang object ay magkaibang object.
• Halimbawa, ang x is y ay iba sa x == y dahil sine-check nito ang object identity, hindi value equality.

Pagsusuri ng Uri

Sa Python, ginagamit mo ang function na isinstance() upang suriin kung ang halaga ay may tiyak na uri. Maaari mo ring gamitin ang function na type() para makita ang eksaktong uri ng isang variable. Bagaman hindi ito mga operator, mga pangunahing mekanismo ito para sa pagsusuri ng uri.

 1x = 10
 2print(isinstance(x, int))  # True
 3
 4y = "hello"
 5print(isinstance(y, str))  # True
 6
 7z = [1, 2, 3]
 8print(isinstance(z, list))  # True
 9
10print(type(10))        # <class 'int'>
11print(type("hello"))   # <class 'str'>
12
13print("isinstance(3, int) : ", isinstance(3, int))  # True
14print("type(3) is int : ", type(3) is int)          # True
15print("type(True) is bool : ", type(True) is bool)  # True

• Ang isinstance() ay isang function na sumusuri kung ang isang object ay instance ng isang tinukoy na class o subclass nito.
• Ang type() ay isang function na nagbabalik ng eksaktong uri (class) ng isang object. Kadalasang ginagamit ito kung gusto mong magsagawa ng mahigpit na paghahambing ng uri.
• Isinasaalang-alang ng isinstance() ang mga relasyon sa pamana, habang ang type() ay nagbabalik lang ng eksaktong tugma.

Buod

Kapag gumagamit ng bawat operator, kailangan mong pumili nang naaangkop batay sa layunin at uri nito. Dahil ang Python ay isang dynamic na typed na wika, maaaring magbago ang resulta ng isang operasyon depende sa uri ng mga halagang kinakalkula.

Maaari mong sundan ang artikulo sa itaas gamit ang Visual Studio Code sa aming YouTube channel. Paki-check din ang aming YouTube channel.

YouTube Video