© Drepturi de autor de SDA Sp.

z oo

Toate drepturile rezervate. Copierea, reproducerea, partajarea totală sau par•ială

fără acordul SDA Sp. z oo Este interzis.

Permitem ca coperta căr•ii să fie distribuită numai online.

Introducere în Python
Academia de Dezvoltare Software

Versiunea 2.1, aprilie 2020

Cuprins
cuvânt înainte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 Rezumat . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 Partea I No•iuni de bază ale sintaxei în Python . . . . . . . . . . . . . . . . . .

............................................3

Introducere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 Bună ziua lume! . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 Caracteristici de bază •i filosofia Python . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 Repl.It - mediu de dezvoltare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . 12 tipuri simple •i operatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

Tip întreg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 Tipul virgulă mobilă . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 Tip boolean (bool) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 tip •ir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . 20 Niciun tip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 Turnare -

conversie de tipuri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 comentarii . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 Variabile •i declara•ie de atribuire . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 Condi•ii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . 29 Bucle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

În timp ce bucla . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 de tipuri complexe . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

Listă . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 Dic•ionar . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 Pentru buclă . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 Rezumatul păr•ii I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . 39 Partea II Refactorizarea codului . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

Introducere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 Gruparea codului în func•ii .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 Gruparea unui cod în clase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 Concluzie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . 51 Anexa A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 Anexa B . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

Rezumatul tipurilor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 Rezumatul operatorilor . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 Rezumatul cuvintelor cheie . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
cuvânt înainte

Programarea este distractivă - rareori pot fi auzite astfel de cuvinte. La urma urmei, programarea este o putere înnăscută îmbunătă•ită în subsolurile

întunecate iluminate cu ecrane de monitorizare •i este disponibilă doar pentru mintea adep•ilor foarte talenta•i ai artei secrete, de preferin•ă înainte

de a ajunge la vârsta de doisprezece ani. Această abilitate

este practic inaccesibil pentru un muritor obi•nuit. Aceasta este o convingere care a apărut par•ial din cauza filmelor care creează imaginea unui
programator-hacker, un tip antisocial cu barbă lungă, care î•i formulează gândurile folosind cifre •i care poate vedea culorile •i sunetele în •iruri
de numere. Par•ial, se datorează oamenilor în•i•i, care în căutare de legende •i superputeri atribuie proprietă•i supranaturale programării.

De fapt, programarea este una dintre multele abilită•i interesante •i foarte atractive pe care fiecare dintre noi le poate dobândi. Nu trebuie să vă
plimba•i prin almanahuri umflate sau să merge•i la Ivy League. Nici nu trebuie să te na•ti cu aceste abilită•i. Pentru început, această scurtă
discu•ie va fi suficientă. După ce citi•i acest manual, ve•i fi gata să începe•i să scrie•i singur primele programe.

1
rezumat
Acest registru de lucru constă din două păr•i.

Prima parte oferă o introducere generală la programare •i discută structurile de bază utilizate în Python. În timpul lec•iilor de gramatică
de la •coală, a•i aflat despre păr•i ale propozi•iei (subiect, predicat, atribut etc.) în limba dvs. maternă, iar acum ve•i afla despre păr•ile
de bază ale propozi•iei (cod) în Python:

• tipuri simple •i operatori

• variabile •i declara•ie de atribuire

• condi•ii

• bucle

• tipuri complexe

Informa•iile con•inute în partea 1 vă vor fi suficiente pentru a scrie orice program complicat. Cu toate acestea, un astfel de cod va con•ine multe
repetări •i probabil că nu va fi u•or de citit.

Un cod este scris o dată, dar este citit de multe ori. În a doua parte a registrului nostru de lucru, ve•i învă•a cum să evita•i repetările în
codul dvs. •i să scrie•i un cod frumos care va fi o plăcere pentru al•i dezvoltatori să citească. Prezentarea generală acoperă cele mai
populare două tehnici de refactorizare a codului:

• gruparea codului în func•ii

• gruparea codului în clase

Fiecare capitol se încheie cu un set de exerci•ii. Exerci•iile sunt o modalitate bună de a verifica în sine nivelul de în•elegere a materialului
discutat. În plus, utilizarea practică a cuno•tin•elor dobândite vă poate ajuta în mod semnificativ să le rezolva•i în minte.

Toate exemplele incluse în acest manual de lucru urmează recomandările PEP8 (un set de linii directoare pentru formatarea unui cod în
Python).

2
Partea I Noțiuni de bază ale sintaxei în Python

3
Introducere
Programarea este procesul de a da comenzi computerului. Computerele nu în•eleg limbajul uman. Au propriile limbi. Pentru a da o comandă pe
care un computer o va în•elege, trebuie să o face•i într-o limbă pe care o cunoa•te. De aceea, învă•area programării înseamnă învă•area unui nou
limbaj. Un limbaj care poate fi în•eles de computer. Dar programarea este ceva mai mult decât abilitatea de a utiliza un alt limbaj.

Folosim un limbaj pentru a ne exprima gândurile. Exprimarea gândurilor într-un limbaj pentru computer necesită o conversie u•oară a modului
în care gândim. Învă•area unui mod specific de gândire este al doilea pas al învă•ării programării. Modul de gândire caracteristic programării
este adesea denumit gândire algoritmică. De•i la început s-ar putea să vi se pară pu•in deranjant (gândirea algoritmică pentru majoritatea dintre
noi nu este un mod natural de gândire cu care s-au născut), după numărul adecvat de exerci•ii ve•i începe să percepe•i multe probleme în mod
diferit.

Învă•area gândirii algoritmice este un pic ca un puzzle bun care necesită să vă schimba•i perspectiva mentală •i să privi•i o anumită problemă
dintr-un unghi u•or diferit. De obicei, rămâi blocat pe un astfel de puzzle, dar dacă î•i dai pu•in mai mult timp pentru rezolvare, după câteva ore sau
zile întâlne•ti un nou indiciu sau un gând nou care te duce la solu•ie. Trebuie doar să fii pu•in răbdător •i persistent. Un puzzle bun este un puzzle
în care solu•ia te obligă să-•i schimbi perspectiva mentală. Rezolvarea unui puzzle bun vă poate oferi multe satisfac•ii. Acela•i lucru se aplică
programării. După ceva timp, ve•i observa cu mare plăcere cum computerele încep să vă asculte •i să vă implementeze comenzile cu o viteză •i o
precizie de neconceput. Cu toate acestea, înainte ca acest lucru să se întâmple, trebuie să vă bloca•i, să nu renun•a•i, •i schimbă-•i pu•in
mentalitatea. Aceasta este via•a de zi cu zi a unui programator. Să începem.

4
Salut Lume!
Computerele, de•i par adesea a fi dispozitive foarte inteligente, la cel mai scăzut nivel pot în•elege doar zerouri •i unele. În interior sunt doar
o colec•ie de miliarde de lumini minuscule (tranzistoare). Pentru un computer, „unu” înseamnă că curentul electric trece prin una dintre
aceste lămpi, în timp ce „0” înseamnă că curentul nu circulă prin această lampă. Calculatoarele pot aprinde •i opri aceste lumini cu viteza de
miliarde de opera•ii pe secundă. Ei î•i datorează toată puterea acestei viteze.

Primele programe (adică seturi de instruc•iuni pentru un computer) arătau mai mult sau mai pu•in a•a:

110011100111000001111100000001000011111000011111100000000010000011001111100001

100010000010011111000100000000000001001111100000111110001000000000000000001000

111110010000001100001111100011000000000100111110011100111000111000001000111000

001111100000111110010000011111000110011111100001111000001111000001110011111100

001111000110011100000111000100011111000001111100100000110000000111000001110001

111100011111000111000001000001000011000111110001000001000000011100000111001000

111110001111000001111000011111100001111110000011110000000000000000011110000011

100111000011110011111000111110001111100000100000000000000000000000111110001110

000001110000011100011100111110001000100000000011100001111100110000000010011111

000111100000111100111100010011100000111110000011111001100111100010001111000000000001000111110010000010011110011001110001000111110001100000100011111000011110

011100111111000111100000111100011111000000011110000011100100001111000100011111

001100011111000111100000111001110001100111100100000000000000011111000001111100

010010000011100001111100100000100011100000111000110011110001001111110001100000

111100011111000111100000111001000011110001001111100000111110000000011110000011

110000000000000000111000001110000011000001100000111000111000001100111110000111

111001001110000011111000001100011000001001111110000011100110011111000000000111

000001110000111100001100111100011111000111100000111001000011110001001111100000111110000000011110000011

110000000000000000001110000011100000110000011000001110001110000011001111100100111 11100100111000001111100000110001100000100111111000111001100111100011111000111100000111001000011110

Programul indică direct prin ce lămpi curentul ar trebui sau nu să curgă. Chiar dacă
o astfel de înregistrare este convenabilă pentru un computer, un om trebuie să lucreze din greu pentru ao crea. Este •i mai dificil de ghicit ce face
un astfel de program pe baza secven•ei de unii •i zerouri. Privind „codul” de mai sus, pute•i ghici ce ar trebui să facă acest program? Era extrem de
incomod pentru oameni să folosească un astfel de limbaj. De aceea, în curând au început să apară •i alte limbaje de programare computerizate,
care erau mai u•or de în•eles pentru oameni.

org 0x100

mov dx, msg

mov ah, 9
int 0x21

mov ah, 0x4c

int 0x21

msg db "Bună ziua, lume!", 0x0d, 0x0a, "$"

Codul de mai sus a fost scris într-una din multele versiuni ale limbajului Assembler. Po•i ghici

5
ce face programul reprezentat de acest cod? Probabil că nu o pute•i ghici încă, dar probabil că pute•i recunoa•te unele elemente familiare din
acesta, cum ar fi: „mov” înseamnă probabil mutare, iar „msg” probabil indică un mesaj.

Odată cu apari•ia de noi limbaje de programare mai u•or de citit de oameni, a apărut nevoia de a le traduce într-un limbaj u•or de în•eles de
computer, adică într-un limbaj de zerouri •i unii. În industria IT, un astfel de traducător dintr-un limbaj de nivel înalt (mai convenabil pentru
oameni) într-un limbaj de nivel scăzut (în•eles de un computer) se nume•te compilator. Au început să apară compilatoare, adică programe a
căror sarcină era să traducă un program scris în noua limbă într-o succesiune de zerouri •i unii.

În a doua jumătate a secolului XX, au fost create sute de limbaje noi •i compilatoare. Prima versiune a limbajului Assembler a fost creată în 1947,
în cooperare cu John von Neumann (creatorul computerelor de astăzi). Asamblorul este foarte legat de hardware. Diferite procesoare •i-au folosit
propriile versiuni Assembler. Dacă dori•i ca programul dvs. să ruleze pe mai multe computere diferite, trebuie să scrie•i acest program în mai
multe versiuni. Prin urmare, a fost nevoie să scrie•i un limbaj a cărui specifica•ie nu se va modifica în func•ie de parametrii computerului. La
începutul anilor 1970, Dennis Ritchie a dezvoltat unul dintre cele mai populare limbaje de programare din lume - limbajul C.

# include <stdio.h>

int main () {
printf („Bună ziua, lume!”);
retur 0;
}

Probabil pute•i observa aici •i mai multe elemente pe care le pute•i recunoa•te. În•elesul „include” •i „principal” este evident, iar „printf”
înseamnă probabil „tipăre•te ceva”. Cu toate acestea, în afară de fragmentele u•or de în•eles, codul limbajului C con•ine încă o mul•ime de
caractere ciudate: punct •i virgulă, hash, paranteze rotunde, paranteze cretate •i paranteze unghiulare. 20 de ani mai târziu, în 1991, Guido
van Rossum a dezvoltat prima specifica•ie de limbaj Python.

print („Bună ziua, lume!”)

Inten•ia creatorilor a fost să dezvolte un limbaj de programare cu un cod care să poată fi citit în modul în care cite•ti romanele. Au dorit ca sintaxa
Python să fie cât mai aproape de sintaxa limbajului natural. Când vă uita•i la codul programului scris în Python, pute•i ghici ce face programul?
•ansele par a fi mult mai mari decât în cazul celor trei versiuni anterioare. •i totu•i, fiecare dintre cele patru programe prezentate mai sus face
acela•i lucru: afi•ează textul „Bună ziua, lume!” pe ecran.

În IT, este o regulă ca primul program care să fie scris în limba nou învă•ată să fie programul care afi•ează cuvintele „Bună ziua, lume!”.

Primul exemplu arată „Bună ziua, lume!” program în a•a-numitul limbaj ma•ină. Al doilea exemplu este „Bună ziua, lume!” program scris în
limbajul Assembler pentru Intel pe 64 de bi•i

6
procesoare. Al treilea exemplu este „Bună ziua, lume!” program scris în C. Python, care este chiar un limbaj de nivel superior. Traducătorul
Python pentru limbajul automat pe care îl vom folosi aici (CPython) a fost scris în limbajul C. În timp ce scriau specifica•iile limbajului Python,
creatorii au fost inspira•i în principal din limbile ABC, Smalltalk •i ALOGL 68. Programele care traduc un cod într-o serie de zerouri •i unele în limbi
precum Python nu se numesc compilatoare, ci interpreti. În acest moment, diferen•ele dintre compilatori •i interpre•i nu sunt importante pentru noi.

„Bună ziua, lume!” programul îndepline•te func•ia unui test ini•ial. În acest fel pute•i verifica dacă a•i instalat •i configurat totul corect •i dacă pute•i
rula programul pe care l-a•i scris. De•i programele pot fi scrise în orice editor de text, vom folosi mediul de dezvoltare integrat Repl.It complet
configurat •i gata de utilizare. Este disponibil pentru scrierea de programe la https://repl.it/languages/python3 .

În plus, Anexa A oferă instruc•iuni complete de instalare •i configurare pentru mediul de dezvoltare integrat PyCharm. PyCharm este mediul
de dezvoltare integrat recomandat de SDA. Citi•i Anexa A dacă dori•i să rula•i aceste exemple, indiferent dacă ave•i sau nu acces la Internet.

Să începem cu „Bună ziua, lume!” program. Mergi la https://repl.it/languages/python3 iar în fereastra din mijloc introduce•i:

print („Bună ziua, lume!”)

Apoi face•i clic pe butonul Executare din partea de sus a paginii. După un timp, rezultatul programului dvs. va fi afi•at în dreapta.

A•i reu•it să rula•i acest program? Felicitări! Tocmai a•i scris primul dvs. program în Python. Programul dvs. afi•ează textul „Bună ziua,
lume!” pe ecran.

Exerci•ii

1. Dacă nu a•i făcut-o încă, încerca•i să scrie•i •i să rula•i „Bună ziua, lume!” program într-unul din mediile de dezvoltare integrate (IDE). În
Anexa A ve•i găsi instruc•iuni despre cum să instala•i •i să rula•i mediul de dezvoltare integrat PyCharm

2. Scrie•i un program care afi•ează „Bună ziua, <Numele tău>!” pe ecran (în loc de „<Numele tău>”, introduce•i numele dvs.)

3. Elimina•i unul dintre ghilimelele din jurul textului „Bună ziua, lume”. Încerca•i să rula•i programul. Citi•i mesajul care descrie eroarea care
a apărut. Apoi corecta•i ghilimelele •i încerca•i să strica•i programul într-un mod diferit (de fiecare dată citi•i descrierea erorii întâlnite),
de exemplu:

◦ elimina•i sau adăuga•i o paranteză

◦ elimina•i una dintre literele din cuvântul „tipări•i”

4. Înainte de a executa următoarele linii ale codului, încerca•i să ghici•i care va fi rezultatul:

◦ print („Ce zi frumoasă”)

◦ print („Ce”, „a” „frumos”, „zi”)

◦ tipar (3)

7
 ◦ print (3, 4, 5)

◦ print („1”, „2”, 3, 4, 5)

◦ print („Ce”, „a” „frumos”, „zi”, sep = „,”)

5. Scrie•i o linie de cod care începe cu #. Executarea unei astfel de linii de cod nu va cauza nicio ac•iune. În Python, caracterul # este folosit
pentru a comenta linia. Când interpretul Python întâlne•te caracterul #, acesta trece la următoarea linie a codului. Prin urmare, acest
caracter este folosit pentru a introduce comentarii în cod. Comentariile vor fi utile pentru al•i programatori care vă citesc codul sau
pentru dvs.

8
Caracteristicile de bază și filozofia Python
Python este un limbaj cu scop general (multi-paradigmă). Aceasta înseamnă că nu for•ează programatorul să folosească un anumit mod
(paradigmă) pentru a scrie codul. În Python, pute•i grupa cu u•urin•ă
codul dvs. în func•ii sau clase sau în multe alte moduri. Are o bibliotecă standard extinsă, care include, printre altele:

• Matematică - o bibliotecă pentru calcule matematice (are func•ii precum evolu•ie, păcat, cos, ...)

• Datetime - o bibliotecă pentru a lucra cu date reprezentând timpul (ore, zile, luni, ani, ...)

• Colec•ii - o bibliotecă pentru a lucra cu structuri de date personalizate

În plus, con•ine multe biblioteci externe. Python a atins cea mai mare popularitate datorită bibliotecilor sale concepute pentru:

• programare în re•ea (Django, Flask, Pyramid)

• învă•are automată •i re•ele neuronale artificiale (scikit-learn, PyTorch, Keras)

• calcule •tiin•ifice (Numpy, Matplotlib, Scipy, Pandas, TensorFlow)

Aceasta este doar o mică parte a colec•iei uria•e de biblioteci Python disponibile pe internet. Acolo pute•i găsi biblioteci pentru scrierea
interfe•elor grafice ale utilizatorului (PyQt, Tkinter, WxPython), biblioteci pentru scrierea jocurilor (Arcade, Pygame), biblioteci pentru lucrul cu
sunetul (playsound, simpleaudio, pyaudio) •i multe altele.

Python este un limbaj interpretabil. Aceasta înseamnă că, atunci când rula•i un cod scris în Python, nu trebuie să trece•i singur prin faza de
compilare a codului. Pur •i simplu rula•i fi•ierul cu codul dvs. •i Python face restul pentru dvs.

Dezvoltatorii Python au adunat 19 dintre cele mai importante principii care le-au ghidat crearea limbajului într-o colec•ie numită Zen of Python.
Pentru a-i afi•a con•inutul, introduce•i următorul text în fereastra din mijloc:

importă acest lucru

•i face•i clic pe butonul Executare.

9
În fereastra din dreapta, ve•i vedea manifestul Python,

Zenul lui Python, de Tim Peters

Frumos este mai bun decât urât. Explicit este mai bun
decât implicit. Simplul este mai bun decât complexul.
Complexul este mai bun decât complicat. Plat este mai
bine decât cuibărit.

Sparse este mai bine decât dens.

Citibilitatea contează.
Cazurile speciale nu sunt suficient de speciale pentru a încălca regulile. De•i
practicitatea bate puritatea.
Erorile nu ar trebui să treacă niciodată în tăcere. Cu excep•ia cazului

în care este redusă în mod explicit.

În fa•a ambiguită•ii, refuză tenta•ia de a ghici.

Ar trebui să existe una - •i, de preferin•ă, o singură - modalitate evidentă de a o face. De•i a•a s-ar putea să
nu fie evident la început dacă nu sunte•i olandez. Acum este mai bine ca niciodată.

De•i niciodată nu este adesea mai bun decât * chiar acum.

Dacă implementarea este greu de explicat, este o idee proastă.
Dacă implementarea este u•or de explicat, poate fi o idee bună. Spa•iile de nume sunt o idee excelentă
- să facem mai multe dintre acestea!

10
Regulile de mai sus sunt un set de 19 discipline pe care ar trebui să le urma•i în timp ce scrie•i codul. Să ne uităm la principiul nr. 6. La
început, con•inutul său poate părea a fi cel mai ciudat.

Sparse este mai bine decât dens.

A•a cum un limbaj natural permite exprimarea aceluia•i gând în multe feluri, într-un limbaj de programare există multe moduri de a nota aceea•i
opera•ie.

Când lucra•i la orice problemă, aceasta se apropie de dvs. în timp. După câteva zile de muncă, tu
poate fi tentat să prezinte toate concluziile colectate în forma cea mai concisă posibilă. A cincea versiune a codului nostru ne poate încânta cu
con•inutul său. Am reu•it să împachetăm într-un singur rând numărul care a fost scris ini•ial în 12 rânduri.

print ('\ n'.join (f "{j} octe•i = {j * 8} bi•i care are {256 ** j-1} valori posibile." pentru j în (1 << i pentru i în intervalul (8 ))))

Am făcut codul nostru cât mai dens posibil. Este foarte concis. Cu toate acestea, există un risc semnificativ ca persoanele care nu au
colaborat cu noi la acest cod •i care vor trebui să îl citească să nu fie atât de încântate. Putem scrie acela•i lucru în câteva rânduri:

pentru i în intervalul (8):

j = 1 << i
print (f "{j} octe•i = {j * 8} bi•i care are {256 ** j-1} valori posibile."

Rezultatul este acela•i, dar codul este mult mai clar acum. Principiul nr. 6 recomandă evitarea supraîncărcării codului cu con•inut în
detrimentul lizibilită•ii acestuia. Pe măsură ce ve•i deveni mai experimentat, principiile con•inute în manifestul Python vă vor deveni din ce în
ce mai u•or de în•eles.

11
Repl.It - mediu de dezvoltare
Înainte de a începe să scriem alte programe, permite•i-ne să ne cunoa•tem pu•in mai bine mediul de dezvoltare.

Pentru a scrie •i a rula programe Python, nu ne trebuie decât un computer •i un acces la Internet. Dacă dori•i să rula•i programele,
indiferent dacă ave•i sau nu acces la Internet, ve•i avea
au nevoie de un mediu de dezvoltare integrat. În Anexa A ve•i găsi instruc•iunile pentru instalarea •i configurarea PyCharm - mediul de
dezvoltare integrat recomandat de SDA.

Când accesa•i site-ul Repl.It, ve•i vedea trei ferestre.

Prima fereastră (din stânga) con•ine o previzualizare a directorului proiectului. Aici ve•i crea noile fi•iere •i foldere. Când volumul codului dvs.
cre•te, va trebui să îl împăr•i•i în fi•iere •i, în timp, chiar •i în foldere. O faci în prima fereastră. La pornire, Repl.It creează automat un fi•ier main.py
gol în directorul proiectului. Fi•ierele de cod Python se numesc scripturi. Conven•ia impune ca scripturilor să li se dea extensia py. A doua
fereastră, în

mijloc, afi•ează con•inutul fi•ierului indicat în directorul proiectului (în cazul nostru, este main.py). Deocamdată este un fi•ier gol. În capitolul
anterior am scris următorul cod în el:

"Salut Lume!"

•i apoi am executat scriptul făcând clic pe butonul Run. După ce face•i clic pe butonul Run, interpretul Python:

• a început func•ionarea

• a tradus (interpretat) scriptul nostru (print („Bună ziua, lume!”)) În zerouri •i unii

• a transmis zero •i unele către procesor

• a primit ie•irea de la procesor

• a afi•at ie•irea primită de la procesor în a treia fereastră (dreapta),

• opera•ia terminată.

În acest fel, am pornit interpretul Python în modul script.

Interpretul Python poate func•iona •i în alt mod, adică în modul interactiv. Modul interactiv este adesea denumit Python Shell. A treia fereastră
(în dreapta) este responsabilă pentru modul interactiv din mediul Repl.It. În modul script, a treia fereastră este un tabel în care este afi•at
rezultatul executării programului. În modul interactiv, pute•i utiliza a treia fereastră atât pentru scrierea codului, cât •i pentru afi•area rezultatului.
În modul interactiv, introduce•i codul în fereastra din dreapta •i apăsa•i Enter pentru a ob•ine rezultatul afi•at mai jos. Acest mod de func•ionare
este, de asemenea, cunoscut sub numele de REPL. Fiecare literă a acestui acronim corespunde opera•iei relevante pe care Python Shell o
efectuează când este apăsat Enter. A•adar:

12
 R (Citire) înseamnă citire
E (Eval) înseamnă evaluare (calcul) P (Tipărire) înseamnă
afi•are
L (Buclă) înseamnă revenirea la starea ini•ială.

Să urmărim modul în care func•ionează Python Shell, folosind „Bună ziua, lume!” program ca exemplu nostru. După pornirea mediului
Repl.It, caracterul> apare în a treia fereastră. Acesta este a•a-numitul semn de prompt care indică locul de introducere a codului. Python
Shell este în modul de a•teptare.

După ce introduce•i următorul text în fereastra din dreapta:

"Salut Lume!"

•i apăsa•i Enter, Shell-ul Python va:

• Citi•i ® informa•iile dvs.

• Evalua•i (E) contribu•ia dvs. (în acest caz, nu este nimic de evaluat)

• Imprima•i (P), adică afi•a•i ie•irea pe ecran

• Bucla (L), adică revenirea la starea de a•teptare.

Ie•irea a fost afi•ată în fereastra din dreapta •i semnul prompt de mai jos a indicat faptul că Shell a revenit la starea de a•teptare.

Vă rugăm să re•ine•i că linia de cod de mai sus, în timp ce rulează în modul script (fereastra din mijloc), nu va returna nicio ie•ire (func•ia de
imprimare lipse•te). Acest lucru nu s-a întâmplat în modul interactiv, deoarece afi•area automată a ie•irii (P în acronimul REPL) este una dintre
etapele modului interactiv. Nu trebuie să vă aminti•i să insera•i instruc•iunea Print, deoarece Python Shell afi•ează automat rezultatul. În timp ce
adăugarea declara•iei Print în modul script se schimbă foarte mult, nu contează deloc în modul interactiv.

Modul interactiv este folosit pentru a prezenta sau testa bucă•i mici de cod la un moment dat. Un cod introdus în Python Shell nu poate fi salvat.
Când codul devine multi-linie, modul script nu mai este convenabil. Din motive de claritate a problemelor introduse, la început vom lucra în
modul interactiv. De-a lungul timpului, când codul nostru încetează să mai fie o singură linie, vom începe să lucrăm în modul script.

Înainte de a trece la noi probleme, să analizăm „Bună ziua, lume!” programează din nou.

print („Bună ziua, lume!”)

Aici pute•i vedea declara•ia de imprimare •i paranteză de deschidere. Apoi, există un ghilimel •i un •ir de aproximativ o duzină de caractere,
urmat de al doilea ghilimel •i paranteză de închidere. În Python, expresiile precum print sunt denumite func•ii. Func•ia noastră se nume•te
print. Sarcina func•iei de imprimare este de a afi•a parametrii trecu•i către aceasta. Parametrii pe care îi transmitem func•iei sunt plasa•i în
paranteze, după numele func•iei. În acest caz, parametrul care

13
trecem la func•ia de imprimare este „Bună ziua, lume!” (•irurile sunt plasate între ghilimele). Func•ia de tipărire afi•ează parametrul trecut în
parantezele de pe ecranul computerului. În cazul nostru este „Bună ziua, lume!” text. Tocmai am început să analizăm gramatica Python (sau
mai precis, sec•iunea sa numită sintaxă). La fel ai făcut •i în •coala elementară în timpul orelor de limbă maternă. În timpul cursului de
gramatică, a•i aflat despre păr•i ale propozi•iei, cum ar fi subiectul •i predicatul. Aici vom avea tipuri •i operatori, instruc•iuni de atribuire,
condi•ii, bucle, func•ii •i clase. Să aruncăm o privire mai atentă la primul dintre ele, adică la tipuri •i operatori.

14
Tipuri simple și operatori
•tim deja cum să folosim Python pentru a scrie un program care afi•ează un text pe ecran. Este un început bun. Dar cum să-l faci pe Python să

facă toate aceste lucruri uimitoare pe care le pot face computerele moderne? Pentru a afla acest lucru, trebuie să afla•i mai multe despre

Python în sine.

Mai întâi, să vedem dacă Python poate afi•a mai mult decât •iruri. Poate Python să afi•eze numere?

Tasta•i 3 în fereastra din dreapta •i apăsa•i Enter. Ve•i vedea numărul trei în linia de mai jos.

>3
3

Iată ce a făcut Python Shell după ce Enter a fost apăsat:

1. R - a citit ceea ce a•i introdus

2. E - l-a evaluat (în acest caz calculul a fost din nou banal)

3. P - a afi•at ie•irea

4. L - a revenit la starea ini•ială •i a afi•at semnul prompt.

•i Python poate rezuma numere?

>3+5
8

Poate.

Dar multiplicarea?

>3*5
15

•i împăr•ind?

> 3/2
1.5

Acum să scriem o expresie pu•in mai complexă, de ex

> 3 * (2 + 4) - 3 15

Functioneaza!

15
Să încercăm încă o dată. Iată ce a făcut Python Shell după ce Enter a fost apăsat:

1. v-a citit codul (Citi•i)

2. a evaluat rezultatul (3 * (2 + 4) - 3 = 15) (Eval)

3. a afi•at rezultatul pe ecran (Print)

4. a revenit la starea de a•teptare (Loop).

Aceasta înseamnă că Python poate adăuga, scădea •i înmul•i numerele •i poate în•elege nota•ia paranteză. Python poate adăuga •iruri de
caractere? Să verificăm:

> "Bună ziua lume" + "!" Salut

Lume!

Poate. Opera•ia de adăugare a •irurilor se nume•te concatenare. Îi poate înmul•i?

> "Bună ziua lume" * "!"

Traceback (ultimul apel cel mai recent): fi•ierul „<stdin>”,
linia 1, în <modul>
TypeError: nu se poate multiplica secven•a cu non-int de tipul 'str'

Am primit o eroare ciudată. Erorile sunt modul în care Python comunică faptul că ceva nu a mers bine. După cum vede•i, Python nu
poate multiplica •irurile.

Ceea ce am început să facem este examinarea diferitelor tipuri de date care există în Python (deocamdată •tim doar •irurile •i numerele) •i
opera•iunile permise pe aceste date (deocamdată am învă•at adunarea, scăderea, înmul•irea •i împăr•irea pentru numere •i concatenări
pentru •iruri).

Există mai multe tipuri în Python. Diviziunea de bază clasifică tipurile în simple •i complexe. Tipurile complexe vor fi discutate mai târziu
în acest manual. Tipurile simple includ:

• întreg

• pluti

• •ir

• bool

• Nici unul

Dacă dori•i să verifica•i tipul valorii introduse, pute•i utiliza func•ia de tip pentru aceasta. La fel cum func•ia de imprimare este utilizată
pentru a afi•a pe ecran valoarea trecută în paranteze, func•ia de tip este utilizată pentru a afi•a tipul acestei valori.

Să verificăm tipul valorii 3.

16
 > tasta•i (3)
<class 'int'>

Python a afi•at <class 'int'>. Deocamdată nu vom avea de-a face cu cuvântul clasă. Pe lângă el, putem vedea •i: int. Int este o abreviere
pentru întreg, care înseamnă un tip întreg. Este unul dintre cele trei tipuri numerice acceptate în Python.

Cele mai populare tipuri numerice din Python includ:

• tip întreg

• tip virgulă mobilă

Tip întreg

Tipul întreg reprezintă numere întregi. Valorile care apar•in tipului întreg sunt de ex

>3
> 24562
> - 5364

Valorile acceptabile pentru un anumit tip sunt adesea denumite literale. Pute•i considera valorile de mai sus ca fiind exemple de literali întregi
valabili.

Tipul întreg acceptă to•i operatorii matematici de bază, cum ar fi:

• Adăugare

• Scădere -

• Multiplicare *

• Divizia /

• Exponen•ierea **

• Divizia întregi //

• Restul din diviziune (modulo)%

Tipul cu virgulă mobilă

Tipul cu virgulă mobilă reprezintă numere reale. Exemple de litere în virgulă mobilă sunt următoarele:

> 3.4
> 4,25
> - 6.32314
>. 4

Tipurile numerice pot fi comparate între ele:

17
 > 3 == 3.0
Adevărat

> 4 == 2
Fals
> 5 <3
Fals
> 45,3> = 10
Adevărat

Grupul de operatori rela•ionali include următoarele:

• Egal cu ==

• Nu este egal cu! =

• Mai mare decât>

• Mai mare sau egal cu> =

• Mai pu•in de <

• Mai mic sau egal cu ⇐

Operatorul rela•ional î•i calculează expresia din dreapta, apoi calculează expresia din stânga,
•i returnează True dacă ambele valori primite sunt egale; altfel se întoarce False. Una dintre cele două valori de tip boolean. •i care este tipul
boolean?

Tip boolean (bool)

Tipul boolean reprezintă o valoare logică în Python. Este nevoie de una dintre cele două valori: Adevărat sau Fals. Literele booleene sunt după cum

urmează:

> Adevărat

Adevărat

> Fals
Fals

Tipurile booleene func•ionează pe to•i operatorii matematici. În opera•iile matematice, True este tratat ca 1 •i False ca 0.

> 3 + Adevărat

4
> 2 * Fals
0
> 5 / Adevărat

5.0

În plus, tipurile booleene acceptă trei operatori logici pe care îi cunoa•tem dintr-un curs de bază de logică: •i, sau •i nu.

18
Operatorul •i corespunde unei conjunc•ii logice. Conjunc•ia este adevărată numai atunci când ambele argumente sunt adevărate.
Corespunde conjunc•iei „•i” dintr-o propozi•ie.

> Adevărat •i Adevărat

Adevărat

> 5> 3 •i 1 <3 Adevărat

> Adevărat •i Fals

Fals
> 5> 3 •i 1> 3 Fals

Tabelul adevărului pentru conjunc•ie este după cum urmează:

p q p și q

1 1 1

1 0 0

0 1 0

0 0 0

Operatorul sau este o alternativă logică. Alternativa nu este adevărată numai atunci când ambele argumente nu sunt adevărate.

Corespunde conjunc•iei „sau” dintr-o propozi•ie.

> Adevărat sau Fals

Adevărat

> 5> 3 sau 1> 3

Adevărat

> Fals sau Fals

Fals
> 5 <3 sau 1> 3
Fals

Tabelul adevărului pentru alternativă este după cum urmează:

p q p sau q

1 1 1

1 0 1

0 1 1

0 0 0

Operatorul not corespunde unei nega•ii logice. Negarea este o ac•iune unară. Întoarce o negare a unui argument.

19
 > nu este adevărat

Fals
> nu 5> 3
Fals
> nu Fals
Adevărat

> nu 1> 3
Adevărat

Tabelul adevărului pentru negare este după cum urmează:

p nu p

1 1

0 1

Tipul șirului

Tipul de •ir reprezintă •iruri în Python. Un •ir este creat prin încadrarea •irului de caractere între ghilimele simple sau duble. Exemple de litere
•ir:

> „Lui John îi place Mary”

Lui John îi place Mary

> „Lui John îi place Mary”

Lui John îi place Mary

În acest fel pute•i crea •iruri cu o singură linie. Dacă dori•i să crea•i un •ir cu mai multe linii, ar trebui să utiliza•i trei apostrofe.

> „” „Lui John îi place Mary,

. . . Lui Mary îi place lui John "" "

„Lui John îi place Mary, \ n Lui Mary îi place John

Caracterul \ n din linia de ie•ire este modul Python de a-•i aminti loca•ia caracterului newline.

•irurile pot fi adăugate:

> „Ioan” + „aprecieri” + „Maria” + „.” Lui John îi place

Mary.

Opera•ia de adăugare a •irurilor se nume•te concatenare. În plus, •irurile pot fi înmul•ite cu numere întregi. Această opera•ie se nume•te
multiplicare a •irului. Restul operatorilor matematici nu func•ionează pe •iruri.

20
Corzile pot fi comparate.

•irurile sunt comparate alfabetic, literă cu literă. Literele mici sunt mai mari decât literele mari. Spa•iul sau niciun caracter nu este întotdeauna mai
mic decât orice alt personaj.

> „Ioan” == „Ioan”

Adevărat

> 'John' == 'john'

Fals
> "john"> "John"
Adevărat

> „john”> „lui John îi place„ False

Niciun tip

În Python, tipul None reprezintă lipsa de valoare. Se folose•te de obicei pentru a indica lipsa datelor. Un literal de tipul None este după
cum urmează:

> Niciuna

Anexa B con•ine lista tuturor tipurilor de bază Python •i lista tuturor operatorilor disponibili în Python.

Turnare - conversie de tipuri

Uneori poate dori•i să modifica•i tipul valorii deja introduse. Modificarea tipului de valoare se nume•te conversie sau distribuire. Acest lucru
se face cu utilizarea func•iilor de turnare. Fiecare tip (cu excep•ia tipului None) are func•ia de turnare:

• func•ia de turnare la tipul întreg: int ()

• func•ia de turnare la tipul cu virgulă mobilă: float ()

• func•ia de turnare la tipul •irului: str ()

• func•ia de turnare la tipul boolean: bool ()

Dacă dori•i să arunca•i tipul întreg (de ex. 5) la tipul cu virgulă mobilă, introduce•i doar:

> plutitor (5)

5.0

În acest fel, din tipul întreg (literal 5) a•i ob•inut tipul cu virgulă mobilă (literal 5.0). Aruncarea în direc•ia opusă (de la tipul cu virgulă mobilă
la tipul întreg) rotunje•te valoarea:

21
 > int (4.2)
4
> int (4.9)
4

Nu toate distribu•iile sunt posibile. Dacă încerca•i să arunca•i tipul •irului la tipul întreg, este posibil să primi•i o eroare.

> int ("1024")

1024
int> „Ioan îi place Maria”)
Traceback (ultimul apel cel mai recent): fi•ierul „<stdin>”,
linia 1, în <modul>
ValueError: literal nevalid pentru int () cu baza 10: „lui John îi place Mary”

Dacă •irul de caractere dintre ghilimele nu creează un literal întreg, încercarea de a-l converti în tipul întreg va duce la o eroare. În exemplul
nostru, Python •tie să convertească •irul de caractere „1024” într-un număr întreg, dar nu •tie cum să convertească •irul „Ioan îi place Maria”
într-un număr întreg. Ne informează despre aceasta aruncând o eroare. Când apare o eroare, Python încetează programul •i afi•ează
informa•ii despre eroare. În cazul nostru, este un ValueError: un literal nevalid trecut la func•ia int cast: „Ioan îi place Mary”.

Comentarii

Comentariile sunt folosite pentru a plasa informa•ii în cod pentru persoanele care le vor citi. Comentariile sunt create folosind simbolul #.

> int ("1024") # Aten•ie la aruncarea literelor gre•ite 1024

Când interpretul Python întâlne•te caracterul #, acesta ignoră toate caracterele ulterioare •i trece la linia următoare.

22
Exerci•ii

1. Determina•i tipul literelor (valorilor) următoare:

"Salut"
2
2.
2.0
„2”
4.55
- 4.3
54 + 5j
Adevărat

Nici unul

2. Determina•i tipul următoarelor rezultate ale expresiei:

2+2
2 + 2.
4/2
4/3
2. * 4
3 * „a”

3. Calcula•i media aritmetică a oricăror cinci numere.

4. Calcula•i următoarele expresii:

3 + 45 - 2,5 * 4 2 ̂ 3

3,5 * (3-2)
501,0 - 99,9999
10.0 / 4.0
10.0 // 4.0
5% 2
2 == 2
1! = 1
99> 1.1
Adevărat sau fals
2 == 2 sau 1! = 1
Adevărat •i Adevărat •i Fals
2 == 2 •i 99> 1.1 •i 1! = 1 nu este fals

nu 1! = 1

5. Corecta•i expresiile logice astfel încât fiecare expresie să returneze valoarea Adevărată.

23
 "asd" == "qwe"
3> 6
„ca” <= „anun•”
„z” <„n”
45! = 45

6. Efectua•i turnarea după cum urmează:

◦ arunca•i următoarele valori la tipul întreg: 15.5, 4.01, 4.99, -4.01, -4.99

◦ arunca•i următoarele numere la tipul cu virgulă mobilă: 0, 100, -4

◦ arunca•i următoarele numere la tipul boolean: 2, -6.1, 'a', "abc", 0, 0.0, "", ""

Vă rugăm să re•ine•i că singurele valori pe care operatorul bool le aruncă la False sunt 0, 0.0 •i un •ir gol. Toate valorile rămase sunt
exprimate în True. Valorile care după lansarea în bool au valoarea falsă se numesc Falsuri, iar cele care au valoarea adevărată sunt
denumite Adevăruri.

24
Variabile și declarație de atribuire
Problemele discutate până în acest punct ne permit să efectuăm calcule unice. Rezultatul este afi•at pe ecran. Dar dacă dori•i să utiliza•i
rezultatul ob•inut pentru alte calcule? Ave•i nevoie de ceva în care să vă pute•i stoca rezultatul. Nu pute•i realiza acest lucru numai cu tipuri •i
operatori. Ai nevoie de un nou element sintactic.

Ar fi convenabil să da•i valorii dvs. un anumit nume (de exemplu, Valoarea_mea mea), astfel încât ori de câte ori dori•i să utiliza•i această
valoare, o pute•i apela doar după nume (valoarea_meu). În programare, această func•ie este realizată de variabile. O variabilă este un
nume care indică valoarea. Îl pute•i imagina ca o cutie cu o etichetă. Eticheta con•ine numele casetei. Pute•i pune orice valoare în casetă.

>a=4
>

În exemplul de mai sus, am pus valoarea 4 în „caseta etichetată ca a”. Spunem că variabila a este atribuită cu valoarea 4.

>a
4

De data aceasta, „scoatem” con•inutul „din cutie” etichetat ca. Spunem că returnăm valoarea
stocat în variabil A.

Numele atribuit unei variabile este adesea denumit identificator. Identificatorii pot avea orice lungime. Python permite identificatorilor să fie
compu•i din litere, cifre •i caracterul de subliniere (_). Python face distinc•ie între litere mari •i mici, astfel încât identificatorii care diferă doar între
litere mari •i mici sunt diferi•i (valoarea_mi este o variabilă diferită de valoarea mea_). Identificatorul nu trebuie să înceapă cu un număr. În plus,
nu poate fi nici unul dintre cele 33 de cuvinte cheie (rezervate), de exemplu def, class. Un tabel care con•ine lista cuvintelor cheie Python poate fi
găsit în Anexa B.

Semnul = se nume•te operator de atribuire. Vă rugăm să nu-l confunda•i cu semnul de ecua•ie pe care îl cunoa•te•i din lec•iile de
matematică. Opera•ia operatorului de atribuire se reduce la calculul a ceea ce se află în partea dreaptă a operatorului •i atribuirea
rezultatului identificatorului (numele) din partea stângă a operatorului. Operatorul de atribuire împreună cu laturile sale din stânga •i din
dreapta se nume•te declara•ie de atribuire. Exemple de declara•ii de atribuire:

>a=3

Rezultatul calculelor din dreapta (3) este atribuit variabilei a.

>b=4*2+4

Rezultatul calculului din dreapta (12) este atribuit variabilei b. Variabila poate stoca date de orice tip:

25
 > valoarea_mea = 3
> my_string = "asd"
> x = Adevărat

Pute•i introduce variabile în func•ie

> a = 2,5
> print (a)
2.5
> tasta•i (a)
pluti
> int (a)
2

Pute•i efectua opera•ii pe variabile caracteristice tipului stocat:

Exemplul 1

>a=4
>b=5
>c=a*b

Exemplul 2

> d = "lui John îi place"

> e = "mary".
>f=d+e

Aminti•i-vă: Operatorul = are o func•ie diferită în programare decât în matematică. Operatorul = în matematică indică egalitatea. Egalitatea este
o afirma•ie care spune că ceea ce este în dreapta
este egal cu ceea ce este în stânga. În programare, operatorul = înseamnă atribuire. Atribuire înseamnă calcularea a ceea ce este în partea
dreaptă a operatorului •i salvarea rezultatului sub numele din partea stângă a operatorului. În special, linii precum:

>a=4
>a=a+2

nu au nici un sens în matematică. A doua linie con•ine o afirma•ie falsă (4 = 4 + 2). În programare, pe de altă parte, a doua linie înseamnă:
calcula•i ceea ce este în dreapta (4 + 2, adică 6) •i atribui•i rezultatul în partea stângă (adică variabilei a). Înainte de executarea liniei (2),
valoarea variabilei a era 4. După executarea acestei linii, valoarea a va fi 6.

Deoarece semnul = în Python este un operator de atribuire, există vreun echivalent al mărcii de egalitate matematică din Python?
Echivalentul operatorului de egalitate matematică în programare este

26
unul dintre operatorii rela•ionali discuta•i în capitolul 3, adică operator de egalitate ==. Pe lângă operatorul de egalitate ==, Python are un alt
operator care îndepline•te un rol similar, adică este operatorul de identitate.

Diferen•a de func•ionare dintre ace•ti doi operatori este bine ilustrată de numele lor. Operatorul de egalitate verifică dacă valorile tipurilor
comparate sunt egale. În special, un tip întreg cu valoarea 4 este egal cu un tip în virgulă mobilă cu valoarea 4.0.

> 4 == 4.0
Adevărat

Cu toate acestea, acestea nu sunt acelea•i valori identice (sunt de tipuri diferite). Pute•i verifica acest lucru folosind operatorul de
identitate.

> 4 este 4.0

Fals

Exerci•ii

1. Crea•i variabile apar•inând următoarelor tipuri:

◦ întreg

◦ punctul de plutire

◦ şir

◦ bool

2. Crea•i variabila person_age •i atribui•i-i o valoare de tip întreg. Afi•a•i valoarea •i tipul variabilei age_person pe ecran

3. Arunca•i variabila în virgulă mobilă cu valoarea de 4,3 în tipul întreg. Arunca•i variabila de tip •ir cu valoarea „45” în tipul întreg.

4. Scrie•i un program care afi•ează •irul „Bună ziua, <Numele tău>!! Pe ecran. Fă-•i numele stocat într-o variabilă de tip •ir.

5. Declara•i mai multe variabile de diferite tipuri •i testa•i func•ionarea următorilor operatori pe acestea:

-
*
/
**

6. Declara•i două variabile corespunzătoare laturilor dreptunghiului •i număra•i aria •i perimetrul acestuia. Formula pentru:

◦ aria unui dreptunghi: P = a * b

◦ perimetrul unui dreptunghi: L = 2 * a + 2 * b

27
 7. Declara•i variabila corespunzătoare diametrului cercului •i calcula•i aria •i circumferin•a acestuia. Formulele relevante sunt după cum
urmează:

◦ zona cercului P = pi * r ^ 2̂

◦ circumferin•a cercului L = 2 * pi * r

Să presupunem 3.14 ca valoare a lui pi.

28
Condiții
Programele pe care le-am scris până acum au efectuat acela•i set de afirma•ii de fiecare dată. Indiferent de datele pe care le introduce•i
într-un astfel de program, de fiecare dată se va executa o secven•ă identică •i liniară de comenzi (adică face•i ceva, aminti•i-vă ceva, scrie•i
ceva pe ecran).

>a=7
>b=5
> c = 9 / (ab)
> int (c)
4

Ce se întâmplă dacă în Exerci•iul 2 din capitolul anterior am dori ca programul să imprime pe ecran mesajul „persoana este adultă” în
locul vârstei stocate, dacă valoarea variabilei age_person este mai mare sau egală cu 18? Nu ve•i realiza acest lucru folosind doar tipuri,
operatori •i variabile.

Pentru o astfel de sarcină ve•i avea nevoie de un alt element sintactic. Se presupune că programul nostru se comportă diferit în func•ie de
valoarea pe care o ia variabila age_person. Afirma•ia care vă permite să „ramifica•i” fluxul de control se nume•te condi•ie.

vârsta = 20
dacă vârsta> = 18:
print („Adult”)

Am folosit aici afirma•ia if. Sintaxa instruc•iunii if poate fi reprezentată schematic după cum urmează:

dacă expresia booleană:

statement1
declara•ie2

Cuvântul if este urmat de o expresie booleană (Adevărat, Fals) •i de două puncte. Cuvântul if împreună cu expresia booleană care îl
urmează formează o condi•ie. Mai jos, indentat, plasa•i un bloc al codului care trebuie executat dacă expresia booleană con•inută în
condi•ie este adevărată (adică returnează True).

Re•ine•i indentarea din cod. În multe limbi, acoladele sunt folosite pentru a eviden•ia blocul de cod. În Python, indentarea este utilizată pentru
aceasta. De aceea spa•iul alb este atât de important în Python. Plasarea unei declara•ii la un nivel de indentare gre•it va duce la defectarea
programului. În cazuri speciale, va rezulta o eroare. PEP8 recomandă introducerea indentărilor în cod folosind patru spa•ii.

•i ce se întâmplă dacă condi•ia nu este îndeplinită? Interpretul Python va sări peste liniile de cod din interiorul condi•iei, va merge mai departe, va

ajunge la sfâr•itul scriptului •i va termina opera•iunea. Pentru a sus•ine un caz când condi•ia nu este îndeplinită, se folose•te instruc•iunea if /

else.

29
 vârsta = 20
dacă vârsta> = 18:
print („Adult”)
altceva:

print („Minor”)

Declara•ia condi•ională if / else poate fi prezentată utilizând următoarea schemă:

dacă expresia booleană:

statement1
declara•ie2
altceva:

declara•ie3
declara•ie4

Blocul de cod din instruc•iunea else va fi executat dacă condi•ia nu este îndeplinită (adică returnează Fals).

Pentru a pune mai multe condi•ii în cod (mai multe ramuri), se folose•te instruc•iunea elif (prescurtare pentru elseif). Să presupunem că
dori•i ca programul dvs. să fie tipărit:

• „adult” - dacă valoarea variabilei de vârstă este mai mare sau egală cu 18

• „adolescent” - dacă valoarea vârstei variabile se încadrează în intervalul (16, 18)

• • „minor” - în caz contrar

vârsta = 20
dacă vârsta> = 18:

print („Adult”)
vârsta elif> = 16 •i vârsta <18
print („Adolescent”)
altceva:

print („Minor”)

Condi•ii suplimentare pot fi adăugate prin duplicarea declara•iei elif. Secven•a if-elif-else este o imagine completă a enun•ului condi•ional.

Exerci•ii

1. Scrie•i un program care va fi afi•at pe ecran dacă valoarea variabilei este divizibilă cu 7

2. Scrie•i un program care va afi•a textul „Valoarea variabilei este impar” pe ecran dacă valoarea variabilei este impar, iar în caz contrar
afi•a•i textul „Valoarea specificată este pară”.

3. Scrie•i un program care va afi•a pe ecran dacă valoarea variabilă este divizibilă cu 7, cu 5
sau cu 3. Dacă valoarea variabilei nu este divizibilă cu niciunul dintre aceste numere, programul ar trebui să afi•eze un mesaj adecvat.

30
4. Scrie•i un program care va afi•a următoarele rezultate pentru variabila specificată:

◦ diferen•a dintre valoarea acestei variabile •i 17 dacă diferen•a este mai mică de 17

◦ o pătratul acestei diferen•e, altfel.

5. Scrie•i un program care returnează suma celor trei numere date. Dacă toate cele trei numere sunt
egal, programul va returna valoarea triplă a sumei lor ..

31
Bucle
Până acum, când rulam programul, fiecare dintre liniile de cod pe care le-am scris a fost executată exact o dată. Cu toate acestea, atunci
când rulăm un joc bun, îl putem juca câteva ore sau chiar zile. Asta înseamnă că codul acestui joc con•ine un număr mare de linii •i timp de
câteva zile computerul
merge pe fiecare dintre aceste linii o singură dată? Nu, dar nu ve•i ob•ine acest efect doar cu tipurile, operatorii, instruc•iunile de atribuire •i
condi•iile. Ai nevoie de un alt element sintactic.

Jocul nostru folose•te o structură care în programare se nume•te buclă. O buclă este o instruc•iune pentru a repeta blocul de cod indicat.

Există două tipuri de bucle în Python:

• while loop

• pentru buclă

În timp ce bucla

Bucla while se mai nume•te •i buclă condi•ională. Execută blocul de cod pe care îl con•ine atâta timp cât expresia booleană din buclă este
îndeplinită.

x=0①
în timp ce x <5: ②
x=x+1③
print (x) ④

① Valoarea 0 este atribuită variabilei x.

② Condi•ia buclei înseamnă: face•i următoarele, atâta timp cât x <5

③ Prima linie a corpului buclei. Cre•te valoarea x cu una. După executarea acestei linii,
valoarea lui x va fi 1.

④ A doua linie a corpului buclei. Tipăre•te valoarea curentă a lui x pe ecran. Valoarea curentă

din variabila x este 1.

La sfâr•itul corpului buclei, interpretul Python revine la starea buclei. Se verifică dacă condi•ia buclei este încă îndeplinită (1 <5). Dacă
condi•ia este îndeplinită, execută din nou corpul buclei. După
următoarea execu•ie a corpului, valoarea lui x va fi 2. Secven•a se repetă atâta timp cât este îndeplinită condi•ia buclei, adică atâta timp cât
valoarea variabilei x este mai mică de 5. Prima valoare a variabilei x care va fi nu îndepline•te condi•ia buclei este 5. X atinge valoarea 5 în a
cincea buclă. Interpretul Python va imprima valoarea pe ecran •i apoi va merge din nou la starea buclei, care de data aceasta nu va fi îndeplinită.
În acest moment, interpretul Python va încheia execu•ia buclei deoarece condi•ia buclei nu mai este îndeplinită.

Bucla while poate fi reprezentată de următoarea schemă:

32
 în timp ce expresia booleană:
statement1
declara•ie2

Bucla while constă dintr-o stare •i un corp. Cuvântul „în timp ce” urmat de o expresie booleană •i de două puncte se nume•te condi•ie de
buclă. Corpul buclei este blocul de instruc•iuni plasat direct sub ea. Corpul buclei se termină cu o instruc•iune cu acela•i nivel de indentare
sau cu cea inferioară ca •i condi•ia buclei •i, în absen•a unei asemenea instruc•iuni, cu sfâr•itul fi•ierului. Execu•ia corpului buclei se repetă
atâta timp cât este îndeplinită condi•ia buclei. Notă! Dacă condi•ia buclei este întotdeauna îndeplinită, se prime•te o buclă infinită. În special,
dacă scrie•i:

în timp ce este adevărat:

print („Bună”)

interpretul Python va începe să afi•eze Hi pe ecran din nou •i din nou. O buclă infinită poate fi întreruptă cu o comandă rapidă Ctrl + C
(a•a-numitul semn de pauză).

Pentru bucle vor fi discutate în capitolul următor, imediat după discutarea tipurilor complexe.

Exerci•ii

1. Scrie•i un program care afi•ează toate numerele naturale cuprinse între 0 •i 50.

2. Scrie•i un program care afi•ează toate numerele pare între 0 •i 100.

3. Scrie•i un program care afi•ează pătratele tuturor numerelor între 0 •i 10.

4. Folosind bucla, scrie•i numere de la -20 la 20. Apoi scrie•i:

◦ primele 6 numere

◦ ultimele 6 numere

◦ toate numerele pare

◦ toate numerele, cu excep•ia cifrei 5

◦ toate numerele până la cifra 7 inclusiv

◦ toate numerele divizibile cu 3

◦ suma tuturor numerelor

◦ suma numerelor mai mari sau egale cu 4

◦ toate numerele •i puterile lor

◦ toate numerele •i valorile lor pentru modulul 10

5. Scrie•i un program care afi•ează numere care sunt multipli de 5 •i sunt divizibili cu 7 în intervalul 1500 - 2700.

6. Scrie•i un program care scrie numere de la 0 la 6 •i omite 3 •i 6. Face•i acest lucru în două versiuni: cu •i fără declara•ia continue.

33
Tipuri complexe

În plus fa•ă de tipurile de bază discutate în capitolul trei, există •i tipuri complexe în Python. Tipurile complexe sunt containere pentru tipuri
simple. Pute•i stoca multe valori în ele. Tipurile complexe de bază din Python includ:

1. Listă (listă ang.)

2. Tuple (ang. Tuplu)

3. Dict (ang. Dict)

4. Set (set ang.)

Lista •i setul sunt cele mai frecvent utilizate tipuri complexe din Python.

Listă

O listă este un container în care pute•i plasa orice număr de valori de orice tip. Exemple de litere de listă sunt după cum urmează:

> [] # Lista goală []

> [1] # Listă cu un singur articol [1]

> [1, 4] # Lista cu două articole [1, 4]

> [1, 4, „Lui John îi place Mary”, -4,5] # Listă cu mai multe articole [1, 4, „Lui
John îi place Mary”, -4,5]

O listă poate fi atribuită unei variabile:

> a_list = [1, 3.4, 0]

Pute•i adăuga două liste împreună (concatenarea listelor):

> list_1 = [1, 3.4]

> list_2 = [-4,5, 0]
> list_1 + list_2
[1, 3.4, -4.5, 0]

O listă poate fi înmul•ită cu un număr (înmul•irea listei):

> list_1 = [1, 2, 3]

> list_1 * 2
[1, 2, 3, 1, 2, 3]

34
Folosind func•ia len, pute•i verifica lungimea listei:

> a_list = [0, 4,5, 2,32, -5]

> len (a_list)
4

Indexurile oferă acces la elementele individuale ale listei. Primul articol al listei are index 0. Următorul articol are indexul 1. Indexul
ultimului articol al listei este lungimea listei minus 1. La indexurile individuale ale listei se face referire folosind paranteze pătrate.

> a_list = [1, 3.4, -5, 0, 3, 4, 5]

> a_list [0] # primul element din listă 1

> a_list [1] # al doilea element din listă

3.4
> a_list [len (a_list) -1] # ultimul element al listei 5

Re•ine•i că primul elementul listei are index 0. Al doilea are index 1. Aceasta este o cauză frecventă a erorilor. Listele din Python sunt
indexate de la 0.

Python acceptă, de asemenea, indicii inversi. Ultimul element al listei are index -1, lângă ultimul are index -2, iar primul are index -lungimea
listei.

> a_list = [1, 3.4, -5, 0, 3, 4, 5]

> a_list [-1]
5
> a_list [-2]
4
> a_list [-len (a_list)]
1

Fapt amuzant

Python tratează •irurile ca un tip special de listă constând din caractere unice. •irurile acceptă toate opera•iunile de pe listele discutate mai
sus.

Pute•i verifica lungimea •irului cu func•ia len:

> a_string = "Lui John îi place Mary"

> len (a_string)
11

Caracterele individuale ale •irului pot fi accesate folosind nota•ia index.

35
 > a_string = "Lui John îi place Mary"
> a_string [0]
'A'
> a_string [4]
'm'
> a_string [-1]
'A'

Dic•ionarul este un alt tip complex utilizat frecvent în Python.

Dicţionar

Dic•ionarul nu este un tip indexabil, adică nu are indici. Numele său reflectă foarte bine caracterul său. La fel ca în dic•ionarele lingvistice
pute•i găsi termenul •i defini•ia acestuia, în tipul de dic•ionar ave•i cheia •i valoarea. Un meniu de restaurant are o structură de dic•ionar în
care numele felurilor de mâncare sunt cheia, iar valorile sunt pre•urile acestora. O agendă telefonică are o structură de dic•ionar în care
tastele sunt numele persoanelor, iar valorile sunt numerele lor de telefon. Un dic•ionar stochează perechi cheie-valoare. Putem spune că o
listă este un caz special al dic•ionarului, unde tastele sunt numere naturale consecutive (indici).

Exemple de litere din dic•ionar sunt după cum urmează:

> {} # Dic•ionar gol {}

> {'key1': 1} # dic•ionar cu un singur articol {'key1': 1}

> {'key_1': 1, 'key_2': 4} # Dic•ionar cu două articole {'key_1': 1, 'key_2': 4}

> {'a': 1, 'b': 4, 'c': "Lui John îi place Mary", 'd': -4.5} # Dic•ionar cu mai multe articole {'a': 1, 'b': 4, ' c ':' Ioan îi
place Maria ',' d ': -4.5}

Tine minte!

O cheie din dic•ionar trebuie să aibă o valoare unică. Acest lucru diferă de tipul dic•ionarului din agenda în care pute•i găsi zeci de nume
John Smith.

Pentru a vă referi la elemente individuale ale dic•ionarului, utiliza•i tasta.

> a_dict = {'a': 1, 'b': 4, 'c': lui Ioan îi place Maria ", 'd': -4.5}
> a_dict ['a']
1
> a_dict ['c']
„Lui John îi place Mary”

36
Pentru buclă

Bucla for, ca orice altă buclă, este utilizată pentru a repeta un bloc de instruc•iuni, dar o folosim într-un mod u•or diferit. Bucla for trece prin
elementele ulterioare de tip complex, de fiecare dată executând instruc•iunile con•inute în corpul său.

a_list = [1, 3.4, -5, 0] ①

pentru elementul dintr-o listă: ②

print (articol) ③

1
3.4
-5
0

① O variabilă a_list este alocată unei liste cu 4 articole.

② Începem să parcurgem articolele din lista noastră cu patru articole. În interiorul corpului, ne vom referi la următorul

elemente ale buclei folosind un identificator.

③ Corpul buclei. Tipărim elementul curent al listei pe ecran.

Bucla for este a•a-numitul zahăr sintactic. Nu introduce nimic nou în colec•ia noastră substan•ială de instrumente de dezvoltare. Acela•i
efect poate fi ob•inut prin utilizarea elementelor sintactice învă•ate anterior.

a_list = [1, 3.4, -5, 0] idx = 0

while idx <len (a_list):

item = a_list [idx]
print (articol)
idx = idx + 1

1
3.4
-5
0

Cu toate acestea, datorită introducerii buclei for, codul nostru este mai clar •i mai concis. Opera•iunea de parcurgere a tuturor articolelor dintr-o
colec•ie se nume•te iterare prin articolele sale. Cu bucla for, pute•i repeta cu u•urin•ă elementele colec•iei.

Pute•i itera după caracterele •irului:

37
 a_string = „Lui John îi place Mary” pentru
caracter în a_string:
print (caractere)

o
h

n
l

eu

k
e
M
A
r
y

Pute•i itera după tastele dic•ionarului.

a_dict = {'a': 1, 'b': 4, 'c': "Lui John îi place Mary", 'd': -4.5} pentru articolul din
a_dict:
print (articol)

'A'
'b'
„c”
"d"

38
Rezumatul părții I
Aici am terminat de discutat elementele sintactice de bază ale Python. Informa•iile prezentate în prima parte vă permit să scrie•i orice
program complex. Orice program de computer, joc sau portal web existent poate fi scris folosind acelea•i tipuri, operatori, declara•ii de
atribuire, condi•ii •i bucle.

Exerci•ii

1. Scrie•i un program care să afi•eze, unul câte unul, toate elementele împreună cu tipurile lor pentru o listă dată. Pentru următoarea listă:

a_list = [4, True, None]

programul ar trebui să afi•eze următorul rezultat:

4 <class 'int'>
Adevărat <clasa 'bool'>
None <class 'NoneType'>

1. O matrice de 10 elemente este dată: a_list = [1, 3, 5, 2, 5, 6, 7, 4, 9, 7]. Scrie•i un program care tipăre•te:

◦ toate cifrele,

◦ primele 6 cifre,

◦ ostatnich cyfr,

◦ toate cifrele pare,

◦ toate cifrele de pe indici impari,

◦ toate cifrele, cu excep•ia cifrei 5,

◦ toate cifrele până la cifra 7 inclusiv,

◦ toate cifrele divizibile cu 3,

◦ suma tuturor cifrelor,

◦ suma cifrelor mai mare sau egală cu 4,

◦ cea mai mică •i cea mai mare cifră.

2. Scrie•i un program care pentru numărul dat de cuvinte, de ex. A_list = ['cat', 'primer', 'window', 'computer'] va afi•a articolele ulterioare ale
listei împreună cu informa•ii despre lungimea acestor elemente.

3. Scrie•i un program care pentru lista dată de cuvinte, de ex

list_of_words = ["spam", "tabel", "spam", "maro", "aer", "malware", "spam", "sfâr•it"]

va afi•a numai articolele din listă care nu au valoare „spam”. În plus, dacă valoarea articolului din listă este „malware”, programul ar trebui să
înceteze opera•iunea imediat. Folosi•i declara•ia de pauză. Căutare

39
în Internet pentru informa•ii despre cum func•ionează declara•ia de pauză.

40
Partea II Refactorizarea codului

41
Introducere
Declara•ia de atribuire, condi•ia •i bucla sunt suficiente pentru a scrie orice aplica•ie sau joc. În acest moment este posibil să nu-l vede•i
încă, dar pute•i scrie orice program complex folosind tehnicile pe care le-a•i învă•at. Ai nevoie doar de pu•ină practică pentru asta

Acum, când •tii să scrii programe, este timpul să înve•i să le scrii perfect. Un program scris doar cu instruc•iuni de atribuire, condi•ii •i bucle va
func•iona, dar codul său va func•iona
să fie greu de citit •i dezvoltat. Acesta va con•ine multe repetări ale acelora•i linii ale codului. Introducerea unei singure modificări va necesita ca
programatorul să facă modificări în multe locuri din cod, care cel mai probabil vor fi împră•tiate pe sute de linii ale codului. Pentru a evita acest
lucru, dezvoltatorii încearcă să ofere codului lor o structură mai consistentă.

Unul dintre principiile de bază ale programării este descris cu acronimul DRY (Don'tRepeatYourself). Conform acestui principiu, ar trebui să
elimina•i orice repetare, adică linii identice ale codului. În acest fel, reduce•i semnificativ susceptibilitatea codului la erori •i facilita•i
dezvoltarea sa ulterioară.

Cele mai populare două metode de refactorizare a codului care implementează principiul DRY sunt următoarele:

1. Încapsularea blocurilor de cod repetitive în func•ii

2. Încapsularea blocurilor de cod repetitive în clase

Le vom discuta individual.

42
Gruparea codului în funcții
Cea mai simplă metodă de refactorizare a codului, care facilitează dezvoltarea •i între•inerea proiectului, este de a încapsula fragmente
repetitive de cod în func•ii. O func•ie este un bloc de cod.

Dacă observa•i un bloc de cod care se repetă în programul dvs., îl pute•i extrage, denumi •i apoi înlocui fiecare apari•ie a acestui bloc cu un apel
cu o singură linie format din numele blocului •i paranteze. În acest scop, au fost create func•ii.

A•i ajuns deja să cunoa•te•i două func•ii: tipărire •i tip. Acestea sunt func•ii încorporate în Python. A•i învă•at cum să le folosi•i. Acum ve•i
învă•a cum să vă crea•i propriile func•ii.

Să presupunem că programul dvs. con•ine un bloc repetat în mai multe locuri. Face•i ca acest bloc să imprime un mesaj pe ecran format din trei
linii de cod identice.

a = 24

dacă a / 2 == 0:
b=a/2
print („Prima linie de mesaj”) ①
print ("A doua linie de mesaj") print ("A treia linie
de mesaj") altfel:

b=a/3

# Undeva mai departe în cod

dacă b! = 1:
print („Prima linie de mesaj”) ②
print ("A doua linie de mesaj") print ("A treia linie
de mesaj")

Dacă dori•i să introduce•i o modificare în prima linie a mesajului, ar trebui să o face•i oriunde apare (în cazul nostru, în rândurile <1> •i <2>).
Acest lucru dublează probabilitatea de a face o gre•eală atunci când introduce•i modificări. În plus, este u•or să omite•i o repetare dacă există
multe dintre ele. Conform principiului DRY (Don'tRepeatYourself), ar trebui să elimina•i orice repetare observată în codul dvs.

În primul pas, extrage•i liniile repetate de cod •i da•i blocului extras

def print_communique ():

print ("Prima linie de mesaj") print ("A doua linie
de mesaj") print ("A treia linie de mesaj")

43
Codul de mai sus define•te func•ia print_communique. Defini•ia func•iei constă din cuvântul def urmat de numele func•iei (în cazul nostru, este
print_communique), paranteze •i două puncte. Blocul de cod indentat de mai jos se nume•te corpul func•iei. Corpul func•iei este un cod care va
fi executat de fiecare dată când func•ia este apelată. Defini•ia func•iei este plasată la începutul scriptului.

În al doilea pas, înlocui•i toate instan•ele celor trei linii repetate ale codului apelând func•ia print_communique. Apela•i func•ia introducând
numele acesteia urmat de deschiderea •i închiderea parantezelor.

print_communique ()

Uneori pute•i introduce parametrii de intrare între paranteze. Parametrii de intrare ai func•iei vor fi discuta•i mai târziu în acest capitol. După
refacturare, programul va avea următoarea formă:

def print_communique ():

print („Prima linie de mesaj”) ①
print ("A doua linie de mesaj") print ("A treia linie
de mesaj")

a = 24

dacă a / 2 == 0:

b=a/2
print_communique ()
altceva:

b=a/3

# Undeva mai departe în cod

dacă b! = 1:
print_communique ()

① După refactorizare, pentru a face o modificare în prima linie a mesajului va trebui să introduce•i

schimbarea într-un singur loc în cod.

O func•ie poate fi comparată cu o cutie neagră în care pune•i ceva. Caseta neagră procesează ceea ce a•i pus în ea •i returnează
rezultatul.

Prima noastră func•ie, adică print_communique, nu a luat niciun parametru de intrare •i nu a returnat nimic. A imprimat doar un mesaj pe trei
rânduri pe ecran.

A doua noastră func•ie, adică double_input, va lua un parametru de intrare •i va returna rezultatul. Sarcina sa este de a returna o valoare

dublată a parametrului de intrare.

44
 def double_input (x):
returnează 2 * x

Func•ia double_input acceptă un parametru de intrare. În corpul func•iei, vă ve•i referi la acest parametru folosind identificatorul x. Func•ia
are un corp cu o singură linie. După declara•ia return, introduce•i ceea ce dori•i să vă returneze func•ia. În cazul nostru, este o valoare dublă
a parametrului de intrare.

Valoarea returnată de func•ie poate fi tipărită pe ecran sau transferată unei variabile. Apela•i func•ia pentru mai multe argumente:

print (double_input (3))

a = double_input (10)
b = double_input (25)
c = double_input (2.0)
print (b)
print (c)

După implementarea codului de mai sus, va fi afi•at următorul rezultat:

>6
> 50
> 4.0

Să analizăm încă o func•ie. Următoarea noastră func•ie, adică sum_up, ia doi parametri la intrare •i le returnează suma la ie•ire. Programul
care implementează (execută) această func•ie are următoarea formă:

def sum_up (x, y): ①

returnează x + y ②

a = sum_up (3, 4) ③
b = sum_up (2,5, 7,5) ③
c = sum_up (4, -2) ③

print (a) ④
print (b) ④
print (c) ④

① Defini•i o func•ie numită sum_up care ia doi parametri de intrare: x •i y.

② Crea•i corpul func•iei sum_up. În această linie, ambii parametri sunt adăuga•i unul la altul,
iar rezultatul este returnat în exteriorul func•iei folosind instruc•iunea return.

③ Apela•i func•ia de trei ori pentru valori diferite ale parametrilor de intrare. Atribui•i restituit
valorile de ie•ire la variabile.

④ Imprima•i valorile stocate în variabilele a, b, c pe ecran.

45
Ca urmare a executării scriptului, pe ecran vor fi afi•ate trei valori:

7
10.0
2

46
Gruparea unui cod în clase
Închiderea blocurilor de cod repetitive în clase este o altă metodă comună pentru refactorizarea codului. Ideea de a structura codul ca o
clasă este o extensie naturală a tendin•ei (discutată în Cuvânt înainte) de a da unui limbaj de programare (•i, astfel, codului scris în acel
limbaj) o structură din ce în ce mai prietenoasă cu oamenii. Cursurile sunt o încercare de a face percep•ia noastră despre lumea
înconjurătoare reflectată în cod.

Când viziona•i filmul „Lassie Come Home”, •ti•i că colie cu părul lung care apare pe ecran este un câine. Nu a•i avut nevoie de nimeni care să vă explice că acest câine pe care l-a•i văzut

pentru prima dată (dacă nu vă uita•i din nou la acest film) a fost un câine. •tiu asta, de•i nu am văzut niciodată un câine model. Un astfel de câine model nici măcar nu există. Câinii pot fi foarte

diferi•i. Pudelii arată complet diferit de marii danezi, iar ace•tia sunt foarte diferi•i de câinii cu crestă chineză. Mai mult, dacă un astfel de câine î•i pierde toate cele patru picioare •i coada într-un

accident, nu va înceta să mai fie un câine. Cum putem indica fără explica•ia nimănui că obiectul specific pe care îl putem vedea pentru prima dată în via•a noastră este un câine? Care este

defini•ia de a fi un câine? •i ce zici de o masă? Ce este o masă? În fiecare zi întâlni•i multe implementări ale clasei Table. O masă de cantină diferă de masa de reabilitare, iar aceasta din urmă

diferă de masa ata•ată la spatele unui scaun de avion. •i totu•i, toate aceste obiecte se numesc tabele •i le pute•i recunoa•te cu u•urin•ă. Ce este o clasă de masă? Este o masă ceva cu patru

picioare •i un blat? Nu neaparat. O masă poate avea două picioare, un picior sau poate fi suspendată. •i dacă pune•i o fa•ă de masă pe un trunchi gros de copac •i adăuga•i un scaun lângă el,

acest trunchi nu va deveni o masă? •i totu•i, toate aceste obiecte se numesc tabele •i le pute•i recunoa•te cu u•urin•ă. Ce este o clasă de masă? Este o masă ceva cu patru picioare •i un blat?

Nu neaparat. O masă poate avea două picioare, un picior sau poate fi suspendată. •i dacă pune•i o fa•ă de masă pe un trunchi gros de copac •i adăuga•i un scaun lângă el, acest trunchi nu va

deveni o masă? •i totu•i, toate aceste obiecte se numesc tabele •i le pute•i recunoa•te cu u•urin•ă. Ce este o clasă de masă? Este o masă ceva cu patru picioare •i un blat? Nu neaparat. O

masă poate avea două picioare, un picior sau poate fi suspendată. •i dacă pune•i o fa•ă de masă pe un trunchi gros de copac •i adăuga•i un scaun lângă el, acest trunchi nu va deveni o masă?

Ra•ionamentul de mai sus ne conduce la concluzia că identificăm obiectele care ne înconjoară nu numai pe
baza caracteristicilor lor (denumite atribute), dar •i pe baza func•iilor (metodelor) pe care le îndeplinesc. Uneori, po•i recunoa•te un câine doar prin
faptul că latră, dă din coadă •i este condus cu lesa. Acela•i lucru se aplică claselor de programare. O clasă este o entitate generală, un model care
define•te un concept. Pentru noi va fi un câine sau o masă. Obiectele sunt diferite implementări ale acestei clase. Masa la care ai luat micul dejun
astăzi este doar una dintre implementările (obiectele) clasei Table, în timp ce Buddy, câinele vecinilor tăi pe care ai •tiut că ieri ai ie•it din casă ieri
diminea•ă, este un obiect apar•inând clasei Dog.

Să programăm Buddy câinele. Buddy va fi obiectul clasei noastre de câine. Mai întâi, să definim clasa de câine goală.

Clasa de câine:

trece

Pentru a crea un obiect al clasei dvs., apela•i clasa sa (la fel cum numi•i func•ii).

dog1 = Dog ()

Crearea unui obiect se nume•te ini•ializarea acestuia. Imediat după ini•ializare, obiectul clasei Dog este atribuit variabilei dog1. Dar
deocamdată obiectul nostru nu poate face nimic. •ablonul său este gol. Lasă-ne să ne gândim la abilită•ile pe care •i-ai dori să le aibă
obiectele din clasa Câinelui (Buddy, de exemplu). Lăsa•i to•i câinii pe care îi creăm să latre. Abilită•ile obiectului se numesc metode. O
metodă este o func•ie specială

47
acea:

1. Este definit în cadrul clasei

2. Primul parametru al metodei este cuvântul sine

În metoda de scoar•ă, ar putea fi redat un fi•ier de sunet cu lătrat. Cu toate acestea, nu toată lumea are la îndemână un astfel de fi•ier
sonor, a•a că lătratul să fie exprimat cu textul „Woof, woof!” imprimate pe ecran.

Clasa de câine:

coaja def (auto):

print ("Vai, vai!")

Acum obiectele clasei tale pot latra.

dog1 = Dog ()
dog1.bark () ①

① Pentru a apela metoda obiectului, pune•i un punct după obiectul însu•i •i apoi scrie•i numele
metoda pe care dori•i să o apela•i, plus parantezele.

Pe lângă abilită•i, obiectele pot avea •i proprietă•i (atribute). Ce proprietă•i a•i dori să aibă obiectele din clasa Dog? Poate un nume? Toate
atributele sunt plasate în special init •i se utilizează o nota•ie specifică.

clasa Câine ():

def __init __ (auto, nume): ①
self.name = nume ②
coaja def (auto):
print ("Woof, woof")

① Plasa•i între paranteze toate atributele pe care dori•i să le atribui•i obiectelor dvs. (aici este doar unul, adică

un nume, deoarece auto este atributul implicit pe care îl plasăm în fiecare metodă).

② Atribui•i aceste atribute unei alte variabile prefixând-o cu cuvântul sine •i un punct. Din această
punct, pute•i utiliza nota•ia obiectului pentru a vă referi la atributul de nume al obiectelor clasei dvs. Să verificăm cum func•ionează.

câine1 = Câine („Prieten”)) ①

câine1.nume
dog1.bark ()

Atributele obiectului sunt introduse în paranteze în timpul ini•ializării (în acela•i mod în care am plasat parametrii de intrare în func•ie). Acum
obiectele clasei tale pot latra •i au un nume. Lucrurile pe care le au obiectele (de ex. Un nume) se numesc atributele lor. Lucrurile pe care le pot
face obiectele (de exemplu, lătratul) se numesc metodele lor. Atributele •i metodele sunt numite câmpuri obiect.

În acest concept, metodele sunt adesea considerate ca func•ii care schimbă valoarea unui atribut dat

48
(adică starea obiectului). De exemplu, să ne învă•ăm obiectele din clasa Câine să mănânce.

Ce poate face metoda mânca? Poate schimba starea câinelui dvs. de la flămând la hrănit. Să introducem un nou atribut clasei noastre,
care spune dacă câinelui îi este foame: is_hungry. Apoi, metoda eat va verifica dacă atributul is_hungry al obiectului clasei Dog este setat
la True. Dacă da, se va schimba
acest atribut False. În acest fel, câinele dvs. nu va mai fi flămând, adică din starea flămândă (is_hungry = True) va intra în starea hrănită (is_hungry
= False).

clasa Câine ():

def __init __ (self, name, is_hanggry):
self.name = nume
self.is_hungry = is_hungry
def eat (self):
dacă self.is_hungry == Adevărat:
self.is_hungry = False

•i să vedem dacă func•ionează.

dog1 = Dog ("Prieten", Adevărat) ①

dog1.is_hgry ②
dog1.eat () ③
dog1.is_hgry ④

Iată ce s-a făcut:

① Am creat o instan•ă (obiect) a clasei Dog cu atributele name = "Buddy" •i

is_hungry = Adevărat, iar apoi a atribuit obiectul creat variabilei dog1

② Am întrebat despre valoarea atributului is_happy al obiectului dog1 (pentru a verifica dacă câinelui1 îi este foame).

Adevărat a fost afi•at.

③ Am numit metoda de mâncare pentru obiectul nostru.

④ Am întrebat din nou despre valoarea atributului is_hungry for object dog1. De data aceasta False a fost

afi•at. Metoda noastră de mâncare func•ionează conform inten•iei. A•a ne-am învă•at câinii să mănânce. În acest fel putem învă•a câinii
no•tri totul. Îi po•i învă•a să zboare sau să mănânce cu be•i•oare. Ai nevoie doar de ceva mai mult cod •i multă imagina•ie.

Din motive de claritate a materialului lec•iei, pute•i utiliza nume în limba dvs. maternă în cod. Cu toate acestea, este o bună practică de
programare să nu amesteca•i limbaje •i să scrie•i cod numai în engleză. Acum, când introducerea este în spatele nostru, să încercăm
să aplicăm numai bunele practici.

Exerci•ii

1. Crea•i o clasă de persoană

◦ adăuga•i câmpuri: nume, prenume, sex, vârstă, număr de identificare personal

◦ adăuga•i o metodă pentru a verifica dacă o persoană a atins vârsta de pensionare (pentru femeile care au vârsta de pensionare> = 60,

pentru bărba•i> = 65)

◦ adăuga•i o metodă care returnează diferen•a de vârstă între o persoană dată •i o altă persoană:

49
 ◦ face•i ca metoda să accepte un parametru de tip Persoană

◦ Nu ar trebui să returneze valori negative ca diferen•ă de ani.

◦ Adăuga•i o metodă care calculează •i returnează numărul de ani răma•i la pensionare.

50
Concluzie
Acest registru de lucru prezintă elementele de bază ale programării. Este un început minunat al drumului programatorului.

Drumul interesant •i nesfâr•it. Există multe furci pe el, viraje surprinzătoare •i ni•te adâncituri fascinante. Pe Internet •i la librării pute•i găsi
numeroase ghiduri excelente •i cursuri care discută sec•iunile sale individuale. Nu este nimic de a•teptat. Doar ie•i•i pe drum.

După ce citi•i acest manual, •ti•i cum să da•i instruc•iuni unui computer. Pute•i utiliza instrumentul care efectuează miliarde de opera•ii pe
secundă cu o precizie fără precedent. Vă oferă o putere extraordinară •i o responsabilitate mare. Ce vei face cu el? Scrie un program mi•to!

51
Anexa A
Rularea programului pe care l-a•i scris necesită software suplimentar. În multe studii, cititorul trebuie să instaleze acest software înainte de a scrie
primul program. Procesul de instalare •i configurare poate fi obositor. În caz de e•ec, acesta descurajează •i demotivează cititorul chiar înainte de
a scrie prima linie a unui cod. Astăzi nu mai este o etapă necesară. Mediile de dezvoltare complet configurate •i gata de utilizare sunt disponibile
pe Internet. Pentru nevoile acestui manual de lucru, unul dintre ele va fi suficient. Cu toate acestea, pentru scrierea regulată a codului, este
necesar să instala•i •i să configura•i mediul de dezvoltare pe computer.

Orice editor de text (de ex. Notepad) este bun pentru a scrie un program Python. Pentru a rula programul scris, ave•i nevoie de un
interpret Python, adică un program care traduce un cod scris în Python într-un •ir de
zerouri •i unii. Interpretul Python poate fi descărcat de pe site-ul oficial Python. În plus, mediul de dezvoltare integrat (IDE) este adesea instalat
în locul editorului de text obi•nuit.

COMENTARUL AUTORULUI: Elevii primesc instruc•iunile de instalare a software-ului la începutul cursului. Nu l-am citit, dar nu am întâlnit încă
un student care s-ar plânge, a•a că probabil este suficient să-l pun aici.

Instruc•iunea acoperă atât modul interactiv, cât •i modul script. Se încheie cu rularea „Bună ziua, lume!” program în Pycharm.

52
Anexa B

Rezumatul tipurilor
Tabelul 1. Tipuri de date

Desemnare Nume Exemple de literali valabili

<class 'int'> Tip întreg 10, -768, 080, -0490, 0x260

<class 'float'> Tip virgulă mobilă 0,0, 15,2, -21,9, 32,2e18, 70,34E-5 Tipul complex

<clasă 'complex'> 1j, 0, 2.3 + 4.5j, -34j, 3e-3-3j,

<clasa 'bool'> Tipul boolean Adevarat fals

<clasa „Niciuna”> Nici unul set (), set (2), set ()

<class 'bytes'> Octet octe•i (), octe•i (4), octe•i ([1,43,5]), octe•i ("abc", "utf-8")

<class 'str'> Tipul •irului "", '', "Bună ziua, lume!", "123", " ! @ # $%", "Abc"

<class 'list'> Listă [], [2,], [„abcd”, 786, 2.23, „Ioan”, Adevărat]

<class 'dict'> Dicţionar {}, {'imie': 'john', 'code': 6734, 'wiek': 32}, {'john': '766-234245', 'ann':
'677-345-268'}

<clasa 'tuplu'> Tuple (), (2,), ('abcd', 786, 2.23, "John", True) set (), set

<class 'set'> A stabilit (['abcd', 786, 2.23, "John", True])

<class 'frozenset'> Set înghe•at frozenset (), frozenset (['abcd', 786, 2.23, "John", True])

Rezumatul operatorilor
Tabelul 2. Operatori aritmetici

Simbol Nume

+ La care se adauga

- Minus

* Multiplicare

/ Divizia

// Diviziunea întregi

% Modulo

Tabelul 3. Operatori de compara•ie

Simbol Nume

< Mai pu•in decât

> Mai mare ca

<= Mai mic sau egal cu

53
Simbol Nume

>= Mai mare sau egal cu Egal cu

==

!= Nu este egal cu

este Este

nu este Nu este

Tabelul 4. Operatori booleni

Simbol Nume

•i Conjunc•ie booleană

sau Alternativă booleană

nu Negatie booleana

Tabelul 5. Operatori bit-bit

Simbol Nume

<< Shift stânga

>> Shift dreapta

| Alternativă bitwise

^ Bitwise XOR

~ Negare bitwise

Rezumatul cuvintelor cheie

Fals asteapta altceva import trece

Nici unul pauză cu exceptia în a ridica

Adevărat clasă in cele din urma este întoarcere

•i continua pentru lambda încerca

la fel de def din nelocal in timp ce

afirma del global nu cu

asincron elif dacă sau Randament

54