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 + 2 → 5 |
- |
Subtraksjon | 3 - 2 → 1 |
* |
Multiplikasjon | 3 * 2 → 6 |
/ |
Divisjon (alltid flyttall) | 3 / 2 → 1.5 |
// |
Hele divisjon | 3 // 2 → 1 |
% |
Rest (modulo) | 3 % 2 → 1 |
** |
Eksponentiering | 3 ** 2 → 9 |
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 += 2 → x = x + 2 |
-= |
Trekk fra og tildel | x -= 2 → x = x - 2 |
*= |
Multipliser og tildel | x *= 2 → x = x * 2 |
/= |
Divider og tildel | x /= 2 → x = x / 2 |
//= |
Hele divisjon | x //= 2 → x = x // 2 |
%= |
Tildel rest | x %= 2 → x = x % 2 |
**= |
Tildel eksponentiering | x **= 2 → x = x ** 2 |
&= |
Tildel ved hjelp av OG (AND) | x &= 0b1010 → x = x & 0b1010 |
|= |
Tildel ved hjelp av ELLER (OR) | x | = 0b0011 →x = x | 0b0011 |
^= |
Tildel ved hjelp av XOR | x ^= 0b0101 → x = x ^ 0b0101 |
<<= |
Tildel etter venstreforskyvning | x <<= 2 → x = x << 2 |
>>= |
Tildel etter høyreforskyvning | x >>= 1 → x = 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 == 3 → True |
!= |
Ikke lik | 3 != 4 → True |
> |
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
ellerFalse
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 False → False |
or |
Returnerer True hvis én av dem er True | True or False → True |
not |
Inverterer den boolske verdien | not True → False |
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 returnererTrue
bare hvis begge betingelsene til venstre og høyre erTrue
.or
er en logisk operator som returnererTrue
hvis enten den venstre eller høyre betingelsen erTrue
.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 & 3 → 1 |
| |
Bitvis ELLER | 5 | 3 →7 |
^ |
Bitvis eksklusiv ELLER (XOR) | 5 ^ 3 → 6 |
~ |
Bitvis IKKE | ~5 → -6 |
<< |
Venstreforskyvning | 5 << 1 → 10 |
>> |
Høyreforskyvning | 5 >> 1 → 2 |
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 frax == 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, menstype()
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.