Python Fundamentals I, II, III
Operatori Matematici
Operator Operatie Exemplu
** Exponent 2 ** 3 = 8
% Modulo/Rest 22 % 8 = 6
// Integer division/Floor 22 // 8 = 2
division
/ Impartire 22 / 8 = 2.75
* Inmultire 3 * 3 = 9
- Diferenta 5 - 2 = 3
+ Adunare 2 + 2 = 4
Exemple in shell-ul REPR:
>>> 2 + 3 * 6
20
>>> (2 + 3) * 6
30
>>> 2 ** 8
256
>>> 23 // 7
>>> 23 % 7
>>> (5 - 1) * ((7 + 1) / (3 - 1))
16.0
Tipuri de date
Tip de date Exemple
Integers - Intregi -2, -1, 0, 1, 2, 3, 4, 5
Floating-point numbers - Rationale -1.25, -1.0, --0.5, 0.0, 0.5, 1.0, 1.25
Strings - Siruri de caractere 'a', 'aa', 'aaa', 'Hello!', '11 cats'
Concatenarea si replicarea stringurilor
Concatenarea stringurilor:
>>> 'Alice' 'Bob'
'AliceBob'
>>> 'Alice' + 'Bob'
'AliceBob'
Replicarea stringurilor
>>> 'Alice' * 5
'AliceAliceAliceAliceAlice'
Manipularea stringurilor
Caractere speciale(Escape characters)
Caracter Se printeaza ca
\' Glilimea simpla
\" Ghilimea dubla
\t Tab
\n Rand nou
\\ Backslash
Exemplu:
>>> print("Hello there!\nHow are you?\nI\'m doing fine.")
Hello there!
How are you?
I'm doing fine.
Stringuri Raw
Un string raw ignora complet toate caracterele speciale si printeaza orice backslash apare in
string.
>>> print(r'That is Carol\'s cat.')
That is Carol\'s cat.
Nota: Se foloseste indeosebi pentru lucrur cu cai in linux si pentru definirea expressilor regex
Stringuri pe mai multe linii (triple ghilimele)
>>> print('''Dear Alice,
>>>
>>> Eve's cat has been arrested for catnapping, cat burglary, and
extortion.
>>>
>>> Sincerely,
>>> Bob''')
Dear Alice,
Eve's cat has been arrested for catnapping, cat burglary, and
extortion.
Sincerely,
Bob
Indexarea si slicingul sirurilor de caractere
>>> spam = 'Hello world!'
>>> spam[0]
'H'
>>> spam[4]
'o'
>>> spam[-1]
'!'
Slicing:
>>> spam[0:5]
'Hello'
>>> spam[:5]
'Hello'
>>> spam[6:]
'world!'
>>> spam[6:-1]
'world'
>>> spam[:-1]
'Hello world'
>>> spam[::-1]
'!dlrow olleH'
>>> spam = 'Hello world!'
>>> fizz = spam[0:5]
>>> fizz
'Hello'
Operatorii in si not in in lucrul cu stringuri:
>>> 'Hello' in 'Hello World'
True
>>> 'Hello' in 'Hello'
True
>>> 'HELLO' in 'Hello World'
False
>>> '' in 'spam'
True
>>> 'cats' not in 'cats and dogs'
False
upper(), lower(), isupper(), and islower()
upper() si lower():
>>> spam = 'Hello world!'
>>> spam = [Link]()
>>> spam
'HELLO WORLD!'
>>> spam = [Link]()
>>> spam
'hello world!'
startswith() si endswith()
>>> 'Hello world!'.startswith('Hello')
True
>>> 'Hello world!'.endswith('world!')
True
>>> 'abc123'.startswith('abcdef')
False
>>> 'abc123'.endswith('12')
False
>>> 'Hello world!'.startswith('Hello world!')
True
>>> 'Hello world!'.endswith('Hello world!')
True
join() si split()
join():
>>> ', '.join(['cats', 'rats', 'bats'])
'cats, rats, bats'
>>> ' '.join(['My', 'name', 'is', 'Simon'])
'My name is Simon'
>>> 'ABC'.join(['My', 'name', 'is', 'Simon'])
'MyABCnameABCisABCSimon'
split():
>>> 'My name is Simon'.split()
['My', 'name', 'is', 'Simon']
>>> 'MyABCnameABCisABCSimon'.split('ABC')
['My', 'name', 'is', 'Simon']
>>> 'My name is Simon'.split('m')
['My na', 'e is Si', 'on']
Eliminarea spatiilor si a terminatorilor de rand cu strip(),
rstrip(), and lstrip()
>>> spam = ' Hello World '
>>> [Link]()
'Hello World'
>>> [Link]()
'Hello World '
>>> [Link]()
' Hello World'
>>> spam = 'SpamSpamBaconSpamEggsSpamSpam'
>>> [Link]('ampS')
'BaconSpamEggs'
Formatarea stringurilor
Operatorul %
>>> name = 'Pete'
>>> 'Hello %s' % name
"Hello Pete"
Putem folosi operatorul de format specific %x pentru a converti un int intr-un string:
>>> num = 5
>>> 'I have %x apples' % num
"I have 5 apples"
Nota: Pentru cod nou folosirea metodei [Link] sau a f-strings (Python 3.6+) este cu mult
recomandata in pofida folosirii operatorului “%”.
Formatarea stringurilor ([Link])
Python 3 a introdus o noua metoda de formatare a stringurilor care face ca sintaxa pentru
formatarea stringurilor sa fie mult mai consistenta.
>>> name = 'John'
>>> age = 20'
>>> "Hello I'm {}, my age is {}".format(name, age)
"Hello I'm John, my age is 20"
>>> "Hello I'm {0}, my age is {1}".format(name, age)
"Hello I'm John, my age is 20"
Documentatia oficiala Python 3.x recomanda folosirea [Link]:
The formatting operations described here exhibit a variety of quirks that lead to a number of
common errors (such as failing to display tuples and dictionaries correctly). Using the newer
formatted string literals or the [Link]() interface helps avoid these errors. These alternatives
also provide more powerful, flexible and extensible approaches to formatting text.
F-string literals sau f-strings (Python 3.6+)
>>> name = 'Elizabeth'
>>> f'Hello {name}!'
'Hello Elizabeth!
Este posibil chiar sa facem calcule de aritmetica inline cu metoda aceasta
>>> a = 5
>>> b = 10
>>> f'Five plus ten is {a + b} and not {2 * (a + b)}.'
'Five plus ten is 15 and not 30.'
Variabile
Puteti da orice nume unei variabile atata timp cat urmeaza urmatoarele reguli:
1. Poate fi un singur cuvant.
2. Se pot folosi doar litere, cifre si caracterul “_”.
3. Nu poate incepe cu un numar.
4. Variabilele ale caror nume incep cu “_” sunt considerate nefolositoare.
Exemplu:
>>> spam = 'Hello'
>>> spam
'Hello'
>>> _spam = 'Hello'
_spam nu ar trebui sa mai fie folosit din nou in cod.
Comentarii
# Acesta este un comentariu
Cod + comentariu:
a = 1 # initializare/asignare
Functia print()
>>> print('Hello world!')
Hello world!
>>> a = 1
>>> print('Hello world!', a)
Hello world! 1
Functia Input()
Cod exemplu:
>>> print('What is your name?') # Cereti utilizatorului numele
>>> myName = input()
What is your name?
Al
>>> print('It is good to meet you, {}'.format(myName))
It is good to meet you, Al
Functia len()
Arata lungimea unu string (sau a unui iterabil - eg: liste, tupluri, etc.)
>>> len('hello')
Nota: Pentru a testa daca un string, lista, dictionar etc. este gol/goala se recomanda o evaluare a
valorii de adevar si nu folosirea functiei len().
>>> a = [1, 2, 3]
>>> if a:
>>> print("the list is not empty!")
Functiile str(), int() si float()
Integer in String sau Float:
>>> str(29)
'29'
>>> print('I am {} years old.'.format(str(29)))
I am 29 years old.
>>> str(-3.14)
'-3.14'
Float to Integer:
>>> int(7.7)
>>> int(7.7) + 1
Flow Control
Operatori de comparare
Operator Functionalitate
== egal cu
!= nu e egal cu
< mai mic decat
> mai mare decat
<= mai mic sau egal ca
>= mai mare sau egal ca
Operatiile cu acesti operatori returneaza True sau False in functie de valorile pe care le dam
membrilor operatiei.
Exemple pentru operatorii de comparatie:
>>> 42 == 42
True
>>> 40 == 42
False
>>> 'hello' == 'hello'
True
>>> 'hello' == 'Hello'
False
>>> 'dog' != 'cat'
True
>>> 42 == 42.0
True
>>> 42 == '42'
False
Evaluarea
Nu se recomanda folosirea operatorilor == sau != pentru evaluarea unei operații booleene.
Folositi operatorii is sau is not, sau, cel mai facil evaluarea implicita.
>>> True is True
True
>>> True is not False
True
Cele 3 exemple de mai jos sunt echivalente intre ele:
>>> if a is True:
>>> pass
>>> if a is not False:
>>> pass
>>> if a: #Cea mai recomandata dintre abordari
>>> pass
Si acestea:
>>> if a is False:
>>> pass
>>> if a is not True:
>>> pass
>>> if not a:
>>> pass
Operatori Booleeni
Exista 3 operatori booleeni: and, or, and not.
Tabela de adevar a operatorului “and”:
Expresie/Operatie Rezultat
True and True True
True and False False
False and True False
False and False False
Tabela de adevar a operatorului “or”:
Expresie/Operatie Rezultat
True or True True
True or False True
False or True True
False or False False
Tabela de adevar a operatorului “not”:
Expresie/Operatie Rezultat
not True False
not False True
Comparatii si operatori booleeni
>>> (4 < 5) and (5 < 6)
True
>>> (4 < 5) and (9 < 6)
False
>>> (1 == 2) or (2 == 2)
True
>>> 2 + 2 == 4 and not 2 + 2 == 5 and 2 * 2 == 2 + 2
True
Statement-ul if:
if name == 'Alice':
print('Hi, Alice.')
Statementul else:
name = 'Bob'
if name == 'Alice':
print('Hi, Alice.')
else:
print('Hello, stranger.')
Statementul elif:
name = 'Bob'
age = 5
if name == 'Alice':
print('Hi, Alice.')
elif age < 12:
print('You are not Alice, kiddo.')
name = 'Bob'
age = 30
if name == 'Alice':
print('Hi, Alice.')
elif age < 12:
print('You are not Alice, kiddo.')
else:
print('You are neither Alice nor a little kid.')
Bucle while:
spam = 0
while spam < 5:
print('Hello, world.')
spam = spam + 1
Statement-ul break
Daca in executia unei bucle (simple sau imbricate – while cuprins intr-alt while) se intalneste
cuvantul cheie break se iese imediat din bucla in care s-a intalnit statement-ul break:
while True:
print('Please type your name.')
name = input()
if name == 'your name':
break
print('Thank you!')
Statement-ul continue
Cand se intalneste cuvantul cheie continue intr-o bucla, se sare imediat la inceputul buclei.
Celelalte instructiuni din bucla nu mai sunt executate
while True:
print('Who are you?')
name = input()
if name != 'Joe':
continue
print('Hello, Joe. What is the password? (It is a fish.)')
password = input()
if password == 'swordfish':
break
print('Access granted.')
Bucle for si functia range():
>>> print('My name is')
>>> for i in range(5):
>>> print('Jimmy Five Times ({})'.format(str(i)))
My name is
Jimmy Five Times (0)
Jimmy Five Times (1)
Jimmy Five Times (2)
Jimmy Five Times (3)
Jimmy Five Times (4)
Functia range() poate fi folosita cu 3 argumente. Primele 2 sunt valorile de start si stop si a 3-a
este valoarea pasului. Pasul reprezinta valoarea cu care variabila este incrementata in fiecare
iteratie.
>>> for i in range(0, 10, 2):
>>> print(i)
8
Se pot folosi si numere negative pentru a face ca bulca for sa mearga inapoi
>>> for i in range(5, -1, -1):
>>> print(i)
Importarea modulelor
import getpass
user = input(‘Insert username: ’)
password = [Link](‘Insert password: ’)
Liste
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam
['cat', 'bat', 'rat', 'elephant']
Extragerea unei singure valori dintr-o lista folosind indecsi
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[0]
'cat'
>>> spam[1]
'bat'
>>> spam[2]
'rat'
>>> spam[3]
'elephant'
Indecsi Negativi
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[-1]
'elephant'
>>> spam[-3]
'bat'
>>> 'The {} is afraid of the {}.'.format(spam[-1], spam[-3])
'The elephant is afraid of the bat.'
Extragerea unei subliste folosind slicing
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[0:4]
['cat', 'bat', 'rat', 'elephant']
>>> spam[1:3]
['bat', 'rat']
>>> spam[0:-1]
['cat', 'bat', 'rat']
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[:2]
['cat', 'bat']
>>> spam[1:]
['bat', 'rat', 'elephant']
Daca folosim operatia de slicing pentru extragerea tuturor elementelor dintr-o lista se creeaza o
copie.
>>> spam2 = spam[:]
['cat', 'bat', 'rat', 'elephant']
>>> [Link]('dog')
>>> spam
['cat', 'bat', 'rat', 'elephant', 'dog']
>>> spam2
['cat', 'bat', 'rat', 'elephant']
Obtinerea lungimii unei liste cu functia len()
>>> spam = ['cat', 'dog', 'moose']
>>> len(spam)
Modificarea in place a unui element din lista folosind indecsi
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[1] = 'aardvark'
>>> spam
['cat', 'aardvark', 'rat', 'elephant']
>>> spam[2] = spam[1]
>>> spam
['cat', 'aardvark', 'aardvark', 'elephant']
>>> spam[-1] = 12345
>>> spam
['cat', 'aardvark', 'aardvark', 12345]
Concatenarea si replicarea listelor
>>> [1, 2, 3] + ['A', 'B', 'C']
[1, 2, 3, 'A', 'B', 'C']
>>> ['X', 'Y', 'Z'] * 3
['X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z']
>>> spam = [1, 2, 3]
>>> spam = spam + ['A', 'B', 'C']
>>> spam
[1, 2, 3, 'A', 'B', 'C']
Folosirea buclelor for pentru parcurgerea listelor
>>> supplies = ['pens', 'staplers', 'flame-throwers', 'binders']
>>> for supply in supplies:
>>> print(supply)
pens
staplers
flame-throwers
binders
Operatorii in si not in:
>>> 'howdy' in ['hello', 'hi', 'howdy', 'heyas']
True
>>> spam = ['hello', 'hi', 'howdy', 'heyas']
>>> 'cat' in spam
False
>>> 'howdy' not in spam
False
>>> 'cat' not in spam
True
Assignarea multipla
Daca stim exact cate elemente sunt intr-o lista exista o scurtatura pentru a assigna valorile din
acea lista unor variabile. In loc sa facem ceva de genul urmator:
>>> cat = ['fat', 'orange', 'loud']
>>> size = cat[0]
>>> color = cat[1]
>>> disposition = cat[2]
Putem face ceva de genul acesta:
>>> cat = ['fat', 'orange', 'loud']
>>> size, color, disposition = cat
Acelasi truc se poate folosi si pentru a inversa valorile a 2 variabile intre ele:
>>> a, b = 'Alice', 'Bob'
>>> a, b = b, a
>>> print(a)
'Bob'
>>> print(b)
'Alice'
Operatori augmentati de assignare
Operator Echivalent
spam += 1 spam = spam + 1
spam -= 1 spam = spam - 1
spam *= 1 spam = spam * 1
spam /= 1 spam = spam / 1
spam %= 1 spam = spam % 1
Exemple:
>>> spam = 'Hello'
>>> spam += ' world!'
>>> spam
'Hello world!'
>>> bacon = ['Zophie']
>>> bacon *= 3
>>> bacon
['Zophie', 'Zophie', 'Zophie']
Gasirea unei valori intr-o lista cu metoda index
>>> spam = ['Zophie', 'Pooka', 'Fat-tail', 'Pooka']
>>> [Link]('Pooka')
Adaugarea unei valori intr-o lista cu metodele append() si
insert()
append(): #Adauga o valoare la sfarsitul listei
>>> spam = ['cat', 'dog', 'bat']
>>> [Link]('moose')
>>> spam
['cat', 'dog', 'bat', 'moose']
insert(): #Adauga o valoare la pozitia pe care o dam ca argument: insert(pozitie, valoare)
>>> spam = ['cat', 'dog', 'bat']
>>> [Link](1, 'chicken')
>>> spam
['cat', 'chicken', 'dog', 'bat']
Eliminarea unei valori dintr-o lista cu functiile remove() si
pop()
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> [Link]('bat')
>>> spam
['cat', 'rat', 'elephant']
>>> [Link](1)
>>> spam
['cat', 'elephant']
Daca o valoare apare de mai multe ori in lista, doar prima ei aparitie va fi eliminate folosind
functia remove()
Sorting the Values in a List with the sort() Method
>>> spam = [2, 5, 3.14, 1, -7]
>>> [Link]()
>>> spam
[-7, 1, 2, 3.14, 5]
>>> spam = ['ants', 'cats', 'dogs', 'badgers', 'elephants']
>>> [Link]()
>>> spam
['ants', 'badgers', 'cats', 'dogs', 'elephants']
Functia sort are si argumentul optional reverse (cu valoarea default=False), caruia putem sa ii
dam valoarea true pentru a avea o lista ordonata descrescator:
>>> [Link](reverse=True)
>>> spam
['elephants', 'dogs', 'cats', 'badgers', 'ants']
Tipul de date - Tuple
>>> eggs = ('hello', 42, 0.5)
>>> eggs[0]
'hello'
>>> eggs[1:3]
(42, 0.5)
>>> len(eggs)
Principalul mod in care tuplurile si listele difera este ca tuplurile sunt imutabile.
Modificarea tipului de date din tuple in list si viceversa.
>>> tuple(['cat', 'dog', 5])
('cat', 'dog', 5)
>>> list(('cat', 'dog', 5))
['cat', 'dog', 5]
>>> list('hello')
['h', 'e', 'l', 'l', 'o']
Seturi
Din documentatia oficiala Python 3:
A set is an unordered collection with no duplicate elements. Basic uses include membership
testing and eliminating duplicate entries. Set objects also support mathematical operations like
union, intersection, difference, and symmetric difference.
Initializarea unui set
Exista 2 metode pentru initializarea unui set: folosind acoladele {} functia standard
python set()
>>> s = {1, 2, 3}
>>> s = set([1, 2, 3])
Cand se doreste crearea unui set gol nu folositi {} ci folositi functia set(). S = {} va returna un
dictionar gol.
>>> s = {}
>>> type(s)
<class 'dict'>
Seturile: colectii neordonate de valori unice:
Un set elimina automat toate aparitiile duplicate ale unei valori.
>>> s = {1, 2, 3, 2, 3, 4}
>>> s
{1, 2, 3, 4}
Fiind un tip de date neordonat nu poate fi indexat.
>>> s = {1, 2, 3}
>>> s[0]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'set' object does not support indexing
>>>
Functiile add() si update()
Folosind functia add() putem sa adaugam un singur element setului.
>>> s = {1, 2, 3}
>>> [Link](4)
>>> s
{1, 2, 3, 4}
Si cu update(), mai multe.
>>> s = {1, 2, 3}
>>> [Link]([2, 3, 4, 5, 6])
>>> s
{1, 2, 3, 4, 5, 6} # Observam cum seturile elimina automat
aparitiile multiple ale unui element.
set remove() si discard()
Ambele functii elimina un element din set dar remove() o sa ridice o exceptie (key
error) daca valoarea nu exista.
>>> s = {1, 2, 3}
>>> [Link](3)
>>> s
{1, 2}
>>> [Link](3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 3
discard() nu ridica nici o exceptie.
>>> s = {1, 2, 3}
>>> [Link](3)
>>> s
{1, 2}
>>> [Link](3)
>>>
set union()
union() sau | o sa creeze un nou set cu toate elementele din cele 2 seturi.
>>> s1 = {1, 2, 3}
>>> s2 = {3, 4, 5}
>>> [Link](s2) # sau 's1 | s2'
{1, 2, 3, 4, 5}
set intersection()
intersection sau & o sa returneze un nou set care contine doar eementele commune celor 2
seturi.
>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> [Link](s2) # sau 's1 & s2
{3}
set difference()
difference sau – o sa returneze doar elementele care sunt intr-un singur set.
>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> [Link](s2) # sau 's1 - s2'
{1}
