Operatorer i Python

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 + 25
- Subtraktion 3 - 21
* Multiplikation 3 * 26
/ Division (alltid flyttal) 3 / 21.5
// Heltalsdivision 3 // 21
% Rest (modulo) 3 % 21
** Exponentiering 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
  • 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 += 2x = x + 2
-= Subtraherar och tilldelar x -= 2x = x - 2
*= Multiplicerar och tilldelar x *= 2x = x * 2
/= Dividerar och tilldelar x /= 2x = x / 2
//= Heltalsdivision x //= 2x = x // 2
%= Tilldelar rest x %= 2x = x % 2
**= Tilldelar exponentiering x **= 2x = x ** 2
&= Tilldela med hjälp av OCH (AND) x &= 0b1010x = x & 0b1010
|= Tilldela med hjälp av ELLER (OR) x | = 0b0011x = x | 0b0011
^= Tilldela med hjälp av XOR x ^= 0b0101x = x ^ 0b0101
<<= Tilldela efter vänsterskift x <<= 2x = x << 2
>>= Tilldela efter högerskift x >>= 1x = 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 == 3True
!= Inte lika 3 != 4True
> 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 eller False 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 FalseFalse
or Returnerar True om någon av dem är True True or FalseTrue
not Inverterar det booleska värdet not TrueFalse
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 returnerar True endast om båda villkoren till vänster och höger är True.
  • or är en logisk operator som returnerar True om antingen det vänstra eller högra villkoret är True.
  • 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 & 31
| Bitvis ELLER (OR) 5 | 37
^ Bitvis exklusiv ELLER (XOR) 5 ^ 36
~ Bitvis INTE (NOT) ~5-6
<< Vänsterskift 5 << 110
>> Högerskift 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ö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ån x == 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, medan type() 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.

YouTube Video