Această lecție va aborda diferiți operatori și expresii în Python, incluzând operatorii aritmetici, de comparare, logici, de atribuire și operatori pentru lucrul cu secvențe.
Operatori aritmetici
Operatorii aritmetici sunt utilizați pentru efectuarea operațiilor matematice între două valori. Aceștia includ:
+– Adunare-– Scădere*– Înmulțire/– Împărțire//– Împărțire întreagă (rezultatul va fi întotdeauna un număr întreg)%– Modulo (restul împărțirii)**– Exponențiere (ridicare la putere)
x = 10
y = 3
adunare = x + y # 13
scadere = x - y # 7
inmultire = x * y # 30
impartire = x / y # 3.3333333333333335
impartire_intreaga = x // y # 3
modulo = x % y # 1
exponentiere = x ** y # 1000
Operatori de comparare
Operatorii de comparare sunt utilizați pentru a compara două valori și a returna o valoare booleană (True sau False). Aceștia includ:
==– Egalitate!=– Diferență<– Mai mic>– Mai mare<=– Mai mic sau egal>=– Mai mare sau egal
x = 10
y = 3
egalitate = x == y # False
diferenta = x != y # True
mai_mic = x < y # False
mai_mare = x > y # True
mai_mic_sau_egal = x <= y # False
mai_mare_sau_egal = x >= y # True
Operatori logici
Operatorii logici sunt utilizați pentru a combina mai multe expresii și a returna o valoare booleană (True sau False). Aceștia includ:
and– Și logic (returneazăTruedacă ambele expresii sunt adevărate)or– Sau logic (returneazăTruedacă cel puțin una dintre expresii este adevărată)not– Negare logică (returneazăTruedacă expresia este falsă, șiFalsedacă expresia este adevărată)
x = True
y = False
si_logic = x and y # False
sau_logic = x or y # True
negare_logica = not x # False
Operatori de atribuire
Operatorii de atribuire sunt utilizați pentru a atribui o valoare unei variabile. Aceștia includ:
=– Atribuire+=– Adunare și atribuire-=– Scădere și atribuire*=– Înmulțire și atribuire/=– Împărțire și atribuire//=– Împărțire întreagă și atribuire%=– Modulo și atribuire**=– Exponențiere și atribuire
x = 10
x += 5 # echivalent cu x = x + 5; x devine 15
x -= 3 # echivalent cu x = x - 3; x devine 12
x *= 2 # echivalent cu x = x * 2; x devine 24
x /= 4 # echivalent cu x = x / 4; x devine 6.0
x //= 2 # echivalent cu x = x // 2; x devine 3.0
x %= 2 # echivalent cu x = x % 2; x devine 1.0
x **= 3 # echivalent cu x = x ** 3; x devine 1.0## Operatori pentru lucrul cu secvențe
Operatorii pentru lucrul cu secvențe sunt utilizați pentru a manipula și accesa elementele din secvențe, cum ar fi liste, tuple și șiruri de caractere.
1. `[]` - Accesarea elementelor (indexare)
2. `[start:stop]` - Accesarea unei subsecvențe (slicing)
3. `[start:stop:step]` - Accesarea unei subsecvențe cu un pas specificat (slicing cu pas)
4. `in` - Verificarea dacă un element se află în secvență
5. `not in` - Verificarea dacă un element nu se află în secvență
6. `+` - Concatenarea a două secvențe
7. `*` - Repetarea unei secvențe de un număr specificat de ori
```python
lista = [1, 2, 3, 4, 5]
element = lista[1] # 2 (indexarea începe de la 0)
subsecventa = lista[1:4] # [2, 3, 4]
subsecventa_cu_pas = lista[0:5:2] # [1, 3, 5]
prezent = 3 in lista # True
absent = 6 not in lista # True
concatenare = [1, 2, 3] + [4, 5, 6] # [1, 2, 3, 4, 5, 6]
repetare = [1, 2] * 3 # [1, 2, 1, 2, 1, 2]
Acești operatori funcționează în mod similar și pentru alte tipuri de secvențe, precum tuple și șiruri de caractere:
sir_caractere = "abcde"
caracter = sir_caractere[1] # 'b'
substring = sir_caractere[1:4] # 'bcd'
substring_cu_pas = sir_caractere[0:5:2] # 'ace'
prezent = 'c' in sir_caractere # True
absent = 'f' not in sir_caractere # True
concatenare = "abc" + "def" # 'abcdef'
repetare = "ab" * 3 # 'ababab'
Rețineți că, spre deosebire de liste, tuplele și șirurile de caractere sunt imutabile, ceea ce înseamnă că nu puteți modifica elementele lor direct prin indexare.
tuplu = (1, 2, 3, 4, 5)
element = tuplu[1] # 2
subsecventa = tuplu[1:4] # (2, 3, 4)
subsecventa_cu_pas = tuplu[0:5:2] # (1, 3, 5)
# Aceasta va genera o eroare, deoarece tuplurile sunt imutabile
# tuplu[1] = 10