Operatorer i Python
Den här artikeln förklarar operatorer i Python.
YouTube Video
Operatorer i Python
Python har olika operatorer, som kan delas in i följande kategorier. Vi kommer att förklara representativa operatorer för varje kategori.
Aritmetiska operatorer
Aritmetiska operatorer är operatorer som används för att utföra beräkningar på siffror.
Operator | Betydelse | Exempel |
---|---|---|
+ |
Addition | 3 + 2 → 5 |
- |
Subtraktion | 3 - 2 → 1 |
* |
Multiplikation | 3 * 2 → 6 |
/ |
Division (alltid flyttal) | 3 / 2 → 1.5 |
// |
Heltalsdivision | 3 // 2 → 1 |
% |
Rest (modulo) | 3 % 2 → 1 |
** |
Exponentiering | 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
- Utöver de fyra grundläggande aritmetiska operationerna tillhandahåller Python operatorer för division (
/
), heltalsdivision (//
), modulus (%
) och exponentiering (**
). Division returnerar ett flyttal även när heltal divideras.
Tilldelningsoperatorer
Tilldelningsoperatorer används för att tilldela värden till variabler.
Operator | Betydelse | Exempel |
---|---|---|
= |
Tilldelning | x = 5 |
+= |
Adderar och tilldelar | x += 2 → x = x + 2 |
-= |
Subtraherar och tilldelar | x -= 2 → x = x - 2 |
*= |
Multiplicerar och tilldelar | x *= 2 → x = x * 2 |
/= |
Dividerar och tilldelar | x /= 2 → x = x / 2 |
//= |
Heltalsdivision | x //= 2 → x = x // 2 |
%= |
Tilldelar rest | x %= 2 → x = x % 2 |
**= |
Tilldelar exponentiering | x **= 2 → x = x ** 2 |
&= |
Tilldela med hjälp av OCH (AND) | x &= 0b1010 → x = x & 0b1010 |
|= |
Tilldela med hjälp av ELLER (OR) | x | = 0b0011 →x = x | 0b0011 |
^= |
Tilldela med hjälp av XOR | x ^= 0b0101 → x = x ^ 0b0101 |
<<= |
Tilldela efter vänsterskift | x <<= 2 → x = x << 2 |
>>= |
Tilldela efter högerskift | x >>= 1 → x = x >> 1 |
:= |
Tilldelningsuttryck (valrossoperatorn) | if (n := len(data)) > 10: → Tilldela till n samtidigt som villkoret utvärderas |
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}")
- Tilldelningsoperatorer tillåter att kombinera vanlig tilldelning med olika operatorer för att tilldela resultatet.
- Valrossoperatorn (
:=
) är ett tilldelningsuttryck som finns tillgängligt i Python 3.8 och senare. - Medan vanlig tilldelning bara kan användas som ett uttryck, möjliggör valrossoperatorn tilldelning inuti ett uttryck.
Jämförelseoperatorer
Jämförelseoperatorer jämför värden och returnerar True
eller False
.
Operator | Betydelse | Exempel |
---|---|---|
== |
Lika | 3 == 3 → True |
!= |
Inte lika | 3 != 4 → True |
> |
Större än | 5 > 2 |
< |
Mindre än | 5 < 2 |
>= |
Större än eller lika med | 5 >= 5 |
<= |
Mindre än eller lika 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
- Jämförelseoperatorer jämför två värden för ordning eller likhet och returnerar
True
ellerFalse
som resultat. - I Python bör du vara försiktig när du jämför olika datatyper. Vissa typer kan jämföras med varandra, men resultaten kan vara ologiska.
Logiska operatorer
Logiska operatorer används för att kombinera logiska uttryck.
Operator | Betydelse | Exempel |
---|---|---|
and |
Returnerar True om båda är True | True and False → False |
or |
Returnerar True om någon av dem är True | True or False → True |
not |
Inverterar det booleska värdet | 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
är en logisk operator som returnerarTrue
endast om båda villkoren till vänster och höger ärTrue
.or
är en logisk operator som returnerarTrue
om antingen det vänstra eller högra villkoret ärTrue
.not
är en logisk operator som inverterar sanningsvärdet för ett villkor. Om det är Sant blir det Falskt, och om det är Falskt blir det Sant.
Prioritet för logiska operatorer
Operatorer har prioritet. Detta är regeln som bestämmer vilken operator som utvärderas först i ett uttryck. Logiska operatorer utvärderas i ordningen: not
, and
och sedan or
.
1result = True or False and False
2print(result) # True
3
4result = (True or False) and False
5print(result) # False
たとえば、
I det första exemplet utvärderas and
först, så False and False
blir False
, och som ett resultat blir True or False
till True
. Du kan också ändra utvärderingsordningen genom att använda parenteser, som visas i det andra exemplet.
Bitvisa operatorer
Bitvisa operatorer utför operationer på bitnivå.
Operator | Betydelse | Exempel |
---|---|---|
& |
Bitvis OCH (AND) | 5 & 3 → 1 |
| |
Bitvis ELLER (OR) | 5 | 3 →7 |
^ |
Bitvis exklusiv ELLER (XOR) | 5 ^ 3 → 6 |
~ |
Bitvis INTE (NOT) | ~5 → -6 |
<< |
Vänsterskift | 5 << 1 → 10 |
>> |
Högerskift | 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öra bitvisa operationer som OCH (AND), ELLER (OR), XOR, INTE (NOT), samt bitförskjutningar. Du kan också kombinera dem med tilldelningsoperatorer som
&=
.
Medlemskapsoperatorer
Medlemskapsoperatorer används med samlingar som listor och ordböcker.
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
-operatorn används för att avgöra om ett angivet värde finns i en sekvens såsom en lista eller sträng, eller en samling såsom en ordbok (dictionary).not in
-operatorn används för att avgöra om ett angivet värde inte finns i en sekvens eller samling.
Identitetsoperatorer
Identitetsoperatorer kontrollerar objekts 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
- Operatorn
is
kontrollerar om två objekt är samma objekt (dvs pekar till samma minnesplats). - Operatorn
is not
kontrollerar om två objekt är olika objekt. - Till exempel skiljer sig
x is y
frånx == y
genom att den kontrollerar objektidentitet, inte värdelikhet.
Typkontroll
I Python använder du funktionen isinstance()
för att kontrollera om ett värde är av en specifik typ. Du kan också använda funktionen type()
för att kontrollera den exakta typen för en variabel. Även om dessa inte är operatorer är de grundläggande mekanismer för typkontroll.
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()
är en funktion som kontrollerar om ett objekt är en instans av en angiven klass eller dess subklass.type()
är en funktion som returnerar den exakta typen (klassen) för ett objekt. Den används vanligtvis när du vill göra en strikt typjämförelse.isinstance()
tar hänsyn till arv, medantype()
kontrollerar exakt överensstämmelse.
Sammanfattning
När du använder varje operator behöver du välja lämpligt baserat på dess syfte och typ. Eftersom Python är ett dynamiskt typat språk kan resultatet av en operation variera beroende på typen av värden som beräknas.
Du kan följa med i artikeln ovan med hjälp av Visual Studio Code på vår YouTube-kanal. Vänligen kolla även in YouTube-kanalen.