Operatoren in Python

Dit artikel legt operatoren in Python uit.

YouTube Video

Operatoren in Python

Python heeft verschillende operatoren, die grofweg als volgt kunnen worden gecategoriseerd. We zullen representatieve operatoren voor elke categorie uitleggen.

Rekenkundige Operatoren

Aritmetische operatoren zijn operatoren die worden gebruikt om berekeningen op getallen uit te voeren.

 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

• Naast de vier basis rekenkundige bewerkingen biedt Python operatoren voor deling (/), gehele deling (//), modulus (%) en machtsverheffing (**). Deling levert een kommagetal op, zelfs bij het delen van gehele getallen.

Toewijzingsoperatoren

Toewijzingsoperatoren worden gebruikt om waarden aan variabelen toe te wijzen.

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

• Toewijzingsoperatoren maken het mogelijk om standaard toewijzing te combineren met verschillende operatoren om het resultaat toe te wijzen.
• De walrus-operator (:=) is een toewijzingsuitdrukking die beschikbaar is in Python 3.8 en later.
• Standaard toewijzing kan alleen als een statement worden gebruikt, terwijl de walrus-operator toewijzing binnen een expressie mogelijk maakt.

Vergelijkingsoperatoren

Vergelijkingsoperatoren vergelijken waarden en geven True of False terug.

 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

• Vergelijkingsoperatoren vergelijken twee waarden op volgorde of gelijkheid en geven True of False als resultaat.
• In Python moet je voorzichtig zijn bij het vergelijken van verschillende datatypes. Sommige types kunnen met elkaar worden vergeleken, maar de resultaten kunnen niet intuïtief zijn.

Logische Operatoren

Logische operatoren worden gebruikt om logische expressies te combineren.

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

• and is een logische operator die alleen True teruggeeft als zowel de linker- als rechtervoorwaarde True zijn.
• or is een logische operator die True teruggeeft als ofwel de linker- of rechtervoorwaarde True is.
• not is een logische operator die de waarheidswaarde van een voorwaarde omkeert. Als het True is, wordt het False, en als het False is, wordt het True.

Voorrang van logische operatoren

Operatoren hebben voorrang. Dit is de regel die bepaalt welke operator het eerst wordt geëvalueerd in een expressie. Logische operatoren worden geëvalueerd in deze volgorde: not, and, daarna or.

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

たとえば、

In het eerste voorbeeld wordt and als eerste geëvalueerd, dus False and False wordt False, en als resultaat wordt True or False gelijk aan True. Je kunt de volgorde van evaluatie ook veranderen door haakjes te gebruiken, zoals getoond in het tweede voorbeeld.

Bitwise-operatoren

Bitgewijze operatoren voeren bewerkingen uit op bitniveau.

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

• U kunt bitwise AND, OR, XOR, NOT operaties uitvoeren, evenals bitverschuifoperaties. U kunt ze ook combineren met toewijzingsoperatoren zoals &=.

Lidmaatschapsoperatoren

Lidmaatschapsoperatoren worden gebruikt met collecties zoals lijsten en woordenboeken.

 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

• De operator in wordt gebruikt om te bepalen of een specifieke waarde voorkomt in een reeks zoals een lijst of string, of in een collectie zoals een woordenboek.
• De operator not in wordt gebruikt om te bepalen of een specifieke waarde niet voorkomt in een reeks of collectie.

Identiteitsoperatoren

Identiteitsoperatoren controleren de identiteit van objecten.

 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

• De is-operator controleert of twee objecten hetzelfde object zijn (dus naar dezelfde geheugenlocatie verwijzen).
• De is not-operator controleert of twee objecten verschillende objecten zijn.
• Bijvoorbeeld, x is y verschilt van x == y doordat het objectidentiteit controleert in plaats van waarde-gelijkheid.

Typecontrole

In Python gebruik je de functie isinstance() om te controleren of een waarde van een bepaald type is. Je kunt ook de functie type() gebruiken om het exacte type van een variabele te controleren. Hoewel dit geen operatoren zijn, zijn het basismechanismen voor typecontrole.

 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() is een functie die controleert of een object een instantie is van een opgegeven klasse of een subklasse daarvan.
• type() is een functie die het exacte type (klasse) van een object teruggeeft. Het wordt meestal gebruikt wanneer je een strikte typevergelijking wilt uitvoeren.
• isinstance() houdt rekening met overervingsrelaties, terwijl type() alleen exacte overeenkomsten controleert.

Samenvatting

Bij het gebruik van elke operator moet je zorgvuldig kiezen op basis van het doel en het type. Aangezien Python een dynamisch getypte taal is, kan het resultaat van een bewerking variëren afhankelijk van het type waarden dat wordt berekend.

Je kunt het bovenstaande artikel volgen met Visual Studio Code op ons YouTube-kanaal. Bekijk ook het YouTube-kanaal.

YouTube Video