Operatorer i Python

Operatorer i Python

Denne artikel forklarer operatorer i Python.

YouTube Video

Operatorer i Python

Python har forskellige operatorer, som groft sagt kan opdeles som følger. Vi forklarer repræsentative operatorer for hver kategori.

Aritmetiske operatorer

Aritmetiske operatorer er operatorer, der bruges til at udføre beregninger på tal.

Operator Betydning Eksempel
+ Addition 3 + 25
- Subtraktion 3 - 21
* Multiplikation 3 * 26
/ Division (altid flydende-tal) 3 / 21.5
// Gulv-division (heltalsdivision) 3 // 21
% Rest (modulo) 3 % 21
** Potensiering 3 ** 29
 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
  • Ud over de fire grundlæggende aritmetiske operationer tilbyder Python operatorer til division (/), heltalsdivision (//), modulus (%) og potensiering (**). Division returnerer et flydende tal selv ved division af heltal.

Tildelingsoperatorer

Tildelingsoperatorer bruges til at tildele værdier til variable.

Operator Betydning Eksempel
= Tildeling x = 5
+= Læg til og tildel x += 2x = x + 2
-= Træk fra og tildel x -= 2x = x - 2
*= Gang og tildel x *= 2x = x * 2
/= Divider og tildel x /= 2x = x / 2
//= Gulv-division (heltalsdivision) x //= 2x = x // 2
%= Tildel rest x %= 2x = x % 2
**= Tildel potensiering x **= 2x = x ** 2
&= Tildel ved hjælp af AND x &= 0b1010x = x & 0b1010
|= Tildel ved hjælp af OR x | = 0b0011x = x | 0b0011
^= Tildel ved hjælp af XOR x ^= 0b0101x = x ^ 0b0101
<<= Tildel efter venstreskift x <<= 2x = x << 2
>>= Tildel efter højreskift x >>= 1x = x >> 1
:= Tildelingsudtryk (valse-operator) if (n := len(data)) > 10:Tildel til n mens betingelsen evalueres
 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}")
  • Tildelingsoperatorer tillader at kombinere almindelig tildeling med forskellige operatorer for at tildele resultatet.
  • Valse-operatoren (:=) er et tildelingsudtryk, der er tilgængeligt i Python 3.8 og nyere.
  • Mens almindelig tildeling kun kan bruges som en sætning, tillader valse-operatoren tildeling inden for et udtryk.

Sammenligningsoperatorer

Sammenligningsoperatorer sammenligner værdier og returnerer True eller False.

Operator Betydning Eksempel
== Lige med 3 == 3True
!= Ikke lige med 3 != 4True
> Større end 5 > 2
< Mindre end 5 < 2
>= Større end eller lig med 5 >= 5
<= Mindre end eller lig med 3 <= 4
 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
  • Sammenligningsoperatorer sammenligner to værdier for orden eller lighed og returnerer True eller False som resultat.
  • I Python skal du være forsigtig, når du sammenligner forskellige datatyper. Nogle typer kan sammenlignes med hinanden, men resultaterne er måske ikke intuitive.

Logiske operatorer

Logiske operatorer bruges til at kombinere logiske udtryk.

Operator Betydning Eksempel
and Returnerer True, hvis begge er sande True and FalseFalse
or Returnerer True, hvis en af dem er sand True or FalseTrue
not Invertér den boolske værdi not TrueFalse
1x = 10
2print(x > 5 and x < 20)  # True
3print(x < 5 or x > 20)   # False
4print(not x == 10)       # False
  • and er en logisk operator, der kun returnerer True, hvis begge betingelser til venstre og højre er True.
  • or er en logisk operator, der returnerer True, hvis enten den venstre eller højre betingelse er True.
  • not er en logisk operator, der inverterer sandhedsværdien af en betingelse. Hvis det er sandt, bliver det falsk, og hvis det er falsk, bliver det sandt.

Præcedens for logiske operatorer

Operatorer har præcedens. Dette er reglen, der bestemmer, hvilken operator der evalueres først i et udtryk. Logiske operatorer evalueres i rækkefølgen: not, and og derefter or.

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

たとえば、

I det første eksempel evalueres and først, så False and False bliver til False, og som et resultat bliver True or False til True. Du kan også ændre rækkefølgen af evalueringen ved at bruge parenteser, som vist i det andet eksempel.

Bitvise operatorer

Bitvise operatorer udfører operationer på bitniveau.

Operator Betydning Eksempel
& Bitvis AND 5 & 31
| Bitvis OR 5 | 37
^ Bitvis eksklusiv OR (XOR) 5 ^ 36
~ Bitvis NOT ~5-6
<< Venstreflytning 5 << 110
>> Højreflytning 5 >> 12
 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}")
  • Du kan udføre bitvise AND, OR, XOR, NOT-operationer samt bit-skift operationer. Du kan også kombinere dem med tildelingsoperatorer som &=.

Medlemskabsoperatorer

Medlemskabsoperatorer bruges med samlinger som lister og ordbøger.

 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
  • in-operatoren bruges til at afgøre, om en bestemt værdi findes i en sekvens såsom en liste eller en streng, eller i en samling såsom en ordbog.
  • not in-operatoren bruges til at afgøre, om en bestemt værdi ikke findes i en sekvens eller samling.

Identitetsoperatorer

Identitetsoperatorer tjekker objekters identitet.

 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
  • Operatoren is tjekker, om to objekter er det samme objekt (dvs. henviser til den samme hukommelsesplacering).
  • Operatoren is not tjekker, om to objekter er forskellige objekter.
  • For eksempel adskiller x is y sig fra x == y ved, at det tjekker objektidentitet og ikke værdi-lighed.

Typekontrol

I Python bruger du funktionen isinstance() til at tjekke, om en værdi har en bestemt type. Du kan også bruge funktionen type() til at tjekke den nøjagtige type af en variabel. Selvom disse ikke er operatorer, er de grundlæggende mekanismer til typekontrol.

 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() er en funktion, der tjekker, om et objekt er en instans af en angivet klasse eller dens underklasse.
  • type() er en funktion, der returnerer den præcise type (klasse) af et objekt. Den bruges normalt, når du vil foretage en streng type-sammenligning.
  • isinstance() tager hensyn til arvforhold, mens type() tjekker efter nøjagtige matches.

Sammendrag

Når du bruger hver operator, skal du vælge passende baseret på dens formål og type. Da Python er et dynamisk typet sprog, kan resultatet af en operation variere afhængigt af typen af værdier, der beregnes.

Du kan følge med i ovenstående artikel ved hjælp af Visual Studio Code på vores YouTube-kanal. Husk også at tjekke YouTube-kanalen.

YouTube Video