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 + 2 → 5 |
- |
Subtraktion | 3 - 2 → 1 |
* |
Multiplikation | 3 * 2 → 6 |
/ |
Division (altid flydende-tal) | 3 / 2 → 1.5 |
// |
Gulv-division (heltalsdivision) | 3 // 2 → 1 |
% |
Rest (modulo) | 3 % 2 → 1 |
** |
Potensiering | 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
- 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 += 2 → x = x + 2 |
-= |
Træk fra og tildel | x -= 2 → x = x - 2 |
*= |
Gang og tildel | x *= 2 → x = x * 2 |
/= |
Divider og tildel | x /= 2 → x = x / 2 |
//= |
Gulv-division (heltalsdivision) | x //= 2 → x = x // 2 |
%= |
Tildel rest | x %= 2 → x = x % 2 |
**= |
Tildel potensiering | x **= 2 → x = x ** 2 |
&= |
Tildel ved hjælp af AND | x &= 0b1010 → x = x & 0b1010 |
|= |
Tildel ved hjælp af OR | x | = 0b0011 →x = x | 0b0011 |
^= |
Tildel ved hjælp af XOR | x ^= 0b0101 → x = x ^ 0b0101 |
<<= |
Tildel efter venstreskift | x <<= 2 → x = x << 2 |
>>= |
Tildel efter højreskift | x >>= 1 → x = 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 == 3 → True |
!= |
Ikke lige med | 3 != 4 → True |
> |
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
ellerFalse
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 False → False |
or |
Returnerer True, hvis en af dem er sand | True or False → True |
not |
Invertér den boolske værdi | 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, der kun returnererTrue
, hvis begge betingelser til venstre og højre erTrue
.or
er en logisk operator, der returnererTrue
, hvis enten den venstre eller højre betingelse erTrue
.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 & 3 → 1 |
| |
Bitvis OR | 5 | 3 →7 |
^ |
Bitvis eksklusiv OR (XOR) | 5 ^ 3 → 6 |
~ |
Bitvis NOT | ~5 → -6 |
<< |
Venstreflytning | 5 << 1 → 10 |
>> |
Højreflytning | 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 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 frax == 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, menstype()
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.