Operatorer i Python

Operatorer i Python

Denne artikkelen forklarer operatorer i Python.

YouTube Video

Operatorer i Python

Python har ulike operatorer som kan deles inn i følgende kategorier. Vi vil forklare representative operatorer for hver kategori.

Aritmetiske operatorer

Aritmetiske operatører er operatører som brukes til å utføre beregninger på tall.

Operator Betydning Eksempel
+ Addisjon 3 + 25
- Subtraksjon 3 - 21
* Multiplikasjon 3 * 26
/ Divisjon (alltid flyttall) 3 / 21.5
// Hele divisjon 3 // 21
% Rest (modulo) 3 % 21
** Eksponentiering 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
  • I tillegg til de fire grunnleggende regneoperasjonene tilbyr Python operatorer for divisjon (/), heltallsdivisjon (//), modulus (%) og eksponentiering (**). Divisjon returnerer et flyttall selv når man deler heltall.

Tildelingsoperatorer

Tildelingsoperatorer brukes til å tildele verdier til variabler.

Operator Betydning Eksempel
= Tildeling x = 5
+= Legg til og tildel x += 2x = x + 2
-= Trekk fra og tildel x -= 2x = x - 2
*= Multipliser og tildel x *= 2x = x * 2
/= Divider og tildel x /= 2x = x / 2
//= Hele divisjon x //= 2x = x // 2
%= Tildel rest x %= 2x = x % 2
**= Tildel eksponentiering x **= 2x = x ** 2
&= Tildel ved hjelp av OG (AND) x &= 0b1010x = x & 0b1010
|= Tildel ved hjelp av ELLER (OR) x | = 0b0011x = x | 0b0011
^= Tildel ved hjelp av XOR x ^= 0b0101x = x ^ 0b0101
<<= Tildel etter venstreforskyvning x <<= 2x = x << 2
>>= Tildel etter høyreforskyvning x >>= 1x = x >> 1
:= Tildelingsuttrykk (havfrue-operatoren) 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 lar deg kombinere standard tildeling med ulike operatorer for å tildele resultatet.
  • Havfrue-operatoren (:=) er et tildelingsuttrykk tilgjengelig i Python 3.8 og nyere.
  • Mens standard tildeling kun kan brukes som en setning, lar havfrue-operatoren deg tildele innenfor et uttrykk.

Sammenligningsoperatorer

Sammenlikningsoperatører sammenligner verdier og returnerer True eller False.

Operator Betydning Eksempel
== Lik 3 == 3True
!= Ikke lik 3 != 4True
> Større enn 5 > 2
< Mindre enn 5 < 2
>= Større enn eller lik 5 >= 5
<= Mindre enn eller lik 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 verdier for rekkefølge eller likhet og returnerer True eller False som resultat.
  • I Python bør du være forsiktig når du sammenligner forskjellige datatyper. Noen typer kan sammenlignes med hverandre, men resultatene kan være uintuitive.

Logiske operatorer

Logiske operatører brukes til å kombinere logiske uttrykk.

Operator Betydning Eksempel
and Returnerer True hvis begge er True True and FalseFalse
or Returnerer True hvis én av dem er True True or FalseTrue
not Inverterer den boolske verdien 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 som returnerer True bare hvis begge betingelsene til venstre og høyre er True.
  • or er en logisk operator som returnerer True hvis enten den venstre eller høyre betingelsen er True.
  • not er en logisk operator som inverterer sannhetsverdien til en betingelse. Hvis det er Sant, blir det Usant, og hvis det er Usant, blir det Sant.

Prioritet for logiske operatorer

Operatorer har prioritet. Dette er regelen som avgjør hvilken operator som evalueres først i et uttrykk. Logiske operatorer evalueres i rekkefølgen: not, and, deretter or.

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

たとえば、

I det første eksempelet evalueres and først, så False and False blir False, og derfor blir True or False til True. Du kan også endre rekkefølgen for evaluering ved å bruke parenteser, som vist i det andre eksempelet.

Bitvise operatorer

Bitvise operatører utfører operasjoner på bitnivå.

Operator Betydning Eksempel
& Bitvis OG 5 & 31
| Bitvis ELLER 5 | 37
^ Bitvis eksklusiv ELLER (XOR) 5 ^ 36
~ Bitvis IKKE ~5-6
<< Venstreforskyvning 5 << 110
>> Høyreforskyvning 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 utføre bitvise OG (AND), ELLER (OR), XOR, IKKE (NOT) operasjoner, samt bitforskyvningsoperasjoner. Du kan også kombinere dem med tildelingsoperatorer som &=.

Medlemskapsoperatorer

Medlemsoperatører brukes med samlinger som lister og ordbøker.

 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 brukes for å avgjøre om en spesifisert verdi finnes i en sekvens som en liste eller streng, eller en samling som et ordbok.
  • not in-operatoren brukes for å avgjøre om en spesifisert verdi ikke finnes i en sekvens eller samling.

Identitetsoperatorer

Identitetsoperatører sjekker identiteten til objekter.

 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 sjekker om to objekter er det samme objektet (dvs. refererer til samme minneplassering).
  • Operatoren is not sjekker om to objekter er forskjellige objekter.
  • For eksempel, x is y er forskjellig fra x == y ved at den sjekker objektidentitet, ikke verdi-likhet.

Typekontroll

I Python bruker du funksjonen isinstance() for å sjekke om en verdi er av en bestemt type. Du kan også bruke funksjonen type() for å sjekke den nøyaktige typen til en variabel. Selv om dette ikke er operatorer, er de grunnleggende mekanismer for typekontroll.

 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 funksjon som sjekker om et objekt er en instans av en spesifisert klasse eller dens underklasse.
  • type() er en funksjon som returnerer den eksakte typen (klassen) til et objekt. Den brukes vanligvis når du ønsker å gjøre en streng type-sammenligning.
  • isinstance() tar hensyn til arverelasjoner, mens type() sjekker etter eksakte treff.

Sammendrag

Når du bruker hver operator, må du velge passende basert på dens formål og type. Siden Python er et dynamisk typet språk, kan resultatet av en operasjon variere avhengig av typen verdier som beregnes.

Du kan følge med på artikkelen ovenfor ved å bruke Visual Studio Code på vår YouTube-kanal. Vennligst sjekk ut YouTube-kanalen.

YouTube Video