Contents

1. Introducere ........................................................................................................................................... 2
2. Elemente de programare .............................................................................................................. 3
2.1. Tipuri de date ................................................................................................................................ 3
2.1.1. Numeric (int, float, complex) ................................................................................................ 3
2.1.2. Şiruri de caractere ................................................................................................................. 4
2.2. Variabile ........................................................................................................................................ 4

2.2.1.Tipuri de variabile – Colecţii de date ............................................................................................ 5

2.2.1.1. Liste .......................................................................................................................................... 5

2.2.1.2. Tupluri ...................................................................................................................................... 6
2.2.1.3. Seturi ....................................................................................................................................... 6
2.2.1.4. Dicţionare ................................................................................................................................ 7
2.3. Operatori ............................................................................................................................................ 9
2.4. Structuri de programare ..................................................................................................................... 9

2.4.1 Structuri alternative – Clauza IF ................................................................................................ 10

2.4.2. Structuri repetitive – Clauza for ............................................................................................... 11

1
1. Introducere
Python este un limbaj de programare ușor de învățat. Are structuri de date la nivel înalt și o
abordare simplă, dar eficientă, a programării orientate obiect. Sintaxa elegantă și scrierea dinamică
a lui Python, împreună cu natura sa interpretată, îl fac un limbaj ideal pentru scrierea și dezvoltarea
rapidă a aplicațiilor în multe zone de pe majoritatea platformelor.
Free și Open Source - Python este un exemplu de FLOSS (Free / Libré și Open Source Software).
În termeni simpli, puteți să distribuiți gratuit copii ale acestui software, să citiți codul sursă, să
efectuați modificări și să folosiți bucăți din acesta în noile programe gratuite. FLOSS se bazează
pe conceptul unei comunități care împărtășește cunoștințele. Acesta este unul dintre motivele
pentru care Python este atât de bun - a fost creat și este în mod constant îmbunătățit de o comunitate
care vrea doar să vadă un Python mai bun.
Portabil - Datorită naturii sale cu sursă deschisă, Python a fost portat (adică modificat pentru a funcționa)
pe multe platforme. Toate programele Python pot funcționa pe oricare dintre aceste platforme fără a
necesita modificări, dacă sunteți suficient de atent pentru a evita orice funcții dependente de sistem. Puteți
folosi Python pe GNU / Linux, Windows, FreeBSD, Macintosh, Solaris, OS / 2, Amiga, AROS, AS / 400,
BeOS, OS / 390, z / OS, Palm OS, QNX, VMS, Psion, Acorn RISC OS, VxWorks, PlayStation, Sharp
Zaurus, Windows CE și PocketPC! Puteți chiar utiliza o platformă ca Kivy pentru a crea jocuri pentru
computer și pentru iPhone, iPad și Android.
Orientat Obiect - Python susține programarea orientată spre procedură, precum și programarea
orientată pe obiecte. În limbile orientate spre proceduri, programul este construit în jurul unor
proceduri sau funcții care nu sunt decât piese de program reutilizabile. În limbajele orientate pe
obiecte, programul este construit în jurul obiectelor care combină date și funcționalități. Python
are o modalitate foarte puternică, dar simplistă de a face OOP, mai ales atunci când este comparată
cu limbi mari precum C ++ sau Java.
Extensibil - Dacă aveți nevoie de o bucată critică de cod pentru a rula foarte repede sau doriți să
nu aveți o bucată de algoritm care să nu fie deschisă, puteți să codificați acea parte a programului
în C sau C++ și apoi să o utilizați din programul dvs. Python.
Încorporabil - Puteți încorpora Python în programele C / C ++ pentru a oferi capabilități de
scripting pentru utilizatorii programului dvs.
Biblioteci extinse - Biblioteca standard Python este într-adevăr imensă. Acesta vă poate ajuta să
faceți diverse lucruri care implică expresii regulate, generarea de documente, testarea unităților,
filetarea, baze de date, browsere web, CGI, FTP, email, XML, XML-RPC, HTML, fişiere WAV,
criptografie, GUI (graphical user interfaces) și alte facilităţi dependente de sistem. Amintiți-vă,
toate acestea sunt întotdeauna disponibile oriunde este instalat Python. Aceasta se numește
filosofia “bateriilor incluse” din Python. Pe lângă biblioteca standard, există și alte biblioteci de
înaltă calitate pe care le puteți găsi la Python Package Index.
Comentarii - încep cu caracterul #
Constante literare - un exemplu de constanta literala este un numar ca 5, 1.23 sau un sir ca "Acesta
este un sir" sau "Este un sir!". Ea reprezintă întotdeauna el însuși și nimic altceva - este o constantă
deoarece valoarea sa nu poate fi schimbată.

2
Numerele - sunt în principal de două tipuri - întregi și float. Un exemplu de număr întreg este 2,
care este doar un număr întreg. Exemple de numere float sunt 3.23 și 52.3E-4. Notația E indică
puteri de 10. În acest caz, 52.3E-4 înseamnă 52.3 * 10 ^ -4 ^
Siruri de caractere - Puteți specifica șiruri de caractere utilizând ‘şir de caractere’ sau "şir de
caractere ". Puteți specifica șiruri de caractere pe mai multe linii utilizând ghilimele triple - """.
Puteți utiliza ghilimele simple și ghilimele duble în cadrul ghilimelilor triple.
Fiecare instrucţiune se scrie pe un rând. Dacă se doreşte scrierea mai multor instrucţiuni pe
acelaşi rând se folodeşte ; (i = 5; print(i);)
Indentare – Caracterul spațiul este important în Python. Spațiul principal (spațiile și tab-urile) de
la începutul liniei logice este utilizat pentru a determina nivelul de indentare al liniei logice, care
la rândul său este folosit pentru a determina gruparea de declarații. Aceasta înseamnă că
declarațiile care merg împreună trebuie să aibă aceeași indentare. Fiecare astfel de set de declarații
se numește bloc. O indentare greșită poate da naștere unor erori.
Metoda format() - Uneori este posibil să dorim să construim șiruri din alte informații.
Programul
varsta = 20
nume = 'Popescu'
print('{0} a avut {1} ani cand a scris aceasta carte'.format(nume,
varsta))
print('De ce {0} a scris aceasta carte?'.format(nume))

va avea ca ieşire
Popescu a avut ani cand a scris aceasta carte
De ce Popescu a scris aceasta carte?

Pentru a combina un şir de caractere cu o variabilă, utilizăm +, care are rolul de a concatena:

x = "pachete software"
print("Seminar " + x)

sau
x = "Seminar "
y = "Pachete Software"
z= x+y
print(z)

2. Elemente de programare

2.1. Tipuri de date

2.1.1. Numeric (int, float, complex)
 Variabile de tipul numeric sunt create atunci cand li se atribuie valoare. Nu
necesita declarare.

3
  Int sau integer reprezintă un număr întreg, pozitiv sau negativ, fără zecimale, de
lungime nelimitată.
 Float reprezintă un număr pozitiv sau negativ, cu una sau mai multe zecimale.
 complex conţin "j" care desemnează partea imaginară.
2.1.2. Şiruri de caractere
 marcate cu “ ” sau ‘ ’
 Sunt considerate ca vectori.
 Parantezele [ ] sunt utilizate pentru a accesa elementele şirului.
 Pentru şirul a = "Seminar pachete software"
o obţinerea caracterului de la poziţia 1 (primul caracter are poziţia 0):
print(a[1])
 extragerea unui subşir. Obţinerea caracterelor de la poziţia 2 la 5 (exclusiv):
print(a[2:5])
 returnarea lungimiia şirului - metoda len(): print(len(a))
 transformarea şirul în litere mici - metoda lower(): print(a.lower())
 transformarea şirul în litere mari - metoda upper(): print(a.upper())
 înlocuirea unui şir cu un alt şir - metoda replace():print(a.replace(" ", ""))
 împărţirea şirului în mai multe şiruri după un separator - metoda split():
print(a.split(",")) face să se obţină o lista de valori ['Seminar', ' pachete
software']

2.2. Variabile
 În Python, variabilele sunt case-sensitive.
 Denumirea variabilelor trebuie să înceapă cu o literă sau underscore (nu cu un număr)
şi poate conţine numai caractere alfanumerice: de la A-z, 0-9 şi underscore.
 Spre deosebire de alte limbaje, în Pythono variabilă nu se declară neapărat explicit, fiind
necesar să i se atribuie valoare.
 Nu este necesar să se precizeze tipul de data al variabilei
x=5
y = "Python"
print(x)
print(y)
 Tipul de data al variabilei poate fi schimbat ulterior
x = 4 - x este de tip int
x = "Python" - x este de tip str
print(x)
 Specificarea tipului de dată pentru o variabilă
Atunci când se doreşte specificarea tipului de dată pentru o variabilă, utilizăm următorii
constructori:
– int() - construieşte un număr întreg dintr-un număr întreg, un număr cu zecimale
(prin eliminarea zecimalelor) sau un şir de caractere (când şirul reprezintă un număr
întreg);

4
 – float() - construieşte un număr cu zecimale dintr-un număr întreg, un număr cu
zecimale sau un şir de caractere (când şirul reprezintă un număr întreg sau un număr cu
zecimale);
– str() - construieşte un şir de caractere dintr-o varietate de tipuri de date, incluzând
şiruri de caractere, numere întregi şi numele cu zecimale.

2.2.1.Tipuri de variabile – Colecţii de date

2.2.1.1. Liste
– Listă este o structură de date care deține o colecție ordonată de elemente
 Permite elemente identice.
 Elementele sunt despărţite prin virgula.
 Lista de articole ar trebui să fie închisă în paranteze pătrate [ ].
 După ce ați creat o listă, puteți să adăugați, să eliminați sau să căutați elemente din listă.
 Elementele pot fi modificate.

Metoda Descriere
Crearea şi afişarea unei liste lista = ["laptop", "creion", "flipchart"]
print(lista)
Accesarea elementelor din listă se lista = ["laptop", "creion", "flipchart"]
realizează prin index: print(lista[1])
Modificarea unui element: lista = ["laptop", "creion", "flipchart"]
lista[1] = "carioca"
print(lista)
append() Adaugă un element la sfârşitul listei lista = ["laptop", "creion", "flipchart"]
lista.append("rucsac")
print(lista)
clear() Elimină toate elementele listei lista = ["laptop", "creion", "flipchart"]
(golirea listei) lista.clear()
print(lista)
copy() Crează o copie a listei
Del() Ştergerea întreagii liste lista = ["laptop", "creion", "flipchart"]
del lista
Eliminarea elementului de la indexul lista = ["laptop", "creion", "flipchart"]
specificat del lista [0]
print(lista)
len() Determinarea numărului de lista = ["laptop", "creion", "flipchart"]
elemente din listă - metoda print(len(lista))

count() Returnează numărul de apariţii al

elementului în listă

5
extend() Adăugă elemente la sfârşitul unei
liste
index() Returnează indexul unui element
insert() Adaugă un element la poziţia lista = ["laptop", "creion", "flipchart"]
specificată lista.insert(1, "rucsac")
print(lista)
pop() Elimină elementul de la poziţia lista = ["laptop", "creion", "flipchart"]
specificată sau ultimul element în lista.pop()
cazul în care indexul nu este print(lista)
specificat
remove() Elimină elementul specificat lista = ["laptop", "creion", "flipchart"]
lista.remove("laptop")
print(lista)
reverse() Inversează ordinea elementelor în
listă
sort() Sortează lista
list() Crearea unei liste prin intermediul lista = list(("laptop", "creion",
constructorului list(). "flipchart")) #observaţi parantezele
rotunde duble
print(lista)

2.2.1.2. Tupluri
 colecţii de date ordonate şi nemodificabile.
 tuplurile permit elemente identice.
 sunt reprezentate utilizând ( )

Metoda Descriere
Crearea şi afişarea unui tuplu:
Accesarea elementelor din tuplu se
realizează prin index
tuplu = ("laptop", "creion", "flipchart")
print(tuplu)
tuplu = ("laptop", "creion", "flipchart")
print(tuplu[1])

Modificarea unui element nu este tuplu = ("laptop", "creion", "flipchart")

posibilă, tuplul rămâne nemodificat. tuplu[1] = "carioca"
TypeError: 'tuple' object does
not support item assignment
count() Returnează numărul de apariţii al
elementului în tuplu
index() Returnează poziţia unui element în
tuplu

2.2.1.3. Seturi

6
Seturile sunt colecții neordonate de obiecte simple. Acestea sunt folosite atunci când existența
unui obiect într-o colecție este mai importantă decât ordinea sau de câte ori apare.

Folosind seturi, puteți testa pentru apartenență, indiferent dacă este vorba de un subgrup al altui
set, găsiți intersecția dintre două seturi și așa mai departe.

 Colecţii de date neordonate

 Neindexate
 Nu pot fi modificate elementele unui set
 Nu sunt acceptate elemente identice.
 Accesarea elementelor din set nu este posibilă,
 Seturile sunt reprezentate prin { }
 Elementele pot fi parcurse cu for
 Existenţa unui element poate fi verificată cu in
 Crearea şi afişarea unui set (fiind elemente neordonate, afişarea este aleatoare)
set = {"laptop", "creion", "flipchart"}
print(set)

add() Adaugă un element

clear() Elimină toate elementele setului
copy() Returnează o copie a setului
difference() Returnează un set reprezentând diferenţa dintre două
sau mai multe seturi
difference_update() Elimină elementele dintr-un set care sunt conţinute de
un alt set specificat
discard() Elimină un element specificat
intersection() Returnează un set reprezentând intersecţia a două seturi
intersection_update() Elimină elementele dintr-un set care nu sunt în alt set
isdisjoint() Arată dacă două seturi se intersectează sau nu
issubset() Arată dacă un set este inclus într-un alt set sau nu
issuperset() Arată dacă un set conţine un alt set sau nu
pop() Elimină un element
remove() Elimină elementul specificat
symmetric_difference() Returnează un set cu elementelenecomune celor doua
seturi
symmetric_difference_update() Inserează într-un set diferenţele dintre două seturi
union() Returnează un set reprezentând reuniunea a două seturi
update() Actualizează setul cu reuniunea dintre un set şi altele

2.2.1.4. Dicţionare

7
Un dicționar este ca o agendă unde găsiți adresa sau datele de contact ale unei persoane, cunoscând
doar numele acesteia, adică asociăm cheile (numele) cu valorile (detalii). Rețineți că cheia trebuie
să fie unică, la fel cum nu puteți afla informațiile corecte dacă aveți două persoane cu același
nume.

 Colecţii de date neordonate,

 Modificabile
 Indexate.
 Nu sunt admise elemente identice
 Reprezentate prin { }
 Au suplimentar chei şi valori.

Crearea şi afişarea unui dicţionar:

dictionar = {"laptop":"IBM", "creion":"FaberCastell", "flipchart":"M3"}
print(dictionar)
Accesarea elementelor din dicţionar se realizează
 prin cheie:
dictionar = {"laptop":"IBM", "creion":"FaberCastell", "flipchart":"M3"}
x = dictionar["laptop"]
print(x)
 sau prin metoda get():
print(dictionar.get("laptop"))
Modificarea unui element din dicţionar se realizează prin cheie:
dictionar = {"laptop":"IBM", "creion":"FaberCastell", "flipchart":"M3"}
dictionar["laptop"] = "HP"
print(dictionar)

Metoda Descriere
clear() Elimină toate elementele din dicţionar
copy() Returnează o copie a dicţionarului
fromkeys() Returnează un dicţionar cu chei valori specificate
get() Returnează valoarea pentru o anumită cheie
items() Returnează o listă conţinând un tuplu pentru fiecare pereche cheie-valoare
keys() Returnează o listă conţinând cheile dicţionarului
pop() Elimină elementul având o anumită cheie specificată
popitem() Elimină ultima pereche adăugată cheie valoare
setdefault() Returnează valoarea pentru o cheie specificată. Dacă cheia nu există, o adaugă
update() Actualizează dicţionarul cu perechile cheie-valoare specificate
values() Returnează o listă cu toate valorile dicţionarului

8
2.3. Operatori
Tip Operator Denumire Exemplu
+ Adunare x+y
- Scădere x-y
Aritmetici * Înmulţire x*y
/ Împărţire x/y
% Restul împărţirii x%y
** Exponenţial x ** y
// Partea întreagă a împărţirii x // y
== Egal x == y
!= Diferit x != y
Comparaţie
> Mai mare x>y
< Mai mic x<y
>= Mai mare sau egal x >= y
<= Mai mic sau egal x <= y
and Returnează True dacă ambele expresii sunt x < 5 and x <
adevărate 10
Logici
or Returnează True dacă cel puţin o expresie este x < 5 or x < 4
adevărată
not Negaţia, inversează rezultatul returnând False not(x < 5 and
dacă rezultatul este adevărat x < 10)
= x=5 x=5
+= x=x+3 x += 3
-= x=x-3 x -= 3
Atribuire
*= x=x*3 x *= 3
/= x=x/3 x /= 3
%= x=x%3 x %= 3
//= x = x // 3 x //= 3
**= x = x ** 3 x **= 3
is Returnează True dacă ambele variabile sunt x is y
Identitate
acelaşi obiect
is not Returnează True dacă ambele variabile nu sunt x is not y
acelaşi obiect
in Returnează True dacă o secvenţă cu o valoare x in y
Apartenenţă
specificată este prezentă în obiect
not in Returnează True dacă o secvenţă cu o valoare x not in y
specificată nu este prezentă în obiect

2.4. Structuri de programare

Chiar dacă în alte limbaje indentarea nu e relevantă, în Python indentarea este esenţială, fiind
utilizată pentru a indica un bloc de cod.

9
2.4.1 Structuri alternative – Instrucţiunea IF
Sintaxa
if condiţie:
instructiune
instructiune
……
guess < number:
instructiune
instructiune
……
else:
instructiune
instructiune
……
instrucţiune din afara If (Această ultimă instrucțiune este întotdeauna executată după executarea
instrucțiunii if.)
Clauza elif care combină efectiv două declarații if else - if else într-o singură declarație combinată
if-elif-else. Acest lucru face ca programul să fie mai ușor și reduce cantitatea de indentare necesară.
Declarațiile elif și else trebuie să aibă simbolul : la sfârșitul liniei logice urmate de blocul de
declarații corespunzător (cu indentare corespunzătoare, desigur)
O instrucțiune if poate fi imbricată.
Pentru introducerea unor valori de la tastatura, se utilizează funcţia predefinită input

x = 23
Exemplu: y = int(input(Introduceti un numar: '))

if y == x:
print(‘Ai ghicit')
START print('Felicitari')
elif y < x:
print(‘Y < X’)
X = 23 else:
print(‘Y < X’)

Citeste Y print('Gata')

NU DA
Y=X
NU DA
Afiseaza “Ai ghicit”
Y<X

Afiseaza “Y > X” Afiseaza “Y < X” “Felicitari”

Afiseaza “Gata”

STOP

10
2.4.2. Structuri repetitive – Instrucţiunile WHILE şi FOR
Instrucţiunea While

Instrucțiunea while permite să se execute în mod repetat un bloc de declarații atâta timp cât o
condiție este adevărată. Ea este o declarație de tip buclă. O declarație while poate avea o altă
clauză opțională.

Sintaxa
WHILE condiţie
Bloc de instrucţiuni
Exemplu:

STAR
T

X = 23

x = 23
raspuns = True
Raspuns = adevarat

while raspuns:
DA y = int(input(Introduceti un numar: '))
if y == x:
Raspuns = print(‘Ai ghicit')
adevarat raspuns = False
elif y < x:
NU Citeste Y
print('Nu, numarul trebuie sa fie mai
mare')
NU DA else:
STOP
print('Nu, numarul trebuie sa fie mai
Y= mic')
X
else:
DA
Afiseaza “Ai ghicit” print(‘Sfarsit încercare')
Y<
X

Afiseaza “Y > X” Afiseaza “Y < X”

Raspuns = fals

Afiseaza “Sfarsit încercare”

11
Instrucţiunea For

Sintaxa

for conditie:
bloc instrucţiuni
else:
bloc instrucţiuni

Exemplu
for i in range(1, 5):
print(i)
else:
print('i este in afara intervalului')

Funcţia range() returnează o secvenţă de numere

Clauza else se execută când se termină for

Instrucţiunea BREAK

Instrucțiunea break este folosită pentru a ieși dintr-o buclă, adică sw opreşte executarea unei
instrucțiuni while sau for, chiar dacă condiția de buclă nu a devenit Falsă sau secvența de elemente
nu a fost complet repetată.

i=1
while i<6:
print(i)
if i == 3:
break
i += 1

Instrucţiunea CONTINUE

Instrucțiunea continue este folosită pentru a ignora restul instrucțiunilor din blocul actual de buclă
și a continua la iterația următoare a buclă.

i=0
while i<6:
i += 1
if i == 3:
continue
print(i)

12