Operatory w Pythonie

Ten artykuł wyjaśnia operatory w Pythonie.

YouTube Video

Operatory w Pythonie

Python posiada różnorodne operatory, które można szeroko sklasyfikować w następujący sposób. Wyjaśnimy reprezentacyjne operatory dla każdej kategorii.

Operatory Arytmetyczne

Operatory arytmetyczne to operatory używane do wykonywania obliczeń na liczbach.

 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

• Oprócz czterech podstawowych operacji arytmetycznych, Python udostępnia operatory dzielenia (/), dzielenia całkowitego (//), reszty z dzielenia (%) oraz potęgowania (**). Dzielenie zwraca liczbę zmiennoprzecinkową nawet podczas dzielenia liczb całkowitych.

Operatory przypisania

Operatory przypisania służą do przypisywania wartości zmiennym.

 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}")

• Operatory przypisania umożliwiają łączenie standardowego przypisania z różnymi operatorami, aby przypisać wynik.
• Operator morski (:=) to wyrażenie przypisania dostępne w Pythonie 3.8 i nowszych.
• Standardowe przypisanie może być używane tylko jako instrukcja, natomiast operator morski pozwala na przypisanie w wyrażeniu.

Operatory Porównawcze

Operatory porównania porównują wartości i zwracają True lub 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

• Operatory porównania porównują dwie wartości pod względem porządku lub równości i zwracają True lub False jako wynik.
• W Pythonie należy zachować ostrożność podczas porównywania różnych typów danych. Niektóre typy można ze sobą porównywać, ale wyniki mogą być nieintuicyjne.

Operatory Logiczne

Operatory logiczne są używane do łączenia wyrażeń logicznych.

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

• and to operator logiczny, który zwraca True tylko wtedy, gdy oba warunki po lewej i po prawej stronie są True.
• or to operator logiczny, który zwraca True, jeśli którykolwiek z warunków po lewej lub prawej stronie jest True.
• not to operator logiczny, który odwraca wartość logiczną warunku. Jeśli wartość jest True, staje się False, a jeśli jest False, staje się True.

Priorytet operatorów logicznych

Operatory mają priorytet. To zasada określająca, który operator jest obliczany jako pierwszy w wyrażeniu. Operatory logiczne są oceniane w kolejności: not, potem and, następnie or.

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

たとえば、

W pierwszym przykładzie najpierw oceniany jest operator and, więc False and False daje False, a w rezultacie True or False daje True. Można też zmienić kolejność wykonywania używając nawiasów, jak pokazano w drugim przykładzie.

Operatory bitowe

Operatory bitowe wykonują operacje na poziomie bitów.

 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}")

• Można wykonywać operacje bitowe AND, OR, XOR, NOT, a także operacje przesunięć bitowych. Można je także łączyć z operatorami przypisania, takimi jak &=.

Operatory przynależności

Operatory przynależności są używane z kolekcjami, takimi jak listy i słowniki.

 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

• Operator in służy do sprawdzenia, czy określona wartość znajduje się w sekwencji takiej jak lista lub ciąg znaków, albo w kolekcji takiej jak słownik.
• Operator not in służy do sprawdzenia, czy określona wartość nie znajduje się w sekwencji lub kolekcji.

Operatory tożsamości

Operatory tożsamości sprawdzają identyczność obiektów.

 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

• Operator is sprawdza, czy dwa obiekty to ten sam obiekt (czyli odnoszą się do tego samego miejsca w pamięci).
• Operator is not sprawdza, czy dwa obiekty to inne obiekty.
• Na przykład x is y różni się od x == y tym, że sprawdza tożsamość obiektów, a nie równość wartości.

Sprawdzanie typu

W Pythonie używasz funkcji isinstance() aby sprawdzić, czy wartość jest określonego typu. Możesz także użyć funkcji type(), aby sprawdzić dokładny typ zmiennej. Chociaż nie są to operatory, stanowią podstawowe mechanizmy do sprawdzania typu.

 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

• isinstance() to funkcja, która sprawdza, czy obiekt jest instancją określonej klasy lub jej podklasy.
• type() to funkcja, która zwraca dokładny typ (klasę) obiektu. Zwykle jest używana, gdy chcesz wykonać ścisłe porównanie typów.
• isinstance() uwzględnia relacje dziedziczenia, podczas gdy type() sprawdza dokładne dopasowanie.

Podsumowanie

Podczas korzystania z każdego operatora należy odpowiednio go dobrać w zależności od jego przeznaczenia i typu. Ponieważ Python jest językiem dynamicznie typowanym, wynik operacji może się różnić w zależności od rodzaju obliczanych wartości.

Możesz śledzić ten artykuł, korzystając z Visual Studio Code na naszym kanale YouTube. Proszę również sprawdzić nasz kanał YouTube.

YouTube Video