Informatica CS mate-info, clasa a IX-a

MINISTERUL EDUCAȚIEI ȘI CERCETĂRII

Ștefania Penea Radu-Eugen Boriga Cosmin-Ionuț Florescu Bogdan-Petru Vrînceanu

Manualul este prezentat în variantă

similar celei tipărite. În plus, cuprinde o serie de activități multimedia interactive de învățare (exerciții interactive, jocuri educaționale, animații, filme, simulări).

Educația nu schimbă lumea. Schimbă oamenii care vor schimba lumea.

Paulo Freire

Informatică

Varianta digitală are un conținut

Manual pentru clasa a IX-a

tipărită și în variantă digitală.

INFORMATICĂ

9

curriculum de specialitate (CS), filiera teoretică, profilul real, specializarea matematică-informatică

Manual pentru clasa a IX-a

ISBN 978-630-355-962-9

MINISTERUL EDUCAȚIEI ȘI CERCETĂRII

Ștefania Penea Radu-Eugen Boriga Cosmin-Ionuț Florescu Bogdan-Petre Vrînceanu

INFORMATICĂ curriculum de specialitate (CS), filiera teoretică, profilul real, specializarea matematică-informatică

Manual pentru clasa a IX-a

9

Manualul școlar a fost aprobat de Ministerul Educației și Cercetării prin Ordinul de ministru nr. . . . . . . . . . . . . . . . .

Manualul este distribuit elevilor în mod gratuit, atât în format tipărit, cât și digital, și este transmisibil timp de opt ani școlari, ­începând cu anul școlar 2026–2027.

Inspectoratul școlar .......................................................................................................................................................................................................

Colegiul/Liceul ................................................................................................................................................................................................................

ACEST MANUAL A FOST FOLOSIT: Anul

Numele elevului

Clasa

Anul școlar

Aspectul manualului* la primire la predare

1 2 3 4 5 6 7 8

* Pentru precizarea aspectului manualului se va folosi unul dintre următorii termeni: nou, bun, îngrijit, neîngrijit, deteriorat.

• Cadrele didactice vor verifica dacă informațiile înscrise în tabelul de mai sus sunt corecte.

• Elevii nu vor face niciun fel de însemnări pe manual.

Informatică: curriculum de specialitate (CS), filiera teoretică, profilul real, specializarea matematică-informatică.

Manual pentru clasa a IX-a Ștefania Penea, Radu-Eugen Boriga, Cosmin-Ionuț Florescu, Bogdan-Petre Vrînceanu Referenți științifici: lector dr. Anca-Mădălina Dobrovăț, prof. gr. I. Georgiana-Ligia Berbece

Copyright © 2026 Litera Educațional Toate drepturile rezervate

Editura Litera tel.: 0374 82 66 35; 021 319 63 90; 031 425 16 19 e‑mail: contact@litera.ro www.litera.ro Editor: Vidrașcu și fiii Redactor: Gabriela Caracaș Credite foto: arhiva Litera, arhiva personală Cosmin-Ionuț Florescu Ilustrație copertă: arhiva personală Cosmin-Ionuț Florescu Layout și copertă: Lorena Ionică Tehnoredactare și prepress: Marin Popa

I.1.

I.2.

I.3.

I.4.

I.5.

Gândirea computațională ....................................................................................................................7 Principalele moduri de reprezentare a algoritmilor........................................................................ 10 Scheme logice și limbajul pseudocod. Aplicații practice ............................................................... 15 Testarea algoritmilor. Urmărirea evoluției valorilor variabilelor ................................................... 19 Principalele etape ale elaborării unui program............................................................................... 23 Probleme propuse ............................................................................................................................ 26 Fișă de evaluare ................................................................................................................................ 27

CUPRINS

I. Gândirea computațională. Strategii de rezolvare a problemelor ............................................ 7

II. Prelucrări numerice. Algoritmi elementari. Baze de numerație ............................................ 29 II.1. Accesarea cifrelor unui număr .......................................................................................................... 29 II.2. Algoritmi de construire a numerelor prin adăugarea cifrelor la dreapta ...................................... 32 II.3. Algoritmi de construire a numerelor prin adăugarea cifrelor la stânga......................................... 36 II.4. Divizorii unui număr natural ............................................................................................................. 39 II.5. Prelucrarea selectivă a cifrelor unui număr .................................................................................... 43 II.6. Algoritmi elementari pentru divizori și multiplii comuni ................................................................ 46 II.7. Baze de numerație. Conversii între sisteme de numerație ............................................................. 50 Probleme propuse ............................................................................................................................ 53 Fișă de evaluare ................................................................................................................................ 54

III. Subprograme. Introducere în programarea orientată pe obiecte ......................................... 55 III.1. Proiectarea modulară a algoritmilor. Funcții fără parametri ......................................................... 55 III.2. Funcții cu parametri. Variabile locale și globale ............................................................................. 59 III.3. Module. Funcții predefinite .............................................................................................................. 65 III.4. Introducere în programarea orientată pe obiecte .......................................................................... 70 Probleme propuse ............................................................................................................................ 73 Fișă de evaluare ................................................................................................................................ 75

IV. Modalități de comunicare cu programul. Fișiere text. Interfețe grafice ............................. 77 IV.1. Gestionarea comunicării cu utilizatorul. Principii de lucru cu fișiere text ..................................... 77 IV.2. Aplicații practice cu fișiere text ........................................................................................................ 84 IV.3. Realizarea interfețelor grafice utilizând biblioteca Tkinter ............................................................ 90 IV.4. Componente pentru introducerea datelor utilizând biblioteca Tkinter ........................................ 94 IV.5. Manageri de geometrie. Canvas ..................................................................................................... 101 Probleme propuse .......................................................................................................................... 107 Fișă de evaluare ................................................................................................................................. 108

V. Modelul conceptual liniar. Clasa list. Metode de sortare. Eficiența algoritmilor ........... 109 V.1. Modelul conceptual liniar: listă, stivă, coadă și listă de frecvențe ............................................... 109 V.2. Clasa list. Accesarea elementelor unei liste. Operatori specifici .................................................. 112 V.3. Crearea unei liste prin citire. Funcții predefinite pentru liste ...................................................... 117 V.4. Metode ale clasei list pentru adăugarea, inserarea, ștergerea și căutarea unui element .......... 121 V.5. Generarea sistematică a elementelor unei liste. Alte metode ale clasei list ............................... 127 V.6. Metode de sortare a elementelor unei liste ................................................................................... 131 V.7. Liste de frecvențe. Sortarea cu listă de frecvențe ......................................................................... 136 V.8. Eficiența algoritmilor ...................................................................................................................... 140 Probleme propuse .......................................................................................................................... 146 Fișă de evaluare .............................................................................................................................. 147 Indicații și rezolvări scurte ............................................................................................................ 148

3

STRUCTURA MANUALULUI MINISTERUL EDUCAȚIEI ȘI CERCETĂRII

Manualul de Informatică. Clasa a IX-a – Curriculum de specialitate (CS). Filiera teoretică, profilul real, specializarea matematică-informatică, este structurat pe unități tematice, care dezvoltă conținuturile din Programă. Prezentate într-o formă deosebit de atractivă, lecțiile cuprind exemple de activități care conduc la formarea competențelor spe­ci­fice disciplinei. Organizarea conținutului permite crearea de relații cu celelalte discipline studiate.

VARIANTA TIPĂRITĂ

Manual pentru clasa a IX-a

Titlul capitolului

CAPITOLUL I Gândirea computațională.

Strategii de rezolvare a problemelor

Competențele vizate în cadrul acestui capitol

COMPETENȚE SPECIFICE VIZATE CS 1.3 Identifică specificul, caracteristicile și etapele unor strategii de rezolvare a problemelor prin proiectarea modulară a algoritmilor CS 2.3 Explică etapele unor strategii de rezolvare a problemelor prin proiectarea modulară a algoritmilor CS 3.3 Aplică strategii de rezolvare a problemelor prin proiectarea modulară a algoritmilor CS 4.3 Analizează aplicabilitatea, avantajele și dezavantajele utilizării unor strategii de rezolvare a problemelor prin proiectarea modulară a algoritmilor CS 5.3 Evaluează corectitudinea și eficiența algoritmilor care utilizează strategii de rezolvare a problemelor prin proiectarea modulară a algoritmilor

Titlul lecției

9

INFORMATICĂ

curriculum de specialitate (CS), filiera teoretică, profilul real, specializarea matematică-informatică

I.1. Gândirea computațională Bun venit în universul informaticii! În acest an școlar vei descoperi cum poți să rezolvi diverse probleme folosind raționamente logice în mod eficient. Înainte de a scrie cod, trebuie să cunoști și să înțelegi metodele de rezolvare a problemelor.

Gândirea computațională este un mod de a rezolva probleme eficient, de a înțelege sisteme complexe și de a construi soluții clare și verificabile. Într-o lume tot mai digitalizată, gândirea computațională devine o abilitate de bază care te învață că nicio problemă nu este prea dificilă, ci doar insuficient descompusă și analizată.

Un avantaj major al gândirii computaționale este faptul că poate fi folosită în aproape orice domeniu, deoarece toate domeniile conțin probleme, date și procese, de exemplu: Domeniul

Gândirea computațională

educație

ajută elevii să rezolve probleme logic, să-și dezvolte gândirea critică și creativă sau să învețe să lucreze sistematic și organizat

cercetare

susține implicarea în cercetarea modernă de simulări, analize de date și modele matematice

medicină

este folosită pentru analiza imaginilor medicale sau predicția riscurilor și a diagnosticului asistat

economie

este esențială pentru analiza afacerilor și luarea deciziilor pe baza informațiilor

industrie

stă la baza proiectării asistate de calculator, automatizării fabricilor sau programării roboților

Figura 1.1.

Gândire computațională

ȘTIAI CĂ...

Printre primii cercetători care au promovat, în anii ’80, ideea de a folosi concepte din informatică pentru dezvoltarea gândirii elevilor a fost Seymour Papert. El este unul dintre creatorii limbajului de programare Logo, pe care l-a folosit pentru a învăța copiii concepte matematice și logice într-un mod interactiv, controlând o „țestoasă” care desena pe ecran.

7

Rubrica PORTOFOLIUL DIGITAL – elevii sunt încurajați să creeze anumite teme și exerciții care vor fi arhivate într-un portofoliu digital domeniului.

STUDIU DE CAZ

Următoarele caracteristici ale gândirii computaționale ajută la rezolvarea problemelor: ◗ descompunerea - abilitatea de a împărți o problemă mare în subprobleme mai mici și mai ușor de gestionat; ◗ recunoașterea tiparelor - observarea unor similitudini între problema curentă și probleme rezolvate în trecut; ◗ abstractizarea - procesul de filtrare a informațiilor, prin care păstrăm doar aspectele esențiale ale unei probleme și le eliminăm pe cele irelevante, în scopul creării unui model simplificat care să fie mai ușor de analizat și de rezolvat; ◗ algoritmizarea - crearea unui set de operații a căror executare pas cu pas permite rezolvarea problemei.

Produs final: Un document Word ilustrat, de 1–2 pagini, intitulat gandire_computationala.docx.

Cerință: Alege o situație din viața de zi cu zi, de exemplu: organizarea ghiozdanului, planificarea unei excursii, pregătirea pentru un test sau organizarea unei activități sportive. Explică rezolvarea situației prin cele patru componente ale gândirii computaționale: descompunerea, recunoașterea tiparelor, abstractizarea și algoritmizarea. Pentru fiecare componentă, redactează 3–5 rânduri și oferă un exemplu concret.

Element suplimentar: La final, adaugă o scurtă autoevaluare de 5–6 rânduri.

Recunoașterea tiparelor

Abstractizarea

Algoritmizarea

Figura 1.2. Cele patru caracteristici ale gândirii computaționale

2. Indicați succesiunea logică a etapelor gândirii computaționale atunci când abordăm o problemă nouă: A. abstractizarea -> descompunerea -> algoritmizarea -> recunoașterea șabloanelor

Scopul acestui sistem este de a îmbunătăți circulația în intersecții prin reducerea aglomerației.

Cele patru caracteristici fundamentale ale gândirii computaționale pot fi descrise astfel:

B. algoritmizarea -> abstractizarea -> recunoașterea șabloanelor -> descompunerea

1. Descompunerea: problema generală constă în organizarea traficului dintr-o intersecție. Aceasta poate fi împărțită în subprobleme:

C. recunoașterea șabloanelor -> algoritmizarea -> descompunerea -> abstractizarea

• detectarea numărului de vehicule de pe fiecare bandă; • stabilirea duratei semaforului verde; • evitarea blocajelor în trafic.

D. descompunerea -> recunoașterea șabloanelor -> abstractizarea -> algoritmizarea

2. Recunoașterea tiparelor: sistemul identifică tipare. Acestea ajută la adaptarea funcționării semafoarelor și pot fi:

• orele de vârf în care traficul este intens; • benzile pe care se formează frecvent cozi; • intervalele orare în care traficul este redus.

3. Abstractizarea: unele date colectate sunt utile pentru găsirea soluției, dar altele nu sunt necesare. De exemplu, detalii precum tipul mașinilor sau culoarea acestora nu sunt relevante pentru găsirea soluției, dar următoarele date sunt esențiale:

• numărul de vehicule; • direcția de deplasare.

4. Algoritmizarea: soluția poate fi exprimată pas cu pas.

• Pasul 1: se măsoară traficul pe fiecare bandă; • Pasul 2: se acordă prioritate benzii mai aglomerate; • Pasul 3: se ajustează timpul pentru culoarea verde a semaforului; • Pasul 4: se repetă procesul periodic.

DESCOPERĂ Persoana care a adus gândirea computațională în centrul educației moderne este Jeannette Wing. În anul 2006 a publicat articolul “Computational Thinking” în care afirmă: “Gândirea computațională presupune rezolvarea de probleme, proiectarea sistemelor și înțelegerea comportamentului uman, bazându-se pe concepte fundamentale ale informaticii.”

8

Rubrica DESCOPERĂ în care elevul investighează elemente suplimentare pe care le studiază singur în scopul aprofundării domeniului.

4

EXERSEAZĂ!

1. Explicați de ce gândirea computațională este o abilitate de bază în lumea actuală.

STUDII DE CAZ • 1. Gestionarea traficului rutier prin semafoare inteligente

PROBLEME PROPUSE

FIȘĂ DE EVALUARE FINALĂ

1. Se citesc temperatura t din clasă și valoarea c a concentrației de CO₂. Dacă temperatura este mai mare decât 27 sau concentrația de CO₂ este mai mare decât 1000, se afișează mesajul "AERISIRE". În caz contrar, se afișează "CONDITII BUNE".

Indicații: Citește cu atenție fiecare cerință. Pentru itemii subiectivi se punctează atât corectitudinea logică, cât și claritatea redactării.

PORTOFOLIU DIGITAL Creează în calculator un folder principal cu numele Portofoliul digital. În interiorul acestuia, vei crea un subfolder dedicat capitolului 1. Pentru fiecare capitol crează un folder dedicat Rezolvarea unei probleme folosind gândirea computațională

Organizarea și salvarea fișierelor: În folderul Portofoliul digital\Capitolul 1\Rezolvare_problema\, salvează fișierul principal cu numele gandire_computationala.docx.

Descompunerea

Rubrica PROBLEME PROPUSE se află la sfârșitul fiecărui capitol și conține probleme propuse pentru aprofundarea noțiunilor însușite în capitolul respectiv

2. Se citește distanța d, realizată la proba de săritură în lungime la un concurs sportiv. Dacă d < 4, se afișează "începător". Dacă 4 ≤ d < 6, se afișează "mediu". Dacă d ≥ 6, se afișează "avansat".

3. Se citește numărul de minute m cu care un elev a întârziat la un eveniment. Dacă m = 0, se afișează "la timp".

Dacă 1 ≤ m ≤ 10, se afișează "întârziere mică". În celelalte situații, se afișează "întârziere mare".

4. Se citește n, apoi numărul elevilor prezenți în fiecare dintre n clase. Să se determine câte clase au cel puțin 25 de elevi prezenți.

5. Se citesc temperaturile din 7 zile. Să se afișeze temperatura maximă.

6. Se citește n, apoi n note. Să se calculeze media aritmetică a notelor și să se afișeze mesajul "promovat" dacă media este cel puțin 5, altfel "nepromovat".

DESCOPERĂ Așa cum “informatica nu este despre calculatoare, la fel cum astronomia nu este despre telescoape” (Edsger W. Djikstra), ci despre modul în care gândim și rezolvăm probleme cu ajutorul lor – gândirea computațională ne învață să analizăm, să structurăm și să automatizăm soluții, devenind o abilitate esențială pentru viața modernă, nu doar pentru programare.

3. O companie de curierat dorește să optimizeze livrările prin gruparea coletelor care merg în aceeași zonă a orașului și folosirea aceleiași rute pentru vehicule diferite în zile diferite. Indicați componenta gândirii computaționale utilizată în acest caz: A. descompunerea B. algoritmizarea C. abstractizarea D. recunoașterea șabloanelor

7. Se citesc cantitățile de precipitații din 5 zile. Să se determine câte zile au avut precipitații strict mai mari decât 0 și cantitatea totală de precipitații.

8. Gigel își dorește foarte mult să-și cumpere o jucărie. Pentru a reuși cât mai repede acest lucru, el se hotărăște să depună în pușculița sa, în fiecare zi, câte o sumă de bani (număr natural nenul). Cunoscând prețul jucăriei și sumele depuse de Gigel zilnic, scrieți un algoritm care afișează după câte zile Gigel reușește să strângă în pușculiță suma necesară, suma medie zilnică pe care acesta a depus-o în pușculiță, precum și suma care îi va rămâne după ce își va cumpără jucăria.

9.

O parcare este inițial goală. Se citește n, apoi pentru fiecare interval se citesc numărul de mașini care intră și numărul de mașini care ies. Să se determine numărul final de mașini din parcare și numărul maxim de mașini aflate simultan în parcare.

10. Se citește n, apoi pentru fiecare produs se citește stocul său. Să se determine câte produse au stoc sub 5 și care este stocul minim.

11. Se citesc, pe rând, minutele de întârziere ale elevilor care ajung la un eveniment. Citirea se oprește când se introduce valoarea -1. Determinați câți elevi au ajuns la timp, câți au avut întârziere mică și câți au avut întârziere mare. Un elev este considerat: la timp, dacă m = 0, cu întârziere mică, dacă 1 ≤ m ≤ 10 și cu întârziere mare, dacă m > 10.

12. Se citesc numărul e de elevi și numărul b de bănci duble. Să se stabilească dacă toți elevii pot fi așezați în clasă și, dacă da, câte locuri rămân libere. Dacă nu, să se afișeze câți elevi rămân fără loc.

4. În dezvoltarea unui sistem de recunoaștere facială pentru deblocarea unui telefon, inginerii decid să ignore culoarea ochilor sau stilul coafurii utilizatorului, concentrându-se exclusiv pe distanța dintre punctele cheie ale feței. Indicați componenta gândirii computaționale utilizată în acest caz: A. descompunerea B. algoritmizarea C. abstractizarea D. recunoașterea șabloanelor

13. Se citește umiditatea inițială u. Cât timp umiditatea nu aparține intervalului [45,55], se fac corecții: dacă u < 45, se citește o valoare a și se adaugă la umiditate; dacă u > 55, se citește o valoare b și se scade din umiditate. Să se determine numărul corecțiilor efectuate și umiditatea finală.

14. Un robot transportă cărți între săli. El pornește cu energia 100. Se citește n, numărul maxim de curse (n ≤ 8).

Pentru fiecare cursă se citesc d = distanța parcursă, în zeci de metri, și s = 1 dacă robotul a urcat scări, 0 în caz contrar. Consumul unei curse este d unități pentru distanță și încă 5 unități dacă s = 1. Robotul execută cursele în ordine, dar se oprește imediat dacă energia rămasă ar deveni mai mică decât 10. Să se determine numărul curselor efectuate, energia rămasă, distanța maximă parcursă într-o cursă efectuată, numărul curselor în care a urcat scări și mesajul "misiune completă" sau "misiune oprită".

9

Rubrica EXERSEAZĂ conține exerciții și probleme pentru aprofundarea cunoștințelor; are ca scop evaluarea formativă a elevilor

26

SUBIECTE 1. La organizarea unui muzeu virtual, echipa păstrează pentru proiect următoarele informații: numărul sălii, traseul vizitatorului și durata explicației audio. Culoarea pereților, modelul scaunelor și marca boxelor nu sunt luate în calcul. Componenta gândirii computaționale utilizată este: ...................................................... 6p A. descompunerea B. recunoașterea tiparelor C. abstractizarea D. algoritmizarea 2. Pentru elaborarea unui program, asociați fiecare situație din coloana A cu etapa potrivită din coloanal B. ... 6p A 1. Se stabilesc datele de intrare, datele de ieșire și restricțiile.

B a) implementarea

2. Se scrie programul într-un limbaj de programare.

b) testarea

3. Se verifică rezultatele pe mai multe exemple.

c) depanarea

4. Se corectează erorile descoperite după rulare.

d) analiza problemei

3. Scrieți A (adevărat) sau F (fals) în dreptul următoarelor afirmații. .................................................................. 8p a) Un algoritm clar conține instrucțiuni precise și neambigue. b) Finitudinea înseamnă că algoritmul poate fi aplicat la multe probleme asemănătoare. c) Corectitudinea înseamnă că algoritmul produce rezultatul cerut. d) Un algoritm poate fi bun chiar dacă nu se oprește niciodată.

4. Identificați metoda de reprezentare a unui algoritm corespunzătoare pentru fiecare afirmație, alegând dintre: A schemă logică, B pseudocod sau C limbaj de programare: ......................................................................... 10p 1. Este potrivită când vrem să evidențiem vizual deciziile și traseul execuției.

2. Este potrivită când vrem să descriem logica fără sintaxă strictă.

3. Este folosită pentru implementarea efectivă a algoritmului.

4. Poate deveni greu de desenat pentru algoritmi foarte mari.

5. Nu poate fi executată direct de calculator.

5. Un liceu organizează o Zi a porților deschise și vrea să primească vizitatorii în mod eficient. Precizați: ...... 10p a) două subprobleme în care poate fi împărțită problema generală; b) un tipar care ar putea fi observat din anii anteriori; c) o informație care poate fi ignorată în rezolvarea problemei; d) doi pași ai unui posibil algoritm de organizare.

6. Se citește vârsta unei persone pentru a determina ce tip de bilet de intrare la muzeu trebuie sa achite. Scrieți un algoritm în pseudocod care afișează mesajul „gratuit” dacă vârsta este mai mică decât 7 sau mai mare decât 65, mesajul „redus” dacă vârsta este cel mult 18 și mesajul „întreg” în celelalte situații. ............... 12p

27

Rubrica FIȘĂ DE EVALUARE FINALĂ ajută la aprecierea rezultatelor elevilor și le oferă acestora posibilitatea de autoevaluare, prin compararea rezolvărilor proprii cu baremul și răspunsurile disponibile în varianta digitală.

II.2. Algoritmi de construire a numerelor prin adăugarea cifrelor la dreapta

Această rubrică reamintește elevilor noțiuni pe care le au din anii precedenți.

SĂ NE REAMINTIM! Pentru formularea condițiilor folosim operatori relaționali.

Operator

În numeroși algoritmi, rezultatul nu este obținut direct, ci se construiește treptat, prin adăugarea succesivă a unor cifre. O astfel de situație apare atunci când formăm un nou număr pornind de la un număr dat și atașăm la sfârșitul scrierii sale una sau mai multe cifre.

unde c este o cifră, adică un număr întreg din mulțimea {0,1,2,…,9}.

Exemplul 1: Să se adauge la dreapta numărului 58 cifra 3.

Rubrica OBSERVĂ conține noțiuni clarificatoare pentru noțiunile prezentate.

mai mic sau egal cu mai mare decât

>=

Adăugarea unei cifre la dreapta nu trebuie confundată cu adunarea obișnuită.

Dacă n = 24 și c = 7, atunci:

mai mare sau egal cu

De exemplu: ● u == 0 ● n >= 100

◗ 24 + 7 = 31 ◗ 24 * 10 + 7 = 247

3. Adăugarea la dreapta folosind instrucțiunea if SĂ NE REAMINTIM!

Așadar, operația corectă pentru adăugarea cifrei 7 la dreapta lui 24 este: 24 · 10+7=247

Instrucțiunea if permite executarea unui bloc de instrucțiuni numai atunci când o condiție este adevărată.

Forma generală este: if condiție: instrucțiuni

Exemplul 3: Să se adauge la dreapta lui n cifra 9, numai dacă ultima cifră a lui n este mai mică decât 5.

1. Adăugarea succesivă a mai multor cifre Uneori, noul număr se construiește treptat, prin mai multe operații de adăugare la dreapta.

Rubrica REȚINE! conține noțiunile foarte importante care trebuie reținute.

mai mic decât

>

OBSERVĂ

n = 58 n = n * 10 + 3 print(n)#Se obține: 583 Explicația este: 58·10+3=580+3=583

Exemplul 2: Pornind de la numărul 2, să se adauge succesiv la dreapta cifrele 4, 1 și 9.

egal cu diferit de

< <=

Adăugarea unei cifre la dreapta unui număr este o operație importantă în problemele care prelucrează cifrele numerelor naturale.

SĂ NE REAMINTIM! În sistemul zecimal, înmulțirea unui număr natural cu 10 deplasează toate cifrele sale cu o poziție spre stânga.

De exemplu: 24→240 Dacă după această deplasare adăugăm cifra 7, obținem: 240+7=247 Prin urmare, dacă vrem să adăugăm la dreapta lui n cifra c, folosim relația: n = n * 10 + c

Semnificație

== !=

n = int(input("n = ")) u = n % 10 if u < 5: n = n * 10 + 9

Pentru n = 132, avem u = 2, deci se obține: 132 · 10+9=1329 Pentru n = 147, avem u = 7, deci condiția nu este îndeplinită și numărul rămâne 147.

print(n)

n = 2 n = n * 10 + 4 n = n * 10 + 1 n = n * 10 + 9 print(n) # Rezultatul este: 2419

OBSERVĂ În acest exemplu: ◗ u reprezintă ultima cifră a lui n; ◗ condiția verificată este u < 5; ◗ dacă aceasta este adevărată, se formează noul număr; ◗ dacă este falsă, numărul rămâne neschimbat.

4. Adăugarea la dreapta folosind if ... else SĂ NE REAMINTIM! Atunci când avem două posibilități, folosim structura: if condiție: instrucțiuni1 else: instrucțiuni2

Explicația se poate urmări pas cu pas: 2→24→241→2419

REȚINE!

OBSERVĂ

Exemplul 4: Dacă ultima cifră a lui n este mai mică decât 5, se adaugă la dreapta cifra 1; în caz contrar, se adaugă cifra 8.

Dacă adăugăm mai multe cifre la dreapta, aplicăm de fiecare dată aceeași regulă: n = n * 10 + c

2. Adăugarea cifrei la dreapta depinde de o condiție În unele probleme, cifra care trebuie adăugată la dreapta nu este precizată direct. Ea se stabilește în funcție de anumite proprietăți ale numărului sau ale ultimei sale cifre. În aceste situații, folosim o instrucțiune de decizie.

În ambele cazuri se construiește un nou număr prin aceeași formulă:

n = int(input("n = ")) u = n % 10

n = n * 10 + ...

Se modifică doar cifra adăugată la dreapta.

Dacă n = 63, atunci u = 3, deci rezultatul este: 63 · 10+1=631 Dacă n = 78, atunci u = 8, deci rezultatul este: 78 · 10+8=788

if u < 5: n = n * 10 + 1 else: n = n * 10 + 8 print(n)

32

33

Rubrica EXEMPLE conține probleme rezolvate care îi ajută pe elevi să înțeleagă și să aprofundeze modul în care trebuie rezolvate probleme de acest tip.

Varianta digitală cuprinde integral conținutul manualului în variantă tipărită, având în plus o serie de activități multimedia interactive de învățare (AMII): animate, statice, interactive.

Paginile din manual pot fi vizionate pe diverse dispozitive (desktop, laptop, tabletă, telefon), oferind o excelentă experiență de navigare.

VARIANTA DIGITALĂ

Următoarele caracteristici ale gândirii computaționale ajută la rezolvarea problemelor: Z descompunerea - abilitatea de a împărți o problemă mare în subprobleme mai mici și mai ușor de gestionat; Z recunoașterea tiparelor - observarea unor similitudini între problema curentă și probleme rezolvate în trecut; Z abstractizarea - procesul de filtrare a informațiilor, prin care păstrăm doar aspectele esențiale ale unei probleme și le eliminăm pe cele irelevante, în scopul creării unui model simplificat care să fie mai ușor de analizat și de rezolvat; Z algoritmizarea - crearea unui set de operații a căror executare pas cu pas permite rezolvarea problemei.

PORTOFOLIU DIGITAL Creează în calculator un folder principal cu numele Portofoliul digital. În interiorul acestuia, vei crea un subfolder dedicat capitolului 1. Pentru fiecare capitol crează un folder dedicat Rezolvarea unei probleme folosind gândirea computațională Produs final: Un document Word ilustrat, de 1–2 pagini, intitulat gandire_computationala.docx.

Cerință: Alege o situație din viața de zi cu zi, de exemplu: organizarea ghiozdanului, planificarea unei excursii, pregătirea pentru un test sau organizarea unei activități sportive. Explică rezolvarea situației prin cele patru componente ale gândirii computaționale: descompunerea, recunoașterea tiparelor, abstractizarea și algoritmizarea. Pentru fiecare componentă, redactează 3–5 rânduri și oferă un exemplu concret.

Organizarea și salvarea fișierelor: În folderul Portofoliul digital\Capitolul 1\Rezolvare_problema\, salvează fișierul principal cu numele gandire_computationala.docx.

Element suplimentar: La final, adaugă o scurtă autoevaluare de 5–6 rânduri.

Descompunerea

Recunoașterea tiparelor

Abstractizarea

Algoritmizarea

Figura 1.2. Cele patru caracteristici ale gândirii computaționale

B. algoritmizarea -> abstractizarea -> recunoașterea șabloanelor -> descompunerea

1. Descompunerea: problema generală constă în organizarea traficului dintr-o intersecție. Aceasta poate fi împărțită în subprobleme:

Următoarele caracteristici ale gândirii computaționale ajută la rezolvarea problemelor:

• orele de vârf în care traficul este intens; • benzile pe care se formează frecvent cozi; • intervalele orare în care traficul este redus.

3. Abstractizarea: unele date colectate sunt utile pentru găsirea soluției, dar altele nu sunt necesare. De exemplu, detalii precum tipul mașinilor sau culoarea acestora nu sunt relevante pentru găsirea soluției, dar următoarele date sunt esențiale:

• numărul de vehicule; • direcția de deplasare.

Element suplimentar: La final, adaugă o scurtă autoevaluare de 5–6 rânduri.

Recunoașterea tiparelor

Abstractizarea

Algoritmizarea

Figura 1.2. Cele patru caracteristici ale gândirii computaționale

B. algoritmizarea -> abstractizarea -> recunoașterea șabloanelor -> descompunerea C. recunoașterea șabloanelor -> algoritmizarea -> descompunerea -> abstractizarea

• detectarea numărului de vehicule de pe fiecare bandă; • stabilirea duratei semaforului verde; • evitarea blocajelor în trafic.

D. descompunerea -> recunoașterea șabloanelor -> abstractizarea -> algoritmizarea

2. Recunoașterea tiparelor: sistemul identifică tipare. Acestea ajută la adaptarea funcționării semafoarelor și pot fi:

• orele de vârf în care traficul este intens; • benzile pe care se formează frecvent cozi; • intervalele orare în care traficul este redus.

3. Abstractizarea: unele date colectate sunt utile pentru găsirea soluției, dar altele nu sunt necesare. De exemplu, detalii precum tipul mașinilor sau culoarea acestora nu sunt relevante pentru găsirea soluției, dar următoarele date sunt esențiale:

• numărul de vehicule; • direcția de deplasare.

4. Algoritmizarea: soluția poate fi exprimată pas cu pas.

• Pasul 1: se măsoară traficul pe fiecare bandă; • Pasul 2: se acordă prioritate benzii mai aglomerate; • Pasul 3: se ajustează timpul pentru culoarea verde a semaforului; • Pasul 4: se repetă procesul periodic.

(;(56($=Ä 1. Explicați de ce gândirea computațională este o abilitate de bază în lumea actuală.

2. Indicați succesiunea logică a etapelor gândirii computaționale atunci când abordăm o problemă nouă: A. abstractizarea -> descompunerea -> algoritmizarea -> recunoașterea șabloanelor

1. Descompunerea: problema generală constă în organizarea traficului dintr-o intersecție. Aceasta poate fi împărțită în subprobleme:

'(6&23(5Ä Persoana care a adus gândirea computațională în centrul educației moderne este Jeannette Wing. În anul 2006 a publicat articolul “Computational Thinking” în care afirmă: “Gândirea computațională presupune rezolvarea de probleme, proiectarea sistemelor și înțelegerea comportamentului uman, bazându-se pe concepte fundamentale ale informaticii.”

8

4. Algoritmizarea: soluția poate fi exprimată pas cu pas.

'(6&23(5Ä Așa cum “informatica nu este despre calculatoare, la fel cum astronomia nu este despre telescoape” (Edsger W. Djikstra), ci despre modul în care gândim și rezolvăm probleme cu ajutorul lor – gândirea computațională ne învață să analizăm, să structurăm și să automatizăm soluții, devenind o abilitate esențială pentru viața modernă, nu doar pentru programare.

D. descompunerea -> recunoașterea șabloanelor -> abstractizarea -> algoritmizarea

2. Recunoașterea tiparelor: sistemul identifică tipare. Acestea ajută la adaptarea funcționării semafoarelor și pot fi:

Produs final: Un document Word ilustrat, de 1–2 pagini, intitulat gandire_computationala.docx.

Cerință: Alege o situație din viața de zi cu zi, de exemplu: organizarea ghiozdanului, planificarea unei excursii, pregătirea pentru un test sau organizarea unei activități sportive. Explică rezolvarea situației prin cele patru componente ale gândirii computaționale: descompunerea, recunoașterea tiparelor, abstractizarea și algoritmizarea. Pentru fiecare componentă, redactează 3–5 rânduri și oferă un exemplu concret.

Organizarea și salvarea fișierelor: În folderul Portofoliul digital\Capitolul 1\Rezolvare_problema\, salvează fișierul principal cu numele gandire_computationala.docx.

Descompunerea

STUDII DE CAZ • 1. Gestionarea traficului rutier prin semafoare inteligente Scopul acestui sistem este de a îmbunătăți circulația în intersecții prin reducerea aglomerației.

Cele patru caracteristici fundamentale ale gândirii computaționale pot fi descrise astfel:

C. recunoașterea șabloanelor -> algoritmizarea -> descompunerea -> abstractizarea

• detectarea numărului de vehicule de pe fiecare bandă; • stabilirea duratei semaforului verde; • evitarea blocajelor în trafic.

PORTOFOLIU DIGITAL Creează în calculator un folder principal cu numele Portofoliul digital. În interiorul acestuia, vei crea un subfolder dedicat capitolului 1. Pentru fiecare capitol crează un folder dedicat Rezolvarea unei probleme folosind gândirea computațională

• Pasul 1: se măsoară traficul pe fiecare bandă; • Pasul 2: se acordă prioritate benzii mai aglomerate; • Pasul 3: se ajustează timpul pentru culoarea verde a semaforului; • Pasul 4: se repetă procesul periodic.

'(6&23(5Ä Așa cum “informatica nu este despre calculatoare, la fel cum astronomia nu este despre telescoape” (Edsger W. Djikstra), ci despre modul în care gândim și rezolvăm probleme cu ajutorul lor – gândirea computațională ne învață să analizăm, să structurăm și să automatizăm soluții, devenind o abilitate esențială pentru viața modernă, nu doar pentru programare.

2. Indicați succesiunea logică a etapelor gândirii computaționale atunci când abordăm o problemă nouă: A. abstractizarea -> descompunerea -> algoritmizarea -> recunoașterea șabloanelor

Scopul acestui sistem este de a îmbunătăți circulația în intersecții prin reducerea aglomerației.

Cele patru caracteristici fundamentale ale gândirii computaționale pot fi descrise astfel:

Z descompunerea - abilitatea de a împărți o problemă mare în subprobleme mai mici și mai ușor de gestionat; Z recunoașterea tiparelor - observarea unor similitudini între problema curentă și probleme rezolvate în trecut; Z abstractizarea - procesul de filtrare a informațiilor, prin care păstrăm doar aspectele esențiale ale unei probleme și le eliminăm pe cele irelevante, în scopul creării unui model simplificat care să fie mai ușor de analizat și de rezolvat; Z algoritmizarea - crearea unui set de operații a căror executare pas cu pas permite rezolvarea problemei.

(;(56($=Ä 1. Explicați de ce gândirea computațională este o abilitate de bază în lumea actuală.

STUDII DE CAZ • 1. Gestionarea traficului rutier prin semafoare inteligente

'(6&23(5Ä Persoana care a adus gândirea computațională în centrul educației moderne este Jeannette Wing. În anul 2006 a publicat articolul “Computational Thinking” în care afirmă: “Gândirea computațională presupune rezolvarea de probleme, proiectarea sistemelor și înțelegerea comportamentului uman, bazându-se pe concepte fundamentale ale informaticii.”

3. O companie de curierat dorește să optimizeze livrările prin gruparea coletelor care merg în aceeași zonă a orașului și folosirea aceleiași rute pentru vehicule diferite în zile diferite. Indicați componenta gândirii computaționale utilizată în acest caz: A. descompunerea B. algoritmizarea C. abstractizarea D. recunoașterea șabloanelor 4. În dezvoltarea unui sistem de recunoaștere facială pentru deblocarea unui telefon, inginerii decid să ignore culoarea ochilor sau stilul coafurii utilizatorului, concentrându-se exclusiv pe distanța dintre punctele cheie ale feței. Indicați componenta gândirii computaționale utilizată în acest caz: A. descompunerea B. algoritmizarea C. abstractizarea D. recunoașterea șabloanelor

Următoarele caracteristici ale gândirii computaționale ajută la rezolvarea problemelor: Z descompunerea - abilitatea de a împărți o problemă mare în subprobleme mai mici și mai ușor de gestionat; Z recunoașterea tiparelor - observarea unor similitudini între problema curentă și probleme rezolvate în trecut; Z abstractizarea - procesul de filtrare a informațiilor, prin care păstrăm doar aspectele esențiale ale unei probleme și le eliminăm pe cele irelevante, în scopul creării unui model simplificat care să fie mai ușor de analizat și de rezolvat; Z algoritmizarea - crearea unui set de operații a căror executare pas cu pas permite rezolvarea problemei.

8

3. O companie de curierat dorește să optimizeze livrările prin gruparea coletelor care merg în aceeași zonă a orașului și folosirea aceleiași rute pentru vehicule diferite în zile diferite. Indicați componenta gândirii computaționale utilizată în acest caz: A. descompunerea B. algoritmizarea C. abstractizarea D. recunoașterea șabloanelor

9 Descompunerea

Recunoașterea tiparelor

Abstractizarea

Algoritmizarea

Figura 1.2. Cele patru caracteristici ale gândirii computaționale

Următoarele caracteristici ale gândirii computaționale ajută la rezolvarea problemelor: Z descompunerea - abilitatea de a împărți o problemă mare în subprobleme mai mici și mai ușor de gestionat; Z recunoașterea tiparelor - observarea unor similitudini între problema curentă și probleme rezolvate în trecut; Z abstractizarea - procesul de filtrare a informațiilor, prin care păstrăm doar aspectele esențiale ale unei probleme și le eliminăm pe cele irelevante, în scopul creării unui model simplificat care să fie mai ușor de analizat și de rezolvat; Z algoritmizarea - crearea unui set de operații a căror executare pas cu pas permite rezolvarea problemei.

STUDII DE CAZ • 1. Gestionarea traficului rutier prin semafoare inteligente Scopul acestui sistem este de a îmbunătăți circulația în intersecții prin reducerea aglomerației.

Cele patru caracteristici fundamentale ale gândirii computaționale pot fi descrise astfel:

Descompunerea

Recunoașterea tiparelor

Abstractizarea

Algoritmizarea

Figura 1.2. Cele patru caracteristici ale gândirii computaționale

4. În dezvoltarea unui sistem de recunoaștere facială pentru deblocarea unui telefon, inginerii decid să ignore culoarea ochilor sau stilul coafurii utilizatorului, concentrându-se exclusiv pe distanța dintre punctele cheie ale feței. Indicați componenta gândirii computaționale utilizată în acest caz: A. descompunerea B. algoritmizarea C. abstractizarea D. recunoașterea șabloanelor

1. Descompunerea: problema generală constă în organizarea traficului dintr-o intersecție. Aceasta poate fi împărțită în subprobleme:

• detectarea numărului de vehicule de pe fiecare bandă; • stabilirea duratei semaforului verde; • evitarea blocajelor în trafic.

STUDII DE CAZ • 1. Gestionarea traficului rutier prin semafoare inteligente Scopul acestui sistem este de a îmbunătăți circulația în intersecții prin reducerea aglomerației.

Cele patru caracteristici fundamentale ale gândirii computaționale pot fi descrise astfel:

2. Recunoașterea tiparelor: sistemul identifică tipare. Acestea ajută la adaptarea funcționării semafoarelor și pot fi:

• orele de vârf în care traficul este intens; • benzile pe care se formează frecvent cozi; • intervalele orare în care traficul este redus.

1. Descompunerea: problema generală constă în organizarea traficului dintr-o intersecție. Aceasta poate fi împărțită în subprobleme:

• detectarea numărului de vehicule de pe fiecare bandă; • stabilirea duratei semaforului verde; • evitarea blocajelor în trafic.

2. Recunoașterea tiparelor: sistemul identifică tipare. Acestea ajută la adaptarea funcționării semafoarelor și pot fi:

• orele de vârf în care traficul este intens; • benzile pe care se formează frecvent cozi; • intervalele orare în care traficul este redus.

3. Abstractizarea: unele date colectate sunt utile pentru găsirea soluției, dar altele nu sunt necesare. De exemplu, detalii precum tipul mașinilor sau culoarea acestora nu sunt relevante pentru găsirea soluției, dar următoarele date sunt esențiale:

9

• numărul de vehicule; • direcția de deplasare.

4. Algoritmizarea: soluția poate fi exprimată pas cu pas.

• Pasul 1: se măsoară traficul pe fiecare bandă; • Pasul 2: se acordă prioritate benzii mai aglomerate; • Pasul 3: se ajustează timpul pentru culoarea verde a semaforului; • Pasul 4: se repetă procesul periodic.

8

Activitățile multimedia interactive de învățare încurajează elevii să-și dezvolte gândirea critică și să-și sporească interesul și cunoștințele.

'(6&23(5Ä Persoana care a adus gândirea computațională în centrul educației moderne este Jeannette Wing. În anul 2006 a publicat articolul “Computational Thinking” în care afirmă: “Gândirea computațională presupune rezolvarea de probleme, proiectarea sistemelor și înțelegerea comportamentului uman, bazându-se pe concepte fundamentale ale informaticii.”

3. Abstractizarea: unele date colectate sunt utile pentru găsirea soluției, dar altele nu sunt necesare. De exemplu, detalii precum tipul mașinilor sau culoarea acestora nu sunt relevante pentru găsirea soluției, dar următoarele date sunt esențiale:

• numărul de vehicule; • direcția de deplasare.

4. Algoritmizarea: soluția poate fi exprimată pas cu pas.

• Pasul 1: se măsoară traficul pe fiecare bandă; • Pasul 2: se acordă prioritate benzii mai aglomerate; • Pasul 3: se ajustează timpul pentru culoarea verde a semaforului; • Pasul 4: se repetă procesul periodic.

'(6&23(5Ä Persoana care a adus gândirea computațională în centrul educației moderne este Jeannette Wing. În anul 2006 a publicat articolul “Computational Thinking” în care afirmă: “Gândirea computațională presupune rezolvarea de probleme, proiectarea sistemelor și înțelegerea comportamentului uman, bazându-se pe concepte fundamentale ale informaticii.”

8

Descoperiți informații utile pentru utilizarea manualului digital examinând schema de mai jos.

AMII statice galerii de imagini, informații suplimentare, diagrame și hărți conceptuale AMII animate filmulețe sau animații AMII interactive jocuri sau exerciții, la finalul cărora elevul poate verifica corectitudinea răspunsurilor oferite

5

Competențe generale și specifice, conform programei școlare pentru disciplina Informatică. Clasa a IX-a – Curriculum de specialitate (CS). Filiera teoretică, profilul real, specializarea matematică-informatică aprobată prin OMEC nr. 6930/2025 CG1 Identifică principalele caracteristici ale modelelor conceptuale și operaționale ale dezvoltării produselor software, pentru înțelegerea fundamentelor programării CS 1.1. Identifică principalele caracteristici ale organizării datelor în cadrul unor modele conceptuale fundamentale – date simple sau liste, pentru a structura și accesa date în vederea prelucrării acestora CS 1.2. Identifică specificul, caracteristicile și etapele unor algoritmi specializați pe clase de probleme, pentru a îi putea utiliza în prelucrarea algoritmică a numerelor, sortarea sau generarea sistematică a unor secvențe de valori CS 1.3. Identifică specificul, caracteristicile și etapele unor strategii de rezolvare a problemelor prin proiectarea modulară a algoritmilor CS 1.4. Identifică principalele elemente ale limbajului de programare utilizate pentru prelucrarea datelor organizate în modele fundamentale – date simple sau liste, respectiv pentru transmiterea datelor de la și către un program, în vederea rezolvării eficiente a problemelor informatice CS 1.5. Identifică elementele de sintaxă și componentele din definiția și apelul subprogramelor și subprogramelor predefinite pentru operații uzuale, pentru a le utiliza în implementarea algoritmilor în limbaj de programare CG2 Explică principii care stau la baza modelelor conceptuale și operaționale ale dezvoltării produselor software, pentru a fundamenta în mod logic proiectarea și implementarea soluțiilor informatice CS 2.1. Explică principiile de organizare a datelor în cadrul unor modele conceptuale fundamentale – date simple sau liste, pentru a le gestiona eficient CS 2.2. Explică etapele algoritmilor specializați pe clase de probleme, pentru a îi putea utiliza în prelucrarea algoritmică a numerelor, sortarea sau generarea sistematică a unor secvențe de valori CS 2.3. Explică etapele unor strategii de rezolvare a problemelor prin proiectarea modulară a algoritmilor CS 2.4. Explică rolul principalelor elemente ale limbajului de programare utilizate pentru prelucrarea datelor organizate în modele fundamentale – date simple sau liste, respectiv pentru transmiterea datelor de la și către un program în vederea rezolvării eficiente a problemelor informatice CS 2.5. Explică mecanismul de executare a subprogramelor și subprogramelor predefinite pentru operații uzuale, pentru a le utiliza în implementarea algoritmilor în limbaj de programare CG3 Utilizează modele conceptuale și operaționale ale dezvoltării produselor software, în scopul obținerii de soluții informatice funcționale și eficiente CS 3.1. Utilizează modul de organizare și prelucrare a datelor în cadrul unor modele conceptuale fundamentale – date simple sau liste, pentru a rezolva probleme de gestionare a datelor CS 3.2. Aplică algoritmi specializați pe clase de probleme, pentru a îi putea utiliza în prelucrarea algoritmică a numerelor, sortarea sau generarea sistematică a unor secvențe de valori CS 3.3. Aplică strategii de rezolvare a problemelor prin proiectarea modulară a algoritmilor CS 3.4. Utilizează principalele elemente ale limbajului de programare utilizate pentru prelucrarea datelor organizate în modele fundamentale – date simple sau liste, respectiv pentru transmiterea datelor de la și către un program, în vederea rezolvării eficiente a problemelor informatice CS 3.5. Utilizează elementele de sintaxă și componentele din definiția și apelul subprogramelor și subprogramelor predefinite pentru operații uzuale, în implementarea algoritmilor în limbaj de programare CG4 Analizează caracteristicile și aplicabilitatea modelelor conceptuale și operaționale ale dezvoltării produselor software, pentru a selecta soluțiile cele mai potrivite în funcție de contextul informatic dat CS 4.1. Analizează caracteristicile, modul de prelucrare, avantajele și dezavantajele utilizării unor modele conceptuale fundamentale – date simple sau liste, pentru a alege structura adecvată în rezolvarea unor probleme concrete CS 4.2. Analizează comportamentul, aplicabilitatea, avantajele și dezavantajele utilizării unor algoritmi specializați pe clase de probleme pentru prelucrarea numerelor, sortarea sau generarea sistematică a unor secvențe de valori CS 4.3. Analizează aplicabilitatea, avantajele și dezavantajele utilizării unor strategii de rezolvare a problemelor prin proiectarea modulară a algoritmilor CS 4.4. Analizează aplicabilitatea, avantajele și dezavantajele utilizării unor elemente ale limbajului de programare, pentru a identifica soluția adecvată prelucrării datelor organizate în modele fundamentale - date simple sau liste, respectiv pentru transmiterea datelor de la și către un program, în vederea rezolvării eficiente a problemelor informatice CS 4.5. Analizează aplicabilitatea, avantajele și dezavantajele utilizării subprogramelor, în implementarea algoritmilor în limbaj de programare CG5 Evaluează corectitudinea și eficiența soluțiilor informatice, în vederea optimizării și asigurării funcționalității în diverse scenarii de utilizare CS 5.1. Argumentează alegerea unor modele conceptuale fundamentale – date simple sau liste – și a modurilor de prelucrare a acestora pentru rezolvarea unor probleme informatice concrete CS 5.2. Evaluează corectitudinea și eficiența soluțiilor cu algoritmi specializați pe clase de probleme pentru prelucrarea numerelor, sortarea sau generarea sistematică a unor secvențe de valori CS 5.3. Evaluează corectitudinea și eficiența algoritmilor care utilizează strategii de rezolvare a problemelor prin proiectarea modulară a algoritmilor CS 5.4. Evaluează corectitudinea și eficiența aplicațiilor care utilizează elemente specifice de limbaj de programare pentru prelucrarea datelor organizate în modele fundamentale – date simple sau liste, respectiv pentru transmiterea datelor de la și către un program, în vederea rezolvării eficiente a problemelor informatice CS 5.5. Evaluează corectitudinea și eficiența programelor care utilizează subprograme, pentru a rezolva probleme informatice CG6 Elaborează algoritmi și programe personalizate, pentru a crea soluții informatice coerente și adaptate cerințelor CS 6.1. Proiectează algoritmi personalizați care utilizează modele conceptuale fundamentale – date simple sau liste pentru organizarea și prelucrarea eficientă a datelor, utilizând algoritmi de bază, în vederea rezolvării unor probleme CS 6.2. Proiectează soluții cu aplicarea personalizată a algoritmilor specializați pe clase de probleme pentru prelucrarea numerelor, sortarea sau generarea sistematică a unor secvențe de valori CS 6.3. Proiectează modular algoritmi personalizați pentru rezolvarea problemelor CS 6.4. Implementează aplicații care integrează în mod personalizat elemente specifice de limbaj de programare pentru prelucrarea datelor organizate în modele fundamentale – date simple sau liste, respectiv pentru transmiterea datelor de la și către un program, în vederea realizării unor soluții funcționale și performante CS 6.5. Implementează aplicații în limbaj de programare care integrează subprograme personalizate, pentru a modulariza și organiza eficient codul în cadrul soluțiilor informatice

6

CAPITOLUL I Gândirea computațională.

Strategii de rezolvare a problemelor COMPETENȚE SPECIFICE VIZATE CS 1.3 Identifică specificul, caracteristicile și etapele unor strategii de rezolvare a problemelor prin proiectarea modulară a algoritmilor CS 2.3 Explică etapele unor strategii de rezolvare a problemelor prin proiectarea modulară a algoritmilor CS 3.3 Aplică strategii de rezolvare a problemelor prin proiectarea modulară a algoritmilor CS 4.3 Analizează aplicabilitatea, avantajele și dezavantajele utilizării unor strategii de rezolvare a problemelor prin proiectarea modulară a algoritmilor CS 5.3 Evaluează corectitudinea și eficiența algoritmilor care utilizează strategii de rezolvare a problemelor prin proiectarea modulară a algoritmilor

I.1. Gândirea computațională Bun venit în universul informaticii! În acest an școlar vei descoperi cum poți să rezolvi diverse probleme folosind raționamente logice în mod eficient. Înainte de a scrie cod, trebuie să cunoști și să înțelegi metodele de rezolvare a problemelor.

Gândirea computațională este un mod de a rezolva probleme eficient, de a înțelege sisteme complexe și de a construi soluții clare și verificabile. Într-o lume tot mai digitalizată, gândirea computațională devine o abilitate de bază care te învață că nicio problemă nu este prea dificilă, ci doar insuficient descompusă și analizată.

Un avantaj major al gândirii computaționale este faptul că poate fi folosită în aproape orice domeniu, deoarece toate domeniile conțin probleme, date și procese, de exemplu: Domeniul

Gândirea computațională

educație

ajută elevii să rezolve probleme logic, să-și dezvolte gândirea critică și creativă sau să învețe să lucreze sistematic și organizat

cercetare

susține implicarea în cercetarea modernă de simulări, analize de date și modele matematice

medicină

este folosită pentru analiza imaginilor medicale sau predicția riscurilor și a diagnosticului asistat

economie

este esențială pentru analiza afacerilor și luarea deci­ ziilor pe baza informațiilor

industrie

stă la baza proiectării asistate de calculator, automa­ tizării fabricilor sau programării roboților

ȘTIAI CĂ...

Printre primii cercetători care au promovat, în anii ’80, ideea de a folosi concepte din informatică pentru dezvoltarea gândirii elevilor a fost Seymour Papert. El este unul dintre creatorii limbajului de programare Logo, pe care l-a folosit pentru a învăța copiii concepte matematice și logice într-un mod interactiv, controlând o „țestoasă” care desena pe ecran.

7

Următoarele caracteristici ale gândirii computaționale ajută la rezolvarea problemelor: ◗ descompunerea - abilitatea de a împărți o problemă mare în subprobleme mai mici și mai ușor de gestionat; ◗ recunoașterea tiparelor - observarea unor similitudini între problema curentă și probleme rezolvate în trecut; ◗ abstractizarea - procesul de filtrare a informațiilor, prin care păstrăm doar aspectele esențiale ale unei probleme și le eliminăm pe cele irelevante, în scopul creării unui model simplificat care să fie mai ușor de analizat și de rezolvat; ◗ algoritmizarea - crearea unui set de operații a căror executare pas cu pas permite rezolvarea problemei.

Descompunerea

Recunoașterea tiparelor

Abstractizarea

Algoritmizarea

STUDIU DE CAZ

Gestionarea traficului rutier prin semafoare inteligente Scopul acestui sistem este de a îmbunătăți circulația în intersecții prin reducerea aglomerației.

Cele patru caracteristici fundamentale ale gândirii computaționale pot fi descrise astfel: 1. Descompunerea: problema generală constă în organizarea traficului dintr-o intersecție. Aceasta poate fi împărțită în subprobleme:

• detectarea numărului de vehicule de pe fiecare bandă; • stabilirea duratei semaforului verde; • evitarea blocajelor în trafic.

2. Recunoașterea tiparelor: sistemul identifică tipare. Acestea ajută la adaptarea funcționării semafoarelor și pot fi:

• orele de vârf în care traficul este intens; • benzile pe care se formează frecvent cozi; • intervalele orare în care traficul este redus.

3. Abstractizarea: unele date colectate sunt utile pentru găsirea soluției, dar altele nu sunt necesare. De exemplu, detalii precum tipul mașinilor sau culoarea acestora nu sunt relevante pentru găsirea soluției, dar următoarele date sunt esențiale:

• numărul de vehicule; • direcția de deplasare.

4. Algoritmizarea: soluția poate fi exprimată pas cu pas.

• Pasul 1: se măsoară traficul pe fiecare bandă; • Pasul 2: se acordă prioritate benzii mai aglomerate; • Pasul 3: se ajustează timpul pentru culoarea verde a semaforului; • Pasul 4: se repetă procesul periodic.

8

DESCOPERĂ Persoana care a adus gândirea computațională în centrul educației moderne este Jeannette Wing. În anul 2006 a publicat articolul “Computational Thinking” în care afirmă: “Gândirea computațională presupune rezolvarea de probleme, proiectarea sistemelor și înțelegerea comportamentului uman, bazându-se pe concepte fundamentale ale informaticii.”

PROIECT DE ECHIPĂ: Rezolvarea unei probleme folosind gândirea computațională Produs final: Un document Word ilustrat, de 2–3 pagini, intitulat proiect_gandire_computationala.docx.

Cerință: Lucrați în echipe de 3–4 elevi și alegeți o situație din viața de zi cu zi precum organizarea ghiozdanului, planificarea unei excursii, pregătirea pentru un test sau organizarea unei activități. Explicați cum poate fi rezolvată situația aleasă folosind cele patru componente ale gândirii computaționale: descompunerea, recunoașterea tiparelor, abstractizarea și algoritmizarea. Pentru fiecare componentă, scrieți 2–4 rânduri și oferiți un exemplu concret.

Organizarea fișierelor: Salvați documentul în folderul Proiect\Capitolul 1\Proiect_echipa, cu numele proiect_ gandire_computationala.docx.

EXERSEAZĂ!

1. Explicați de ce gândirea computațională este o abilitate de bază în lumea actuală.

2. Indicați succesiunea logică a etapelor gândirii computaționale atunci când abordăm o problemă nouă: A. abstractizarea -> descompunerea -> algoritmizarea -> recu­noaș­ terea șabloanelor B. algoritmizarea -> abstractizarea -> recunoașterea șabloanelor -> descompunerea C. recunoașterea șabloanelor -> algoritmizarea -> descompunerea -> abstractizarea D. descompunerea -> recunoașterea șabloanelor -> abstractizarea -> algoritmizarea

DESCOPERĂ Așa cum “informatica nu este despre calculatoare, la fel cum astronomia nu este despre telescoape” (Edsger W. Dijkstra), ci despre modul în care gândim și rezolvăm probleme cu ajutorul lor – gândirea computațională ne învață să analizăm, să structurăm și să automatizăm soluții, devenind o abilitate esențială pentru viața modernă, nu doar pentru programare.

3. O companie de curierat dorește să optimizeze livrările prin gruparea coletelor care merg în aceeași zonă a orașului și folosirea aceleiași rute pentru vehicule diferite în zile diferite. Indicați componenta gândirii computaționale utilizată în acest caz: B. algoritmizarea A. descompunerea C. abstractizarea D. recunoașterea șabloanelor 4. În dezvoltarea unui sistem de recunoaștere facială pentru deblocarea unui telefon, inginerii decid să ignore culoarea ochilor sau stilul coafurii utilizatorului, concentrându-se exclusiv pe distanța dintre punctele cheie ale feței. Indicați componenta gândirii computaționale utilizată în acest caz: A. descompunerea B. algoritmizarea C. abstractizarea D. recunoașterea șabloanelor

9

I.2. Principalele moduri de reprezentare a algoritmilor Algoritmii sunt prezenți atât în domeniul informaticii, cât și în viața de zi cu zi, având un rol esențial în rezolvarea problemelor și organizarea activităților. Prin intermediul algoritmilor, procesele devin mai clare, mai eficiente și mai ușor de controlat.

Așa cum ați învățat, un algoritm este o succesiune de operații cunoscute executate într-o anumită ordine astfel încât plecând de la date de intrare se obțin într-un interval finit de timp date de ieșire. Acesta se caracterizează prin următoarele proprietăți, prezentate într-o ordine uzuală: ◗ generalitate – algoritmul poate fi aplicat pentru o clasă întreagă de probleme, nu doar pentru un caz particular; ◗ corectitudine – algoritmul oferă întotdeauna rezultatul corect dacă este aplicat corespunzător; ◗ finitudine – algoritmul se încheie după un număr finit de pași; ◗ claritate – fiecare instrucțiune este precisă și lipsită de ambiguitate; ◗ eficiență – rezolvarea problemei se face cu un consum rezonabil de timp și resurse.

Algoritmii pot fi observați ușor în activitățile cotidiene, de exemplu, împrumutul unei cărți de la bibliotecă.

Pașii acestui algoritm pot fi descriși astfel: 1. cauți cartea în catalog; 2. verifici dacă este disponibilă; 3. prezinți legitimația; 4. soliciți cartea bibliotecarului; 5. bibliotecarul aduce cartea de la raft; 6. bibliotecarul înregistrează împrumutul; 7. primești termenul de returnare.

OBSERVĂ Pașii algoritmului sunt ordonați și clari. Dacă lipsește un pas (de exemplu, „verifici disponibilitatea”), procesul poate eșua.

Pentru a fi înțeleși și aplicați mai ușor, algoritmii pot fi reprezentați în mai multe moduri: 1. Schema logică (diagrama de flux) este o modalitate de reprezentare a algoritmilor prin simboluri grafice și săgeți, care indică succesiunea operațiilor și a deciziilor.

Pentru reprezentarea schemelor logice, simbolurile uzuale sunt: Simbol

Descriere Linie de flux: reprezintă trecerea controlului între formele conectate Bloc de proces: reprezintă un bloc de calcul Bloc de subprogram/modul: reprezintă un apel de subprogram/modul care este reprezentat printr-o schemă logică separată Bloc de intrare/ieșire: reprezintă intrarea (CITIRE) sau ieșirea (SCRIERE) datelor Bloc de decizie: reprezintă o decizie care are ca rezultat două ieșiri, reprezentând cele două valori posibile (Da/Nu sau Adevărat/Fals) Bloc terminal: reprezintă momentul de început (START) sau de final (STOP) al procesului Bloc conector: reprezintă conectarea a două sau mai multe puncte ale schemei logice

10

◗ Caracteristici: folosește simboluri grafice (de exemplu, romburi pentru decizii, dreptunghiuri pentru operații de atribuire, elipse pentru început/sfârșit) unite prin săgeți. ◗ Avantaje: vizibilitate bună a fluxului logic; ideală pentru începători în înțelegerea structurilor repetitive și decizionale. ◗ Limite: dificil de utilizat pentru algoritmi complecși deoarece necesită mult spațiu și timp pentru desenare.

2. Limbajul pseudocod este o formă de descriere a algoritmului care folosește instrucțiuni simple, apropiate de limbajul natural, fără a respecta regulile stricte ale unui limbaj de programare.

Pentru reprezentarea algoritmilor în pseudocod, convențiile uzuale sunt: ◗ Indentare: liniile sunt indentate pentru a indica faptul că sunt conținute într-o structură dintr-o linie anterioară. ◗ Operațiile de intrare și ieșire sunt precizate prin comenzile citește <identificator sau identificatori, separați prin virgulă> respectiv scrie <expresie sau expresii, separate prin virgulă> ◗ Operațiile de atribuire sunt precizate în următorul format: <identificator>  <expresie> ◗ Comentariile sunt precedate de două bare oblice // și continuă până la sfârșitul liniei. ◗ Pentru operații aritmetice se utilizează simboluri standard ale operatorilor aritmetici: + (adunare), – (scădere), * (înmulțire), / (împărțire), ^ (ridicare la putere), √ (rădăcină pătrată), pentru partea întreagă a unui număr real se utilizează încadrarea expresiei între paranteze drepte, iar pentru restul împărțirii a două numere întregi se utilizează operatorul %. ◗ Structurile de control sunt: TIPUL STRUCTURII structură de decizie

structură repetitivă cu test inițial structură repetitivă cu test final structură repetitivă cu număr cunoscut de pași

FORMA GENERALĂ ┌dacă <condiție> atunci │ <Instrucțiuni1> │[altfel │ <Instrucțiuni2>] └■ ┌cât timp <condiție> execută │ <Instrucțiuni> └■ ┌repetă │ <Instrucțiuni> └până când <condiție> ┌pentru <contor>  <expInit>,<expFin>[,<pas>] execută │ <Instrucțiuni> └■

◗ Caracteristici: nu respectă regulile stricte de sintaxă ale unui limbaj de programare, dar respectă logica (de exemplu: dacă... atunci... altfel, cât timp...). ◗ Avantaje: se concentrează în principal pe logică, fără a pierde timpul cu erori de sintaxă și este ușor de tradus ulterior în orice limbaj de programare. ◗ Limite: nu poate fi executat direct de calculator, nu este standardizat, claritatea depinde de cel care-l scrie.

3. Limbajele de programare sunt un set formal de instrucțiuni și reguli (sintaxă) utilizate pentru a comunica cu computerul, permițând crearea de software. Altfel spus, un limbaj de programare permite unui programator să transpună un algoritm într-un format pe care computerul îl poate procesa și executa.

REȚINE! ◗ Un algoritm poate fi implementat în limbaje de programare diferite, însă pentru aceleași date de intrare va produce aceleași date de ieșire.

11

Clasificarea limbajelor de programare și caracteristici de bază Limbajele de programare nu sunt toate la fel. Ele au fost create pentru scopuri diferite și îi ajută pe programatori să rezolve tipuri variate de probleme. Unele limbaje sunt mai apropiate de modul în care funcționează calculatorul, iar altele sunt mai ușor de înțeles și de folosit de către oameni. De aceea, limbajele de programare pot fi împărțite în mai multe categorii, în funcție de anumite criterii. Cunoașterea acestor clasificări ne ajută să înțelegem mai bine la ce folosește fiecare limbaj și de ce, în practică, nu există un singur limbaj potrivit pentru toate situațiile.

A. După nivelul de apropiere față de modul de funcționare a calculatorului ◗ Limbaje de nivel scăzut o apropiate de limbajul mașină; o sunt greu de înțeles de oameni, dar rapide pentru calculator; o exemple: limbaj mașină, limbaj de asamblare. ◗ Limbaje de nivel înalt o apropiate de limbajul uman și ușor de învățat; o permit scrierea facilă a programelor și sunt independente de arhitectura sistemului de calcul; o exemple: Python, C++, Java, Pascal.

B. După modul de executare ◗ Limbaje compilate o programul este convertit complet în cod mașină înainte de executare; o oferă performanță ridicată în timpul rulării, dar implică un flux de lucru mai rigid, deoarece fiecare schimbare de cod impune regenerarea fișierului executabil; o portabilitate scăzută: Programul este transformat într-un fișier executabil specific unui anumit sistem de operare (de exemplu: un fișier .exe pentru Windows nu va rula pe macOS). Pentru a rula pe o altă platformă, codul trebuie compilat separat pentru acea arhitectură; o exemple: C, C++, Pascal. ◗ Limbaje interpretate o instrucțiunile sunt convertite în cod mașină și executate pe rând; o mai lente decât cele compilate, dar mai ușor de testat și modificat; o portabilitate ridicată: Codul sursă poate rula pe orice sistem de operare care are instalat interpretorul corespunzător (de exemplu: același script Python rulează și pe Windows, și pe Linux, fără modificări); o exemple: Python, JavaScript.

REȚINE! Pentru a înțelege mai bine diferența dintre un limbaj compilat și unul interpretat, imaginează-ți că: ◗ limbajul compilat este o carte tradusă și tipărită special pentru publicul din România; dacă vrei să o vinzi în Franța, trebuie să tipărești o ediție complet nouă; ◗ limbajul interpretat este ca un discurs în limba engleză la care participă mai mulți traducători (interpreți), vorbitorul spune același lucru, iar „interpreții” (software-ul instalat pe calculator) traduc mesajul pe loc pentru publicul local, indiferent de țară. ◗ Atât limbajele compilate, cât și cele interpretate permit realizarea de programe, în cazul limbajelor interpretate acestea sunt adesea denumite scripturi.

12

◗ Caracteristici: un limbaj de programare se caracterizează prin reguli stricte de sintaxă și detalii de implementare, spre deosebire de pseudocod și scheme logice, care descriu doar logica algoritmului. ◗ Avantaje: permit executarea unor sarcini repetitive sau complexe în milisecunde, sarcini care ar lua oamenilor mai mult timp; există „pachete” de cod gata scrise pentru multe domenii (de exemplu: inteligență artificială, grafică 3D, plăți online), ceea ce permite crearea cu ușurinţă a unor aplicaţii complexe; limbajele populare au milioane de utilizatori care oferă soluții gratuite la diverse probleme (de exemplu: Stack O ­ verflow, GitHub). ◗ Limite: nu există un limbaj universal ci există limbaje specializate pe domenii (de exemplu, pentru aplicaţii web, baze de date, automatizări); un limbaj foarte popular astăzi poate deveni irelevant în 10 ani, forțând companiile să rescrie sisteme întregi cu costuri mari; transformarea unui algoritm descris prin schemă logică sau pseudocod în program funcțional presupune cunoașterea detaliată a unui limbaj de programare, iar procesul de învățare a acestor detalii poate fi de durată.

TABEL COMPARATIV Modalitate de reprezentare

Nivel de detaliu

Ușurință

Executabil

Schemă logică

Vizual

Ridicată

Nu

Pseudocod

Logic

Ridicată

Nu

Limbaj interpretat

Tehnic

Medie

Da (prin interpretor)

Limbaj compilat

Tehnic

Scăzută

Da (direct)

CONCLUZIE ◗ Schemele logice sunt utile pentru reprezentarea vizuală a algoritmului. ◗ Pseudocodul este utilizat pentru organizarea logică a operaţiilor efectuate de un algoritm. ◗ Limbajele de programare sunt folosite pentru implementarea efectivă a algoritmului.

P ORTOFOLIU DIGITAL Carnetul de note Organizare

Creează folderele: Portofoliu digital > Capitolul 1 > Carnetul de note > Tema 1.

Cerința 1

Se citește o notă. Afișați "promovat" dacă nota este cel puțin 5, altfel "nepromovat".

Cerința 2

Se citesc trei note și media dorită. Calculați media și afișați mesajul "esti in grafic" dacă media obținută este cel puțin egală cu media dorită, altfel "mai trebuie sa inveti".

Salvează

carnetul_de_note.docx

Document

Realizează un document foarte scurt despre aplicație, cu câte un exemplu de rulare pentru fiecare algoritm. Nume recomandat: tema1_prezentare.docx.

13

EXERSEAZĂ!

1. Completați algoritmul scris în limbajul pseudocod astfel încât acesta să calculeze în variabila S suma primelor n numere naturale nenule. citește n S  0 i  1 ┌ cât timp i <= n execută │ . . . . . . │ i  i + 1 └ ■ scrie S

A. B. C. D.

S  S + i S  i S + i  S i  S

2. Precizați care dintre următoarele afirmații este adevărată: A. limbajele compilate rulează doar pe sistemul de operare Windows, iar cele interpretate doar pe Linux B. limbajele compilate sunt traduse integral înainte de executare, iar cele interpretate sunt traduse în timpul executării C. limbajele interpretate sunt mai rapide decât cele compilate D. limbajele compilate nu pot avea erori de sintaxă 3. Precizați care dintre următoarele limbaje este interpretat: A. C B. Pascal C. Python

D. limbaj de asamblare

4. Precizați tipul structurii de control utilizate în fiecare secvență:

A.

┌ dacă x > 0 atunci │ scrie "pozitiv" │ altfel │ scrie "negativ" └■

B.

n  10 ┌ cât timp n > 0 execută │ scrie n, " " │ n  n - 1 └■

C.

D.

┌ pentru i  1, 10 execută │ scrie i, " " └■

i  1 ┌ repetă │ scrie i, " " │ i  i + 1 └ până când i > 10

5. Precizați ce va afișa următorul algoritm pentru n = 27. citește n i  2 ┌ cât timp n > 1 execută │ ┌ dacă n % i = 0 atunci │ │ scrie i, " " │ │ ┌ cât timp n % i = 0 execută │ │ │ n  [n / i] │ │ └■ │ └■ │ i  i + 1 └■

14

A. 9 3 B. 27 9 3 C. 3 9 27 D. 3

I.3. Scheme logice și limbajul pseudocod. Aplicații practice Algoritmii pot fi reprezentați prin scheme logice și limbajul pseudocod, două modalități care evidențiază clar succesiunea pașilor, deciziile și structurile repetitive ale unei soluții. În această lecție, aceste forme de reprezentare vor fi utilizate în rezolvarea unor aplicații practice, pentru a facilita înțelegerea, analiza și transpunerea algoritmilor în programe.

Exemplul 1: În gările din Japonia, durata unei deplasări cu trenul între două orașe este dată în ore, minute și secunde. Haruto trebuie să ajungă din orașul său, Kanazawa, în orașul bunicilor săi, Nagasaki, dar vede că nu are o cursă directă, ci trebuie neapărat să schimbe trenul în Osaka. Scrieți un algoritm care să-l ajute pe Haruto să afle durata totală a călătoriei lui, citind de la tastatură duratele curselor Kanazawa – Osaka și Osaka – Nagasaki.

De exemplu, dacă duratele celor două curse sunt 2 ore, 45 de minute și 50 de secunde, respectiv 3 ore, 30 de minute și 25 de secunde, atunci durata totală este 6 ore, 16 minute și 15 secunde.

PSEUDOCOD

SCHEMA LOGICĂ

citește h1, m1, s1 citește h2, m2, s2 s  s1 + s2 m  m1 + m2 h  h1 + h2 m  m + [s/60] s  s % 60 h  h + [m/60] m  m % 60 scrie h, m, s

Algoritmul folosește următoarele variabile: ● Datele de intrare pentru cele două curse sunt h1, m1, s1, respectiv h2, m2, s2. ● Datele de ieșire h, m, s reprezintă durata totală a călătoriei.

Într-o primă fază, algoritmul însumează independent valorile pentru fiecare unitate de timp: secundele cu secundele, minutele cu minutele și orele cu orele. Dacă suma secundelor (s) este mai mare decât 59, extragem numărul de minute întregi și le adăugăm la totalul minutelor, păstrând doar restul ca secunde. Procedăm la fel pentru minute, transportând surplusul către ore.

Exemplul 2: Într-un proces de diviziune celulară de tip mitoză la planta de porumb, fiecare celulă se divide în alte două celule identice după câte o oră. Considerând o populație formată inițial dintr-o singură celulă de porumb, scrieți un algoritm care să afișeze orele între care numărul celulelor din populația curentă este cuprins între două numere naturale a și b (a≤b) citite de la tastatură, precum și numărul de celule din populația curentă.

De exemplu, pentru a = 100 și b = 1000 algoritmul trebuie să afișeze: Ora 7: 128 celule Ora 8: 256 celule Ora 9: 512 celule

15

Algoritmul folosește următoarele variabile pentru a monitoriza procesul: ● a și b: limitele intervalului dorit (capătul inferior și cel superior) ● nrc: număr celule ● ora: contorul de timp.

Mecanismul de executare 1. Inițializare: Se citesc valorile pentru a și b, se setează ora = 0 și nrc = 1 2. Structura repetitivă – cât timp numărul de celule (nrc) nu a depășit limita maximă b: o Verificarea intervalului: se verifică dacă numărul actual de celule este mai mare sau egal cu limita minimă a și în caz afirmativ se afișează ora curentă și populația o Multiplicarea celulelor: numărul de celule se dublează (nrc = nrc * 2) o Timpul: se incrementează contorul de timp (ora = ora + 1) 3. Finalizarea: structura repetitivă se oprește când nrc depășește valoarea b.

PSEUDOCOD citește a, b ora  0 nrc  1 ┌cât timp nrc ≤ b execută │ ┌dacă nrc ≥ a atunci │ │ scrie "Ora ", ora, ": ", │ │ nrc, "celule" │ └■ │ nrc  nrc * 2 │ ora  ora + 1 └■

Exemplul 3: Un greiere se deplasează efectuând câte o săritură, lungimea inițială a săriturii fiind de x cm. După fiecare n sărituri, lungimea săriturii greierului se micșorează cu p procente. Cunoscându-se valorile x, n, p, precum și numărul de sărituri m pe care le face greierele, să se scrie un algoritm care să afișeze distanța parcursă de greiere.

De exemplu, pentru x=20, n=10, p=10 și m=20 distanța parcursă de greiere este egală cu 380 cm, deoarece primele 10 sărituri efectuate au, fiecare, lungimea de 20 cm, iar următoarele 10 au, fiecare, lungimea de 18 cm.

16

SCHEMA LOGICĂ

PSEUDOCOD

SCHEMA LOGICĂ

citește x, n, p, m salt  x dist  0 ┌pentru i  1, m execută │ dist  dist + salt │ ┌dacă i % n = 0 atunci │ │ salt  salt * (1 - p / 100) │ └■ └■ scrie dist

Problema simulează o deplasare unde lungimea pasului (săriturii) scade periodic cu un anumit procent.

Variabilele utilizate: ● ● ● ●

x: lungimea inițială a săriturii n: numărul de sărituri după care lungimea scade p: procentul cu care scade lungimea m: numărul total de sărituri efectuate.

1. Inițializare: se pornește cu distanța dist = 0 și lungimea curentă a săriturii salt = x 2. Deplasarea greierului – Se folosește o structură repetitivă (pentru...execută) care rulează de m ori (pentru fiecare săritură): o la fiecare pas, lungimea curentă a săriturii se adaugă la distanța totală (dist = dist + salt) o prin testarea lui i % n = 0 se verifică dacă s-a ajuns la pragul de n sărituri o dacă pragul a fost atins, noua lungime se calculează după formula: salt = salt * (1 - p / 100) Astfel se reduce valoarea actuală cu procentul p.

P ORTOFOLIU DIGITAL Variante pentru aceeași problemă Produs final: Un document comparativ, salvat cu numele variante_problema.docx.

Cerință: Alege o problemă și propune două sau trei variante de rezolvare. De exemplu, poți avea o variantă în limbaj natural, una în pseudocod și una prin schemă logică. Sau poți prezenta două metode diferite de rezolvare a aceleiași problemei. Pentru fiecare variantă, argumentează avantajele și limitele ei.

Organizarea și salvarea fișierelor: În folderul 02_Variante_problema, salvează documentul variante_problema. docx și toate fișierele auxiliare necesare.

Element suplimentar: Încheie cu o recomandare personală, precizând ce variantă ai alege pentru a explica problema unui coleg.

17

EXERSEAZĂ!

1. Completați algoritmul astfel încât să afișeze pătratul numărului citit: citește x y  __________ scrie __________

2. Asociați fiecare element din Coloana A (instrucțiune sau simbol pseudocod) cu descrierea corespunzătoare din Coloana B (rolul sau semnificația acestuia).

Coloana A

Coloana B

1. citește x, y

a. Operație de atribuire

2. scrie Rezultat

b. Calculează partea întreagă a unui număr

3. x  y

c. Operație de ieșire (afișare) a datelor

4. a % b

d. Calculează restul împărțirii întregi

5. [ număr ]

e. Operație de intrare (citire) a datelor

3. Se consideră următorul algoritm scris în limbajul pseudocod, care simulează udarea unei grădini cu n flori.

Pentru fiecare floare, se folosește o cantitate de x ml de apă, dar florile aflate pe poziții pare (2, 4, 6...) sunt mai însetate și primesc o cantitate dublă de apă (2 * x ml). Analizați algoritmul scris în limbaj pseudocod și realizați schema logică corespunzătoare. citește n, x total_apa  0 ┌ pentru i  1, n execută │ ┌ dacă i % 2 = 0 atunci │ │ total_apa  total_apa + 2 * x │ │ altfel │ │ total_apa  total_apa + x │ └ ■ └ ■ scrie total_apa

4. Un sportiv începe un program de antrenament alergând în prima zi o distanță de x km. Pentru a-și crește rezistența, după fiecare n zile de antrenament, el decide să mărească distanța parcursă zilnic cu p procente față de perioada anterioară. Să se scrie un algoritm în limbajul pseudocod care citește valorile x, n, p și numărul total de zile m, numere naturale și afișează distanța totală parcursă de sportiv la finalul programului.

Exemplu: Pentru x = 10, n = 5, p = 10 și m = 10, distanța totală este 105.0 km.

(Explicație: Primele 5 zile aleargă câte 10 km/zi (50 km), iar următoarele 5 zile aleargă câte 11 km/zi (55 km)).

5. O știre este postată online și, inițial, o singură persoană o vede. În fiecare oră, fiecare persoană care a citit deja știrea o transmite către alte 2 persoane noi (numărul total de persoane care cunosc știrea se triplează la fiecare oră). Scrieți un algoritm care citește de la tastatură două numere naturale a și b și afișează orele la care numărul persoanelor informate se află în intervalul [a, b], precum și numărul total de persoane din acele ore.

Exemplu: Pentru a = 20 și b = 100, algoritmul va afișa: o Ora 3: 27 persoane o Ora 4: 81 persoane.

18

I.4. Testarea algoritmilor.

Urmărirea evoluției valorilor variabilelor Elaborarea testelor pentru algoritmi trebuie să asigure verificarea sistematică a comportamentului algoritmului pentru cazuri generale, limită și speciale, astfel încât să se obțină un nivel ridicat de încredere în corectitudinea, completitudinea și robustețea soluției. O testare completă presupune că fiecare cerință specifică este acoperită de cel puțin o probă de verificare.

1. Criterii de testare Un set de teste riguros trebuie să respecte următoarele criterii fundamentale: 1. Testarea cazurilor generale Seturile de date de intrare trebuie să cuprindă valori care apar cel mai frecvent în utilizarea algoritmului. ◗ Scop: verificarea logicii principale a algoritmului. ◗ Exemplu: pentru un algoritm care calculează media a două numere, folosim valori pozitive, precum 4 și 7.

2. Testarea cazurilor limită Multe erori de logică apar la „marginile” intervalelor permise pentru valorile datelor de intrare.

Exemple tipice: ◗ valoarea 0 (zero). ◗ cea mai mică sau cea mai mare valoare posibilă.

3. Testarea cazurilor speciale ◗ Seturile cuprind fie valori particulare (de exemplu, valori egale), fie au dimensiune atipică (de exemplu, un element sau chiar niciunul).

4. Gestionarea valorilor exceptate sau invalide Un algoritm robust trebuie să trateze și date de intrare invalide. ◗ Exemplu: împărțirea la zero, introducerea unei valori negative pentru lungimea laturii unui pătrat.

5. Acoperirea tuturor cazurilor Dacă algoritmul conține structuri decizionale (dacă...atunci...altfel), atunci trebuie create teste care să forțeze parcurgerea fiecărei ramuri.

6. Testarea corectitudinii structurilor repetitive Pentru structurile repetitive verificăm: ◗ Cazul „Zero executări”: condiția structurii repetitive este falsă de la bun început; ◗ Cazul „O singură executare”: structura repetitivă se execută exact o dată; ◗ Cazul „N executări”: structura repetitivă funcționează corect pentru un număr mare de iterații.

Exemplul 1: Elaborați criterii de testare pentru următorul algoritm scris în limbajul pseudocod: Explicații:

citește a, b r  [a / b] scrie r

● Caz de bază: a = 10, b = 2 => r = 5 (rezultat corect). ● Caz limită: a = 10, b = 0 => eroare, deoarece împărțirea la 0 este nedefinită!

REȚINE! ◗ Testează întotdeauna valoarea zero dacă ai operații matematice. Un algoritm complet conține un test de validare: dacă b != 0 atunci....

19

Un algoritm nu poate fi considerat corect doar pentru că a funcționat pe câteva teste. Succesul la primele teste este doar un punct de plecare, nu o confirmare finală. Nu încerca doar să demonstrezi că programul tău funcționează; adevărata provocare este să încerci să-l „strici” folosind valori atipice sau cazuri limită.

Aceasta este mentalitatea unui programator bun: să rămână sceptic și să caute mereu eroarea ascunsă.

Exemplul 2: Elaborați criterii de testare pentru următorul algoritm scris în limbajul pseudocod care citește două numere naturale a și b și calculează ab: citește a,b (numere naturale) P  1 i  1 ┌ cât timp i <= b execută │ P  P * a │ i  i + 1 └■ scrie P

Explicații: 1. Inițializarea ● P  1: Variabila P este un produs. ● i  1: Variabila i este o variabilă de manevră și are rol de contor. Aceasta indică numărul de înmulțiri efectuate și permite stabilirea momentului în care algoritmul se oprește.

2. Structura repetitivă (cât timp... execută) Condiția i <= b verifică dacă s-au efectuat b înmulțiri. ● P  P * a: La fiecare pas, rezultatul anterior este înmulțit din nou cu baza a. ● i  i + 1: Această instrucțiune actualizează valoarea contorului i, asigurând modificarea condiției de continuare. În lipsa ei, valoarea lui i ar rămâne constantă, condiția ar fi mereu adevărată, iar algoritmul nu s-ar mai încheia.

3. Analiza pe cazuri – criterii de testare Pentru a fi siguri că algoritmul este robust, trebuie să îl trecem prin mai multe filtre de testare: ● Cazul general (a = 3, b = 4): Algoritmul face 4 pași. Se afișează valoarea 81, deci algoritmul funcționează corect. ● Cazul limită (b = 0): Dacă exponentul este 0, condiția 1 <= 0 este falsă din start. Structura repetitivă nu se execută și se afișează 1, reprezentând valoarea lui P, deci algoritmul funcționează corect (a0 = 1). ● Cazul „o singură execuție” (b = 1): Structura repetitivă se execută o dată și se afișează a reprezentând valoarea lui P, deci algoritmul funcționează corect (a1 = a). ● Cazul special (a = 0): Dacă baza este 0, P va deveni 1 rezultatul corect fiind 0 (0b = 0). Pentru ca algoritmul să furnizeze rezultatul corect indiferent de valorile variabilelor naturale a și b este necesar să înlocuim instrucțiunea scrie P cu următoarea structură de decizie: ┌dacă a=0 atunci scrie 0 │ altfel scrie P └■

REȚINE! ◗ Acest algoritm este unul iterativ. El transformă o operație matematică complexă (ridicarea la putere) într-o serie de operații simple (înmulțiri și adunări) pe care procesorul le poate executa rapid.

20

2. Urmărirea evoluției valorilor variabilelor Identificarea erorilor de logică necesită monitorizarea stării algoritmului prin înregistrarea valorilor succe­ sive ale variabilelor. Această metodă, numită tabel de evoluție a valorilor variabilelor, este esențială pentru a verifica corectitudinea algoritmului.

Exemplul 3: Realizați tabelul de evoluție a valorilor variabilelor pentru următorul algoritm scris în limbajul pseudocod care calculează suma 1 + 2 + … + n considerând pentru variabila n valoarea 4. citește n (număr natural) S  0 i  1 ┌cât timp i <= n execută │ S  S + i │ i  i + 1 └■ scrie S

Explicații: Tabelul de evoluție a valorilor variabilelor: Pasul

n

i

Condiția (i ≤ n)

S

Observații

Pas 1

4

1

-

0

citirea și atribuirile din afara structurii repetitive

Pas 2

4

1

1 ≤ 4 (adevărat)

0+1=1

i devine 2 la finalul pasului

Pas 3

4

2

2 ≤ 4 (adevărat)

1+2=3

i devine 3 la finalul pasului

Pas 4

4

3

3 ≤ 4 (adevărat)

3+3=6

i devine 4 la finalul pasului

Pas 5

4

4

4 ≤ 4 (adevărat)

6 + 4 = 10

i devine 5 la finalul pasului

Pas 6

4

5

5 ≤ 4 (fals)

10

se părăsește structura repetitivă și se afișează S

Exemplul 4: Realizați tabelul de evoluție a valorilor variabilelor pentru următorul algoritm scris în limbajul pseudocod care afișează valoarea maximă și valoarea minimă dintr-un șir de n numere întregi, considerând n = 5 și secvența de valori 7, 3, 9, 2, 8.

Explicație: Algoritmul citește mai întâi numărul de valori din șir, n.

Se citește x, primul element al șirului și se inițializează cu valoarea sa atât minimul cât și maximul.

Apoi, pentru fiecare dintre celelalte elemente: ● dacă valoarea citită x este mai mare decât maxim, atunci maxim se actualizează;

citește n citește x maxim  x minim  x i  2 ┌cât timp i <= n execută │ citește x │ ┌dacă x > maxim atunci │ │ maxim  x │ └■ │ ┌dacă x < minim atunci │ │ minim  x │ └■ │ i  i + 1 └■ scrie maxim," ", minim

● dacă valoarea citită este mai mică decât minim , atunci minim se actualizează.

La final, se afișează valorile maxim și minim.

21

Tabelul de evoluție a valorilor variabilelor: Pasul

n

i

Condiția (i ≤ n) x (citit) maxim

minim Observații

Pas 1

5

2

-

7

7

7

citirile și atribuirile din afara structurii repetitive

Pas 2

5

2

2 ≤ 5 (adevărat)

3

7

3

3 > 7 (fals)=> maxim nu se modifică 3 < 7 (adevărat) => minim 3

Pas 3

5

3

3 ≤ 5 (adevărat)

9

9

3

9 > 7 (adevărat) => maxim 9 9 < 3 (fals)=> minim nu se modifică

Pas 4

5

4

4 ≤ 5 (adevărat)

2

9

2

2 > 9 (fals) => maxim nu se modifică 2 < 3 (adevărat)=> minim 2

Pas 5

5

5

5 ≤ 5 (adevărat)

8

9

2

8 > 9 (fals) => maxim nu se modifică 8 < 2 (fals)=> minim nu se modifică

Pas 6

5

6

6 ≤ 5 (fals)

-

9

2

se părăsește structura repetitivă și se afișează maxim și minim

EXERSEAZĂ!

1. Se consideră un algoritm care calculează aria unui dreptunghi cu lungimea L și lățimea l. a) Specificați condițiile de validare pentru datele de intrare L și l. b) Ce s-ar întâmpla dacă utilizatorul ar introduce valoarea -5 pentru lățime? Justificați prin prisma corectitudinii.

2. Se consideră următorul algoritm scris în limbajul pseudocod: citește n s  1 ┌pentru i  1, n-1 execută │ s  s + i └■ scrie s a) Indicați valoarea lui n pentru care algoritmul furnizează suma 1 + 2 + ... + n. b) Identificați eroarea și corectați algoritmul astfel încât variabila s să memoreze suma 1 + 2 + ... + n pentru orice număr natural n.

3. Știind că nota la examen a unui elev este memorată în variabila N (număr real) și că acesta a promovat dacă a obținut cel puțin nota 5, propuneți valori pentru testarea unui algoritm care afișează dacă elevul a promovat sau nu: B. Caz tipic (Respins): N = ____ A. Caz tipic (Promovat): N = ____ D. Caz invalid: N = ____ C. Caz la limită: N = ____ 4. Se consideră următorul algoritm scris în limbajul pseudocod: citește n (număr natural ≥ 2) i  2 ┌cât timp i < n execută │ scrie i," " │ i  i + 2 └■

A. Identificați modificările necesare astfel încât acesta să afișeze toate numerele pare din intervalul [1,n].

B. Indicați o valoare a variabilei n pentru care algoritmul inițial afișează toate numerele pare din intervalul [1,n].

C. Realizați un tabel de evoluție a valorilor variabilelor pentru n = 9.

22

I.5. Principalele etape ale elaborării unui program Pentru realizarea unui program corect și eficient este necesară parcurgerea unor etape bine definite, care constituie procesul de dezvoltare a programelor.

Principalele etape sunt: 1. analiza problemei; 2. proiectarea soluției (algoritmului); 3. implementarea programului; 4. testarea programului; 5. depanarea programului.

Parcurgerea acestor etape permite programatorului să înțeleagă problema, să găsească o soluție adecvată și să verifice dacă programul funcționează corect.

1. Repere pentru etapa de analiză a problemei Analiza reprezintă prima etapă în elaborarea unui program și constă în studierea atentă a cerinței problemei pentru a înțelege exact ce trebuie rezolvat. În această etapă se identifică: ◗ ◗ ◗ ◗

datele de intrare (input) – informațiile pe care programul le primește; datele de ieșire (output) – rezultatele pe care programul trebuie să le producă; condițiile și restricțiile problemei – limitele valorilor sau condițiile speciale; relațiile dintre date – operațiile care trebuie efectuate pentru obținerea rezultatului.

Analiza problemei este foarte importantă deoarece o înțelegere greșită a cerinței va conduce la o soluție incorectă, indiferent de cât de bine este scris programul. În practică, analiza presupune: ◗ citirea atentă a enunțului; ◗ identificarea informațiilor esențiale; ◗ stabilirea operațiilor care trebuie efectuate asupra datelor.

Rezultatul acestei etape este o descriere clară a problemei și a elementelor implicate în rezolvarea ei.

2. Repere pentru etapa de proiectare a soluției (algoritmului) După ce problema a fost analizată, urmează etapa de proiectare a soluției, în care se stabilește modul de rezolvare. În această etapă se recomandă: ◗ stabilirea pașilor necesari pentru rezolvarea problemei; ◗ organizarea acestor pași într-o succesiune logică; ◗ utilizarea unor structuri algoritmice fundamentale: secvențiale, de decizie, repetitive; ◗ descrierea soluției prin pseudocod sau schemă logică; ◗ verificarea logicii algoritmului înainte de implementare.

Un algoritm bine proiectat facilitează implementarea ulterioară și reduce posibilitatea apariției erorilor.

Dacă poți explica strategia unui prieten fără să folosești termeni tehnici, înseamnă că ai proiectat-o corect.

3. Repere pentru etapa de implementare a programului Implementarea constă în transformarea algoritmului într-un program folosind un limbaj de programare. În această etapă trebuie avute în vedere următoarele aspecte: ◗ ◗ ◗ ◗ ◗

alegerea unui limbaj de programare adecvat; respectarea regulilor de sintaxă ale limbajului; utilizarea corectă a variabilelor și a tipurilor de date; transpunerea fidelă a pașilor algoritmului în instrucțiuni ale unui limbaj de programare; scrierea codului într-o formă clară și ușor de înțeles.

23

Implementarea corectă depinde în mare măsură de calitatea algoritmului elaborat în etapa anterioară.

Programul scris într-un limbaj de programare este apoi compilat sau interpretat, pentru a putea fi executat de calculator. Este important ca programatorul să respecte algoritmul proiectat anterior, deoarece implementarea reprezintă transpunerea exactă a algoritmului în cod.

4. Repere pentru etapa de testare a programului Testarea are rolul de a verifica dacă programul produce rezultatele corecte pentru diferite valori ale datelor de intrare. Pentru realizarea unei testări eficiente se recomandă: ◗ utilizarea mai multor seturi de date de test; ◗ verificarea rezultatelor obținute cu rezultatele așteptate; ◗ testarea cazurilor obișnuite, dar și a cazurilor limită; ◗ observarea comportamentului programului în situații diferite.

Testarea permite identificarea eventualelor probleme apărute în timpul executării programului.

Strategia de testare „Black Box” Folosim adesea testarea de tip „Black Box”: nu urmărești codul în timp ce-l testezi, ci te comporți ca un utilizator care nu știe cum a fost scris algoritmul. Pur și simplu introduci date de intrare și compari rezultatul obținut cu rezultatul calculat manual de tine pe hârtie.

5. Repere pentru etapa de depanare a programului În cazul în care în timpul testării sunt descoperite erori, acestea trebuie identificate și corectate. Procesul de găsire și corectare a erorilor se numește depanare (debugging).

Erorile din programe pot fi de mai multe tipuri: a. erori de sintaxă: apar când regulile limbajului de programare nu sunt respectate (de exemplu, lipsa unui simbol sau utilizarea incorectă a unei instrucțiuni); b. erori logice: apar când algoritmul nu este corect, chiar dacă programul se execută fără erori de sintaxă. În acest caz rezultatul obținut este incorect; c. erori de execuție: apar în timpul rulării programului și pot fi cauzate de operații imposibile sau de date necorespunzătoare.

Depanarea presupune: ◗ identificarea locului unde apare eroarea; ◗ analizarea cauzei erorii; ◗ modificarea codului pentru corectarea problemei.

După corectarea erorilor, programul trebuie testat din nou, pentru a verifica dacă problema a fost rezolvată.

Depanarea este o etapă importantă deoarece contribuie la obținerea unui program funcțional și stabil.

Concluzie: Aplicarea corectă a etapelor de elaborare a unui program în rezolvarea problemelor presupune respectarea unor repere clare pentru fiecare etapă: analiză, proiectare, implementare, testare și depanare.

Aceste repere facilitează: ◗ înțelegerea corectă a problemei; ◗ realizarea unui program corect;

◗ ◗

dezvoltarea unui algoritm logic și eficient; identificarea și corectarea erorilor.

Prin utilizarea sistematică a acestor etape și repere se dezvoltă gândirea algoritmică și capacitatea de a rezolva probleme utilizând calculatorul. În acest an școlar vom explora împreună Python, un limbaj de programare modern și prietenos, creat de Guido van Rossum la sfârșitul anilor ’80. Python este conceput special pentru a fi ușor de învățat având o sintaxă clară, foarte apropiată de limbajul natural. Acest lucru ne va permite să ne concentrăm pe ceea ce este cu adevărat important: logica algoritmilor și rezolvarea eficientă a problemelor.

24

Python nu este doar un instrument de învățare, ci un lider în tehnologia modernă, fiind utilizat pentru a construi platforme globale și soluții complexe în domenii variate: ◗ Inteligență Artificială și Big Data: este pilonul central pentru antrenarea modelelor de învățare automată și procesarea volumelor masive de date; ◗ Dezvoltare Web: se utilizează pe partea de server (backend) pentru a rula site-uri și aplicații de mare anvergură; ◗ Automatizări: flexibilitatea sa îl face ideal pentru a scăpa de Scanează codul QR sarcinile repetitive prin scripturi inteligente; pentru a urmări un ◗ Finanțe și jocuri video: este esențial în tranzacționările videoclip care te va algoritmice și pentru crearea rapidă de prototipuri în industria ajuta cu instalarea jocurilor; Python și a IDE‑ului ◗ Internet of Things (IoT): simplitatea sa permite controlul dispoPyCharm. zitivelor inteligente și integrarea ușoară în proiecte de robotică.

P ORTOFOLIU DIGITAL Mic ghid vizual pentru colegi: Cum construiesc un algoritm bun?

Produs final: Un poster digital, o broșură sau o prezentare, salvat(ă) cu numele ghid_algoritm.docx, ghid_ algoritm.pptx.

Cerință: Realizează un ghid vizual destinat colegilor de clasă. Ghidul trebuie să conțină cel puțin 5 secțiuni: proprietățile algoritmilor, modurile de reprezentare, importanța ordinii pașilor, rolul testării și etapele elaborării unui program. Pentru fiecare secțiune oferă o explicație scurtă și un exemplu.

Organizarea și salvarea fișierelor: În folderul 3_Ghid_vizual, salvează produsul final. Dacă folosești imagini sau pictograme separate, păstrează-le în același folder.

Element suplimentar: La final, adaugă o secțiune cu titlul Sfaturi pentru colegi.

Exersează!

1. Precizați care este prima etapă în elaborarea unui program: A. Proiectarea soluției (algoritmului) C. Implementarea programului

B. Analiza problemei D. Testarea programului

2. Precizați în ce etapă se alege limbajul de programare adecvat și se respectă regulile de sintaxă ale acestuia: A. Depanare

B. Analiză

C. Implementare

D. Proiectare

3. Precizați ce presupune strategia de testare de tip „Black Box” (Cutia Neagră): A. Modificarea codului sursă în timpul testării B. Verificarea regulilor de sintaxă ale limbajului C. Comportarea ca un utilizator care nu cunoaște codul, comparând datele de intrare cu rezultatele așteptate D. Identificarea locului unde apare o eroare de execuție 4. Precizați cum se numesc erorile care apar atunci când algoritmul nu este corect, deși programul se execută fără a încălca regulile de sintaxă: A. Erori de sintaxă C. Erori de execuție

B. Erori logice D. Erori de compilare

5. Precizați cine a creat limbajul de programare Python la sfârșitul anilor ’80.

A. John von Neumann C. Guido van Rossum

B. Bjarne Stroustrup D. Alan Turing

25

PROBLEME PROPUSE 1. Se citește distanța d, realizată la proba de săritură în lungime la un concurs sportiv. Dacă d < 4, se afișează "începător". Dacă 4 ≤ d < 6, se afișează "mediu". Dacă d ≥ 6, se afișează "avansat".

2. Se citește numărul de minute m cu care un elev a întârziat la un eveniment. Dacă m = 0, se afișează "la timp".

Dacă 1 ≤ m ≤ 10, se afișează "întârziere mică". În celelalte situații, se afișează "întârziere mare".

3. Se citește n, apoi numărul elevilor prezenți în fiecare dintre n clase. Să se determine câte clase au cel puțin 25 de elevi prezenți.

4. Se citesc temperaturile din 7 zile. Să se afișeze temperatura maximă.

5. Se citește n, apoi n note. Să se calculeze media aritmetică a notelor și să se afișeze mesajul "promovat" dacă media este cel puțin 5, altfel "nepromovat".

6. Gigel își dorește foarte mult să-și cumpere o jucărie. Pentru a reuși cât mai repede acest lucru, el se hotărăște să depună în pușculița sa, în fiecare zi, câte o sumă de bani (număr natural nenul). Cunoscând prețul jucăriei și sumele depuse de Gigel zilnic, scrieți un algoritm care afișează după câte zile Gigel reușește să strângă în pușculiță suma necesară, suma medie zilnică pe care acesta a depus-o în pușculiță, precum și suma care îi va rămâne după ce își va cumpăra jucăria.

7. Se citește n, apoi pentru fiecare produs se citește stocul său. Să se determine câte produse au stoc sub 5 și care este stocul minim.

8. Se citesc, pe rând, minutele de întârziere ale elevilor care ajung la un eveniment. Citirea se oprește când se introduce valoarea -1. Determinați câți elevi au ajuns la timp, câți au avut întârziere mică și câți au avut întârziere mare. Un elev este considerat că a ajuns la timp, dacă m = 0, că a ajuns cu întârziere mică, dacă 1 ≤ m ≤ 10 și că a ajuns cu întârziere mare, dacă m > 10.

9. Se citesc numărul e de elevi și numărul b de bănci duble. Să se stabilească dacă toți elevii pot fi așezați în clasă și, dacă da, câte locuri rămân libere. Dacă nu, să se afișeze câți elevi rămân fără loc.

10. Un robot transportă cărți între săli. El pornește cu energia 100. Se citește n, numărul maxim de curse (n ≤ 8).

Pentru fiecare cursă se citesc d = distanța parcursă, în zeci de metri, și s = 1 dacă robotul a urcat scări, 0 în caz contrar. Consumul unei curse este d unități pentru distanță și încă 5 unități dacă s = 1. Robotul execută ­cursele în ordine, dar se oprește imediat dacă energia rămasă ar deveni mai mică decât 10. Să se determine numărul curselor efectuate, energia rămasă, distanța maximă parcursă într-o cursă efectuată, numărul curse­lor în care a urcat scări și mesajul "misiune completă" sau "misiune oprită".

Fișa de observare sistematică a activității și a comportamentului Completează această fișă la sfârșitul fiecărui capitol!

Comportamentul urmărit Am dovedit interes de învățare.

Am urmat instrucțiunile primite.

Am lucrat individual fără a fi distras.

Am cerut ajutor când am avut nevoie.

Când am greșit, am vrut să aflu cum pot corecta.

Am participat activ la activități.

Mi-am spus părerea argumentat.

Am cooperat cu ceilalți în activitățile de grup.

26

Niciodată

Uneori

Deseori

Întotdeauna

FIȘĂ DE EVALUARE FINALĂ Indicații: Citește cu atenție fiecare cerință. Pentru itemii subiectivi se punctează atât corectitudinea logică, cât și claritatea redactării.

SUBIECTE 1. La organizarea unui muzeu virtual, echipa păstrează pentru proiect următoarele informații: numărul sălii, traseul vizitatorului și durata explicației audio. Culoarea pereților, modelul scaunelor și marca boxelor nu sunt luate în calcul. Componenta gândirii computaționale utilizată este: ...................................................... 6p A. descompunerea B. recunoașterea tiparelor C. abstractizarea D. algoritmizarea 2. Pentru elaborarea unui program, asociați fiecare situație din coloana A cu etapa potrivită din coloana B. ... 6p A

B

1. Se stabilesc datele de intrare, datele de ieșire și restricțiile.

a) implementarea

2. Se scrie programul într-un limbaj de programare.

b) testarea

3. Se verifică rezultatele pe mai multe exemple.

c) depanarea

4. Se corectează erorile descoperite după rulare.

d) analiza problemei

3. Scrieți A (adevărat) sau F (fals) în dreptul următoarelor afirmații. .................................................................. 8p a) Un algoritm clar conține instrucțiuni precise și neambigue. b) Finitudinea înseamnă că algoritmul poate fi aplicat la multe probleme asemănătoare. c) Corectitudinea înseamnă că algoritmul produce rezultatul cerut. d) Un algoritm poate fi bun chiar dacă nu se oprește niciodată.

4. Identificați metoda de reprezentare a unui algoritm corespunzătoare pentru fiecare afirmație, alegând dintre: A schemă logică, B pseudocod sau C limbaj de programare: ......................................................................... 10p 1. Este potrivită când vrem să evidențiem vizual deciziile și traseul execuției.

2. Este potrivită când vrem să descriem logica fără sintaxă strictă.

3. Este folosită pentru implementarea efectivă a algoritmului.

4. Poate deveni greu de desenat pentru algoritmi foarte mari.

5. Nu poate fi executată direct de calculator.

5. Un liceu organizează "Ziua porților deschise" și vrea să primească vizitatorii în mod eficient. Precizați: ...... 10p a) două subprobleme în care poate fi împărțită problema generală; b) un tipar care ar putea fi observat din anii anteriori; c) o informație care poate fi ignorată în rezolvarea problemei; d) doi pași ai unui posibil algoritm de organizare.

6. Se citește vârsta unei persoane pentru a determina ce tip de bilet de intrare la muzeu trebuie să achite. Scrieți un algoritm în pseudocod care afișează mesajul "gratuit" dacă vârsta este mai mică decât 7 sau mai mare decât 65, mesajul "redus" dacă vârsta este cel mult 18 și mesajul "întreg" în celelalte situații. ................ 12p

27

7. Se consideră următorul algoritm în limbajul pseudocod: ............................................................................ 12p citește n (număr natural) k  0 i  1 ┌cât timp i <= n execută │ citește x │ ┌dacă x >= 40 atunci │ │ k  k + 1 │ └■ │ i  i + 1 └■ scrie k

Realizați tabelul de evoluție a variabilelor pentru n = 4, iar valorile citite pentru x sunt: 32, 45, 40, 18.

8. Se consideră următorul algoritm. Elaborați 4 teste relevante care să acopere: un caz invalid, un caz limită, un caz general în care se aplică reducerea și un caz general în care nu se aplică reducerea. Pentru fiecare test, scrieți valoarea de intrare, rezultatul așteptat și justificarea. ......................................................................... 12p citește suma ┌dacă suma < 0 atunci │ scrie "valoare invalidă" │altfel │ ┌dacă suma >= 100 atunci │ │ scrie suma * 90 / 100 │ │altfel │ │ scrie suma │ └■ └■

9. În cadrul unui club de lectură, înscrierile se centralizează zilnic. În fiecare zi se notează numărul elevilor înscriși.

Campania durează minimum 1 zi și maximum 7 zile, dar se poate opri mai devreme dacă totalul înscrierilor ajunge la cel puțin 120. Scrieți un algoritm în pseudocod care: .......................................................................... 14p a) citește numărul elevilor înscriși în fiecare zi; b) calculează totalul elevilor înscriși; c) determină numărul zilelor de înscriere efectiv parcurse; d) determină numărul maxim de elevi înscriși într-o zi; e) determină numărul zilelor în care s-au înscris cel puțin 15 elevi; f) calculează media elevilor înscriși pe zi; g) afișează mesajul „grupe complete” dacă totalul este cel puțin 120, altfel „înscrieri insuficiente”.

Precizați datele de intrare, datele de ieșire, variabilele folosite, tipul structurii repetitive și condiția de oprire.

Elaborați și 5 teste relevante.

28

CAPITOLUL II Prelucrări numerice. Algoritmi elementari.

Baze de numerație COMPETENȚE SPECIFICE VIZATE CS 1.2 Identifică specificul, caracteristicile și etapele unor algoritmi specializați pe clase de probleme, pentru a îi putea utiliza în prelucrarea algoritmică a numerelor, sortarea sau generarea sistematică a unor secvențe de valori.

CS 2.2 Explică etapele algoritmilor specializați pe clase de probleme, pentru a îi putea utiliza în prelucrarea algoritmică a numerelor, sortarea sau generarea sistematică a unor secvențe de valori.

CS 3.2 Aplică algoritmi specializați pe clase de probleme, pentru a îi putea utiliza în prelucrarea algoritmică a numerelor, sortarea sau generarea sistematică a unor secvențe de valori.

CS 4.2 Analizează comportamentul, aplicabilitatea, avantajele și dezavantajele utilizării unor algoritmi specializați pe clase de probleme pentru prelucrarea numerelor, sortarea sau generarea sistematică a unor secvențe de valori.

CS 6.2 Proiectează soluții cu aplicarea personalizată a algoritmilor specializați pe clase de probleme pentru prelucrarea numerelor, sortarea sau generarea sistematică a unor secvențe de valori.

II.1. Accesarea cifrelor unui număr În multe probleme de informatică este necesar să prelucrăm numere și să lucrăm direct cu cifrele lor.

Pentru a înțelege și rezolva corect astfel de probleme, vom începe prin a recapitula câteva noțiuni de bază din limbajul Python pe care le-ați studiat în clasele gimnaziale: tipurile de date simple, variabilele, operatorii și funcțiile de citire/scriere.

Pentru început, să ne reamintim tipurile de date simple și noțiunea de variabilă. În Python, datele pot avea tipuri diferite, stabilite automat în funcție de valoarea atribuită (tipizare dinamică). În limbajul Python, o variabilă este un nume (identificator) asociat unei valori stocate în memoria internă. Evident, valoarea unei variabile poate fi modificată pe parcursul executării programului.

Exemple:

Tip

Descriere

Exemple

int

numere întregi

10, 2000, -100, 0

float

numere reale

19.99, 3.14, 200.0

bool

valori logice

True, False

contor = 1 # Initializare: contor are valoarea 1 contor = contor + 1 # Modificare: acum contor are valoarea 2

REȚINE! ◗ În limbajul Python, variabilele nu se declară separat – ele apar în momentul în care le atribui o valoare (­inițializare). Astfel, o variabilă trebuie inițializată înainte de utilizarea sa într-un calcul. ◗ Tipul unei variabile se poate schimba dacă îi atribuim o valoare de alt tip. ◗ Python este un limbaj cu tipizare dinamică, ceea ce înseamnă că tipul unei variabile este stabilit automat în funcție de valoarea atribuită.

După cum știți, atribuirea unei valori unei variabile se realizează, în cel mai simplu mod, folosind instrucțiunea: variabilă = expresie

29

REȚINE! ◗ În limbajul Python, există și alte forme ale instrucțiunii de atribuire: ▪ atribuirea compusă: are forma generală a op= b (echivalentă cu a = a op b), unde op este un operator aritmetic (de exemplu: s += 5 sau n //= 10) ▪ atribuirea multiplă: putem atribui valori mai multor variabile printr-o singură instrucțiune (de exemplu: a, b = 3, 7 sau x, y, z = 1, 3.14, True) ▪ atribuirea înlănțuită: putem atribui aceeași valoare mai multor variabile printr-o singură instrucțiune (de exemplu: a = b = c = 3) ◗ În limbajul Python, interschimbarea valorilor a două variabile se face cel mai simplu prin atribuire fără a folosi o variabilă de manevră: a, b = b, a Operatorii aritmetici permit efectuarea calculelor matematice.

Operator

Semnificație

Exemplu

Rezultat

+

adunare

10 + 3

13

-

scădere

10 - 3

7

*

înmulțire

10 * 3

30

/

împărțire reală

10 / 3

3.333...

//

împărțire întreagă

10 // 3

3

%

modulo

10 % 3

1

ridicare la putere

2 ** 3

8

**

ȘTIAI CĂ... ◗ În limbajul Python, se poate folosi underscore pentru a citi mai ușor numerele mari: x = 19_000_000

◗ Operatorul ** se poate folosi și pentru a calcula rădăcină pătrată: z = 9 ** 0.5 (instrucțiunea atribuie lui z valoarea √9)

REȚINE! ◗ Expresia n % 10 furnizează ultima cifră a numărului n (de exemplu: 125 % 10 este 5). ◗ Expresia n // 10 furnizează numărul obținut prin eliminarea ultimei cifre a lui n (de exemplu: 125 // 10 este 12).

După cum știți, pentru citirea datelor se folosește funcția input(), care fur­ nizează valoarea citită de la tastatură sub formă de text (șir de caractere).

Exemple: ● citire text: nume = input("Cum te numesti? ") ● citire număr întreg: varsta = int(input("Cati ani ai? ")) ● citire număr real: media = float(input("Media ta: "))

REȚINE! ◗ Mesajul explicativ din funcția input() contribuie la o utilizare mai ușoară a programului. ◗ Funcțiile int() și float() realizează conversii la tipul întreg sau la tipul real. Fără aceste conversii, nu puteți realiza calcule matematice corecte cu valorile citite!

Să ne reamintim faptul că pentru a afișa texte, variabile sau expresii folosim funcția print().

30

Exemple: ● afișare simplă: print("Gata!") sau print(x) ● afișare multiplă: print("Cifrele sunt:", a, b, c) ● afișare cu format (f-string): print(f"Suma cifrelor lui {n} este {s}")

REȚINE! ◗ În cazul unei afișări multiple, separatorul implicit este spațiul. Acesta poate fi modificat specificând o altă valoare (de tip șir de caractere) pentru parametrul sep.

De exemplu, instrucțiunea print(1, 2, 3, sep="->") va afișa 1->2->3. ◗ Funcția print() are și un parametru opțional numit end, tot șir de caractere, prin care modificăm ceea ce se afișează la sfârșitul liniei (implicit, se trece la o linie nouă).

De exemplu, secvența următoare va afișa mesajul Limbajul Python: print("Limbajul", end=" ") print("Python")

◗ f-string-urile permit afișarea de text combinat cu valori ale unor variabile. În plus, putem specifica exact câte cifre să apară după punctul zecimal folosind print(f"Mesaj {variabilă:.nf}"), unde n este numărul de zecimale dorit. De exemplu, dacă x = 12.7346 atunci print(f"x = {x:.2f}") va afișa x = 12.73.

Exemplul 1: Se citește de la tastatură un număr natural n cu exact 3 cifre. Să se afișeze suma cifrelor numărului citit. De exemplu, pentru n = 348 , se va afișa 15.

Exemplul 2: Se citește de la tastatură un număr natural n cu exact 3 cifre. Să se afișeze numărul obținut prin interschimbarea cifrei unităților cu cifra sutelor din numărul n. De exemplu, pentru n = 123 se va afișa numărul 321.

# Citirea datelor cu mesaj explicativ

n = int(input("Un număr cu 3 cifre: "))

n = int(input("Un număr cu 3 cifre: "))

# Restul împărțirii la 10 furnizează ultima cifră a lui n unitati = n % 10

# Utilizarea % și // pentru extragerea cifrelor unitati = n % 10 zeci = (n // 10) % 10 sute = n // 100

# Cifra zecilor se obține eliminând ultima cifră a lui n # și apoi luând restul împărțirii la 10 zeci = (n // 10) % 10 # Câtul împărțirii întregi la 100 furnizează prima cifră sute = n // 100 scif = unitati + zeci + sute print(f"Suma cifrelor lui {n} este {scif}")

# Interschimbarea cifrei sutelor cu cea a unităților sute, unitati = unitati, sute # Determinarea noului număr x = 100*sute + 10*zeci + unitati print(f"Numărul obținut din {n} este {x}")

Exersează!

1. Indicați care dintre următoarele variante reprezintă un număr de tip float în Python: A. 5 B. True C. 3.14 D. "10" 2. Indicați ce se întâmplă dacă n = input() și utilizatorul introduce numărul 10: A. n va fi numărul întreg 10 B. n va fi șirul de caractere "10" C. eroare D. n va fi numărul real 10.0 3. Precizați rolul parametrului sep în cadrul funcției print(): A. stabilește separatorul dintre linii B. afișează valorile pe linii separate C. stabilește separatorul dintre valori D. stabilește spațiu ca separator dintre valori 4. Știind că x = 10 și y = 20, indicați care dintre următoarele variante afișează 10 + 20 = 30: A. print(f"{x} + {y} = {x+y}") B. print(f"{x} + {y} = x+y") C. print(f"{x + y} = x+y") D. print(f"x + y = {x+y}")

31

II.2. Algoritmi de construire a numerelor prin adăugarea cifrelor la dreapta În numeroși algoritmi, rezultatul nu este obținut direct, ci se construiește treptat, prin adăugarea succesivă a unor cifre. O astfel de situație apare atunci când formăm un nou număr pornind de la un număr dat și atașăm la sfârșitul scrierii sale una sau mai multe cifre.

Adăugarea unei cifre la dreapta unui număr este o operație importantă în problemele care prelucrează cifrele numerelor naturale.

SĂ NE REAMINTIM! În sistemul zecimal, înmulțirea unui număr natural cu 10 deplasează toate cifrele sale cu o poziție spre stânga.

De exemplu: 24→240 Dacă după această deplasare adăugăm cifra 7, obținem: 240+7=247 Prin urmare, dacă vrem să adăugăm la dreapta lui n cifra c, folosim relația: n = n * 10 + c unde c este o cifră, adică un număr din mulțimea 0, 1, 2, ..., 9.

Exemplul 1: Să se adauge la dreapta numărului 58 cifra 3.

OBSERVĂ Adăugarea unei cifre la dreapta nu trebuie confundată cu adunarea obișnuită.

Dacă n = 24 și c = 7, atunci: ◗ 24 + 7 = 31 ◗ 24 * 10 + 7 = 247 Așadar, operația corectă pentru adăugarea cifrei 7 la dreapta lui 24 este: 24 · 10+7=247

n = 58 n = n * 10 + 3 print(n)#Se obține: 583

Explicația este: 58·10+3=580+3=583

1. Adăugarea succesivă a mai multor cifre Uneori un nou număr se construiește treptat, prin mai multe operații de adăugare la dreapta.

Exemplul 2: Pornind de la numărul 2, să se adauge succesiv la dreapta cifrele 4, 1 și 9.

n = 2 n = n * 10 + 4 n = n * 10 + 1 n = n * 10 + 9 print(n) # Rezultatul este: 2419

Explicația se poate urmări pas cu pas: 2→24→241→2419

REȚINE! Dacă adăugăm mai multe cifre la dreapta, aplicăm de fiecare dată aceeași regulă: n = n * 10 + c

2. Adăugarea unei cifre la dreapta unui număr în funcție de o condiție În unele probleme, cifra care trebuie adăugată la dreapta nu este precizată direct. Ea se stabilește în funcție de anumite proprietăți ale numărului sau ale ultimei sale cifre. În aceste situații, folosim o instrucțiune de decizie.

32

SĂ NE REAMINTIM! Pentru formularea condițiilor folosim operatori relaționali.

Operator

Semnificație

==

egal cu

!=

diferit de

<

mai mic decât

<=

mai mic sau egal cu

>

mai mare decât

>=

mai mare sau egal cu

De exemplu: ● u == 0

● n >= 100

2.1. Adăugarea unei cifre la dreapta folosind instrucțiunea if SĂ NE REAMINTIM! Instrucțiunea if permite executarea unui bloc de instrucțiuni numai atunci când o condiție este adevărată.

Forma generală este: if condiție: instrucțiuni

Exemplul 3: Să se adauge la dreapta lui n cifra 9, numai dacă ultima cifră a lui n este mai mică decât 5.

n = int(input("n = ")) u = n % 10 if u < 5: n = n * 10 + 9 print(n)

2.2. Adăugarea unei cifre la dreapta folosind if ... else

OBSERVĂ În acest exemplu: ◗ u reprezintă ultima cifră a lui n; ◗ condiția verificată este u < 5; ◗ dacă aceasta este adevărată, se formează noul număr; ◗ dacă este falsă, numărul rămâne neschimbat.

Pentru n = 132, avem u = 2, deci se obține: 132 · 10+9=1329 Pentru n = 147, avem u = 7, deci condiția nu este îndeplinită și numărul rămâne 147.

SĂ NE REAMINTIM! Atunci când avem două posibilități, folosim structura: if condiție: instrucțiuni1 else: instrucțiuni2

Exemplul 4: Dacă ultima cifră a lui n este mai mică decât 5, se adaugă la dreapta cifra 1; în caz contrar, se adaugă cifra 8.

OBSERVĂ

n = int(input("n = ")) u = n % 10 if u < 5: n = n * 10 + 1 else: n = n * 10 + 8 print(n)

În ambele cazuri se construiește un nou număr prin aceeași formulă: n = n * 10 + x

Se modifică doar cifra u adăugată la dreapta.

Dacă n = 63, atunci u = 3, deci rezultatul este: 63 · 10+1=631 Dacă n = 78, atunci u = 8, deci rezultatul este: 78 · 10+8=788

33

2.3. Adăugarea unei cifre la dreapta folosind elif SĂ NE REAMINTIM! În unele probleme există mai mult de două situații posibile. În acest caz putem folosi o structură de forma: if condiție1: instrucțiuni1 elif condiție2: instrucțiuni2 else: instrucțiuni3

Exemplul 5: Să se adauge la dreapta lui n: ◗ cifra 2, dacă ultima cifră este mai mică decât 3; ◗ cifra 5, dacă ultima cifră este mai mică decât 7; ◗ cifra 9, în celelalte cazuri. n = int(input("n = ")) u = n % 10

Într-o structură cu elif, condițiile sunt verificate în ordinea în care apar. Se execută doar prima ramură corespunzătoare unei condiții adevărate.

OBSERVĂ Dacă u = 1, prima condiție este adevărată, deci se adaugă 2.

Dacă u = 4, prima condiție este falsă, dar a doua este adevărată, deci se adaugă 5.

Dacă u = 8, niciuna dintre primele două condiții nu este ade­ vărată, deci se adaugă 9.

REȚINE!

if u < 3: n = n * 10 + 2 elif u < 7: n = n * 10 + 5 else: n = n * 10 + 9

În toate exemplele anterioare, operația esențială este aceeași: n = n * 10 + c Diferența nu constă în modul de construire a noului număr, ci în modul de alegere a cifrei c.

print(n)

◗ if este potrivit atunci când verificăm o singură situație; ◗ if ... else este potrivit atunci când avem două posibilități; ◗ elif este util atunci când avem mai multe condiții; ◗ match este convenabil atunci când alegerea se face după valori exacte.

2.4. Adăugarea unei cifre la dreapta unui număr folosind instrucţiunea match SĂ NE REAMINTIM! Atunci când alegerea depinde de valoarea unei expresii, poate fi folosită instrucțiunea match.

Forma generală este: match expresie: case valoare1: instrucțiuni1 case valoare2: instrucțiuni2 ................... case _: instrucțiuni3

Simbolul _ reprezintă cazul rămas neacoperit de celelalte valori.

34

REȚINE!

Exemplul 6: În funcție de ultima cifră a lui n, se adaugă la dreapta: ◗ cifra 4, dacă ultima cifră este 0; ◗ cifra 7, dacă ultima cifră este 5;

OBSERVĂ

◗ cifra 1, în toate celelalte cazuri.

Și în acest caz, regula de formare a noului număr rămâne aceeași: n = n * 10 + c Instrucțiunea match este folosită doar pentru alegerea valorii cifrei c.

Dacă n = 120, atunci u = 0, deci se obține: 120*10+4=1204 Dacă n = 345, atunci u = 5, deci se obține: 345*10+7=3457 Dacă n = 872, atunci se execută ramura implicită și se obține: 872*10+1=8721

n = int(input("n = ")) u = n % 10 match u: case 0: n = n * 10 + 4 case 5: n = n * 10 + 7 case _: n = n * 10 + 1 print(n)

Exersează!

1. Se consideră secvența de program: n = 53 u = n % 10 if u < 4: n = n * 10 + 1 else: n = n * 10 + 8

A. 531 B. 538 C. 61 D. 58

print(n)

Indicați valoarea afișată.

2. Scrieți un program care citește un număr natural n și adaugă la dreapta lui: ◗ cifra 4, dacă ultima cifră a lui n este pară; ◗ cifra 7, în caz contrar.

Programul va afișa noul număr. Exemplu: dacă n = 126, se afișează 1264; dacă n = 135, se afișează 1357.

3. Scrieți un program care citește un număr natural n și adaugă la dreapta lui: ◗ cifra 2, dacă ultima cifră este mai mică decât 3; ◗ cifra 5, dacă ultima cifră este cuprinsă între 3 și 6, inclusiv; ◗ cifra 9, în celelalte cazuri.

Programul va afișa noul număr. Exemple: n = 41 → 412; n = 73 → 735; n = 128 → 1289.

4. Se citește un număr natural n. Scrieți un program care să construiască un nou număr astfel: ◗ ◗ ◗ ◗

dacă ultima cifră a lui n este 0, se adaugă la dreapta cifra 3; dacă ultima cifră a lui n este 5, se adaugă la dreapta cifra 7; dacă ultima cifră a lui n este pară, dar diferită de 0, se adaugă la dreapta cifra 4; în toate celelalte cazuri, se adaugă la dreapta cifra 1.

35

II.3. Algoritmi de construire a numerelor prin adăugarea cifrelor la stânga În multe probleme, cifrele unui număr trebuie analizate una câte una. Uneori se cere calcularea unei sume, alteori eliminarea anumitor cifre sau construirea unui nou număr pe baza unor reguli date. Pentru astfel de situații, cifrele numărului sunt parcurse de la dreapta la stânga, până când numărul devine 0.

SĂ NE REAMINTIM! Pentru repetarea acelorași pași cât timp numărul mai are cifre de prelucrat, folosim instrucțiunea: while n != 0: instrucțiuni

Exemplul 1: Să se determine suma cifrelor numărului natural n. n = int(input("n = ")) s = 0

REȚINE! Schema generală de parcurgere a cifrelor unui număr este: while n != 0: cifra = n % 10 prelucrare cifra n = n // 10

Instrucțiunea n = n // 10 este esențială, deoarece asigură ștergerea ultimei cifre.

while n != 0: cifra = n % 10 s = s + cifra n = n // 10 print(s)

Pentru n = 324, cifrele sunt parcurse în ordinea 4, 2, 3, iar suma se formează treptat: 0→4→6→9. La final, se obține 9.

SĂ NE REAMINTIM! Operatorii logici sunt utilizați pentru a construi condiții compuse, adică expresii în care verificăm simultan două sau mai multe condiții. În limbajul Python, operatorii logici sunt and, or și not.

36

REȚINE! Într-un algoritm de acest tip: ◗ n memorează partea încă neprelucrată a numărului; ◗ cifra reține cifra curentă; ◗ s memorează rezultatul parțial.

Expresie 1

Expresie 2

Expresie 1 and Expresie 2

Expresie 1 or Expresie 2

True

True

True

True

True

False

False

True

False

True

False

True

False

False

False

False

Expresie

not Expresie

True

False

False

True

Scanează codul QR pentru a-ti verifica cunoștiintele

1. Ștergerea cifrelor În unele probleme, nu folosim toate cifrele, ci păstrăm doar cifrele care îndeplinesc o anumită condiție.

Exemplul 2: Scrieți un program în care să se formeze numărul obținut din n după eliminarea tuturor cifrelor care nu aparțin intervalului [3,6]. În cazul de față, păstrăm doar cifrele din intervalul [3,6], adică cifrele 3, 4, 5, 6.

Condiția: cifra >= 3 and cifra <= 6 este adevărată numai pentru cifrele din intervalul [3,6].

n = int(input("n = ")) m = 0 p = 1 while n != 0: cifra = n % 10 if cifra >= 3 and cifra <= 6: m = cifra * p + m p = p * 10 n = n // 10 print(m)

Explicație: Pentru n = 1726358, cifrele numărului sunt analizate de la dreapta la stânga, în ordinea: 8, 5, 3, 6, 2, 7, 1. Dintre acestea, se păstrează numai cifrele care aparțin intervalului [3, 6], adică 5, 3 și 6. Numărul rezultat este 635. În acest algoritm: ◗ variabila m memorează treptat numărul rezultat; ◗ variabila p indică ordinul zecimal pe care va fi așezată următoarea cifră păstrată în numărul rezultat.

La început, p = 1, ceea ce înseamnă că prima cifră păstrată va fi așezată pe ordinul unităților. După adăugarea unei cifre, valoarea lui p se înmulțește cu 10, astfel încât următoarea cifră păstrată să fie plasată pe ordinul zecilor, apoi pe ordinul sutelor și așa mai departe.

Construirea lui m se face prin instrucțiunea: m = cifra * p + m Aceasta are următorul rol:

OBSERVAȚIE Aceeași idee poate fi formulată și invers: se elimină cifrele aflate în afara intervalului [3,6]. În acest caz, condiția de eliminare poate fi exprimată prin operatorul logic or: cifra < 3 or cifra > 6, sau prin negarea condiției folosind operatorul not: not (cifra >= 3 and cifra <= 6).

Aceste condiții sunt adevărate pentru cifrele care nu aparțin intervalului.

◗ cifra * p așază cifra păstrată pe poziția corectă în noul număr; ◗ rezultatul obținut se adaugă la valoarea deja memorată în m.

Evoluția este următoarea: ◗ se păstrează cifra 5; deoarece p = 1, ea este așezată pe ordinul unităților, deci m = 5; ◗ p devine 10; se păstrează cifra 3, care este așezată pe ordinul zecilor, deci m = 3 * 10 + 5 = 35; ◗ p devine 100; se păstrează cifra 6, care este așezată pe ordinul sutelor, deci m = 6 * 100 + 35 = 635.

Astfel, variabila m se construiește treptat, iar variabila p asigură păstrarea cifrelor în aceeași ordine în care apar în scrierea inițială a numărului.

2. Adăugarea cifrelor la stânga numărului n În anumite probleme, rezultatul nu se obține doar prin selectarea sau eliminarea unor cifre, ci prin construirea unui nou număr, folosind reguli precise de transformare a fiecărei cifre din numărul inițial. O astfel de situație apare atunci când fiecărei cifre i se asociază una sau mai multe cifre noi, care sunt apoi adăugate succesiv în rezultatul final. În exemplul următor, fiecare cifră a numărului n este dublată, adică este transformată într-o pereche de cifre identice. Astfel, pornind de la numărul inițial, se construiește treptat un nou număr, păstrând ordinea cifrelor în forma finală.

37

Exemplul 3: Scrieți un program care să se construiască numărul obținut prin dublarea fiecărei cifre a lui n. De exemplu: 123→112233 Explicație: Pentru n = 123: ◗ din cifra 3 se obține 33; ◗ din cifra 2 se obține 22; ◗ din cifra 1 se obține 11.

Numărul final este: 112233

n = int(input("n = ")) m = 0 p = 1 while n != 0: cifra = n % 10 m = (11 * cifra) * p + m p = p * 100 n = n // 10 print(m)

În program, expresia 11 * cifra are rolul de a forma rapid perechea de cifre identice: ◗ pentru 3 obținem 33, ◗ pentru 5 obținem 55, ◗ pentru 7 obținem 77.

Deoarece fiecare pas adaugă două cifre în rezultat, variabila p se înmulțește de fiecare dată cu 100.

3. Greșeli frecvente O eroare frecventă este omiterea instrucțiunii n = n // 10. În această situație, valoarea lui n nu se modifică, iar structura repetitivă nu se mai încheie. O altă eroare este folosirea unei condiții greșite la selectarea cifrelor. De exemplu, pentru intervalul [2,4], condiția corectă este: cifra >= 2 and cifra <= 4, nu cifra >= 2 or cifra <= 4

P ORTOFOLIU DIGITAL

REȚINE! În algoritmii de parcurgere a cifrelor: ◗ folosim instrucțiunea repetitivă while; ◗ ultima cifră a numărului n este n % 10; ◗ eliminarea ultimei cifre a numărului n se face cu n=n // 10, după ce a fost prelucrată; ◗ condițiile compuse se formulează cu operatori logici; ◗ rezultatul se construiește treptat, pe măsură ce cifrele sunt analizate.

Carnetul de note – meniu cu instrucțiunea while Organizare

Creează folderul: Portofoliu digital > Capitolul 2 > Carnetul de note > Tema 2 - Meniu cu while.

Cerința 1

Realizează un program cu meniu repetitiv, folosind instrucțiunea while, cu opțiunile: 1 - promovare după o notă, 2 - verificare după trei note și media dorită, 3 - ieșire.

Cerința 2

Integrează în meniu algoritmii realizați la Tema 1, în carnetul_de_note.docx.

Salvează

tema2_meniu.py (cerințele 1-2)

Document

Realizează un document foarte scurt în care explici rolul meniului și dai un exemplu complet de rulare. Nume recomandat: tema2_prezentare.docx.

Exersează!

1. Scrieți un program care citește de la tastatură un număr natural n și determină suma cifrelor prime ale sale.

2. Scrieți un program care citește de la tastatură un număr natural n și formează numărul obținut din n după eliminarea cifrelor care nu aparțin intervalului [2,5].

3. Precizați cifrele care satisfac condiția: cifra >= 6 and cifra <= 9.

4. Scrieți un program care citește de la tastatură un număr natural n și construiește numărul obținut prin dublarea fiecărei cifre impare a lui n.

5. Explicați de ce, în algoritmii de parcurgere a cifrelor, instrucțiunea n = n // 10 trebuie executată în interiorul instrucțiunii while.

38

II.4. Divizorii unui număr natural Așa cum ați învățat deja, în majoritatea programelor trebuie să executăm în mod repetat anumite operații: să citim sau să afișăm date, să adunăm valori la o sumă sau să incrementăm un contor pentru a determina câte dintre valorile citite îndeplinesc o anumită condiție. Din acest motiv, majoritatea limbajelor de programare, inclusiv limbajul Python, dispun de instrucțiuni repetitive. Unele dintre acestea, cum ar fi instrucțiunea while, repetă un bloc de instrucțiuni cât timp o anumită condiție este adevărată (deci nu se cunoaște de la început de câte ori se va executa), iar altele, cum este instrucțiunea for, repetă un bloc de instrucțiuni de un număr de ori cunoscut de la început.

Spre deosebire de alte limbaje de programare, cum ar fi limbajul pseudocod, C/C++ sau Java, în care instrucțiunea for utilizează explicit un contor numeric, în limbajul Python aceasta iterează direct prin elementele unei secvențe (șir de caractere, listă etc.). Forma generală a acestei instrucțiuni este: for variabilă in secvență: instrucțiuni

De exemplu, secvența de cod for litera in "Python": print(litera, end=".") # va afișa P.y.t.h.o.n.

va parcurge șirul „Python” literă cu literă și va afișa pe ecran P.y.t.h.o.n.

Instrucțiunea for de mai sus nu pare, la prima vedere, să aibă un număr cunoscut de iterații. Totuși, numărul de valori dintr-o secvență este o constantă în momentul începerii executării instrucțiunii. De exemplu, pentru secvența de cod dată, numărul de iterații este egal cu lungimea șirului "Python", adică 6.

Pentru a scrie o instrucțiune for „standard” (cu contor numeric), trebuie să generăm o secvență de numere întregi, de obicei utilizând funcția predefinită range.

Funcția range(start, stop, pas) returnează o secvență de numere întregi generate progresiv, începând cu valoarea start, incrementate cu pas, până la atingerea limitei stop, care nu este inclusă în secvență.

REȚINE! ◗ Dacă valoarea pas este 0, atunci va apărea o eroare la executare! ◗ Dacă valoarea pas este pozitivă, atunci ar trebui ca start ≤ stop, altfel funcția va genera o secvență vidă! ◗ Dacă valoarea pas este negativă, atunci ar trebui ca start ≥ stop, altfel funcția va genera o secvență vidă!

Exemple: Secvență de cod for x in range(1, 6): print(x, end=" ") for x in range(6): print(x, end=" ")

Rezultat afișat

Explicații

1 2 3 4 5

Afișează numerele naturale din intervalul [1, 6).

0 1 2 3 4 5

Parametrul start folosește valoarea implicită 0, deci afișează numerele naturale din intervalul [0, 6).

for x in range(1, 11, 2): print(x, end=" ")

1 3 5 7 9

Afișează numerele naturale impare din intervalul [1, 11).

for x in range(6, 1, -1): print(x, end=" ")

6 5 4 3 2

Afișează în ordine descrescătoare numerele naturale din intervalul (1, 6].

for x in range(1, 6, -2): print(x, end=" ")

Nu se afișează nimic (secvență vidă) deoarece pas = -2 < 0 și start = 1 < stop = 6.

for x in range(6, 1): print(x, end=" ")

Nu se afișează nimic (secvență vidă) deoarece pas = 1 > 0 și start = 6 > stop = 1.

39

Reamintim faptul că divizorii unui număr natural nenul n se împart în două categorii: ◗ divizori improprii: 1 și n n ◗ divizori proprii: orice alt divizor d ∈ {2, 3, …, [ 2 ]} al lui n

Pentru a afișa toți divizorii unui număr natural nenul n vom parcurge cu o variabilă d mulțimea tuturor posibililor săi divizori, respectiv mulțimea {1, 2, ..., n}, și vom afișa doar acele valori d care îl divid pe n: # citim valoarea lui n de la tastatură n = int(input("n = ")) print(f"Divizorii lui {n} sunt:") # parcurgem mulțimea tuturor posibililor divizori d ai lui n, # respectiv mulțimea {1, 2, ..., n} for d in range(1, n+1): # dacă d este divizor al lui n, atunci îl afișăm if n % d == 0: print(d, end=" ")

Deoarece mulțimea posibililor divizori proprii ai unui număr natural n ≥ 2 este formată din numerele naturale n n cuprinse între 2 și [ 2 ], rezultă că un număr natural nenul n nu poate să aibă niciun divizor în mulțimea {[ 2 ] + 1, n [ 2 ] + 2, …, n – 1}, deci putem să eficientizăm programul anterior parcurgând cu variabila d doar mulțimea n posibililor divizori proprii ai lui n, respectiv mulțimea {2, 3, …,[ 2 ]}, și afișând la sfârșit și valoarea lui n: # citim valoarea lui n de la tastatură n = int(input("n = ")) print(f"Divizorii lui {n} sunt:")

# parcurgem mulțimea tuturor posibililor divizori proprii d ai lui n, # respectiv mulțimea {2, 3 ..., n//2+1}, la care îl adăugăm și pe 1 for d in range(1, n//2+1): # dacă d este divizor propriu al lui n, atunci îl afișăm if n % d == 0: print(d, end=" ") # afișăm și ultimul divizor al lui n, respectiv n print(n) Exemplul 1: Se citește de la tastatură un număr natural n ≥ 2. Să se verifice dacă numărul citit este prim.

Reamintim faptul că un număr natural ≥ 2 este prim dacă se divide doar cu 1 și el însuși. Echivalent, n este prim dacă nu are niciun divizor propriu. De exemplu, numărul 11 este prim (nu are divizori proprii, ci doar divizorii improprii 1 și 11), iar numărul 12 nu este prim (are divizorii proprii 2, 3, 4 și 6). Dacă un număr nu este prim, atunci spunem că el este compus.

Astfel, o metodă simplă de a testa dacă un număr natural nenul n ≥ 2 este prim constă în verificarea faptului că el nu are divizori proprii: # citim numărul natural n >= 2 n=int(input("n = ")) # valoarea maximă a unui posibil divizor al numărului n limita_divizori = n//2 # inițializăm cu 0 contorul pentru divizorii lui n

40

OBSERVAȚIE Numerele 0 și 1 nu sunt nici prime, nici compuse!

nr_divizori = 0

# parcurgem cu variabila d mulțimea posibililor divizori ai lui n for d in range(2, limita_divizori + 1): # dacă d este un divizor al lui n if n % d == 0: # atunci incrementăm cu 1 numărul divizorilor lui n nr_divizori += 1 # în funcție de valoarea contorului pentru divizorii lui n # afișăm mesajul corespunzător if nr_divizori == 0: print(f"Numărul {n} este prim!") else: print(f"Numărul {n} este compus!")

O variantă mai eficientă, în care testăm mai puțini posibili divizori, se poate obține utilizând următoarea teoremă: „Un număr natural n ≥ 2 este prim dacă și numai dacă nu are niciun divizor cuprins între 2 și √n."

Practic, este suficient ca în programul de mai sus să modificăm valoarea maximă a unui posibil divizor astfel:­ limita_divizori = int(n**0.5). De exemplu, pentru n = 1000000 noua variantă va efectua aproximativ [√n]=1000 de iterații, în timp ce prima variantă efectua aproximativ [ n ]=500000 de iterații, deci va fi de aproape 2 500 de ori mai rapidă!

Exemplul 2: Se citesc de la tastatură două numere naturale nenule a și b. Să se afișeze divizorii comuni ai celor două numere citite. De exemplu, numerele a = 300 și b = 72 au divizorii comuni 1, 2, 3, 4, 6 și 12.

Rezolvare: Se observă cu ușurință faptul că un divizor comun d al numerelor a și b este întotdeauna cuprins între 1 și minimul dintre a și b, deci vom căuta posibilii divizori comuni în acest interval: # citim numerele naturale nenule a și b a = int(input("a = ")) b = int(input("b = ")) # determinăm valoarea maximă posibilă a unui divizor comun al lui a și b, # respectiv minimul dintre a și b if a < b: divizor_comun_maxim = a else: divizor_comun_maxim = b

DESCOPERĂ Programul de mai sus va afișa întotdeauna cel puțin un număr?

Argumentați!

print(f"Divizorii comuni ai numerelor {a} și {b} sunt:")

# parcurgem cu variabila d mulțimea posibililor # divizori comuni ai numerelor a și b for d in range(1, divizor_comun_maxim + 1): # dacă numerele a și b sunt simultan divizibile cu d if a % d == 0 and b % d == 0: # atunci afișăm divizorul comun d print(d, end=" ")

41

Exemplul 3: Se citește un număr natural n>1 . Să se verifice dacă numărul citit este număr perfect.

Un număr se numește număr perfect dacă suma divizorilor săi (excluzând numărul însuși) este egală cu numărul respectiv. De exemplu, numărul 6 este perfect deoarece 1 + 2 + 3 = 6.

Rezolvare: Deoarece suma divizorilor numărului natural nenul n nu trebuie să-l conțină și pe n, vom căuta posibilii săi divizori doar în mulțimea {1, 2, …, [ n ]}: 2

# citim numărul natural nenul n

n=int(input("n = "))

# inițializăm cu 0 suma divizorilor lui n suma_divizori = 0 # parcurgem cu variabila d mulțimea posibililor divizori ai lui n for d in range(1, n//2 + 1): # dacă d este un divizor al lui n if n % d == 0: # atunci îl adăugăm pe d în sumă suma_divizori += d # în funcție de valoarea sumei divizorilor lui n # afișăm mesajul corespunzător if suma_divizori == n: print(f"Numărul {n} este perfect!") else: print(f"Numărul {n} nu este perfect!")

Scanează codul QR pentru a-ți verifica cunoștiintele

Exersează!

1. Dacă folosim cele două variante ale programului din Exemplul 1 pentru a testa dacă numărul n = 10000000 este prim, atunci aproximativ de câte ori va fi mai rapidă a doua variantă decât prima?

2. Scrieți un program în limbajul Python care citește de la tastatură un număr natural nenul n și afișează numărul divizorilor săi.

3. Scrieți un program care verifică dacă un număr citit de la tastatură este pătrat perfect folosind faptul că un număr natural este pătrat perfect dacă și numai dacă are un număr impar de divizori.

4. Pentru un număr natural n ≥ 2 notăm cu sd(n) suma divizorilor săi, mai puțin numărul însuși. În funcție de relația dintre sd(n) și n, numerele naturale se împart în următoarele categorii: ◗ numere deficitare dacă sd(n) < n (de exemplu, sd(8) = 1 + 2 + 4 = 7 < 8) ◗ numere perfecte dacă sd(n) = n (de exemplu, sd(6)= 1 + 2 + 3 = 6) ◗ numere abundente dacă sd(n) > n (de exemplu, sd(12)= 1 + 2 + 3 + 4 + 6 = 16 > 12) Scrieți un program care afișează categoria din care face parte un număr natural n ≥ 2 citit de la tastatură.

5. Dacă n ≥ 2 este un număr natural, indicați categoria de numere cu proprietatea că orice pereche (n,n) este o pereche de numere prietene (cel mai mare divizor comun al lor este 1): A. numere prime B. pătrate perfecte C. numere perfecte D. numere naturale nenule

42

II.5. Prelucrarea selectivă a cifrelor unui număr După studiul instrucțiunilor repetitive while și for, este util să analizăm și alte instrucțiuni care permit controlul mai precis al executării. În multe situații, nu este suficient să repetăm un bloc de instrucțiuni un anumit număr de pași sau cât timp o condiție este adevărată. Uneori este necesar să întrerupem repetarea, să ignorăm anumite valori sau să executăm un bloc suplimentar numai dacă repetarea s-a încheiat în mod normal. În limbajul Python, aceste roluri sunt îndeplinite de break, care oprește imediat o structură repetitivă, de continue, care întrerupe doar iterația curentă și trece la următoarea, și de else, care poate fi atașat unei instrucțiuni for sau while și se execută numai dacă structura repetitivă se încheie fără break.

1. Rolul instrucțiunii break Instrucțiunea break oprește imediat execuția unei structuri repetitive, indiferent dacă aceasta este for sau while.

Aceasta se folosește atunci când: ◗ s-a găsit deja rezultatul căutat; ◗ nu mai este necesară continuarea repetării; ◗ apare o situație care impune oprirea imediată.

Exemplul 1: Se citesc cel mult 10 numere naturale nenule. Dacă se introduce un număr care conține cifra 0, procesul de citire se oprește imediat. Să se determine câte dintre valorile citite nu conțin cifra 0. cnt = 0 for i in range(10): x = int(input("x = ")) ok=True #Presupunem ca x nu conține cifra 0 while x>0: cifra=x % 10 if cifra==0: ok=False # x conține cifra 0 break x=x//10 if not(ok): #daca x a avut o cifră 0, se părăsește #instructiunea for break cnt += 1

REȚINE! ◗ Instrucțiunea break poate apărea numai în interiorul unei structuri repetitive.

OBSERVĂ În acest exemplu, structura for ar putea executa 10 pași, însă dacă apare cifra 0, instrucțiunea break oprește imediat repetarea, iar pașii rămași nu mai sunt executați.

print(cnt)

2. Rolul instrucțiunii continue Instrucțiunea continue nu oprește structura repetitivă, ci doar întrerupe iterația curentă și trece direct la următoarea.

Aceasta este utilă atunci când: ◗ anumite valori trebuie ignorate; ◗ unele situații nu trebuie prelucrate; ◗ dorim să sărim peste un caz particular, fără a opri întreaga repetare.

REȚINE! ◗ continue nu oprește instrucţiunea repetitivă, ci doar sare peste restul instrucțiunilor din pasul curent.

43

Exemplul 2: Se citesc n numere naturale din intervalul [100, 9999]. Să se determine suma numerelor care au cifra sutelor pară.

OBSERVĂ Dacă valoarea citită are cifra sutelor impară, algoritmul nu o mai prelucrează în pasul curent și trece direct la următoarea citire.

n=int(input("n=")) s = 0 for i in range(1,n+1): x = int(input("x = ")) if x // 100 % 2 != 0: continue s += x print(s)

3. Rolul instrucțiunii else atașate unei structuri repetitive În Python, instrucțiunea else poate fi asociată nu doar cu if, ci și cu o structură repetitivă for sau while.

Blocul else se execută numai dacă structura repetitivă se încheie în mod normal, adică fără ca execuția să fi fost întreruptă prin break.

4. Instrucțiunea else pentru for Exemplul 3: Se citește un număr natural n. Să se verifice dacă în intervalul [1, n] există un număr care are prima cifră egală cu 7. Dacă există, se afișează „gasit”. Dacă nu există, se afișează „nu exista”.

OBSERVĂ Dacă numărul i are prima cifră 7, se execută break, iar blocul else nu se mai execută. Dacă n este mai mic decât 7, bucla se încheie normal și se execută else.

REȚINE! ◗ Pentru for și while , instrucțiunea else are sensul: „execută acest bloc dacă repetarea s-a terminat normal, fără break”.

n = int(input("n = ")) for i in range(1, n + 1): ci=i while (ci>9): ci //= 10 if ci == 7: print("gasit") break else: print("nu exista")

5. Instrucțiunea else pentru while Exemplul 4: Se citește un număr natural nenul n. Să se verifice dacă numărul conține cifra 0.

Dacă da, se afișează „contine 0”. În caz contrar, se afișează „nu contine 0”.

OBSERVĂ Dacă se găsește cifra 0, instrucțiunea break oprește bucla și blocul else nu se execută. Dacă numărul este parcurs complet și nu apare nicio cifră 0, atunci while se încheie normal și se execută else.

n = int(input("n = ")) while n != 0: cifra = n % 10 if cifra == 0: print("contine 0") break n = n // 10 else: print("nu contine 0")

6. Diferența dintre break, continue și else ◗ break oprește complet structura repetitivă; ◗ continue oprește doar iterația curentă și trece la următoarea; ◗ else se execută numai dacă structura repetitivă s-a încheiat normal, fără break.

44

Exemplul 5: Se citesc cel mult 10 numere întregi. Programul trebuie să ignore valorile negative, să oprească citirea dacă întâlnește valoarea 0 și să verifice dacă printre valorile pozitive apare numărul 15. Dacă numărul 15 este găsit, se afișează „valoare gasita”. Dacă procesul se încheie fără a găsi această valoare, se afișează „valoare negasita”.

OBSERVĂ Instrucțiunea else este foarte utilă în probleme de căutare. De regulă, în interiorul buclei căutăm un anumit element; dacă îl găsim, folosim break; dacă repetarea se termină fără break, else ne permite să tratăm situația în care elementul nu a fost găsit.

for i in range(10): x = int(input("x = ")) if x == 0: break if x < 0: continue if x == 15: print("valoare gasita") break else: print("valoare negasita")

Explicații: Acest algoritm utilizează toate cele trei instrucțiuni: break pentru oprirea imediată a repetării, continue pentru ignorarea valorilor negative și else pentru cazul în care repetarea se încheie fără să se fi găsit valoarea căutată.

7. Greșeli frecvente O greșeală frecventă este interpretarea lui else de la for sau while ca pe un else obișnuit al instrucțiunii if. În realitate, el este asociat structurii repetitive și se execută numai dacă aceasta nu a fost întreruptă prin break.

P ORTOFOLIU DIGITAL

REȚINE! ◗ break oprește complet o structură repetitivă; ◗ continue oprește doar iterația curentă; ◗ blocul else se execută numai dacă repetarea se termină normal, fără break; ◗ else pentru bucle este util mai ales în probleme de căutare și validare.

Carnetul de note - prelucrarea notelor cu for Organizare

Creează folderul: Portofoliu digital > Capitolul 2 > Carnetul de note > Tema 3 - Prelucrarea notelor cu for.

Cerința 1

Se citesc n note și media dorită. Calculați media și afișați "esti in grafic" dacă media obținută este cel puțin egală cu media dorită, altfel "mai ai de invatat".

Cerința 2

Adaugă în aplicația cu meniu o opțiune nouă pentru verificarea progresului după n note.

Meniul va avea: 1 – promovare după o notă, 2 – verificare după trei note, 3 – verificare după n note, 4 – ieșire.

Salvează

tema3_n_note.py (cerința 1) și tema3_meniu_extins.py (cerința 2)

Document

Realizează un document foarte scurt în care explici cum ai folosit instrucțiunea for și adaugi două exemple de rulare. Nume recomandat: tema3_prezentare.docx.

Exersează!

1. Se citește un număr natural nenul n. Să se afișeze prima cifră pară întâlnită la parcurgerea numărului de la dreapta la stânga. Dacă numărul nu conține nicio cifră pară, se afișează "nu exista".

2. Se citește un număr natural nenul n. Să se determine suma cifrelor sale, ignorând cifrele egale cu 5.

3. Se citește un număr natural nenul n. Să se verifice dacă numărul conține cifra 9. Dacă numărul conţine cifra 9, se afișează "gasit", iar dacă nu conţine cifra 9, se afișează "negasit".

4. Se citește un număr natural nenul n. Să se afișeze prima cifră strict mai mare decât 5, întâlnită la parcurgerea numărului de la dreapta la stânga. Dacă nu există o astfel de cifră, se afișează "nu exista".

45

II.6. Algoritmi elementari pentru divizori și multipli comuni Descompunerea în factori primi • CMMDC • CMMMC • Multiplii unui număr În studiul informaticii, numerele naturale pot fi analizate ca structuri complexe ale căror proprietăți fundamentale sunt dictate de divizorii primi, considerați „codul sursă” al oricărei valori numerice. Utilizarea celui mai mare divizor comun reprezintă o metodă de optimizare a sistemelor, facilitând reducerea problemelor la forme minimale, în timp ce cel mai mic multiplu comun asigură sincronizarea proceselor care se repetă la intervale distincte.

Integrarea acestor noțiuni în dezvoltarea de software permite trecerea de la calcule secvențiale lente la algoritmi de prelucrare numerică de înaltă performanță. Această arhitectură logică constituie pilonul central în domenii precum securitatea cibernetică și criptografia, unde eficiența algoritmilor determină capacitatea de procesare și protecție a datelor în timp real. În această lecție vom studia: ◗ descompunerea unui număr natural > 1 în factori primi; ◗ determinarea celui mai mare divizor comun a două numere naturale nenule prin doi algoritmi elementari; ◗ determinarea celui mai mic multiplu comun a două numere naturale nenule; ◗ afișarea multiplilor unui număr.

SĂ NE REAMINTIM! Un număr prim este un număr natural mai mare decât 1 care are exact doi divizori pozitivi: 1 și el însuși.

Un divizor prim al unui număr natural este un divizor al său care este, în același timp, număr prim.

Un multiplu al unui număr natural n este orice număr de forma n · k, unde k este număr natural.

Exemple: • 2, 3, 5, 7 și 11 sunt numere prime; • divizorii primi ai lui 12 sunt 2 și 3; • multiplii naturali ai numărului 4 sunt 0, 4, 8, 12, 16, 20, ...

1. Descompunerea unui număr în factori primi Orice număr natural mai mare decât 1 poate fi scris ca produs de factori primi.

Această scriere se numește descompunere în factori primi.

De exemplu: ◗ 12 = 2 · 2 · 3 = 2² · 3 ◗ 18 = 2 · 3 · 3 = 2 · 3² ◗ 60 = 2 · 2 · 3 · 5 = 2² · 3 · 5 Ideea algoritmului Pentru a descompune un număr n în factori primi, începem cu cel mai mic divizor prim posibil, adică 2.

Verificăm de câte ori divide pe n , numărăm aceste împărțiri, afișăm factorul și puterea lui, apoi trecem la următorul divizor posibil.

Dacă un număr prim d divide pe n de p ori, atunci în descompunere apare factorul d la puterea p.

46

Exemplul 1: Se citește de la tastatură un număr natural n > 1. Afișați descompunerea sa în factori primi, precizând pentru fiecare factor și puterea la care apare.

Rezultatul afișat este: 2 3 și 5 1, adică: 40 = 2³ · 5 În acest algoritm, d este divizorul testat, p memorează de câte ori apare factorul d în descompunere, iar n memorează partea numărului care nu a fost încă descompusă.

n = int(input("n = ")) d = 2 while n > 1: p = 0 while n % d == 0: p += 1 n = n // d if p != 0: print(d, p) d += 1

2. CMMDC – cel mai mare divizor comun Cel mai mare divizor comun al două numere naturale nenule a și b, notat CMMDC(a, b), este cel mai mare număr natural care divide simultan pe a și pe b.

Exemple: CMMDC(18, 24) = 6, CMMDC(15, 35) = 5, CMMDC(14, 25) = 1.

Dacă CMMDC(a, b) = 1, atunci numerele a și b se numesc prime între ele.

OBSERVĂ Pentru n = 40, algoritmul func­ ționează astfel: ◗ 40 se divide cu 2 de 3 ori, deci în descompunere apare 2³; ◗ după aceste împărțiri, rămâne 5; ◗ valoarea 4 nu va fi luată în considerare ca factor, deoarece toți factorii de 2 au fost deja extrași prin împărțirile succesive la 2; în plus, 4 nu este număr prim, iar algoritmul urmărește identificarea factorilor primi; ◗ 5 se divide cu 5 o singură dată, deci în descompunere apare 5¹; ◗ la final, n devine 1.

2.1. Algoritmul lui Euclid prin scăderi repetate SĂ NE REAMINTIM! Dacă a > b, atunci CMMDC(a, b) = CMMDC(a – b, b). Aceasta înseamnă că putem înlocui numărul mai mare cu diferența dintre cele două numere, fără a modifica valoarea CMMDC. Repetând acest proces, ajungem în cele din urmă la două numere egale. Acea valoare comună este CMMDC. Exemplul 2: Se citesc de la tastatură două numere naturale nenule a și b. Determinați CMMDC al acestora folosind algoritmul lui Euclid prin scăderi repetate. a = int(input("a = ")) b = int(input("b = ")) while a != b: if a > b: a = a - b else: b = b - a print(a)

OBSERVĂ Pentru a = 48 și b = 18: ◗ 48 > 18, deci 48 - 18 = 30 ◗ 30 > 18, deci 30 - 18 = 12 ◗ 18 > 12, deci 18 - 12 = 6 ◗ 12 > 6, deci 12 - 6 = 6 Acum a = b = 6, deci CMMDC(48, 18) = 6.

REȚINE! ◗ Această variantă este ușor de înțeles, dar poate deveni lentă când valorile sunt foarte diferite ca ordin de mărime (de exemplu, a=1.000.000 și b=2).

47

2.2. Algoritmul lui Euclid prin împărțiri repetate SĂ NE REAMINTIM! Dacă împărțim pe a la b, obținem relația a = b · c + r, unde r este restul împărțirii lui a la b. Atunci CMMDC(a, b) = CMMDC(b, r).

Prin urmare, putem înlocui perechea (a, b) cu (b, a % b) și repetăm procesul până când restul devine 0.

Exemplul 3: Se citesc de la tastatură două numere naturale nenule

a și b. Determinați CMMDC al acestora folosind algoritmul lui Euclid prin

împărțiri repetate. În această variantă, r memorează restul împărțirii întregi. Când b devine 0, valoarea lui a este CMMDC.

OBSERVĂ Pentru a = 84 și b = 30: ◗ 84 % 30 = 24, deci perechea devine (30, 24) ◗ 30 % 24 = 6, deci perechea devine (24, 6) ◗ 24 % 6 = 0, deci perechea devine (6, 0) Algoritmul se oprește, iar rezultatul este CMMDC(84, 30) = 6.

a = int(input("a = ")) b = int(input("b = ")) while b != 0: r = a % b a = b b = r print(a)

Algoritmul este, de regulă, mult mai rapid decât varianta prin scăderi repetate.

3. CMMMC – cel mai mic multiplu comun Cel mai mic multiplu comun al două numere naturale nenule a și b, notat CMMMC(a, b), este cel mai mic număr natural nenul care este multiplu atât al lui a, cât și al lui b.

Exemple: CMMMC(4, 6) = 12, CMMMC(8, 12) = 24.

Legătura dintre CMMDC și CMMMC Pentru două numere naturale nenule a și b, avem relația: CMMMC(a, b) = a · b / CMMDC(a, b)

Această formulă este foarte importantă, deoarece ne permite să calculăm rapid CMMMC dacă știm deja CMMDC. Exemplul 4: Se citesc de la tastatură două numere naturale nenule

a și b. Determinați CMMMC al acestora.

REȚINE! ◗ CMMMC se poate calcula fie prin căutarea multiplilor comuni, fie mult mai eficient, folosind relația cu CMMDC. În practică, a doua metodă este preferată.

48

a = int(input("a = ")) b = int(input("b = ")) x = a y = b while y != 0: r = x % y x = y y = r cmmdc = x cmmmc = a * b // cmmdc print(cmmmc)

OBSERVĂ Pentru a = 12 și b = 18, avem CMMDC(12, 18) = 6, deci CMMMC(12, 18) = 12 · 18 / 6 = 36.

Variabilele x și y sunt folosite pentru aplicarea algoritmului lui Euclid, fără a modifica valorile inițiale ale lui a și b. ◗ x și y preiau inițial valorile lui a și b; ◗ asupra lor se fac transformările succesive necesare pentru determinarea CMMDC; ◗ valorile inițiale a și b trebuie păstrate, deoarece sunt folosite ulterior în formula: cmmmc = a * b // cmmdc

4. Multiplii unui număr Un multiplu natural al unui număr natural n este orice număr obținut prin înmulțirea lui n cu un număr natural.

De exemplu, pentru n = 5, primii multipli sunt: 0, 5, 10, 15, 20, 25, ...

Exemplul 5: Se citește de la tastatură un număr natural n. Afișați primii 10 multipli nenuli ai lui n. n = int(input("n = "))

OBSERVĂ Dacă n = 7, se afișează: 7 14 21 28 35 42 49 56 63 70. În acest algoritm, i ia pe rând valorile 1, 2, 3, ..., 10, iar pentru fiecare valoare calculăm n · i.

for i in range(1, 11): print(n * i, end=" ")

5. Greșeli frecvente ◗ În descompunerea în factori primi, o greșeală frecventă este incrementarea prematură a lui d , înainte ca toate împărțirile posibile cu același factor să fi fost efectuate. ◗ În algoritmul lui Euclid prin scăderi repetate, trebuie tratate corect cazurile a > b și b > a. ◗ În varianta cu împărțiri, ordinea actualizării variabilelor r, x și y este importantă.

REȚINE! ◗ Multiplii unui număr se obțin prin înmulțire, formează un șir nelimitat și sunt utili în determinarea CMMMC și în numeroase probleme de aritmetică elementară.

Exersează!

1. Se citește de la tastatură un număr natural n > 1. Afișați factorul prim care apare la puterea cea mai mare în descompunerea lui n în factori primi. Dacă există mai mulți astfel de factori, se va afișa cel mai mic dintre ei.

2. Se citesc de la tastatură două numere naturale nenule a și b. Verificați dacă numerele sunt prime între ele, ­folosind algoritmul lui Euclid cu împărțiri repetate.

3. Se citesc de la tastatură patru numere naturale nenule a, b, c și d, care reprezintă numărătorii și numitorii a două fracții a / b și c / d. Afișați suma celor două fracții în formă ireductibilă.

Exemplu: pentru a = 2, b = 15, c = 1, d = 10, Se va afișa 7 10 (7/10) 4. Se citesc de la tastatură trei numere naturale n, a și b, cu a <= b. Afișați toți multiplii lui n din intervalul [a, b].

Dacă nu există astfel de valori, afișați mesajul “nu exista”.

5. Un server de Minecraft dă restart la fiecare 12 ore și un script de curățare lag rulează la fiecare 18 ore. Dacă se pornește serverul acum, peste câte ore se vor „lovi” ambele procese în același timp, încetinind jocul?

A. 24

B. 90

C. 36

D. 48

49

II.7. Baze de numerație. Conversii între sisteme de numerație În informatică folosim mai multe sisteme de numerație. Cel mai frecvent utilizăm sistemul zecimal, însă în sistemele de calcul apar foarte des și sistemele binar, octal și hexazecimal. Fiecare sistem de numerație este caracterizat printr-o bază și prin mulțimea simbolurilor care pot fi folosite pentru scrierea numerelor în acea bază.

OBSERVĂ Cifrele care pot fi utilizate într-o bază sunt întotdeauna mai mici decât baza respectivă.

Sistem de numerație

Baza

Cifrele bazei

binar

2

0, 1

octal

8

0, 1, 2, 3, 4, 5, 6, 7

zecimal

10

0, 1, 2, 3, 4, 5, 6, 7, 8, 9

hexazecimal

16

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F

În baza 16 apar și litere deoarece sunt necesare 16 simboluri distincte. Cum cifrele zecimale obișnuite sunt doar 10, pentru valorile 10, 11, 12, 13, 14 și 15 se folosesc literele A, B, C, D, E și F.

1. Transformarea unui număr din baza 10 în baza 2 SĂ NE REAMINTIM! Pentru a transforma un număr din baza 10 în baza 2, împărțim succesiv numărul la 2 și reținem resturile.

Reprezentarea în baza 2 se obține citind resturile în ordine inversă față de ordinea în care au fost obținute.

Exemplul 1: Se citește de la tastatură un număr natural n scris în baza 10. Afișați reprezentarea lui în baza 2.

Rezolvare matematică Pentru a transforma un număr din baza 10 în baza 2, împărțim succesiv numărul la 2 și reținem de fiecare dată restul împărțirii, iar câtul impărțirii la 2, devine noul număr. Procesul se încheie în momentul în care numărul devine 0.

Procedăm astfel deoarece, în baza 2, orice număr se scrie ca sumă de puteri ale lui 2. La fiecare pas, restul împărțirii la 2 ne arată care este cifra binară de pe poziția curentă: ◗ dacă restul este 0, atunci pe acea poziție apare cifra 0; ◗ dacă restul este 1, atunci pe acea poziție apare cifra 1.

Prima împărțire determină ultima cifră a reprezentării în baza 2, adică cifra de pe ordinul unităților. A doua împărțire determină cifra de pe ordinul următor, apoi pe cea de după aceasta și așa mai departe. Din acest motiv, resturile se obțin de la dreapta la stânga, iar la final trebuie citite în ordine inversă.

Pentru n = 25, efectuăm împărțiri succesive la 2: ◗ 25 : 2 = 12, rest 1 ◗ 12 : 2 = 6, rest 0 ◗ 6 : 2 = 3, rest 0 ◗ 3 : 2 = 1, rest 1 ◗ 1 : 2 = 0, rest 1

50

Resturile sunt 1, 0, 0, 1, 1 și dacă le citim în ordine inversă, obținem 11001.

Prin urmare, 25(10) = 11001(2). n = int(input("n = ")) binar = 0 p = 1

OBSERVĂ Variabila binar memorează treptat reprezentarea în baza 2, iar variabila p indică ordinul zecimal pe care va fi așezată următoarea cifră binară în rezultat. La început, p = 1, apoi aceasta devine 10, 100, 1000 și așa mai departe.

while n != 0: binar = (n % 2) * p + binar p = p * 10 n = n // 2 print(binar)

2. Transformarea unui număr din baza 2 în baza 10 SĂ NE REAMINTIM! Pentru a transforma un număr din baza 2 în baza 10, folosim valorile poziționale ale cifrelor. Fiecare cifră se înmulțește cu o putere a lui 2, în funcție de poziția pe care o ocupă în scrierea numărului. Într-un număr scris în baza 2, fiecare cifră are o anumită poziție, iar acestei poziții îi corespunde o putere a lui 2: ◗ ◗ ◗ ◗

cifra din extremitatea dreaptă se înmulțește cu 2⁰; cifra aflată imediat la stânga ei se înmulțește cu 2¹; următoarea cifră se înmulțește cu 2²; și așa mai departe, crescând exponentul cu 1 de fiecare dată când ne deplasăm spre stânga.

Prin urmare, pentru a obține valoarea numărului în baza 10: 1. identificăm fiecare cifră binară; 2. stabilim poziția ei în scrierea numărului; 3. înmulțim cifra cu puterea lui 2 corespunzătoare acelei poziții; 4. adunăm toate valorile obținute.

Exemplul 2: Se citește de la tastatură un număr natural n, considerat scris în baza 2. Afișați valoarea lui în baza 10.

Rezolvare matematică

n = int(input("n = ")) putere = 1 zecimal = 0

◗ 11001(2) = 16 + 8 + 0 + 0 + 1 = 25

while n != 0: cifra = n % 10 zecimal = zecimal + cifra * putere putere = putere * 2 n = n // 10

Prin urmare, 11001(2) = 25(10).

print(zecimal)

Pentru n = 11001, calculăm: ◗ 11001(2) = 1·24 + 1·23 + 0·22 + 0·21 + 1·20

3. Transformarea unui număr din baza a în baza b În general, pentru a transforma un număr din baza a în baza b, se poate proceda în doi pași: ◗ transformăm mai întâi numărul din baza a în baza 10; ◗ transformăm apoi rezultatul din baza 10 în baza b.

OBSERVĂ Cifra memorează cifra binară curentă, putere memorează puterea lui 2 corespunzătoare poziției, iar zecimal memorează treptat valoarea numărului în baza 10.

51

Exemplul 3: Se citesc de la tastatură un număr natural n, baza a în care este scris și baza b în care dorim să-l transformăm, cu 2 ≤ a ≤ 10 și 2 ≤ b ≤ 10.

Afișați reprezentarea lui n în baza b.

Rezolvare matematică Să transformăm 1011(2) în baza 8. ◗ Pasul 1: 1011(2) = 1·23 + 0·22 + 1·21 + 1·20 = 11(10). ◗ Pasul 2: 11 : 8 = 1, rest 3; 1 : 8 = 0, rest 1. ◗ Citind resturile în ordine inversă, obținem 13(8).

Prin urmare, 1011(2) = 13(8).

OBSERVAȚIE În exemplele următoare presupunem că 2 ≤ a ≤ 10 și 2 ≤ b ≤ 10, astfel încât numerele să poată fi prelucrate folosind doar variabile de tip int.

OBSERVĂ În prima parte a algoritmului obținem valoarea numărului în baza 10, iar în a doua parte construim reprezentarea în baza b. Variabila rezultat memorează numărul final, iar p indică poziția următoarei cifre în reprezentarea nouă.

Program Python n = int(input("n = ")) a = int(input("a = ")) b = int(input("b = ")) # transformare din baza a in baza 10 putere = 1 zecimal = 0 x = n while x != 0: cifra = x % 10 zecimal = zecimal + cifra * putere putere = putere * a x = x // 10

# transformare din baza 10 in baza b rezultat = 0 p=1 while zecimal != 0: rezultat = (zecimal % b) * p + rezultat p = p * 10 zecimal = zecimal // b print(rezultat)

4. Greșeli frecvente ◗ Citirea resturilor în ordinea în care au fost obținute, și nu în ordine inversă. ◗ Folosirea greșită a variabilei putere în transformarea din baza b în baza 10; aceasta trebuie înmulțită cu baza, nu cu 10.

Exersează!

1. Un hacker etic primește un cod numeric n, exprimat în sistemul zecimal. Pentru a-l putea introduce într-un modul de analiză, codul trebuie transformat în baza 2. Se citește de la tastatură un număr natural n. Afișați codul binar corespunzător lui n. Exemplu: Pentru n = 13, se afișează 1101.

2. Un specialist în securitate primește un semnal codificat sub forma unui număr alcătuit doar din cifrele 0 și 1.

Pentru a interpreta corect informația transmisă, semnalul trebuie decodat în valoarea sa numerică obișnuită, exprimată în sistemul zecimal. Se citește de la tastatură un număr natural n, considerat scris în baza 2. Afișați valoarea decodificată a semnalului în baza 10. Exemplu: Pentru n = 101101, se afișează 45.

3. Un specialist în securitate primește un cod numeric nenul n, fără să cunoască baza de numerație în care a fost scris. Pentru a putea începe decodarea, trebuie mai întâi să determine baza minimă în care acest cod ar putea fi valid. Se citește de la tastatură un număr natural n. Afișați baza minimă în care poate fi scris acest cod.

4. Un specialist în securitate primește un cod de acces transmis într-un sistem de reprezentare compact, folosind doar cifrele de la 0 la 7. Pentru a putea interpreta corect informația, codul trebuie convertit în valoarea sa numerică obișnuită, exprimată în sistemul zecimal. Se citește de la tastatură un număr natural n, considerat scris în acest sistem de codificare. Afișați valoarea decodificată a codului în baza 10. Exemplu: Pentru n = 157, se afișează 111.

52

PROBLEME PROPUSE 1. Un robot de inspecție primește un cod numeric n. La parcurgerea cifrelor codului de la dreapta la stânga, prima cifră pară strict mai mare decât 4 reprezintă portul corect de încărcare. Dacă se citește de la tastatură codul numeric n, afișați portul corect de încărcare sau mesajul „nu exista”.

Exemplu: pentru n = 12643, se va afișa 6.

2. Un semnal numeric n este analizat cifră cu cifră de la dreapta la stânga. Cifrele egale cu 5 reprezintă zgomot și trebuie ignorate. Dacă apare cifra 0, analiza se oprește imediat. Dacă se citește de la tastatură un semnal numeric n afișați suma cifrelor prelucrate.

Exemplu: pentru n = 37205541, se vor prelucra, de la dreapta la stânga, cifrele 1 și 4, cifrele 5 vor fi ignorate, iar la apariția cifrei 0 analiza se oprește. Se va afișa 5.

3. O poartă automată primește un cod zecimal n, dar unitatea de control lucrează în baza 2. Se citește de la tastatură un număr natural n scris în baza 10. Să se afișeze reprezentarea numărului n în baza 2.

Exemplu: pentru n = 13, se va afișa 1101.

4. Un senzor transmite un cod format numai din cifrele 0 și 1. Se citește de la tastatură un număr natural n, considerat scris în baza 2. Să se afișeze reprezentarea numărului n în baza 10.

Exemplu: pentru n = 101101, se va afișa 45.

5. Două instalații decorative pornesc automat la fiecare a, respectiv b minute. Se citesc de la tastatură două numere naturale nenule a și b. Să se afișeze după câte minute pornesc din nou simultan pentru prima dată.

Exemplu: pentru a = 12 și b = 18, cele două instalații pornesc din nou simultan după 36 minute. Se va afișa 36.

6. Într-o seră, două circuite de irigare au pașii de funcționare a și b. Dacă aceste valori sunt prime între ele, sistemele sunt considerate independente. Se citesc de la tastatură două numere naturale nenule a și b. Să se afișeze mesajul „DA” dacă sistemele sunt independente și mesajul „NU” în caz contrar.

Exemplu: pentru a = 14 și b = 25, deoarece cele două numere sunt prime între ele, se va afișa DA. 7. Un cristal este identificat printr-un număr natural n > 1. Amprenta lui este dată de numărul factorilor primi distincți și de suma tuturor exponenților din descompunerea în factori primi. Se citește de la tastatură un număr natural n > 1. Să se afișeze amprenta cristalului.

Exemplu: pentru n = 360, avem descompunerea 360 = 2³ · 3² · 5¹. Numărul factorilor primi distincți este 3, iar suma exponenților este 3 + 2 + 1 = 6. Se va afișa 3 6.

8. O dronă poate fi lansată doar la momente care sunt multipli ai lui n. Se citesc de la tastatură trei numere naturale nenule n, a și b (a <= b). Să se afișeze primul multiplu al lui n din intervalul [a, b] care are ultima cifră 6. Dacă nu există, un astfel de multiplu se va afișa mesajul „nu exista”.

Exemplu: pentru n = 4, a = 10 și b = 40, multiplii lui 4 din interval sunt 12, 16, 20, ..., iar primul care are ultima cifră 6 este 16. Se va afișa 16.

9. Într-un sistem de securitate, fiecare robot primește un cod numeric N. Pentru validare, codul este transformat în baza 2, iar sistemul verifică dacă reprezentarea binară este un palindrom. Scrieți un program care afișează "DA" dacă reprezentarea binară a lui N se citește la fel în ambele sensuri, respectiv "NU" în caz contrar.

Exemplu: pentru N = 9, (1001) se afișează DA; pentru N = 10, (1010) se afișează NU.

53

FIȘĂ DE EVALUARE FINALĂ Indicații: Rezolvați clar și ordonat. Pentru exercițiile care cer program, se acceptă orice variantă corectă în limbajul Python.

S U B I EC T E 1. Selectați tipul de numere de mai jos care are întotdeauna un număr impar de divizori pozitivi: ...................... 4p A. numerele prime B. pătratele perfecte C. numerele perfecte D. numerele care sunt puteri ale lui 2 2. Numărul natural n > 1 este prim dacă și numai dacă suma divizorilor săi este: .................................................. 6p A. 0

B. n/2

C. n+1

D. n

3. Se consideră valorile a = 6, b = 9 și c = 12. Pentru fiecare dintre expresiile de mai jos, precizați dacă valoarea ei este True sau False: .............................................................................................................................. 10p a) a < b and b < c b) a == c // 2 or b == 8 c) not(a % 2 == 0 and c % 3 == 0) d) a + b <= c and c % a == 0 e) (a < b and b > c) or (c - b == b - a) 4. Se consideră următorul program Python: ........ 8p n = int(input("n = ")) m = 0 p = 1 s = 0 while n > 0: c = n % 10 if c % 2 == 1: m = c * p + m p = p * 10 else: s = s + c n = n // 10 print(m) print(s)

a) Pentru n = 5827436, precizați cele două valori afișate. b) Explicați rolul variabilei p.

5. Un elev a scris următorul program Python, cu intenția de a afișa dacă un număr natural n este prim: ..... 10p n = int(input("n = ")) ok = True for d in range(2, n): if n % d == 0: ok = False if ok == True: print("prim") else: print("nu este prim")

a) Precizați ce se afișează pentru n = 15. b) Explicați de ce programul nu oferă răspunsul corect pentru n = 1. c) Scrieți o variantă corectă a programului.

6. Pentru numărul 127 scris în baza 10, scrieți reprezentarea sa în baza 2 și în baza 8. .......................................... 8p 7. Scrieți un program Python care citește un număr natural n și afișează cifra maximă a lui n și numărul ei de apariții. .................................................................................................................................................................. 12p Exemplu: pentru n = 5289582, se va afișa 9 1.

8. Scrieți un program Python care citește un număr natural n și construiește un nou număr format doar din cifrele nenule lui n care divid pe 12, păstrate în aceeași ordine în care apar în număr. Dacă nu există nicio astfel de cifră, se va afișa 0. ................................................................................................................................. 12p Exemplu: pentru n = 507428316, se va afișa 42316.

9. Un cofetar are A bomboane de ciocolată și B bomboane cu fructe și vrea să pregătească pachete identice pentru copii, astfel încât în fiecare pachet să fie același număr de bomboane de ciocolată și același număr de bomboane cu fructe, fără să-i rămână nicio bomboană. Scrieți un program care citește A și B, apoi afișează numărul maxim de pachete pe care le poate forma cofetarul. ........................................................................ 20p Exemplu: pentru A = 24, B = 36, programul va afișa 12 pachete.

54

CAPITOLUL III Subprograme. Introducere în programarea orientată pe obiecte COMPETENȚE SPECIFICE VIZATE CS 1.5 Identifică elementele de sintaxă și componentele din definiția și apelul subprogramelor și subprogramelor predefinite pentru operații uzuale, pentru a le utiliza în implementarea algoritmilor în limbaj de programare.

CS 2.5 Explică mecanismul de executare a subprogramelor și subprogramelor predefinite pentru operații uzuale, pentru a le utiliza în implementarea algoritmilor în limbaj de programare.

CS 6.3 Proiectează modular algoritmi personalizați pentru rezolvarea problemelor.

CS 3.5 Utilizează elementele de sintaxă și componentele din definiția și apelul subprogramelor și subprogramelor predefinite pentru operații uzuale, în implementarea algoritmilor în limbaj de programare.

CS 4.5 Analizează aplicabilitatea, avantajele și dezavantajele utilizării subprogramelor, în implementarea algoritmilor în limbaj de programare.

CS 6.5 Implementează aplicații în limbaj de programare care integrează subprograme personalizate, pentru a modulariza și organiza eficient codul în cadrul soluțiilor informatice.

III.1. Proiectarea modulară a algoritmilor. Funcții fără parametri În activitatea de programare, multe probleme mai complexe pot fi rezolvate mai ușor dacă sunt împărțite în subprobleme mai mici, fiecare având un rol bine precizat. O astfel de abordare poartă denumirea de proiectare modulară a algoritmilor. Astfel, modularizarea este procesul prin care împărțim o problemă complexă în subprobleme mai mici, mai simple și independente, numite funcții.

Imaginează-ți un set de LEGO. Nu ai o singură piesă uriașă în formă de castel, ci sute de piese mici pe care le poți asambla cum vrei. Dacă o piesă se strică sau trebuie modificată, o repari sau o înlocuiești doar pe ea, nu arunci tot setul LEGO.

1. Rolul funcțiilor Dacă scrii tot codul într-un singur bloc, pot să apară probleme în iden­ tificarea erorilor și mentenanța programului. Iată avantajele organizării modulare a codului: ◗ reutilizarea codului – scrii o singură dată o funcție și apoi o poți folosi în mai multe programe (de exemplu, o funcție care calculează media unor note sau o funcție care verifică dacă un număr este prim); ◗ depanare ușoară (debugging) – dacă în program apare o eroare, nu trebuie să citești mii de linii de cod, ci doar codul funcției în care a apărut eroarea; ◗ lucrul în echipă – într-o firmă de software, fiecare programator poate lucra independent la câte o componentă a unui program complex (de exemplu, un programator poate lucra la funcția de autentificare, în timp ce altul lucrează la o funcție pentru gestionarea unor produse); ◗ lizibilitate – codul devine mult mai ușor de citit și înțeles pentru alții (sau chiar pentru tine, peste 3 luni).

55

De exemplu, dacă dorim să realizăm un program care prelucrează cifrele unui număr și afișează anumite rezultate, putem separa activitatea în mai multe componente: ◗ citirea datelor; ◗ prelucrarea datelor; ◗ afișarea rezultatelor. În loc să scriem toate instrucțiunile într-un singur bloc, putem grupa anumite prelucrări în subprograme. În limbajul Python, subprogramele se numesc funcții.

2. Funcții fără parametri definite de utilizator În Python, crearea unei funcții proprii începe întotdeauna folosind cuvântul-cheie def. În această primă lecție vom utiliza funcții fără parametri, pentru a înțelege mai întâi ideea de bază a modularizării.

Sintaxa generală def nume_functie(): instrucțiuni

# antetul funcției # corpul funcției

3. Caracteristicile funcțiilor O funcție are două părți principale: ◗ antet – linia care conține cuvântul cheie def; ◗ corp – un bloc de instrucțiuni.

REȚINE! ◗ În limbajul Python, blocurile de instrucțiuni sunt delimitate prin indentare!

În această etapă, funcțiile nu vor primi date din exterior (parametri). Dacă o funcție are nevoie de date de intrare, atunci acestea se vor citi în corpul său.

Această abordare este utilă în etapa inițială, deoarece permite înțelegerea mai clară a noțiunii de funcție, a modului în care aceasta se definește și se apelează, precum și a diferenței dintre o funcție care afișează direct un rezultat și una care furnizează un rezultat care poate fi folosit ulterior.

Apelul unei funcții Apelul unei funcții reprezintă momentul în care funcția este folosită în fluxul principal al programului sau în altă funcție, respectiv se execută instrucțiunile definite în corpul ei. Cu alte cuvinte, o funcție nu se execută când este definită, ci numai când ea este apelată. La apel, se transferă execuția către funcția respectivă, iar după terminarea acesteia programul își continuă executarea din punctul în care funcția a fost apelată.

O funcție fără parametri se apelează astfel: nume_functie( )

4. Funcții care nu returnează explicit o valoare O funcție poate executa anumite operații și poate afișa direct rezultatele.

Exemplul 1: Afișarea divizorilor unui număr natural def afiseaza_divizorii(): n = int(input("n = ")) print("Divizorii numarului", n, "sunt:", end=" ") for d in range(1, n + 1): if n % d == 0: print(d, end=" ") print()

#Fluxul principal al programului afiseaza_divizorii()

56

REȚINE! ◗ O funcție se execută numai când este apelată!

Explicații: ◗ numele funcției este afiseaza_divizorii; ◗ se citește valoarea lui n în corpul funcției; ◗ se parcurg valorile de la 1 la n; ◗ pentru fiecare valoare d, se verifică dacă d divide pe n și în caz afirmativ se afișează valoarea lui d.

5. Funcții care returnează o valoare O funcție poate calcula un rezultat și îl poate furniza programului (sau altei funcții) în care a fost apelată folosind instrucțiunea return.

Sintaxa generală def nume_functie(): instrucțiuni return expresie

Instrucțiunea return încheie executarea funcției și trimite rezultatul către punctul în care funcția a fost apelată.

Exemplul 2: Suma cifrelor unui număr natural def suma_cifrelor(): n = int(input("n = ")) s = 0 while n != 0: s = s + n % 10 n = n // 10 return s

#Fluxul principal al programului rezultat = suma_cifrelor() print("Suma cifrelor este", rezultat)

6. Diferența dintre cele două tipuri de funcții Să comparăm cele două exemple: Funcție fără return def afiseaza_divizorii(): instrucțiuni print(...)

Explicații: ◗ funcția citește valoarea lui n; ◗ se extrag pe rând cifrele numărului; ◗ acestea se adună în variabila s; ◗ la final, funcția returnează valoarea lui s.

OBSERVAȚIE În acest caz, funcția nu afișează direct rezultatul, ci îl returnează.

Apoi rezultatul este memorat ­într-o variabilă și poate fi afișat sau utilizat în alte calcule.

Aceasta execută o acțiune și afișează direct rezultatul.

Funcție cu return def suma_cifrelor(): instructiuni return s

Aceasta calculează un rezultat și îl transmite programului.

REȚINE! ◗ Folosim o funcție fără return când dorim, în principal, executarea unei acțiuni. ◗ Folosim o funcție cu return când dorim să obținem un rezultat care va fi utilizat ulterior. ◗ Faptul că o funcție nu conține instrucțiunea return nu înseamnă că ea nu este utilă. Există multe situații în care dorim doar să afișăm, să citim sau să executăm o anumită secvență de instrucțiuni. ◗ În Python, orice funcție returnează cel puțin o valoare. Dacă nu se specifică clar acest lucru, prin cuvântul cheie return, Python adaugă automat la finalul funcției o linie invizibilă: return None (o valoare specială care semnifică „nimic” sau „valoare lipsă”).

57

Exemplul 3: Determinarea c.m.m.d.c. a două numere naturale nenule, folosind o funcție fără parametri def afiseaza_cmmdc(): a = int(input("a = ")) b = int(input("b = ")) x = a y = b while y != 0: r = x % y x = y y = r print("C.M.M.D.C. al numerelor", a, "si", b, "este", x) afiseaza_cmmdc()

Această variantă este utilă pentru început, deoarece întreaga rezolvare este grupată într-o singură funcție ușor de identificat și de apelat.

REȚINE! Avantajele proiectării modulare: ◗ programul este mai bine organizat; ◗ secvențele importante pot fi separate și denumite sugestiv; ◗ aceeași prelucrare poate fi reutilizată.

Exersează!

1. Precizați care este antetul și care este corpul funcției din secvența următoare: def afisare(): print("Python") print("Functii")

2. Analizați următoarea secvență de cod și precizați, în ordinea executării, toate valorile afișate: def calculeaza(): x = 10 print(x - 2) return x + 5 a = calculeaza() print(a * 2)

3. Analizați următoarea secvență și precizați dacă funcția afișează sau returnează rezultatul calculat. Indicați și toate valorile afișate la executare: def test(): n = 8 print(n * n) rez = test() print(rez)

4. Realizați o funcție fără parametri care citește un număr natural nenul și afișează dacă numărul este par sau impar.

Exemplu: pentru n = 27, se va afișa „Numarul este impar.”

5. Realizați o funcție fără parametri care citește un număr natural și returnează oglinditul său.

Exemplu: pentru n = 5072, funcția va returna 2705.

6. Realizați o funcție fără parametri care citește un număr natural și returnează numărul său de cifre.

Exemplu: pentru n = 5072, funcția va returna 4.

7. Realizați o funcție fără parametri care citește un număr natural și returnează suma divizorilor săi.

Exemplu: pentru n = 12, funcția va returna 28.

58

III.2. Funcții cu parametri. Variabile locale și globale În lecția anterioară am studiat funcțiile fără parametri și am observat că un program poate fi organizat mai clar dacă anumite prelucrări sunt grupate în funcții. În multe situații, însă, o funcție trebuie să poată prelucra diferite date de intrare, fără să le citească de fiecare dată în corpul funcției.

O funcție cu parametri primește date din exterior, le prelucrează și poate fie să afișeze un rezultat, fie să returneze una sau mai multe valori. În plus, limbajul Python permite și utilizarea unor parametri cu valori implicite, precum și a unor funcții predefinite foarte utile în rezolvarea problemelor.

1. Funcții cu parametri O funcție poate fi definită astfel încât să primească una sau mai multe date de intrare. Aceste date sunt precizate în antetul funcției prin intermediul parametrilor formali. La apel, parametrilor formali li se asociază valori concrete, obținute prin evaluarea unor expresii, numite parametri efectivi.

Sintaxa generală def nume_functie(parametru1, parametru2, ...): instrucțiuni

În această scriere: ◗ def este cuvântul-cheie folosit pentru definirea unei funcții; ◗ nume_functie este numele funcției; ◗ lista dintre paranteze conține parametrii formali; ◗ instrucțiunile indentate formează corpul funcției.

Apelul unei funcții cu parametri Apelul unei funcții reprezintă momentul în care funcția este folosită în fluxul principal al programului sau într-o altă funcție, respectiv se execută instrucțiunile definite în corpul ei. Cu alte cuvinte, o funcție nu se execută când este definită, ci numai când ea este apelată. La apel, se transferă execuția către funcția respectivă, iar după terminarea acesteia fluxul programului își continuă execuția din punctul în care funcția a fost apelată.

O funcție cu parametri se apelează înlocuind parametrii formali cu parametri efectivi (valori sau expresii): nume_functie(valoare1, valoare2, ...)

2. Parametri formali și parametri efectivi Să analizăm exemplul: def suma(x, y): return x + y s = suma(3, 7) print(s)

◗ x și y sunt parametri formali; ◗ 3 și 7 sunt parametri efectivi; ◗ valoarea returnată de funcție este 10.

REȚINE! ◗ Parametrii formali apar în definiția funcției, iar parametrii efectivi apar în apelul ei.

Funcția devine astfel mai flexibilă, deoarece aceeași prelucrare poate fi aplicată pentru date de intrare diferite.

59

Exemplul 1: Afișarea divizorilor unui număr natural def afiseaza_divizorii(n): print("Divizorii lui", n, end=" ") for d in range(1, n + 1): if n % d == 0: print(d, end=" ") print() afiseaza_divizorii(12) afiseaza_divizorii(18)

Funcția primește parametrul n și afișează direct rezultatul, fără a utiliza instrucțiunea return.

Exemplul 2: Determinarea c.m.m.d.c. a două numere naturale nenule def cmmdc(a, b): while b != 0: r = a % b a = b b = r return a x = cmmdc(18, 24) print("C.M.M.D.C. =", x)

Acest tip de funcție este mai flexibil, deoarece rezultatul returnat poate fi afișat, comparat sau folosit într-un alt calcul.

3. Apel pozițional și apel prin nume La apelul unei funcții, parametri efectivi pot fi transmiși fie pozițional, fie prin nume. a) Apel pozițional

b) Apel prin nume

def diferenta(a, b): return a - b

def diferenta(a, b): return a - b

print(diferenta(10, 3))

print(diferenta(b=3, a=10))

Valorile sunt asociate parametrilor în ordinea în care apar.

Valorile sunt asociate parametrilor pe baza numelor acestora.

OBSERVAȚIE Apelul prin numele parametrilor este util când dorim o scriere mai clară sau când funcția are mai mulți parametri.

4. Parametri cu valori implicite Uneori dorim ca un parametru să aibă o valoare prestabilită, folosită atunci când la apel nu transmitem o valoare explicită pentru acel parametru. În această situație folosim parametri cu valori implicite.

Sintaxa generală def nume_functie(p1,p2,... ,pv1=valoare1,pv2=valoare2,...): instrucțiuni

Exemplul 3: Ridicarea la putere def putere(baza, exponent=2): return baza ** exponent print(putere(5)) print(putere(5, 3)) print(putere(baza=4, exponent=4))

Explicații ◗ parametrul baza este un parametru obișnuit; ◗ parametrul exponent are valoarea implicită 2; ◗ apelul putere(5) înseamnă 5 ** 2, deci rezultatul este 25; ◗ apelul putere(5, 3) înseamnă 5 ** 3, deci rezultatul este 125.

ATENȚIE Dacă într-un antet apar atât parametri obișnuiți, cât și cu valori implicite, atunci cei obișnuiți trebuie scriși primii.

60

Exemplul 4: Suma cifrelor unui număr natural

Exemplul 5: Testarea primalității unui număr natural

def suma_cifrelor(n): s = 0 while n != 0: s = s + n % 10 n = n // 10 return s n = int(input("n = ")) print(suma_cifrelor(n))

def este_prim(n): if n < 2: return False for d in range(2, n // 2 + 1): if n % d == 0: return False return True print(este_prim(17)) print(este_prim(18))

Așa cum se poate observa din exemplul anterior, o funcție poate returna și valorile logice True sau False. În acest caz, la fel ca pentru orice altă expresie logică, putem renunța la compararea explicită a rezultatului furnizat de o funcție cu True: Variantă explicită print("Numere prime cu 3 cifre:") for k in range(100, 1000): if este_prim(k) == True: print(k, end=" ")

Variantă simplificată print("Numerele prime cu 3 cifre:") for k in range(100, 1000): if este_prim(k): print(k, end=" ")

5. Variabile locale și variabile globale O variabilă definită în interiorul unei funcții se numește variabilă locală și poate fi folosită doar în interiorul acelei funcții. O variabilă definită în afara tuturor funcțiilor se numește variabilă globală și este vizibilă în întregul fișier sursă în care a fost definită. Dacă într-o funcție este definită o variabilă locală cu același nume ca o variabilă globală, atunci în funcție se va utiliza variabila locală.

Exemplul 6: variabile locale Considerăm două funcții, funcție_1 și funcție_2, iar în fiecare dintre ele definim câte o variabilă locală x: Cod sursă def functie_1(): x = 10 print("In functie_1: x =", x) def functie_2(): x = 20 print("In functie_2: x =", x) functie_1() functie_2() print(f"In fluxul principal: x = {x}")

Rezultatul executării In functie_1: x = 10 In functie_2: x = 20 Traceback (most recent call last): File "C:\Proiecte\Test.py", line 11, in <module> print(f"In fluxul principal: x = {x}") ^ NameError: name 'x' is not defined

În urma executării programului, observăm faptul că fiecare dintre funcții afișează valoarea variabilei locale x din funcția respectivă. Variabilele x definite în funcțiile functie_1 și functie_2 sunt variabile locale, independente una de alta și inaccesibile în afara funcțiilor. De aceea, încercarea de a afișa x în fluxul principal duce la o eroare.

61

Exemplul 7: variabilă globală Considerăm două funcții, funcție_1 și funcție_2, o variabilă globală x inițializată cu valoarea 100 și o variabilă locală x inițializată cu valoarea 10 în funcție_1: Cod sursă x = 100 def functie_1(): x = 20 print("In functie_1: x =", x)

Rezultatul executării In functie_1: x = 20 In functie_2: x = 100 In fluxul principal: x = 100

def functie_2(): print("In functie_2: x =", x) functie_1() functie_2() print(f"In fluxul principal: x = {x}")

În urma executării programului, observăm faptul că functie_1 afișează valoarea variabilei locale x, iar functie_2 și fluxul principal afișează valoarea variabilei globale x.

Exemplul 8: variabile globale În limbajul Python, nu contează poziția în cod a definirii unei variabile globale față de definirea funcțiilor, deoarece variabilele sunt căutate în momentul apelurilor funcțiilor, și nu la momentul definirii acestora. Totuși, este necesar ca variabilele să fie definite înainte de apelul funcției.

Cod sursă

Rezultatul executării

x = 100 def functie_1(): print(f"In functie_1: x={x}, y={y}, z={z}\n") y = 200 def functie_2(): print(f"In functie_2: x={x}, y={y}, z={z}\n") z = 300 functie_1() functie_2() print(f"In fluxul principal: x={x}, y={y}, z={z}")

In functie_1: x=100, y=200, z=300 In functie_2: x=100, y=200, z=300 In fluxul principal: x=100, y=200, z=300

Exemplul 9: variabile globale Considerăm două funcții, funcție_1 și funcție_2, respectiv o variabilă globală x inițializată cu valoarea 100: Cod sursă x = 100 def functie_1(): print("In functie_1: x =", x) def functie_2(): x = x + 2000 print("In functie_2: x =", x) functie_1() functie_2() print(f"In fluxul principal: x = {x}")

62

Rezultatul executării In functie_1: x = 100 Traceback (most recent call last): File "C:\Proiecte\Test.py", line 10, in <module> functie_2() File "C:\Proiecte\Test.py", line 6, in functie_2 x = x + 2000 ^ UnboundLocalError: cannot access local variable 'x' where it is not associated with a value

În momentul executării programului, se semnalează o eroare la instrucțiunea x = x + 2000, deoarece: ◗ când interpretorul limbajului Python întâlnește o astfel de instrucțiune de atribuire într-o funcție, acesta consideră implicit că variabila din partea stângă (în acest caz, x) este o variabilă locală; ◗ când va încerca să evalueze expresia din partea dreaptă (x + 2000), interpretorul va considera că variabila x este locală, deci nu va mai căuta o eventuală variabilă globală x; ◗ variabila locală x nu este inițializată (nu conține nicio valoare), deci va apărea o eroare.

Dacă dorim ca în funcție_2 să utilizăm variabila globală x, atunci trebuie să specificăm explicit acest lucru, folosind cuvântul cheie global: Cod sursă x = 100 def functie_1(): print("In functie_1: x =", x) def functie_2(): global x x = x + 2000 print("In functie_2: x =", x) functie_1() functie_2() print(f"In fluxul principal: x = {x}")

Rezultatul executării In functie_1: x = 100 In functie_2: x = 2100 In fluxul principal: x = 2100

OBSERVAȚIE În exemplul 7 de mai sus, în funcție_2, variabila x nu este modificată (nu apare în membrul stâng al unei instrucțiuni de atribuire), deci nu va fi considerată automat de către interpretor ca fiind locală. Din acest motiv, interpretorul va căuta și va găsi o variabilă globală cu numele x, pe care o va folosi în funcție, deci nu va apărea nicio eroare la executarea programului!

6. Mecanismul de executare al unei funcții Când apelăm o funcție în Python, se efectuează următorii pași: a) Identificarea funcției apelate – Python caută funcția după numele folosit în apel. b) Suspendarea temporară a fluxului curent – executarea programului se oprește temporar la instrucțiunea de apel și continuă în corpul funcției, iar după terminarea executării funcției, programul își reia fluxul. c) Crearea unui spațiu local de lucru – pentru funcția apelată se creează un spațiu propriu de lucru în memorie. În acest spațiu, funcția își creează propriile etichete pentru variabilele locale și pentru datele primite din exterior (acestea sunt asociate direct valorilor originale, fără a le copia în memorie). d) Asocierea argumentelor cu parametrii (în cazul funcțiilor cu parametri) – valorile trimise la apel (parametri efectivi) sunt asociate parametrilor formali din definiția funcției. Astfel, funcția primește datele pe care trebuie să le prelucreze. e) Executarea instrucțiunilor din corpul funcției – Python execută, în ordine, instrucțiunile scrise în interiorul funcției. În această etapă se realizează calculele sau prelucrările din corpul funcției. f) Returnarea rezultatului – dacă funcția întâlnește instrucțiunea return, executarea sa se termină, iar valoarea calculată este transmisă înapoi către fluxul curent. Daca funcția nu conține nicio instrucțiune return, la final aceasta va returna implicit None. După aceea, spațiul local de lucru al funcției este eliberat, iar variabilele locale nu mai pot fi accesate. g) Reluarea executării fluxului curent – fluxul curent își reia executarea imediat după instrucțiunea de apel al funcției. Dacă funcția returnează o valoare, aceasta este transmisă înapoi în fluxul curent, putând fi utilizată într-o expresie.

63

REȚINE! În general, se recomandă ca funcțiile să comunice între ele prin parametri și valori returnate, nu prin variabile globale, deoarece pot apărea efecte colaterale nedorite, care sunt mai greu de urmărit și depanat (de exemplu, mai multe funcții pot modifica aceeași variabilă globală sau o funcție modifică din greșeală o variabilă globală).

P ORTOFOLIU DIGITAL Carnetul de note – modularizarea aplicației Organizare

Creează folderul: Portofoliu digital > Capitolul 3 > Carnetul de note > Tema 4 - Modularizarea aplicației.

Cerința 1

Pornește de la aplicația carnet_note_v1.py realizată la Tema 3 și transform-o într-o aplicație modulară.

Cerința 2

Realizează funcții separate pentru: afișarea meniului, verificarea promovării după o notă, verificarea progresului după trei note, verificarea progresului după n note, citirea și validarea unei note.

Cerința 3

Adaugă în aplicație o opțiune nouă: statistici rapide pentru un set de note. Pentru această opțiune se citesc n note și se afișează media, nota maximă, nota minimă și numărul notelor de promovare.

Cerința 4

Meniul final va avea opțiunile: 1 - promovare după o notă, 2 - verificare după trei note, 3 - verificare după n note, 4 - statistici rapide pentru un set de note, 5 - ieșire.

Salvează

carnet_note_v2.py (cerințele 1-4)

Document

Realizează un document foarte scurt în care explici de ce este mai avantajos să organizezi aplicația în funcții, precizezi ce rol are fiecare funcție importantă și adaugi două exemple complete de rulare.

Nume recomandat: tema4_prezentare.docx.

Exersează!

1. În secvența următoare, precizați care sunt parametrii formali și care sunt parametrii efectivi: def produs(a, b): return a * b p = produs(4, 7)

2. Analizați secvența și precizați ce se afișează: x = 50 def f(): x = 20 print("In functie:", x) f() print("In program:", x)

3. Scrieți o funcție numar_cifre(n=0) care returnează numărul cifrelor pare ale lui n. Testați funcția pentru apelurile numar_cifre(2326) și numar_cifre(). Exemplu: numar_cifre(2326) → 3, iar numar_cifre() → 1.

4. Scrieți două funcții care primesc ca parametru un număr natural și returnează cea mai mare cifră, respectiv cea mai mică cifră care apare în scrierea sa. Utilizați aceste funcții într-un program care citește un număr natural și afișează cifra maximă și cea minimă. Exemplu: pentru 582743 se afișează 8 2.

5. Se citesc n numere naturale. Să se determine câte dintre acestea au toate cifrele egale. Pentru rezolvare, veți utiliza funcțiile definite în exercițiul anterior! Exemplu: pentru n=5 și 777, 232, 9, 1111, 4004 se afișează 3.

64

III.3. Module. Funcții predefinite Unul dintre principalele avantaje ale proiectării modulare îl constituie reutilizarea codului, respectiv posibilitatea de a utiliza într-un program Python funcții definite în alt program. Practic, orice fișier sursă Python (cu extensia .py) poate fi privit atât ca un program de sine-stătător, cât și ca un modul, adică un fișier din care putem să importăm funcții în alte programe. Această organizare ajută la structurarea mai clară a codului și la reutilizarea lui în mai multe programe.

O funcție se poate importa dintr-un modul și apoi utiliza într-un alt program în mai multe moduri: Varianta 1: 1. se importă tot modulul folosind instrucțiunea import , astfel: import nume_modul 2. se apelează o funcție din modul prin nume_modul.nume_funcție (parametrii efectivi) sau prin nume_modul.nume_funcție().

Varianta 2: 1. se importă din modul doar funcțiile necesare folosind instrucțiunea from nume_modul import nume_funcție1, nume_funcție2,...

2. se apelează funcțiile importate în mod obișnuit, prin numele lor: nume_funcție(parametrii efectivi) sau nume_funcție() Exemplu: from math import sqrt, pow

# Utilizare directă: rezultat = sqrt(25) + pow(2, 3) print (rezultat)

OBSERVAȚIE Deși în limbajul Python se pot importa dintr-un modul și variabile, acest lucru nu este recomandat deoarece codul obținut este mai greu de urmărit și de depanat!

OBSERVAȚIE Varianta 1 se recomandă când într-un program importăm funcții cu același nume din module diferite (de exemplu, putem să avem o funcție calculeaza_aria(r) într-un modul patrat.py și într-un modul cerc.py)!

Exemplul 1: Considerăm modulul su ma_ produs.py , care conține funcția suma(a, b) și funcția produs(a, b), precum și un cod de test al celor două funcții în fluxul principal: Fișierul suma_produs.py def suma(a, b): return a + b def produs(a, b): return a * b print(f"Test functia suma: {suma(20, 30)}") print(f"Test functia produs: {produs(20, 30)}")

65

Din modulul suma_produs.py importăm funcția suma și o utilizăm în alte două programe, folosind ambele modalități prezentate anterior: Fișierul test_1.py

Fișierul test_2.py

import suma_produs

from suma_produs import suma

x = 1000 y = 500 s = suma_produs.suma(x, y) print(f"{x} + {y} = {s}")

x = 1000 y = 500 s = suma(x, y) print(f"{x} + {y} = {s}") Rezultatul executării

Test functia suma: 50 Test functia produs: 600 1000 + 500 = 1500

În urma executării fiecăruia dintre cele două programe de test, observăm faptul că mai întâi s-a executat codul din fluxul principal al programului din fișierul suma_produs.py și apoi cel din fluxul principal al programelor de test, deci s-a importat tot conținutul modulului suma_produs.py, inclusiv codul din fluxul principal!

Pentru a evita acest lucru, trebuie să testăm în fișierul suma_produs.py modalitatea în care el este utilizat de interpretorul Python (ca program sau ca modul) și să rulăm codul din fluxul principal doar în cazul în care el este executat ca un program de sine stătător. În acest scop vom utiliza variabila predefinită __name__ , căreia interpretorul îi atribuie șirul de caractere "__main__" când fișierul este rulat ca un program sau un șir de caractere care conține numele fișierului (fără extensia .py) când acesta este importat în alt program.

Fișierul suma_produs.py (modificat) def suma(a, b): return a + b def produs(a, b): return a * b print(f"Valoarea variabilei __name__: {__name__}") if __name__ == "__main__": print(f"Test functia suma: {suma(20, 30)}") print(f"Test functia produs: {produs(20, 30)}") Rezultatul rulării fișierului suma_produs.py Valoarea variabilei __name__: __main__ Test functia suma: 50 Test functia produs: 600

Rezultatul rulării fișierului test_1.py sau test_2.py Valoarea variabilei __name__: suma_produs 1000 + 500 = 1500

1. Funcții predefinite utile pentru calcule matematice și conversii În limbajul Python sunt implementate multe funcții utile, împărțite în două mari categorii: ◗ funcții predefinite (built-in functions) care sunt disponibile implicit în orice program, fără să fie necesară importarea lor dintr-un modul (de exemplu, funcțiile print, input și range). Aceste funcții fac parte din nucleul limbajului Python și au fost create pentru a efectua operații elementare, frecvent utilizate în programe. Alte funcții predefinite sunt următoarele:

66

a) min(valoare1, valoare2,...) – funcție cu număr variabil de parametri care furnizează cea mai mică valoare dintre cele date ca parametri: ● print(min(20, 10, -20, 100, -10)) #afișează -20 ● print(min(20, 100)) #afișează 20 b) max(valoare1, valoare2,...) – funcție cu număr variabil de parametri care furnizează cea mai mare valoare dintre cele date ca parametri: ● print(max(20, 10, -20, 70, -10)) #afișează 70 ● print(max(20, 100)) #afișează 100 c) abs(număr) – funcție care furnizează valoarea absolută a numărului dat ca parametru: ● print(abs(-10)) #afișează 10 ● print(abs(3.5)) #afișează 3.5 d) round(nr[, z]) – funcție care furnizează numărul obținut prin rotunjirea numărului nr la z zecimale.

Dacă z lipsește, atunci nr va fi rotunjit la cel mai apropiat număr întreg. Dacă valoarea nr se află exact la jumătatea distanței dintre două valori posibile de rotunjire (de exemplu, numărul 2.5 aflat exact la jumătate între 2 și 3), atunci rotunjirea se va face către valoarea pară cea mai apropiată: ● print(round(3.14159, 2)) # se afișează 3.14 ● print(round(3.14159, 3)) # se afișează 3.142 ● print(round(6.6)) # se afișează 7 ● print(round(2.5)) # se afișează 2 ● print(round(3.5)) # se afișează 4 e) int(nr) – funcție care furnizează numărul întreg obținut prin eliminarea părții fracționare (fără rotunjire) din numărul nr sau prin conversia șirului de caractere nr care trebuie să conțină un număr întreg scris în baza 10: ● print(int(2.1)) # se afișează 2 ● print(int(2.5)) # se afișează 2 ● print(int(2.9)) # se afișează 2 ● print(int(-2.1)) # se afișează -2 ● print(int(-2.5)) # se afișează -2 ● print(int(-2.9)) # se afișează -2 ● print(int("123") + 10) # se afișează 133 f) float(nr) – funcție care furnizează numărul real obținut prin conversia lui nr, care poate să fie un număr real sau un șir de caractere care conține un număr real: ● print(float(7)) # se afișează 7.0 ● print(float("3.14") + 10) # se afișează 13.14 ◗ funcții definite în module care sunt organizate în module în raport de tipul prelucrărilor pe care le efectuează și pot fi utilizate în alte programe prin importarea modulului respectiv. De exemplu, modulul math conține funcții pentru calcule matematice, iar modulul datetime funcții pentru lucru cu data și ora.

Alte funcții predefinite în modulul math sunt următoarele: a) sqrt(nr) – funcție care furnizează rădăcina pătrată a numărului pozitiv nr dat ca parametru (dacă numărul este negativ se va genera o eroare): ● print(math.sqrt(2)) # se afișează 1.4142135623730951 ● print(math.sqrt(16)) # se afișează 4.0 ● print(math.sqrt(6.25)) # se afișează 2.5 b) floor(x) – funcție care returnează cel mai mare număr întreg mai mic sau egal cu numărul x. De exemplu, math.floor(3.8) = 3 și math.floor(-2.3) = -3. ● print(math.floor(3.8)) # afișează 3 ● print(math.floor(-2.3)) # afișează -3

67

Exemplul 2: Se citește un număr natural n. Să se afișeze mesajul "Da" daca n este pătrat perfect, sau mesajul "Nu" în caz contrar.

import math numar = int(input("n=: "))

# Verificăm dacă radicalul numărului este un număr întreg if math.sqrt(numar) == int(math.sqrt(numar)): print("Da") else: print("Nu")

2. Funcții care returnează mai multe valori O funcție poate returna mai multe valori simultan, specificând valorile respective în instrucțiunea return, separate prin virgule. Astfel, se poate obține un cod mai compact prin comasarea unor funcții asemănătoare (de exemplu, suma și produsul cifrelor unui număr). def nume_functie(parametru1, parametru2,...): instrucțiuni return rezultat1, rezultat2,...

Exemplu: def operatii_numere(a, b): suma = a + b produs = a * b return suma, produs # Returnează ambele valori

3. Apelarea unei funcții care returnează mai multe valori Folosind instrucțiunea de atribuire multiplă, se pot memora rezultatele returnate de funcție direct în variabile separate: s, p = operatii_numere(5, 3) print(f"Suma este {s}, iar produsul este {p}")

Exemplul 3: Maxim și minim Definiți o funcție care primește ca parametri 3 numere reale și returnează două valori, respectiv maximul și minimul acestora. def numar(a, b, c): maxim = max(a, b, c) # Folosim funcțiile predefinite max() și min() minim = min(a, b, c) return maxim, minim # Returnăm cele două valori separate prin virgulă a = float(input("Introdu primul număr: ")) b = float(input("Introdu al doilea număr: ")) c = float(input("Introdu al treilea număr: "))

#Apelăm funcția și salvăm cele două rezultate Maxim, Minim = numar(a, b, c) print("Maximul este:", Maxim) print("Minimul este:", Minim)

68

Exersează!

1. Se consideră secvența de cod:

2. Se consideră fișierul calcul.py:

import math

def dublu(x): return 2 * x

x = 15.8 y = -4.2

print("Modul încărcat")

a = int(x) + abs(int(y)) b = round(x) + round(y) c = math.sqrt(81) + max(a, b)

if __name__ == "__main__": print(dublu(7))

print(a, b, c)

import calcul print(calcul.dublu(5))

Indicați valorile afișate:

Precizați ce se afișează la rularea fișierului test.py.

și fișierul test.py:

A. 19 12 28.0

B. 19 12 21.0

A. Modul încărcat / 14 / 10

B. 10

C. 18 12 28.0

D. 19 11 28.0

C. Modul încărcat / 10

D. 14 / 10

3. Se citesc trei valori reale t1, t2, t3, reprezentând trei măsurători succesive ale temperaturii făcute de același senzor.

Să se afișeze temperatura minimă, temperatura maximă și media aritmetică a celor trei valori rotunjită la două zecimale.

Rezolvarea trebuie să utilizeze funcțiile predefinite min, max și round.

Exemplu: pentru t1 = -2.5, t2 = 3, t3 = 1.5 se afișează -2.5 3 0.67.

4. Se citesc două numere reale pozitive a și b, considerate lungimile catetelor unui triunghi dreptunghic.

Să se determine și să se afișeze lungimea ipotenuzei, partea întreagă a ipotenuzei, valoarea ipotenuzei rotunjită la 3 zecimale și mesajul "DA" dacă ipotenuza este număr întreg, respectiv "NU" în caz contrar.

Rezolvarea trebuie să utilizeze funcția sqrt din modulul math, precum și funcțiile int și round.

Exemplu: pentru a = 3, b = 4 se afișează 5.0 5 5.0 DA. 5. Se citește un număr natural n (1 ≤ n ≤ 9).

Să se calculeze valoarea E = (1! + 2! + 3! + ... + n!) / sqrt(1 + 2 + 3 + ... + n) și să se afișeze suma factorialelor din numărător, valoarea numitorului și valoarea lui E, rotunjită la 4 zecimale.

Se vor utiliza funcțiile factorial și sqrt din modulul math, precum și funcția round. Nu este permisă definirea unei funcții proprii pentru calculul lui n! Se recomandă folosirea unei funcții predefinite potrivite pentru calculul sumei din radical.

Exemplu: pentru n = 3 se afișează 9 2.449489742783178 3.6742.

6. Precizați valorile afișate: print(abs(-18)) print(round(5.678, 1)) print(int(9.9)) print(float("7.25")) print(round(10.5))

69

III.4. Introducere în programarea orientată pe obiecte În multe situații, nu lucrăm doar cu valori izolate, ci cu entități care au atât informații proprii, cât și operații asociate. Programarea orientată pe obiecte organizează aceste elemente într-o formă naturală: datele și operațiile care le prelucrează sunt grupate împreună. În Python, chiar și valorile numerice pe care le folosim frecvent pot fi privite ca obiecte care aparțin unor clase și care pun la dispoziție anumite metode și atribute.

Pentru a înțelege mai ușor ce înseamnă Programarea Orientată pe Obiecte (POO), ne putem raporta la exemple din viața reală: ◗ un automobil are anumite caracteristici proprii, precum culoare, marcă, combustibil, iar, în același timp, asupra lui se pot realiza anumite operații, cum ar fi pornire, oprire, accelerare; ◗ un cont bancar are atribute precum titularul și soldul, dar și operații precum depunere, retragere sau consultarea soldului.

Observăm că, în toate aceste exemple, datele și operațiile nu apar separat, ci sunt legate între ele. În Python, această organizare este descrisă prin noțiunile de clasă, obiect (instanță), atribut (dată membru) și metodă.

1. Clasă O clasă este un model sau un tipar după care se creează obiecte. Ea descrie datele pe care le pot memora obiectele și operațiile pe care le pot realiza acestea.

Putem compara o clasă cu un plan de construcție. De exemplu, dacă dorim să construim mai multe case asemănătoare, avem nevoie de un proiect. Proiectul nu este o casă concretă, dar descrie cum vor arăta casele care se construiesc după el. În mod asemănător, o clasă nu este un obiect concret, ci modelul după care obiectele sunt create. De exemplu: ◗ clasa Elev poate descrie ce date memorăm referitor la un elev – nume, clasă, medie – și ce operații se pot realiza – calcularea mediei sau afișarea situației școlare. ◗ clasa int descrie numere întregi. Aceasta reprezintă în esență, ce fel de valori sunt considerate numere întregi și ce operații (metode) pot fi aplicate acestora. ◗ clasa Fraction face parte din modulul fractions și este destinată lucrului cu fracții exacte. Ea este utilă în contexte matematice și în probleme în care vrem să păstrăm forma fracționară exactă a rezultatului.

O fracție precum 2/3 nu este memorată aproximativ, ci prin numărător și numitor. În plus, fracțiile pot fi reduse automat la forma ireductibilă.

2. Obiect Un obiect este o entitate concretă creată pe baza unei clase. Dacă o clasă este modelul, obiectul este realizarea concretă a acelui model.

Dacă Elev este o clasă, atunci un anumit elev, precum „Ana Popescu din clasa a IX-a B având media 9.50”, este un obiect concret al acestei clase. Dacă int este o clasă, atunci valoarea 25 poate fi privită ca un obiect al clasei int. În secvența x = int(25), int este clasa, iar x memorează un obiect al acestei clase, cu valoarea 25.

3. Instanță Termenul instanță este, în acest context, un alt nume pentru obiectul creat dintr-o clasă. Spunem că un obiect este o instanță a clasei sale. De exemplu pentru secvența: from fractions import Fraction f = Fraction(2, 3) Fraction este clasa, iar f este o instanță a clasei Fraction.

În multe situații, termenii obiect și instanță sunt folosiți cu același sens. Totuși, formularea „instanță a unei clase” evidențiază mai clar legătura dintre obiect și modelul după care a fost creat.

70

4. Atribute (date membre) Atributele sunt date care aparțin unui obiect și descriu caracteristicile acestuia.

Pentru un automobil, atributele pot fi culoarea, marca și tipul de combustibil. Pentru un elev, atributele pot fi numele, clasa și media. În cazul clasei Fraction, unele atribute oferă informații utile despre obiect. Dacă avem f = Fraction(8, 12), atunci fracția se reduce automat la 2/3, iar f.numerator este 2, iar f.denominator este 3. În Python, atributele se accesează prin operatorul punct. Așadar, numerator și denominator sunt atribute care oferă informații despre obiectul f.

5. Metode Metodele sunt operațiile pe care un obiect le poate realiza și ele descriu comportamentul obiectului.

Dacă ne întoarcem la exemplele din viața reală, un automobil poate porni, opri sau accelera, iar într-un cont bancar se pot efectua depuneri și retrageri. În Python, metodele se apelează prin operatorul punct și sunt urmate de paranteze. De exemplu, în clasa float există metoda is_integer() care verifică dacă partea fracționară a obiectului curent este egală cu 0: x = float("5.00") print(x.is_integer()) y = float("5.50") print(y.is_integer())

#afișează True #afișează False

REȚINE!

6. Bibliotecă O bibliotecă este o colecție de module gata construite, care pot fi importate și reutilizate în programe.

Python oferă numeroase biblioteci standard. În această lecție folosim, de exemplu, biblioteca fractions, din care importăm clasa Fraction.

Instrucțiunea from fractions import Fraction ne permite să folo­ sim în program clasa Fraction, fără a fi nevoie să o definim noi.

Este important să nu confundăm atributele cu metodele.

Atributul reprezintă o caracteristică a obiectului, în timp ce metoda reprezintă o operație pe care obiectul o poate realiza.

Exemplul 1: Cod sursă

Rezultatul executării

from fractions import Fraction a = Fraction(24, 16) b = Fraction.from_float(0.5) print(f"a = {a}") print(f"b = {b}") print("Numaratorul lui a: ", a.numerator) print("Numitorul lui a: ", a.denominator) print("Fractia a este nr. intreg: ", a.is_integer()) print(f"a + b = {a + b}")

Explicații: Fraction este o clasă predefinită; a și b sunt obiecte, adică instanțe ale acestei clase; ­from_­float() și is_integer() sunt metode; numerator și denominator sunt atribute (date membre).

a = 3/2 b = 1/2 Numaratorul lui a: 3 Numitorul lui a: 2 Fractia a este nr. intreg: a + b = 2

False

REȚINE! O clasă reprezintă un șablon care definește structura (datele) și comportamentul (acțiunile) obiectelor create pe baza ei. Un obiect este o instanță a unei clase. Atributele descriu caracteristicile obiectului, iar metodele descriu operațiile pe care acesta le poate efectua. Accesul la atribute și metode se face cu operatorul punct.

71

Exemplul 2: La o competiție sportivă, un elev a parcurs într-o zi 6/10 dintr-un traseu, iar în ziua următoare a parcurs 4/12 din același traseu. Folosind clasa predefinită Fraction, scrieți un program care să determine ce fracție din traseu a parcurs în total elevul și ce fracție mai trebuie să parcurgă.

from fractions import Fraction

# construim cele doua fractii ziua1 = Fraction(6, 10) ziua2 = Fraction(4, 12) # calculam totalul parcurs total = ziua1 + ziua2 # calculam restul de parcurs rest = 1 - total # afisam rezultatele print("Ziua 1:", ziua1) print("Ziua 2:", ziua2) print("Total parcurs:", total) print("Rest de parcurs:", rest)

P ORTOFOLIU DIGITAL Clasa Decimal Organizare

Creați folderul: Portofoliu digital > Capitolul 3 > Tema 5 - Clasa Decimal.

Cerința 1

Documentați-vă și precizați, pe scurt, utilitatea clasei Decimal din modulul decimal în Python.

Cerința 2

Precizați de ce, în anumite situații, clasa Decimal este mai potrivită decât tipul float.

Cerința 3

Realizați un document în care să includeți cel puțin 4 exemple concrete de contexte în care clasa Decimal poate fi utilizată.

Cerința 4

Exemplele pot fi alese din domenii precum: calcule financiare, facturi, prețuri și reduceri, TVA, curs valutar, dobânzi sau aplicații contabile.

Salvează

decimal_documentare.docx

Document

Realizați un document scurt, clar și bine organizat, în care să explicați rolul clasei Decimal și să prezentați exemple de utilizare practică.

Exersează!

1. Precizați care dintre următoarele sunt clase și care sunt obiecte: int, float, Fraction, int(25), float("7.5"), Fraction(3, 4).

2. Analizați secvența și precizați valorile afișate:

y = float("4.0") z = float("2.5") print(y.is_integer()) print(z.is_integer())

3. Creați un obiect al clasei Fraction corespunzător fracției 12/18 și afișați: fracția în formă ireduc­tibilă, numărătorul și numitorul.

4. Scrieți o secvență de program care construiește un obiect float cu valoarea 6.0 și verifică dacă această valoare este un număr întreg.

5. La o bibliotecă, un elev citește o carte în mai multe zile. În prima zi citește 6/14 din carte, în a doua zi citește 5/30 din carte, iar în a treia zi citește 3/10 din carte. Folosind clasa predefinită Fraction, scrieți un program care să determine ce fracție din carte a citit elevul în total și ce fracție mai are de citit.

72

PROBLEME PROPUSE 1. Într-un centru de arhivare digitală, un cod numeric este considerat stabil dacă este prim cu oglinditul său.

Realizați: ● o funcție oglindit(n) care returnează oglinditul numărului natural n; ● o funcție cmmdc(a, b) care returnează cel mai mare divizor comun al numerelor a și b.

Utilizați aceste funcții într-un program care citește un număr natural nenul n, apoi n numere naturale nenule, reprezentând coduri numerice și afișează câte dintre ele sunt stabile.

2. Fiecare insignă a unui concurs are un cod numeric. O insignă este considerată specială dacă suma dintre prima cifră și ultima cifră a codului este un pătrat perfect.

Realizați: ● o funcție prima_ultima(n) care returnează prima și ultima cifră a lui n; ● o funcție patrat_perfect(x) care returnează True dacă x este pătrat perfect și False în caz contrar.

Utilizați aceste funcții într-un program care citește un număr natural nenul n, apoi n numere naturale nenule, reprezentând coduri numerice și afișează câte insigne sunt speciale.

3. Se consideră un interval de numere naturale [a, b]. Un număr se numește favorabil dacă suma divizorilor săi proprii este pătrat perfect.

Realizați:

● o funcție suma_divizorilor_proprii(n) care returnează suma divizorilor proprii ai lui n; ● o funcție care returnează True dacă numărul este pătrat perfect si False altfel.

Utilizați aceste funcții într-un program care citește a și b, două numere naturale nenule (a<b) și afișează: ● cel mai mic număr favorabil din interval; ● suma divizorilor proprii ai acestuia.

Dacă nu există niciun astfel de număr, se va afișa mesajul "NU EXISTA".

4. Definim amprenta de factorizare a unui număr natural n > 1 prin perechea: ● numărul factorilor primi distincți; ● suma exponenților din descompunerea sa în factori primi.

Realizați o funcție amprenta(n) care returnează aceste două valori.

Utilizați funcția într-un program care citește un număr natural nenul n, apoi n numere naturale mai mari decât 1 și afișează câte dintre ele au cele două componente ale amprentei egale.

5. Se spune că un număr are un bloc compact de lungime k dacă în scrierea sa apare o secvență de k cifre egale aflate pe poziții consecutive. Realizați o funcție bloc_maxim(n) care returnează: ● cifra care formează cel mai lung bloc compact; ● lungimea acelui bloc.

Dacă există mai multe blocuri de lungime maximă, se va returna cifra blocului care apare prima de la stânga la dreapta în scrierea numărului.

Utilizați această funcție într-un program care citește un număr natural nenul n, apoi n numere naturale și afișează câte dintre ele au un bloc compact de lungime cel puțin 3.

6. Un cod numeric se numește armonic dacă produsul cifrelor sale nenule este divizibil cu suma cifrelor sale.

Realizați: ● o funcție suma_cifrelor(n) care returnează suma cifrelor lui n; ● o funcție produs_cifre_nenule(n) care returnează produsul cifrelor nenule ale lui n.

Utilizați aceste funcții într-un program care citește un număr natural nenul n, apoi n coduri numerice naturale nenule și afișează câte coduri sunt armonice, precum și cel mai mare cod armonic citit. Dacă nu există niciun cod armonic, se va afișa mesajul "NU EXISTA".

73

7. Pentru un număr natural n, definim cheia extremelor ca diferența dintre cifra sa maximă și cifra sa minimă.

Realizați:

● o funcție cifre_extreme(n) care returnează cifra minimă și cifra maximă din scrierea lui n; ● o funcție numar_divizori(n) care returnează numărul divizorilor lui n.

Utilizați aceste funcții într-un program care citește un număr natural nenul n, apoi n numere naturale și afișează câte dintre ele au cheia extremelor egală cu numărul lor de divizori.

8. Pentru un număr natural n, definim scorul său prin formula scor(n, p) = (suma cifrelor lui n)**p, unde p este un exponent natural. Dacă exponentul nu este precizat, se consideră implicit p = 2.

Realizați o funcție scor(n, p=2) care calculează acest scor.

Utilizați funcția într-un program care citește un număr natural nenul n, apoi n numere naturale și afișează câte dintre ele au scorul implicit mai mare decât 100 și câte dintre ele au scorul calculat pentru p = 3 multiplu de 5.

9. În scrierea unui număr natural, le numim cifre mari pe cele mai mari sau egale cu 5, respectiv cifre mici, cifrele mai mici decât 5. Realizați o funcție analiza_cifrelor(n) care returnează numărul cifrelor mari din scrierea lui n și numărul cifrelor mici din scrierea lui n. Utilizați această funcție într-un program care citește un număr natural nenul n, apoi n numere naturale și afișează numărul pentru care diferența dintre numărul cifrelor mari și numărul cifrelor mici este maximă. Dacă există mai multe astfel de numere, atunci se va afișa cel mai mic dintre ele.

10. Pentru două numere naturale a și b, definim abaterea lor ca fiind egală cu |a - b|; Realizați:

● o funcție abatere(a, b) care returnează valoarea |a - b|, folosind funcția predefinită abs; ● o funcție patrat_perfect(x) care returnează True dacă x este pătrat perfect și False în caz contrar; ● o funcție medie_rotunjita(a, b) care returnează media aritmetică a numerelor, rotunjită la două zecimale.

Utilizați aceste funcții într-un program care citește un număr natural nenul n, apoi n perechi de numere naturale și afișează câte perechi au simultan următoarele două proprietăți: ● abaterea este pătrat perfect; ● media aritmetică este un număr întreg.

11. Se citesc patru numere naturale a, b, c, d, cu b ≠ 0 și d ≠ 0, reprezentând fracțiile a/b și c/d. Utilizând clasa Fraction: ● creați cele două obiecte corespunzătoare fracțiilor; ● determinați suma lor; ● afișați fracția obținută în formă ireductibilă; ● afișați separat numărătorul și numitorul sumei.

12. Într-un depozit automatizat, fiecare lot este identificat printr-un cod numeric. Uneori, sistemul trebuie să elimine din cod toate aparițiile unei anumite cifre considerate marcaj tehnic. Realizați o funcție curata_cod(n, c) care primește un număr natural n, cu cel mult 9 cifre, și o cifră c, apoi afișează numărul obținut prin eliminarea tuturor aparițiilor cifrei c. Dacă după eliminare numărul obținut nu mai conține nicio cifră sau conține doar cifre egale cu 0, atunci funcția va afișa 0.

13. Două mecanisme industriale au perioade de funcționare două numere naturale nenule a și b (a<b). Pentru analiza compatibilității, se definește scorul lor comun ca fiind suma tuturor divizorilor naturali comuni ai numerelor a și b. Realizați definiția completă a funcției suma(a, b), care primește prin parametri două numere naturale nenule și returnează scorul lor comun.

14. Pentru un număr natural n > 1, numim semnătură primă cel mai mic număr natural care are aceiași divizori primi ca n. Realizați definiția completă a funcției minDivPrim(n), care primește un număr natural n > 1 și returnează semnătura sa primă.

74

FIȘĂ DE EVALUARE FINALĂ DE CAPITOL Indicații: Rezolvați clar și ordonat. Pentru exercițiile care cer program, se acceptă orice variantă corectă în limbajul Python.

S U B I EC T E 1. Selectați afirmația corectă despre funcții: .............................................................................................................. 4p A. O funcție care conține return se execută automat, fără apel.

B. O funcție care returnează o valoare poate fi folosită într-o expresie.

C. O funcție cu parametri nu poate avea valori implicite.

D. O funcție care returnează o valoare nu poate afișa nimic.

2. Selectați clasa cea mai potrivită pentru memorarea unui raport distanță / timp: .............................................. 6p A. int

B. float

C. Decimal

D. Fraction

3. Se consideră următoarea secvență Python: (10p) x = 4 def calc(a, b=3): x = a * b return x - 1, abs(a - b)

Precizați valorile afișate pentru următoarele variabile: a) m

b) n

d) q

e) x

c) p

m, n = calc(5) p, q = calc(5, 2) print(m, n) print(p, q) print(x)

4. Se consideră următorul program în limbajul Python: ............................................................................................ 8p def analiza(): n = int(input("n = ")) s = 0 k = 0

a) Pentru n = 5079364, precizați cele două valori afișate. b) Explicați rolul variabilei k.

while n > 0: c = n % 10 if c % 3 == 0: s += c else: k += 1 n //= 10 return s, k a, b = analiza() print(a) print(b)

75

5. Un elev a scris următorul program Python, cu intenția de a afișa dacă un număr natural nenul conține cel puțin două cifre pare: ........................................................................................................................................................ 10p def cifre_pare(n): cnt = 0 while n > 0: if (n % 10) % 2 == 0: cnt += 1 n //= 10 print(cnt)

a) Explicați de ce programul nu funcționează corect. b) Scrieți o variantă corectă a programului.

x = int(input("x = ")) if cifre_pare(x) >= 2: print("DA") else: print("NU")

6. Se consideră următoarea secvență Python: ........................................................................................................... 8p from fractions import Fraction

a) Precizați valorile afișate.

f = Fraction(18, 24)

b) Explicați de ce fracția afișată de program nu rămâne 18/24.

print(f) print(f.numerator, f.denominator)

7. Scrieți o funcție care primește ca parametru un număr natural și returnează suma cifrelor aflate pe poziții pare, numărate de la dreapta la stânga. Prima cifră de la dreapta se consideră pe poziția 1. Utilizați această funcție într-un program care citește un număr natural și afișează valoarea obținută în urma apelului funcției. .................................................................................................................................................................................... 12p Exemplu: pentru n = 582743, cifrele aflate pe poziții pare sunt 4, 7 și 8, deci se va afișa 19.

8. Scrieți o funcție care primește ca parametru un număr natural n și returnează simultan numărul cifrelor pare și produsul cifrelor impare nenule ale lui n. Utilizați această funcție într-un program care citește două numere naturale a și b și afișează: ● A, dacă pentru a suma celor două valori returnate este mai mare; ● B, dacă pentru b suma celor două valori returnate este mai mare; ● EGAL, dacă cele două sume sunt egale. ........................................................................................................... 12p

9. Într-un centru de verificare, un cod numeric este considerat acceptat dacă: CMMDC dintre cod și suma cifrelor sale este 1 și numărul divizorilor codului este par. Scrieți un program modular care citește n, apoi n coduri naturale nenule și afișează: câte coduri sunt acceptate, precum și cel mai mare cod acceptat. Pentru rezolvare, veți defini funcțiile: suma_cifrelor(n), cmmdc(a, b), numar_divizori(n). Dacă nu există niciun cod acceptat, se va afișa 0 la a doua cerință. ................................................................................................................................ 20p

76

CAPITOLUL IV Modalități de comunicare cu programul.

Fișiere text. Interfețe grafice COMPETENȚE SPECIFICE VIZATE CS 1.4 Identifică principalele elemente ale limbajului de programare utilizate pentru prelucrarea datelor organizate în modele fundamentale – date simple sau liste, respectiv pentru transmiterea datelor de la și către un program, în vederea rezolvării eficiente a problemelor informatice.

CS 2.4 Explică rolul principalelor elemente ale limbajului de programare utilizate pentru prelucrarea datelor organizate în modele fundamentale – date simple sau liste, respectiv pentru transmiterea datelor de la și către un program în vederea rezolvării eficiente a problemelor informatice.

CS 3.4 Utilizează principalele elemente ale limbajului de programare utilizate pentru prelucrarea datelor organizate în modele fundamentale – date simple sau liste, respectiv pentru transmiterea datelor de la și către un program, în vederea rezolvării eficiente a problemelor informatice.

CS 4.4 Analizează aplicabilitatea, avantajele și dezavantajele utilizării unor elemente ale limbajului de programare, pentru a identifica soluția adecvată prelucrării datelor organizate în modele fundamentale – date simple sau liste, respectiv pentru transmiterea datelor de la și către un program, în vederea rezolvării eficiente a problemelor informatice.

CS 5.4 Evaluează corectitudinea și eficiența aplicațiilor care utilizează elemente specifice de limbaj de programare pentru prelucrarea datelor organizate în modele fundamentale – date simple sau liste, respectiv pentru transmiterea datelor de la și către un program, în vederea rezolvării eficiente a problemelor informatice.

CS 6.4 Implementează aplicații care integrează în mod personalizat elemente specifice de limbaj de programare pentru prelucrarea datelor organizate în modele fundamentale – date simple sau liste, respectiv pentru transmiterea datelor de la și către un program, în vederea realizării unor soluții funcționale și performante.

IV.1. Gestionarea comunicării cu utilizatorul.

Principii de lucru cu fișiere text Când scriem un program în Python, acesta nu funcționează izolat, ci interacționează cu lumea din exterior.

Mai exact, un program trebuie să poată primi informații, să le prelucreze și apoi să ofere rezultate. Acest proces se numește comunicare și este esențial în orice aplicație, indiferent cât de simplă sau complexă este.

Există trei modalități principale prin care un program Python comunică cu utilizatorul: prin consolă, prin fișiere și prin interfață grafică. Fiecare dintre acestea are rolul său și utilizarea sa depinde de situația concretă.

1. Comunicarea prin intermediul consolei Cea mai simplă formă de comunicare este cea prin consolă. Aceasta este o interfață bazată pe text, în care utilizatorul introduce date de la tastatură (prin funcția input()), iar programul afișează rezultatele tot sub formă de text (prin funcția print()) și a fost utilizat în lecțiile anterioare. Metoda este importantă în etapa de învățare, deoarece este ușor de înțeles și nu implică elemente grafice complicate. De asemenea, programatorii folosesc frecvent consola pentru a testa rapid idei sau chiar un program.

Totuși, consola are și unele limitări: nu este foarte atractivă pentru utilizatori și nu permite interacțiuni complexe. Din acest motiv, aplicațiile destinate publicului larg folosesc, de obicei, interfețe grafice.

77

2. Comunicarea prin intermediul fișierelor Fișierele reprezintă o altă modalitate prin care programele comunică cu utilizatorul. Astfel, programul nu mai interacționează cu utilizatorul în timp real, ci scrie sau citește informații accesând un fișier stocat pe calculator.

Această metodă este utilă atunci când dorim ca datele să fie păstrate și după terminarea programului.

De exemplu, un program poate salva rezultatele unor calcule, poate memora informații introduse anterior sau poate încărca date existente pentru a le prelucra.

Comunicarea prin fișiere presupune mai multe operații: citirea datelor, scrierea lor sau adăugarea de informații noi la cele existente. Aceste operații trebuie realizate cu atenție, deoarece pot apărea erori, cum ar fi lipsa fișierului.

Avantajul principal al acestei metode este că permite stocarea unor cantități mari de informații și utilizarea lor ulterioară. În schimb, este mai puțin interactivă decât comunicarea prin consolă, deoarece utilizatorul nu vede imediat rezultatul în timpul executării.

3. Comunicarea prin interfață grafică Cea mai evoluată formă de comunicare cu utilizatorul este reprezentată de interfața grafică, cunoscută și sub denumirea de GUI (Graphical User Interface). În acest caz, utilizatorul nu mai interacționează cu programul prin text, ci prin elemente vizuale, precum ferestre, butoane, meniuri sau casete de text. În Python, interfețele grafice pot fi create cu ajutorul unor biblioteci speciale, cum ar fi Tkinter, PyQt sau Kivy.

Acestea oferă instrumente pentru construirea unor aplicații vizuale interactive.

Prin intermediul interfețelor grafice, utilizatorul poate introduce date într-un mod intuitiv și atractiv, de aceea majoritatea aplicațiilor le folosesc ca modalitate de comunicare cu utilizatorul.

REȚINE! ◗ Comunicarea prin consolă este cea mai simplă și este utilizată în special pentru învățare și testare; ◗ Comunicarea prin fișiere permite stocarea datelor și utilizarea lor ulterioară, fiind esențială în aplicații care gestionează informații; ◗ Comunicarea prin interfață grafică oferă cea mai bună experiență utilizatorului, dar este și cea mai complexă de realizat; ◗ În practică, multe programe combină aceste metode pentru a oferi o utilizare flexibilă și eficientă.

4. Utilitatea fișierelor Un fișier ne permite să memorăm date pentru o utilizare ulterioară, să refolosim aceleași date fără a le introduce din nou, să separăm datele de program, să transferăm rezultate dintr-un program în altul și să lucrăm mai ușor cu volume mai mari de date. Un fișier text conține informații organizate pe linii, fiecare linie fiind formată din caractere precum litere, cifre sau simboluri, iar caracterele '\r' și '\n' sunt folosite pentru a marca sfârșitul unei linii.

Să presupunem că dorim să calculăm suma cifrelor unui număr. Dacă programul citește valoarea de la tastatură, la fiecare executare trebuie să o introducem din nou. În schimb, dacă numărul este memorat într-un fișier, programul poate citi automat valoarea, rezultatul poate fi scris într-un alt fișier, iar datele de intrare și de ieșire pot fi păstrate și verificate ulterior. Prin urmare, fișierul devine un mijloc de stocare și transfer al datelor.

5. Principii de bază în lucrul cu fișiere text. Clasa TextIOWrapper În această etapă, este important să înțelegem și să aplicăm operațiile de bază cu fișiere text. a) Deschiderea unui fișier înseamnă asocierea într-un program a unui obiect de tip TextIOWrapper cu un fișier propriu-zis, identificat prin numele său (sau prin calea sa, dacă fișierul se află în alt director). Clasa ­TextIOWrapper este o clasă predefinită care acționează ca o interfață între fișier și program, respectiv preia date binare din fișiere text și le convertește în șiruri de caractere. După deschidere, metodele obiectului de tip ­TextIOWrapper pot fi folosite pentru citirea/scrierea datelor din/în fișierul deschis. Pentru un fișier

78

text, operația de citire presupune preluarea datelor de intrare din el în variabilele programului, iar scrierea presupune stocarea în el a datelor de ieșire ale programului.

Deschiderea unui fișier text se realizează folosind funcția predefinită open(): f = open("nume fisier", "mod deschidere")

unde: ◗ f este obiectul de tip TextIOWrapper prin intermediul căruia vom accesa fișierul text ◗ "nume fisier" este un șir de caractere care conține numele sau calea fișierului text ◗ "mod deschidere" este un șir de caractere care conține litera corespunzătoare operației dorite: o "r" pentru citire (de la cuvântul read). Dacă fișierul nu există, atunci va apărea o eroare. o "w" pentru scriere (de la cuvântul write). Dacă fișierul există, atunci conținutul acestuia va fi șters. o "x" pentru scriere exclusivă (de la exclusive write). Dacă fișierul există, atunci acesta nu va fi șters, ci va

apărea o eroare.

o "a" pentru adăugare la sfârșitul fișierului (de la cuvântul append). Dacă fișierul există, atunci se va scrie

imediat după ultimul său caracter, altfel se va crea un fișier nou. o dacă lipsește parametrul mod deschidere, atunci fișierul va fi deschis implicit pentru citire (în mod "r").

b) Închiderea unui fișier este procesul prin care se eliberează resursele sistemului de operare ocupate de acel fișier și se salvează în fișier ultimele date scrise. Închiderea unui fișier text f se realizează folosind metoda close() din clasa TextIOWrapper, astfel: f.close(). c) Citirea întregului conținut al unui fișier text f se realizează folosind metoda read() din clasa TextIOWrapper: variabilă = f.read()

unde: ◗ f este obiectul de tip TextIOWrapper folosit pentru accesarea unui fișier text deschis pentru citire; ◗ variabilă este un șir de caractere care va stoca tot conținutul fișierului text.

Exemplu: citirea unui număr din fișierul text numar.txt care conține o singură valoare numerică f = open("numar.txt", "r") numar = int(f.read())

# sau numar = float(f.read()) f.close() print(f"Numar: {numar}")

Explicație: ◗ se deschide fișierul pentru citire (mod "r"); ◗ se citește tot conținutul său sub forma unui șir de caractere folosind f.read(); ◗ se transformă șirul citit într-o valoare numerică și se memorează în variabila numar; ◗ se închide fișierul.

d) Citirea unei linii dintr-un fișier text f se realizează folosind metoda readline() din clasa TextIOWrapper: variabilă = f.readline()

unde: ◗ f este obiectul de tip TextIOWrapper folosit pentru accesarea unui fișier text deschis pentru citire ◗ variabilă este un șir de caractere care va stoca conținutul liniei curente din fișierul text, inclusiv caracterul ‘\n’ de la sfârșitul său. Imediat după deschiderea fișierului text, linia curentă este prima linie din fișier, iar după fiecare apelare/utilizare a metodei readline() următoarea linie din fișier devine linie curentă.

Când se ajunge la sfârșitul fișierului text (după citirea ultimei sale linii), metoda readline() va returna un șir de caractere vid.

79

Exemplu: citirea a două numere din fișierul text numere.txt care conține două valori numerice, fiecare pe câte o linie: f = open("numere.txt", "r") numar_1 = int(f.readline()) numar_2 = int(f.readline())

# sau numar_1 = float(f.readline()) # sau numar_2 = float(f.readline()) f.close() print(f"Numar 1: {numar_1}") print(f"Numar 2: {numar_2}")

Explicație: ◗ se deschide fișierul pentru citire mod "r"; ◗ se citește conținutul primei linii sub forma unui șir de caractere folosind f.readline(); ◗ se transformă șirul citit într-o valoare numerică și se memorează în variabila numar_1; ◗ se citește conținutul celei de-a doua linii sub forma unui șir de caractere folosind f.readline(); ◗ se transformă șirul citit într-o valoare numerică și se memorează în variabila numar_2; ◗ se închide fișierul.

e) Scrierea într-un fișier text f se realizează folosind metoda write() din clasa TextIOWrapper: f.write(variabilă)

unde: ◗ f este variabila prin intermediul căreia vom accesa fișierul text deschis pentru scriere; ◗ variabilă este un șir de caractere care conține valorile care trebuie scrise în fișier.

Exemplu: scrierea în fișierul text numar.txt a unei singure valori numerice f = open("numar.txt", "w") f.write(str(numar)) f.close()

REȚINE! În fișier, datele sunt text, deci: ◗ la citire → conversie la int / float ◗ la scriere → conversie la str

Exemplul 1: Realizăm un program care citește de la tastatură un număr natural n , calculează suma cifrelor sale și scrie rezultatul în fișierul text suma_cifre.txt.

OBSERVĂ În acest exemplu, programul nu afișează rezultatul pe ecran, ci îl salvează într-un fișier.

Astfel, fișierul devine locul în care este păstrat rezultatul.

80

Explicație: ◗ se deschide fișierul pentru scriere (mod "w"); ◗ numărul este transformat în șir de caractere folosind funcția str(); ◗ se scrie șirul de caractere în fișier folosind metoda write(); ◗ se închide fișierul. # citim un număr de la tastatură

n = int(input("n = "))

# păstrăm valoarea inițială, deoarece n se va modifica în calcul x = n s = 0 # calculăm suma cifrelor while x != 0: s = s + x % 10 x = x // 10 # deschidem fișierul pentru scriere f = open("suma_cifre.txt", "w") # scriem în fișier numărul și suma cifrelor sale, după ce au fost transformate în # șiruri de caractere și am adăugat "\n" pentru trecerea la rând nou f.write("Numarul este: " + str(n) + "\n") f.write("Suma cifrelor este: " + str(s)) # închidem fișierul f.close()

Exemplul 2: Să presupunem că într-un fișier numit numar.txt avem scris un singur număr natural. Dorim să citim acest număr din fișier și să afișăm pe ecran oglinditul său. De exemplu, dacă fișierul text conține numărul 27435, atunci pe ecran vom afișa 53472.

OBSERVĂ În acest exemplu, datele sunt transferate din fișier în variabila n, după care algoritmul se desfășoară exact ca în exemplele studiate anterior cu citire de la tastatură.

Program Python # deschidem fișierul pentru citire f = open("numar.txt", "r") # citim numărul din fișier n = int(f.read()) # închidem fișierul de intrare f.close() # calculăm oglinditul ogl = 0 x = n while x != 0: ogl = ogl * 10 + x % 10 x = x // 10 # afișăm rezultatul pe ecran print("Oglinditul este", ogl)

REȚINE! Se recomandă închiderea unui fișier imediat după terminarea operațiilor de citire sau scriere, pentru a asigura salvarea corectă a datelor și eliberarea resurselor utilizate.

Exemplul 3: Fișierul text numere.txt conține pe primele două linii două numere întregi, fiecare pe câte o linie. Să se adauge suma celor două numere pe a treia linie din fișier.

OBSERVĂ Fișierul text numere.txt este deschis prima dată pentru citire, iar apoi pentru scriere în mod adăugare la sfârșit!

# deschidem fișierul text pentru citire f = open("numere.txt", "r") # citim cele două numere întregi a = int(f.readline()) b = int(f.readline()) # închidem fișierul f.close() # redeschidem fișierul text pentru adăugare # la sfârșitul său f = open("numere.txt", "a") # scriem suma celor două numere întregi a și b pe o linie nouă f.write(f"\n{a+b}") # închidem fișierul f.close()

6. Tratarea excepțiilor Tratarea excepțiilor în limbajul Python este mecanismul prin care un program poate gestiona erorile apărute în timpul executării sale, fără să se oprească brusc. O excepție apare când, în timpul rulării unui program, intervine o situație neașteptată, care perturbă fluxul său normal de executare: împărțire la zero, accesarea unui fișier inexistent sau apelarea unei funcții folosind parametri efectivi incorecți. În Python, tratarea excepțiilor se face cu ajutorul instrucțiunilor try, except, else și finally. Blocul try conține codul care ar putea produce o eroare, iar blocul except conține codul unde putem gestiona eroarea apărută. Blocul else conține un cod care se va executa doar dacă în blocul try nu va apărea nicio eroare, iar codul din blocul finally se va executa întotdeauna, indiferent dacă în blocul try a apărut o eroare sau nu.

81

Exemplu: try:

x = int(input("Introduceti un numar: ")) r = 1 / x print(f"Inversul numărului {x} este {r}") except: print("A aparut o eroare!")

În acest exemplu, programul nu se oprește dacă utilizatorul introduce o valoare greșită pentru x (fie o valoare care nu este un număr întreg în baza 10, cum ar fi 1a23 sau 123?, fie numărul 0), ci afișează mesajul "A aparut o eroare!". Acest mesaj va fi afișat indiferent de natura erorii, respectiv dacă a fost introdusă o valoare care nu reprezintă un număr întreg (eroarea va fi generată de apelul funcției int()), fie dacă introducem numărul 0 (eroarea va fi generată de împărțirea la 0 din instrucțiunea r = 1 / x). Dacă dorim să afișam mesaje mai detaliate, diferite în raport de sursa erorii apărute, putem adăuga mai multe instrucțiuni except și în fiecare dintre ele să precizăm explicit eroarea tratată: try:

x = int(input("Introduceți un număr: ")) r = 1 / x print(f"Inversul numărului {x} este {r}") except ValueError: print("Valoarea introdusă nu este un număr întreg!") except ZeroDivisionError: print("Nu se poate împărți un număr la 0!")

În exemplul de mai sus, observăm faptul că limbajul Python oferă excepții predefinite, cu nume sugestive precum ValueError, ZeroDivisionError sau FileNotFoundError, care semnalează diverse tipuri de erori care pot să apară în timpul executării unui program.

Blocul finally este utilizat dacă dorim ca o anumită acțiune să fie efectuată întotdeauna, indiferent dacă apare o eroare în blocul try sau nu. De exemplu, un fișier text de intrare trebuie închis și după citirea corectă a tuturor valorilor din el și după apariția unei erori la citirea unei valori (presupunem că fișierul numere.txt ar trebui să conțină un număr întreg): f = None # presupunem că fișierul nu există try: f = open("numar.txt") a = int(f.readline()) print(f"{a} ^ 2 = {a * a}") except FileNotFoundError: print("Fișier inexistent!") except ValueError: print("Format incorect al fișierului!") finally: if f is not None: # dacă fișierul a fost deschis, f.close() # atunci îl închidem

Tratarea excepțiilor este importantă deoarece face programele mai sigure și mai ușor de utilizat. În loc ca aplicația să se închidă brusc dacă apar erori, programatorul le poate controla și oferi mesaje clare utilizatorului.

REȚINE! ◗ Fișierele sunt utile pentru memorarea și transferul datelor; ◗ Pentru a lucra cu un fișier, trebuie să îl deschidem; ◗ După deschidere, putem citi/ scrie date din/în fișier; ◗ Datele citite din fișier trebuie adesea convertite la valori numerice; ◗ La final, fișierul trebuie închis; ◗ Algoritmii deja învățați pot fi adaptați ușor pentru lucrul cu fișiere.

7. Greșeli frecvente În lucrul cu fișiere apar frecvent următoarele erori: se omite deschiderea fișierului înainte de citire sau scriere, se omite închiderea fișierului după terminarea prelucrării, se confundă fișierul de intrare cu cel de ieșire sau se deschide un fișier pentru scriere când se dorește citirea sa.

82

P ORTOFOLIU DIGITAL Carnetul de note – raport numeric Organizare

Creează folderul: Portofoliu digital > Capitolul 4 > Carnetul de note > Tema 6 - Raport numeric din fisier.

Cerința 1

Pornește de la aplicația modulară carnet_note_v2.py, realizată la Tema 4, și creează o versiune nouă a aplicației de consolă: carnet_note_v3.py.

Cerința 2

Adaugă în meniu o opțiune nouă: raport note din fisier. Pentru această opțiune, programul va citi datele din fișierul raport_note.in.

Cerința 3

Fișierul raport_note.in va conține pe prima linie numărul natural n, pe următoarele n linii notele elevului, iar pe ultima linie media dorită. Valorile vor fi așezate una sub alta și vor fi citite succesiv cu readline().

Cerința 4

Programul va calcula, prin citire secvențială: media notelor, nota maximă, nota minimă, numărul notelor de promovare, numărul notelor sub 5 și mesajul "in grafic" sau "mai trebuie sa inveti", în funcție de media dorită.

Cerința 5 Cerința 6

Cerința 7 Salvează

Document

Rezultatele vor fi scrise în fișierul raport_note.out, pe linii separate: media rotunjită la două zecimale, nota maximă, nota minimă, numărul notelor de promovare, numărul notelor sub 5 și mesajul final.

Programul va utiliza funcții separate pentru: citirea și prelucrarea notelor din fișier, stabilirea mesajului final și scrierea raportului în fișier.

Adaugă tratarea unor erori simple cu try...except, de exemplu pentru situația în care fișierul de intrare nu există sau conține valori care nu pot fi transformate în numere. carnet_note_v3.py raport_note.in raport_note.out Realizează un document scurt în care explici structura fișierului raport_note.in, ce operații cu fișiere ai folosit și de ce datele citite din fișier trebuie convertite la int sau float. Adaugă un exemplu complet de fișier de intrare și fișier de ieșire. Nume recomandat: tema6_prezentare.docx.

Exersează!

1. Precizați care dintre următoarele instrucțiuni deschid fișierul text numere.txt pentru scriere: A. f = open("numere.txt") C. f = open("numere.txt", "w")

B. f = open("numere.txt", "r") D. f = open("numere.txt", "a")

2. Fișierul text numere.txt conține pe prima linie numărul 50. Precizați conținutul fișierului după executarea următorului program: A. 100 B. 50 100 f = open("numere.txt", "a") C. 50100 D. 50 x = 100 100 f.write(str(x)) f.close() 3. Scrieți un program care citește de la tastatură un număr natural n, calculează numărul de cifre ale lui n și scrie rezultatul într-un fișier numit cifre.txt.

4. În fișierul intrare.txt este scris un număr natural. Realizați un program care citește numărul și afișează suma cifrelor sale.

5. În fișierul cod.txt este scris un număr natural. Realizați un program care construiește numărul format doar din cifrele strict mai mari decât 4 și îl scrie într-un fișier rezultat.txt.

83

IV.2. Aplicații practice cu fișiere text În lecția anterioară am învățat despre rolul fișierelor și cum putem citi sau scrie valori numerice în fișiere text. Am observat că datele pot fi transferate din fișier în program și din program în fișier, iar algoritmii studiați anterior pot fi adaptați cu ușurință pentru această formă de lucru.

ȘTIAI CĂ...

Leonardo Fibonacci a fost un matematician italian din secolul al XIII-lea, renumit pentru introducerea în Europa a sistemului de numerație indo-arab și pentru șirul care îi poartă numele. Șirul lui Fibonacci este o succesiune de numere în care fiecare termen se obține prin adunarea celor două anterioare: 0, 1, 1, 2, 3, 5, 8, 13… și a fost prezentat în lucrarea sa Liber Abaci din anul 1202. Șirul lui Fibonacci are numeroase aplicații în matematică, natură, artă și arhitectură. El apare în structura florilor, a cochiliilor, a conurilor de pin sau în modul de creștere al plantelor. În arhitectură și design este asociat cu proporțiile armonioase și cu raportul de aur, folosit pentru crearea unor compoziții echilibrate estetic. De asemenea, șirul este utilizat în informatică, economie și analiză financiară pentru modelarea unor procese.

Exemplul 1: Șirul lui Fibonacci este definit astfel: primii 2 termeni sunt 0 și 1, iar orice alt termen este suma celor 2 termeni precedenți. De exemplu, primii 10 termeni sunt 0, 1, 1, 2, 3, 5, 8, 13, 21 și 34. Vom scrie un program care citește de la tastatură un număr natural n ≥ 2 și scrie într-un fișier text cu numele fibonacci_n.txt primii n termeni ai șirului, câte unul pe linie.

Explicații: Pentru a calcula primii n termeni ai șirului lui Fibonacci vom folosi 3 variabile a, b și c de tip întreg, astfel: ◗ ◗ ◗ ◗

variabila a va reține penultimul termen calculat și va fi inițializată cu 0; variabila b va reține ultimul termen calculat și va fi inițializată cu 1; la fiecare pas, vom calcula un nou termen c = a + b și îl vom scrie în fișier; vom actualiza valoarea variabilei a cu valoarea variabilei b, iar pe cea a variabilei b cu cea a variabilei c.

Program Python

Fișierul text fibonacci_7.txt

n = int(input("n = ")) f = open(f"fibonacci_{n}.txt", "w") a = 0 b = 1 f.write("Termen 1: 0\n") f.write("Termen 2: 1\n") for k in range(3, n+1): c = a + b f.write(f"Termen {k}: {c}\n") a = b b = c f.close()

Termen 1: 0 Termen 2: 1 Termen 3: 1 Termen 4: 2 Termen 5: 3 Termen 6: 5 Termen 7: 8

Exemplul 2: Un tâmplar are o placă dreptunghiulară de lemn cu lungimea de x cm și lățimea de y cm pe care vrea să o taie în bucăți pătrate identice pentru a confecționa suporturi decorative, având latura maximă, astfel încât să nu rămână lemn nefolosit. Vom scrie un program care determină latura maximă pe care o poate avea un suport și câte astfel de suporturi poate confecționa tâmplarul. Dimensiunile plăcii dreptunghiulare

84

(lungimea și lățimea) se vor citi de pe primele două linii ale fișierului text placa.txt, iar latura unui suport și numărul de suporturi pe care le poate confecționa tâmplarul se vor scrie pe următoarele două linii din fișier, așa cum se poate observa din următorul exemplu: Fișierul placa.txt inițial

Fișierul placa.txt după rularea programului

231 56

231 56 Latura maxima a unui suport: 7 Numarul de suporturi: 264

Explicații: Deoarece tâmplarul nu vrea să rămână cu lemn nefolosit, înseamnă că latura suportului pătrat, pe care o vom nota în program cu latura_suport, trebuie să fie un divizor comun al dimensiunilor x și y ale plăcii dreptunghiulare de lemn, iar din faptul că el dorește ca latura suportului să fie maximă rezultă că latura suportului trebuie să fie cel mai mare divizor comun al dimensiunilor x și y. În acest caz, numărul suporturilor pe care le poate confecționa tâmplarul, notat cu nr_suporturi în program, este egal cu (x // latura_suport) * (y // latura_suport). Pentru datele de intrare din exemplul de mai sus, latura maximă a unui suport este egală cu cmmdc(231, 56) = 7, iar numărul suporturilor pe care le poate confecționa tâmplarul este (231 // 7) * (56 // 7) = 33 * 8 = 264. # funcție care calculează cmmdc-ul a două numere naturale nenule

def cmmdc(a, b): while b != 0: r = a % b a = b b = r return a

# deschidem fișierul placa.txt pentru citire f = open("placa.txt", "r")

OBSERVĂ Pentru a calcula cmmdc-ul dimensiunilor plăcii dreptunghiulare am definit și utilizat funcția cmmdc(), deci valorile inițiale ale variabilelor x și y nu vor fi alterate.

# citim din fișier dimensiunile x și y ale plăcii dreptunghiulare x = int(f.readline()) y = int(f.readline()) # închidem fișierul f.close() # calculăm latura maximă a unui suport și numărul suporturilor care pot fi confecționate latura_suport = cmmdc(x, y) nr_suporturi = (x // latura_suport) * (y // latura_suport) # redeschidem fișierul pentru scriere la sfârșitul său (modul "a" - append) f = open("placa.txt", "a") # scriem la sfârșitul fișierului valorile calculate anterior, # fiecare pe câte o linie separată f.write(f"\nLatura maxima a unui suport: {latura_suport}\n") f.write(f"Numarul de suporturi: {nr_suporturi}\n") # închidem fișierul f.close()

Citirea mai multor numere dintr-un fișier În multe situații, un fișier de intrare conține mai multe valori numerice, câte una pe linie (de exemplu, mediile unui elev, temperaturile înregistrate zilnic într-un interval de timp sau totalul încasărilor unui magazin în fiecare zi dintr-o lună). În continuare, vom studia cum putem citi și prelucra numerele din fișier unul câte unul.

85

Exemplul 3: Fișierul text medii_elevi.txt conține pe prima linie un nenul sau >=1 reprezentând numărul elevilor dintr-o clasă, iar pe fiecare dintre următoarele n linii câte un număr real strict pozitiv reprezentând media generală a unui elev din clasa respectivă. Vom scrie un program care, pe baza informațiilor din fișier, afișează media minimă, media maximă și media clasei. # deschidem fișierul text pentru citire f = open("medii_elevi.txt") # citim numărul n de elevi din clasă de pe prima linie a fișierului de intrare n = int(f.readline()) # inițializăm media minimă și cea maximă cu media primului elev media_minima = media_maxima = float(f.readline()) # inițializăm suma cu media primului elev suma_medii = media_minima # parcurgem fișierul de intrare linie cu linie for i in range(2, n + 1): # citim media unui elev medie = float(f.readline())

OBSERVĂ Afișarea unui număr real x cu n zecimale se realizează prin print(f"{x:.nf}"), valoarea

afișată fiind rotunjită automat. De exemplu, instrucțiunea ­ rint(f"{2.7182:.2f}") va afișa p valoarea 2.72, iar instrucțiunea print(f"{2.7182:.3f}") va afișa 2.718.

# dacă este necesar, actualizăm valoarea mediei minime

if medie < media_minima: media_minima = medie

# dacă este necesar, actualizăm valoarea mediei maxime

if medie > media_maxima: media_maxima = medie

# actualizăm suma mediilor

suma_medii += medie

# închidem fișierul de intrare f.close() # calculăm media clasei media_clasei = suma_medii / n # afișăm pe ecran informațiile cerute, cu două zecimale print(f"Media minimă: {media_minima:.2f}") print(f"Media maximă: {media_maxima:.2f}") print(f"Media clasei: {media_clasei:.2f}")

REȚINE! ◗ În rezolvarea de mai sus am impus ca primul număr din fișierul de intrare să reprezinte numărul valorilor scrise pe restul liniilor din fișier. În unele cazuri, acest lucru poate îngreuna crearea fișierului de intrare.

De exemplu, dacă un fișier conține, pe fiecare linie, încasările dintr-o anumită zi ale unui magazin, atunci el trebuie actualizat zilnic cu vânzările efectuate în ziua precedentă, ceea ce necesită atât actualizarea numărului de pe prima linie (care reprezintă numărul total de zile pentru care se ține evidența vânzărilor), cât și adăugarea valorii vânzărilor din ziua precedentă la sfârșitul fișierului, pe o linie nouă. În limbajul Python, conținutul unui fișier text este direct iterabil, deci poate fi parcurs linie cu linie folosind o instrucțiune for, fără să cunoaștem de la început numărul de linii. În exemplul următor, calculăm suma numerelor din fișierul text numere.txt, în care fiecare linie conține un singur număr întreg: f = open("numere.txt") suma = 0 for linie in f: suma += int(linie) print(f"Suma numerelor din fișier: {suma}") f.close()

86

Exemplul 4: Fișierul text curs_valutar.txt conține pe prima linie un număr natural n ≥ 2, iar pe fiecare dintre următoarele n linii câte un număr real, reprezentând cursul valutar Euro/RON dintr-o zi a unei luni. Valorile sunt date în ordine cronologică: prima valoare reprezintă cursul din prima zi, a doua valoare cursul din a doua zi etc. Vom scrie un program care determină și afișează pe ecran două zile consecutive între care s-a înregistrat cea mai mare creștere a cursului valutar. Dacă nu s-a înregistrat nicio creștere, se va afișa un mesaj corespunzător: Fișierul curs_valutar.txt 7 4.97 4.95 4.98 4.90 5.04 5.10 5.11

Rezultatul afișat pe ecran Creșterea maximă a fost de 0.14 RON între zilele 4 și 5!

Pentru a determina două zile consecutive în care creșterea cursului valutar a fost maximă vom păstra valoarea cursului valutar din ziua precedentă (variabila curs_zi_anterioara, inițializată cu valoarea cursului valutar din prima zi) și vom citi cursul valutar din ziua curentă (variabila curs_zi_curenta). După ce eventual actualizăm creșterea maximă a cursului valutar înregistrată până în ziua curentă (variabila crestere_maxima) și ziua în care aceasta a avut loc (variabila zi_crestere_maxima), actualizăm valoarea variabilei curs_zi_anterioara cu cea a variabilei curs_zi_curenta. La sfârșit, după ce terminăm de parcurs fișierul de intrare și îl închidem, verificăm dacă a avut loc o creștere a cursului valutar în zilele respective sau nu (verificăm dacă valoarea variabilei crestere_maxima este 0 sau nu), după care fie afișăm creșterea maximă a cursului valutar și două zile între care ea a avut loc (pot exista mai multe!), fie afișăm mesajul „Nu a existat nicio creștere a cursului valutar!”. f = open("curs_valutar.txt") n = int(f.readline()) curs_zi_anterioara = float(f.readline()) crestere_maxima = 0 zi_crestere_maxima = 0 for zi_curenta in range(2, n+1): curs_zi_curenta = float(f.readline()) if curs_zi_curenta - curs_zi_anterioara > crestere_maxima: crestere_maxima = curs_zi_curenta - curs_zi_anterioara zi_crestere_maxima = zi_curenta curs_zi_anterioara = curs_zi_curenta f.close()

OBSERVĂ Metoda de rezolvare folosită este asemănătoare unei „ferestre glisante” (sliding window), deoarece comparația se realizează permanent între două valori aflate pe linii consecutive din fișierul de intrare, iar „fereastra” de analiză „glisează” odată cu parcurgerea fișierului.

if crestere_maxima == 0: print("Nu a existat nicio creștere a cursului valutar!") else: crestere_maxima = round(crestere_maxima, 2) print(f"Creșterea maximă a fost de {crestere_maxima} RON " f"între zilele {zi_crestere_maxima-1} și {zi_crestere_maxima}!")

Exemplul 5: Fișierul text temperaturi.txt conține, pe fiecare linie, câte un număr real reprezentând temperatura înregistrată în București în fiecare zi a unei luni. Prima valoare corespunde primei zile a lunii, a doua valoare celei de-a doua zile etc. Vom scrie un program care afișează pe ecran numărul maxim de zile consecutive în care temperatura a crescut de la o zi la alta:

87

Fișierul temperaturi.txt 19.5 18.0 17.4 19.2 20.1 22.2 19.8

Rezultatul afișat pe ecran Numărul maxim de zile consecutive în care temperatura a crescut este 4!

Pentru a determina numărul maxim de zile consecutive în care temperatura a crescut de la o zi la alta vom păstra temperatura din ziua precedentă (variabila temperatura_zi_anterioara, inițializată cu temperatura din prima zi) și vom citi temperatura din ziua curentă (variabila temperatura_zi_curenta). Vom folosi variabila nr_crt_zile_consecutive pentru numărul curent de zile consecutive cu temperatură în creștere și variabila nr_max_zile_consecutive pentru numărul maxim, ambele inițializate cu 1.

Dacă temperatura din ziua curentă este strict mai mare decât temperatura din ziua anterioară, atunci incrementăm numărul curent de zile consecutive în care temperatura a crescut și o comparăm cu numărul maxim de zile consecutive în care temperatura a crescut și, dacă este necesar, actualizăm valoarea variabilei nr_max_zile_consecutive. În caz contrar, dacă temperatura din ziua curentă este mai mică sau egală decât temperatura anterioară, resetăm valoarea variabilei nr_crt_zile_consecutive la 1. Indiferent de caz, actualizăm valoarea variabilei temperatura_zi_anterioara cu cea a variabilei temperatura_zi_curenta. La sfârșit, după ce terminăm de parcurs fișierul de intrare și îl închidem, verificăm dacă a avut loc o creștere a temperaturii în zilele respective sau nu (verificăm dacă nr_max_zile_consecutive este 1 sau nu), după care fie afișăm numărul maxim de zile consecutive în care temperatura a crescut, fie afișăm un mesaj corespunzător. f = open("temperaturi.txt") temperatura_zi_anterioara = float(f.readline()) nr_max_zile_consecutive = nr_crt_zile_consecutive = 1 for linie in f: temperatura_zi_curenta = float(linie) if temperatura_zi_curenta > temperatura_zi_anterioara: nr_crt_zile_consecutive += 1 if nr_crt_zile_consecutive > nr_max_zile_consecutive: nr_max_zile_consecutive = nr_crt_zile_consecutive else: nr_crt_zile_consecutive = 1 temperatura_zi_anterioara = temperatura_zi_curenta

DESCOPERĂ Fișierele CSV permit organizarea datelor în rânduri și coloane. Investighează modulul csv din Python și observă cum pot fi folosite metodele csv.reader() pentru citirea datelor și csv.writer() pentru scrierea acestora într-un format tabelar.

f.close() if nr_max_zile_consecutive == 1: print("Nu a existat nicio perioadă de creștere a temperaturii!") else: print(f"Numărul maxim de zile consecutive în care " f"temperatura a crescut este {nr_max_zile_consecutive}!")

P ORTOFOLIU DIGITAL Carnetul de note – salvarea progresului Organizare

Creează folderul: Portofoliu digital > Capitolul 4 > Carnetul de note > Tema 7 - Salvarea progresului cu append.

Cerința 1

Pornește de la aplicația carnet_note_v3.py realizată la Tema 6 și creează o versiune nouă: carnet_note_v4.py.

88

Cerința 2

Adaugă în meniu o opțiune nouă: salvare progres în fisier. Pentru această opțiune, utilizatorul va introduce de la tastatură numărul de note, notele elevului și media dorită.

Cerința 3

Programul va calcula media, nota maximă, nota minimă, numărul notelor de promovare, numărul notelor sub 5. Prelucrarea se face secvențial, pe măsură ce valorile sunt citite.

Cerința 4

La final, programul va deschide fișierul progres_note.txt în modul adăugare ("a") și va adăuga o notă nouă la sfârșitul fișierului, fără să șteargă înregistrările existente.

Cerința 5 Cerința 6

Cerința 7 Cerința 8 Salvează Document

Fiecare linie din progres_note.txt va conține: media calculată, media dorită, nota maximă, nota minimă, numărul notelor de promovare, numărul notelor sub 5.

Adaugă în meniu o opțiune nouă: afisare progres salvat. Aceasta va citi și afișa pe ecran conținutul fișierului progres_note.txt, folosind read() sau parcurgerea fișierului linie cu linie.

Meniul final va continua meniul aplicației anterioare și va include cel puțin: raport note din fisier, salvare progres in fisier, afisare progres salvat, iesire.

Organizează codul în funcții. Poți folosi funcții pentru calculul raportului, scrierea progresului, citirea progresului salvat. carnet_note_v4.py, progres_note.txt Realizează un document scurt în care explici diferența dintre deschiderea unui fișier în mod scriere ("w") și în mod adăugare ("a"). Include două exemple de înregistrări care pot apărea în progres_ note.txt și explică de ce modul adăugare ("a") este potrivit pentru salvarea progresului.

Exersează!

1. Într-un oraș, 3 autobuze circulă pe linii diferite, dar dimineața pornesc toate 3 simultan din același capăt de linie.

Fiecare autobuz, după ce ajunge la celălalt capăt al liniei sale, se întoarce la capătul de linie comun și își reia traseul. Realizați un program care citește din fișierul text autobuze.txt duratele curselor complete (dus-întors) ale celor 3 autobuze (pe fiecare linie este scrisă durata unei curse în minute) și scrie pe a patra linie din fișierul autobuze.txt numărul de minute după care cele 3 autobuze se vor afla din nou, simultan, la capătul comun de linie. De exemplu, dacă citim din fișier valorile 60, 45 și 75, atunci pe a patra linie trebuie să scriem 900.

2. Fișierul text medii_elevi.txt conține pe prima linie un număr natural n ≥ 3 reprezentând numărul elevilor ­dintr-o clasă, iar pe fiecare dintre următoarele n linii câte un număr real strict pozitiv reprezentând media generală a unui elev din clasa respectivă. Realizați un program care afișează pe ecran media maximă din clasa respectivă, precum și numărul elevilor care au media maximă.

3. Un fișier text conține, pe fiecare linie, câte un număr real reprezentând încasările unui magazin într-o zi d ­ intr-o anumită lună. Pe prima linie din fișier se află încasările din prima zi a lunii, pe a doua linie cele din a doua zi ș.a.m.d. Realizați un program care citește de la tastatură numele fișierului text și un număr natural p, apoi afișează pe ecran prima zi din luna respectivă în care încasările cumulate ale magazinului depășesc pragul p.

Dacă nu există o astfel de zi în luna respectivă, programul va afișa un mesaj corespunzător. De exemplu, dacă numele fișierului de intrare citit de la tastatură este incasari.txt și conține valorile 15234.78, 48765.91, 30124.50, 2234.67 și 39876.03 (fiecare pe câte o linie), iar pragul p citit este 70000, atunci se va afișa mesajul "Pragul a fost depășit în ziua 3!" Încasări cumulate: 94125.19 RON. 4. Fișierul text curs_valutar.txt conține pe prima linie un număr natural n ≥ 2, iar pe fiecare dintre următoarele n linii câte un număr real, reprezentând cursul valutar RON/euro dintr-o zi a unei luni. Valorile sunt date în ordine cronologică: prima valoare reprezintă cursul din prima zi, a doua valoare cursul din a doua zi etc.

Realizați un program care scrie în fișierul curs_valutar.txt, pe o linie nouă, cea mai mare variație a cursului valutar dintre două zile consecutive, indiferent dacă aceasta reprezintă o creștere sau o scădere.

89

IV.3. Realizarea interfețelor grafice utilizând biblioteca Tkinter În programele scrise până acum, datele au fost citite de la tastatură, iar rezultatele au fost afișate în consolă. În multe aplicații reale, utilizatorul nu comunică însă cu programul printr-o fereastră de tip text, ci prin butoane, etichete, meniuri și alte componente vizuale, respectiv printr-o interfață grafică. Tkinter este biblioteca standard din Python pentru realizarea unor astfel de interfețe și permite trecerea de la programe în consolă la aplicații cu elemente vizuale ușor de utilizat și de testat.

Tkinter este biblioteca standard a limbajului Python pentru dezvoltarea de aplicații cu interfață grafică.

Ea oferă clase și metode prin care putem crea ferestre, etichete, butoane și alte componente. În această lecție ne concentrăm asupra elementelor esențiale: fereastra principală, etichetele, butoanele și afișarea unor mesaje. În mod obișnuit, Tkinter se importă astfel: import tkinter as tk. Astfel, "tk" devine o prescurtare pentru biblioteca tkinter, iar componentele ei se vor apela mai simplu, de exemplu tk.Tk(), tk.Label() sau tk.Button().

1. Fereastra principală – clasa Tk Orice aplicație Tkinter începe prin crearea unei ferestre principale folosind clasa Tk. Obiectul creat va reprezenta spațiul vizual în care adăugăm toate celelalte componente grafice ale aplicației.

Exemplu: Vom crea o fereastră de dimensiune 320 x 180 pixeli, având titlul „Prima aplicație”, folosind metode ale clasei Tk, astfel: ◗ fereastra = tk.Tk(): această instrucțiune creează fereastra principală a aplicației. Fără ea, nu avem suportul în care să adăugăm etichete, butoane sau alte widget-uri. Variabila fereastra, de tip Tk, reține obiectul care reprezintă aplicația grafică; ◗ fereastra.title("Prima aplicație"): metoda title() stabilește titlul ferestrei, adică textul afișat în bara de sus a acesteia. Ea nu schimbă conținutul din interiorul ferestrei, ci doar numele sub care fereastra este prezentată utilizatorului; ◗ fereastra.geometry("320x180"): metoda geometry() stabilește dimensiunea inițială a ferestrei în pixeli. Ulterior, fereastra poate fi redimensionată fie de utilizatorul (folosind mouse-ul) sau prin program. În exemplul nostru, fereastra va avea o lățime de 320 pixeli și o înălțime de 180 pixeli. Dimensiunea dorită pentru fereastră este transmisă metodei printr-un șir de caractere de forma "lățime x înălțime" în pixeli; ◗ fereastra.mainloop(): aceasta este una dintre cele mai importante instrucțiuni dintr-un program, deoarece pornește bucla de evenimente a interfeței grafice și menține aplicația activă astfel încât utilizatorul să poată interacționa cu ea. Dacă instrucțiunea lipsește, programul se termină imediat după crearea ferestrei. import tkinter as tk

# creează fereastra principală fereastra = tk.Tk() fereastra.title("Prima aplicație") # stabilește textul din bara de titlu fereastra.geometry("320x180") # stabilește dimensiunea inițială fereastra.mainloop() # menține fereastra deschisă

OBSERVAȚII ◗ Fereastra principală reprezintă containerul părinte pentru toate componentele grafice adăugate ulterior. În Tkinter, la crearea unui widget, primul argument specifică de obicei fereastra (sau cadrul, adică un obiect de tip Frame) în interiorul căreia acesta va fi afișat. ◗ Metoda resizable() a clasei Tk controlează posibilitatea redimensionării ferestrei de către utilizator pe orizontală sau verticală. Metoda are 2 parametri de tip boolean: primul controlează redimensionarea pe lățime, iar al doilea pe înălțime. De exemplu, prin apelul fereastra.resizable(False, True) stabilim că utilizatorul nu poate modifica lățimea ferestrei, dar poate modifica înălțimea acesteia.

90

2. Etichetele – clasa Label Un widget este o componentă vizuală din interfața grafică. În Tkinter, etichetele și butoanele sunt printre cele mai folosite widget-uri de bază. Clasa Label este utilizată pentru a afișa un text sau, în unele situații, o imagine.

O etichetă are rol informativ: transmite un mesaj, explică rolul unei alte componente sau afișează un rezultat.

Exemplu: Vom crea o fereastră de dimensiune 320 x 180 pixeli, având titlul "Exemplu cu etichetă", care va conține o etichetă cu textul „Bun venit în aplicație!” folosind metode ale clasei Tk, astfel: ◗ eticheta = tk.Label(fereastra, text="Bun venit în aplicație!"): prin această instrucțiune se creează o etichetă. Argumentul fereastra indică containerul părinte al etichetei, iar parametrul text stabilește mesajul afișat. Eticheta este creată, dar încă nu este vizibilă. ◗ eticheta.pack(pady=20): metoda pack() afișează eticheta în fereastră și o poziționează automat. În mod implicit, widget-ul este centrat pe orizontală, iar această poziționare se păstrează și atunci când fereastra este redimensionată. Parametrul pady=20 adaugă spațiu liber pe verticală în jurul etichetei, respectiv 20 de pixeli deasupra sa și 20 de pixeli dedesubt. import tkinter as tk fereastra = tk.Tk() fereastra.geometry("320x180") fereastra.title("Exemplu cu etichetă") eticheta = tk.Label(fereastra, text="Bun venit în aplicație!") eticheta.pack(pady=20) fereastra.mainloop()

OBSERVAȚIE Prin parametrul padx al metodei pack() se poate adăuga spațiu pe orizontală, la stânga și la dreapta widgetului, iar prin parametrul pady se poate adăuga spațiu pe verticală, deasupra și dedesubtul său. De exemplu, prin instrucțiunea eticheta.pack(padx=15, pady=10), eticheta va fi încadrată de câte 15 pixeli la stânga și la dreapta, respectiv 10 pixeli sus și jos.

3. Butoanele – clasa Button Clasa Button creează un buton. Acesta devine util atunci când dorim ca utilizatorul să declanșeze o acțiune: schimbarea unui text, afișarea unui mesaj, efectuarea unui calcul sau pornirea unei alte operații.

Exemplu: Vom crea o fereastră care va conține o etichetă cu textul „Apasă butonul de mai jos!” și un buton cu textul „Apasă!” folosind metode ale clasei Tk, astfel: ◗ def saluta(): aceasta este funcția care va fi executată când utilizatorul apasă butonul. În Tkinter, acțiunile butoanelor sunt asociate unor funcții. ◗ eticheta.config(text=”Ai apăsat butonul!”): metoda config() modifică proprietățile unui widget deja creat. În acest exemplu, schimbă valoarea proprietății text pentru etichetă. Eticheta nu este recreată; doar i se modifică textul. ◗ buton = tk.Button(fereastra, text=”Apasă”, command=saluta): această instrucțiune creează butonul.

Parametrul text stabilește textul afișat pe buton, iar command indică funcția care va fi apelată în momentul apăsării butonului. ◗ command=saluta: setăm valoarea parametrului command la numele funcției care dorim să fie apelată, dar fără paranteze. Dacă am scrie command=saluta(), funcția s-ar executa imediat, la pornirea programului, ci nu la apăsarea butonului. import tkinter as tk def saluta(): eticheta.config(text="Ai apăsat butonul!")

91

fereastra = tk.Tk() fereastra.geometry("320x180") fereastra.title("Exemplu cu buton") eticheta = tk.Label(fereastra, text="Apasă butonul de mai jos!") eticheta.pack(pady=10) buton = tk.Button(fereastra, text="Apasă!", command=saluta) buton.pack() fereastra.mainloop()

4. Afișarea mesajelor – modulul messagebox Pe lângă etichetele afișate direct în fereastră, Tkinter oferă și casete de dialog prin intermediul modulului messagebox. Acestea sunt utile atunci când dorim să afișăm o informație, un avertisment sau o eroare.

Exemplu: Vom crea o fereastră care va conține un buton cu textul "Afișează mesaj". La apăsarea butonului se va afișa mesajul "Aplicația a pornit!" într-o casetă de dialog cu titlul "Info", astfel: ◗ from tkinter import messagebox: această instrucțiune importă modulul dedicat casetelor de dialog. ◗ messagebox.showinfo("Info", "Aplicația a pornit!"): metoda showinfo() afișează o fereastră mică de dialog informativă. Primul argument este titlul ferestrei de dialog, iar al doilea este mesajul propriu-zis. ◗ buton.pack(padx=20, pady=20): pentru ca butonul să nu fie lipit de marginile ferestrei, folosim ambele tipuri de spațiere: padx=20 lasă spațiu lateral, iar pady=20 lasă spațiu vertical. import tkinter as tk from tkinter import messagebox def afiseaza_mesaj(): messagebox.showinfo("Info", "Aplicația a pornit!") fereastra = tk.Tk() fereastra.geometry("320x100") fereastra.title("Mesaje") buton = tk.Button(fereastra, text="Afișează mesaj", command=afiseaza_mesaj) buton.pack(padx=20, pady=20) fereastra.mainloop()

DESCOPERĂ Analizați diferiți parametri ai casetelor de dialog de tip messagebox (precum icon, title sau message), apoi explorați funcționalitățile modulului simpledialog din Tkinter.

5. Exemplu rezolvat – Fereastră de prezentare Să realizăm o aplicație care afișează numele unui club școlar și modifică textul dintr-o etichetă, după apăsarea unui buton, pentru a afișa detalii despre clubul respectiv: ◗ fereastra = tk.Tk(): creează fereastra principală. Variabila fereastra sugerează că toate celelalte compo­ nente vor fi adăugate în ea. ◗ fereastra.title("Club școlar"): stabilește textul afișat în bara de titlu a ferestrei. ◗ fereastra.geometry(„360x180”): stabilește dimensiunea inițială a ferestrei. ◗ font="Calibri 14 bold": acest parametru al metodei Label() stabilește familia fontului, dimensiunea sa și stilul îngroșat, astfel textul din eticheta titlu fiind evidențiat. ◗ command=prezinta_club: butonul este asociat cu funcția prezinta_club. La apăsare, aceasta modifică textul etichetei detalii folosind metoda config().

92

import tkinter as tk def prezinta_club(): detalii.config(text="Clubul de robotică se întâlnește miercuri la ora 14:00!") fereastra = tk.Tk() fereastra.geometry("360x180") fereastra.title("Club școlar") titlu = tk.Label(fereastra, text="Cluburi școlare", font="Calibri 14 bold") titlu.pack(pady=10) detalii = tk.Label(fereastra, text="Clubul de robotică") detalii.pack(pady=10) buton = tk.Button(fereastra, text="Detalii", command=prezinta_club) buton.pack(padx=20, pady=20) fereastra.mainloop()

OBSERVAȚIE Metoda config() este o metodă utilizată pentru configurarea și modificarea proprietăților majo­ rității widgeturilor din Tkinter după crearea acestora. Metoda primește ca argumente perechi de tip proprietate=valoare, prin care se stabilesc proprietățile widgetului, precum textul afișat, culorile, dimensiunea, fontul sau stilul. Sintaxa generală este widget.config(proprietate=valoare) sau, pentru modificarea mai multor proprietăți simultan widget.config(proprietate1=valoare1, proprietate2=valoare2).

6. Greșeli frecvente ◗ omiterea instrucțiunii mainloop(); ◗ setarea valorii parametrului command la numele funcției care dorim să fie apelată, dar cu paranteze; ◗ crearea unui widget fără a-l adăuga în fereastră prin pack() – dacă un widget este creat, dar nu primește pack(), el există în memorie, dar nu apare în fereastră.

REȚINE! ◗ ◗ ◗ ◗ ◗ ◗ ◗

Orice aplicație Tkinter pornește de la o fereastră principală creată cu Tk(); Widgetul Label este folosit pentru afișarea unor texte; Widgetul Button permite declanșarea unei acțiuni; Metoda pack() adaugă widget-ul în interfață și îl poziționează automat; Parametrii padx și pady ai metodei pack() controlează spațiile din jurul widget-urilor; Metoda config() modifică proprietățile unui widget deja creat; Metoda mainloop() menține aplicația activă.

Exersează!

1. Scrieți un program care creează o fereastră cu titlul "Salut, Tkinter!", o etichetă cu textul "Prima mea interfață grafică" și un buton prin a cărui apăsare textul etichetei este schimbat în "Am apăsat butonul!".

2. Modificați exemplul din lecție astfel încât butonul să afișeze un mesaj informativ folosind messagebox. showinfo().

3. Explicați rolul instrucțiunii mainloop() și precizați ce se întâmplă dacă aceasta lipsește.

4. Realizați o aplicație care conține două butoane: la apăsarea primului buton se va afișa mesajul "Bun venit!" într-o casetă de dialog, iar la apăsarea celui de-al doilea buton se va afișa mesajul "La revedere!".

93

IV.4. Componente pentru introducerea datelor utilizând biblioteca Tkinter În lecția anterioară am creat primele interfețe grafice în care am folosit etichete, butoane și mesaje. În multe aplicații, utilizatorul trebuie însă să introducă date care vor fi citite și apoi prelucrate de program.

Pentru astfel de situații, Tkinter oferă widgeturi specializate pentru introducerea textului. De asemenea, folosind obiecte de tip Frame putem organiza widgeturile dintr-o fereastră.

1. Casetă de text – clasa Entry Widgetul Entry este folosit când utilizatorul trebuie să introducă un text scurt, care încape pe o singură linie, cum ar fi: nume, clasă, notă, vârstă, cod etc.

Exemplu: Vom crea o fereastră care va conține o etichetă cu textul "Introduceți un număr:", un widget caseta_numar de tip Entry în care utilizatorul trebuie să introducă un număr întreg și un buton cu textul

"Calculează". La apăsarea butonului o etichetă numită rezultat va afișa dublul numărului introdus de utilizator în widgetul caseta_numar:

◗ instrucțiunea text = caseta_numar.get() preia conținutul componentei caseta_numar de tip Entry în variabila text sub forma unui șir de caractere; ◗ valoarea returnată de metoda get() este un șir de caractere, chiar dacă utilizatorul introduce un număr; ◗ instrucțiunea numar = int(text) transformă textul într-un număr întreg, astfel încât el să poată fi folosit în calcule matematice; ◗ rezultatul este afișat în etichetă prin metoda config(), fără a recrea widgetul. import tkinter as tk def afiseaza_dublul(): text = caseta_numar.get() numar = int(text) rezultat.config(text=f"Dublul este {2 * numar}") fereastra = tk.Tk() fereastra.geometry("320x180") fereastra.title("Exemplu cu Entry") tk.Label(fereastra, text="Introduceți un număr:").pack(pady=5) caseta_numar = tk.Entry(fereastra) caseta_numar.pack(pady=5) tk.Button(fereastra, text="Calculează", command=afiseaza_dublul).pack(pady=5) rezultat = tk.Label(fereastra, text="") rezultat.pack(pady=5) fereastra.mainloop()

REȚINE! ◗ Pentru un widget de tip Entry, metoda get() nu primește parametri. Ea returnează direct conținutul casetei sub forma unui șir de caractere.

2. Conversia datelor preluate dintr-o interfață grafică În aplicațiile grafice datele introduse sunt preluate frecvent sub formă de text (șir de caractere). De aceea, înainte de efectuarea unui calcul matematic, este necesar să transformăm textul în tipul numeric potrivit, altfel pot apărea erori:

94

Cod sursă a = "70" b = "30" print(a + b) print(a - b)

Rezultat 7030 Traceback (most recent call last): File "C:\manual\Test.py", line 4, in <module> print(a - b) ~~^~~ TypeError: unsupported operand type(s) for -: 'str' and 'str'

Explicații: În cazul șirurilor de caractere, operatorul + realizează concatenarea (alipirea) celor două șiruri, deci expresia a + b va fi egală cu șirul "7030" (rezultat incorect matematic), iar la evaluarea expresiei a - b va apărea o eroare, deoarece operatorul - nu este definit pentru șiruri de caractere! Varianta corectă este: Cod sursă a = int("70") b = int("30") print(a + b) print(a - b)

Rezultat 100 40

REȚINE! ◗ În interfețele grafice, valorile introduse într-o casetă de tip Entry sunt preluate ca text. Pentru a realiza calcule matematice sau comparații numerice cu ele, mai întâi este necesară conversia lor la un tip de date numeric, precum int sau float.

3. Validarea datelor introduse de către utilizator Când preluăm date dintr-o interfață grafică (sau le citim de la tastatură), nu putem fi siguri că utilizatorul va introduce o valoare de tipul (sau în formatul) la care noi ne așteptăm. Astfel, dacă într-un widget de tip Entry în care trebuie introdus numărul de elevi dintr-o clasă se va introduce un text care nu poate fi convertit în număr întreg (de exemplu, valorile 32., 32e sau "32 elevi"), programul va lansa o eroare. Dacă valoarea introdusă poate fi convertită într-un număr întreg, ulterior trebuie să verificăm și faptul că este validă din punct de vedere logic (de exemplu, numărul de elevi dintr-o clasă nu poate fi negativ și trebuie să fie cuprins între 10 și 30).

Cea mai simplă metodă de a verifica faptul că un șir de caractere preluat dintr-un widget reprezintă un număr (întreg sau real) constă în utilizarea unei instrucțiuni try...except în cadrul căreia să verificăm dacă șirul preluat poate fi convertit într-un număr de tipul dorit. Dacă operația de conversie nu poate fi realizată, atunci se va lansa o excepție de tipul ValueError.

Exemplul 1: Vom crea o fereastră care va conține o etichetă cu textul "Introduceți o notă:", un widget caseta_nota de tip Entry în care utilizatorul trebuie să introducă o notă a unui elev și un buton cu textul "Validează nota". La apăsarea butonului o etichetă denumită rezultat va afișa nota introdusă dacă aceasta este corectă (adică este un număr natural cuprins între 1 și 10) sau, în caz contrar, un mesaj care să detalieze eroarea. import tkinter as tk def validare_nota(): text = caseta_nota.get() try: nota = int(text) if 1 <= nota <= 10: rezultat.config(text=f"Nota introdusă este {nota}", fg="blue")

95

else: rezultat.config(text=f"Eroare! Nota trebuie să fie cuprinsă " f"între 1 și 10!", fg="red") except ValueError: rezultat.config(text=f"Eroare! Nota trebuie să fie " f"un număr natural!", fg="red") fereastra = tk.Tk() fereastra.title("Validare notă") fereastra.geometry("320x180") tk.Label(fereastra, text="Introduceți o notă:").pack(pady=5) caseta_nota = tk.Entry(fereastra) caseta_nota.pack(pady=5) tk.Button(fereastra, text="Validează nota", command=validare_nota).pack(pady=5) rezultat = tk.Label(fereastra, text="") rezultat.pack(pady=5) fereastra.mainloop()

4. Zonă de text – clasa Text Widgetul Text este folosit pentru introducerea și afișarea unor texte de dimensiuni mai mari, care pot ocupa mai multe linii.

Exemplul 2: Vom crea o fereastră care va conține un widget zona_text de tip Text în care utilizatorul trebuie să introducă două numere întregi și un buton cu textul "Calculează suma". La apăsarea butonului se va afișa, sub cele două numere din widgetul zona_text, pe o linie nouă, suma lor: ◗ pentru un widget de tip Text, metoda get() trebuie să fie apelată cu doi parametri efectivi: poziția de început și poziția de sfârșit a textului pe care dorim să-l preluăm din widget. Aceste poziții trebuie scrise sub forma unui șir de caractere de forma "linie.coloană". Liniile dintr-un widget Text sunt numerotate începând de la 1 (de sus în jos), iar coloanele începând de la 0 (de la stânga la dreapta). De exemplu, "2.3" înseamnă caracterul aflat pe a doua linie și a patra coloană. Expresia "end" reprezintă sfârșitul textului din widget. ◗ pentru a modifica textul dintr-un widget de tip Text se folosesc următoarele metode: o insert(p, t) inserează textul t începând cu poziția p din widget (textul care începe pe poziția p + 1 este deplasat spre dreapta pe linia respectivă); o replace(p1, p2, t) înlocuiește textul aflat între pozițiile p1 și p2 în widget cu textul t; o delete(p1, p2) șterge textul aflat între pozițiile p1 și p2 în widget. import tkinter as tk OBSERVĂ from tkinter import messagebox def calculeaza(): În Python, '\n' reprezintă catry: racterul pentru salt la o linie nouă numar_1 = int(zona_text.get("1.0", "2.0")) (newline). Acesta funcționează ca o numar_2 = int(zona_text.get("2.0", "3.0")) apăsare a tastei Enter și este folosuma = numar_1 + numar_2 sit pentru a trece la rândul următor zona_text.insert("3.0", "\nSuma: " + str(suma)) într-un text (șir de caractere). except ValueError: messagebox.showerror("Valori incorecte!", "Introduceți două numere întregi, câte unul pe linie!") fereastra = tk.Tk() fereastra.title("Exemplu cu Text") fereastra.geometry("400x200") zona_text = tk.Text(fereastra, width=35, height=6, font="Calibri 12") zona_text.pack(padx=10, pady=10) tk.Button(fereastra, text="Calculează suma", command=calculeaza).pack(pady=5) fereastra.mainloop()

96

5. Gruparea componentelor – clasa Frame Atunci când o aplicație conține mai multe etichete, casete text și butoane, este util să le organizăm în zone logice. Clasa Frame creează un container în care putem plasa alte widgeturi.

Un widget de tip Frame este util pentru gruparea widgeturilor dintr-un formular și separarea vizuală a diferi­ telor părți ale interfeței grafice.

Exemplul 3: Vom crea un formular, asemănător cu cel din dreapta, care poate fi folosit pentru salvarea unor informații despre clasele dintr-un liceu în fișierul text clase.txt. Widgeturile de tip Label și Entry, folosite pentru introducerea informațiilor dorite, vor fi grupate în două containere de tip Frame.

Explicații: ◗ Instrucțiunea tk.Frame() creează un cadru în interiorul ferestrei principale, iar parametrul bd îi stabilește grosimea marginii în pixeli. ◗ Parametrul relief al metodei tk.Frame() stabilește aspectul vizual al cadrului: "groove" – cadrul este înconjurat de o margine, "raised" – cadrul pare ridicat deasupra ferestrei, "sunken" – cadrul pare îngropat în fereastră etc. ◗ Parametrii padx și pady ai metodei tk.Frame() creează spațiu în interiorul cadrului, astfel încât widgeturile să nu fie lipite de marginile sale. ◗ Pentru a grupa mai multe widgeturi într-un cadru, ele trebuie să fie adăugate în cadrul respectiv, și nu direct în fereastra principală (doar eticheta "Informații" și butonul "Salvare informații" se vor adăuga direct în fereastra principală). import tkinter as tk def salvare_date(): clasa = caseta_clasa.get() diriginte = caseta_diriginte.get() profil = caseta_profil.get() specializare = caseta_specializare.get() f = open("clase.txt", "a") f.write(f"{clasa}, {diriginte}, {profil}, {specializare}\n") f.close() caseta_specializare.delete(0, tk.END) caseta_profil.delete(0, tk.END) caseta_diriginte.delete(0, tk.END) caseta_clasa.delete(0, tk.END)

OBSERVAȚIE Frame nu este doar un element decorativ. El organizează logica interfeței grafice și permite separarea clară a zonelor sale.

DESCOPERĂ Explorați clasa LabelFrame din modulul tkinter!

fereastra = tk.Tk() fereastra.title("Exemplu cu Frame") fereastra.geometry("300x350") tk.Label(fereastra, text="Informații", pady=10).pack() cadru_clasa = tk.Frame(fereastra, bd=2, relief="groove", padx=10, pady=10) cadru_clasa.pack(padx=10, pady=10) tk.Label(cadru_clasa, text="Clasa:").pack() caseta_clasa = tk.Entry(cadru_clasa)

97

caseta_clasa.pack() tk.Label(cadru_clasa, text="Diriginte:").pack() caseta_diriginte = tk.Entry(cadru_clasa) caseta_diriginte.pack() cadru_profil = tk.Frame(fereastra, bd=2, relief="groove", padx=10, pady=10) cadru_profil.pack(padx=10, pady=10) tk.Label(cadru_profil, text="Profil:").pack() caseta_profil = tk.Entry(cadru_profil) caseta_profil.pack() tk.Label(cadru_profil, text="Specializare:").pack() caseta_specializare = tk.Entry(cadru_profil) caseta_specializare.pack() buton_salveaza = tk.Button(fereastra, text="Salvare date", pady=10, command=salvare_date) buton_salveaza.pack() fereastra.mainloop()

6. Organizarea widgeturilor pe linii și coloane – metoda grid() În interiorul unei ferestre sau cadru, poziționarea widgeturilor folosind metoda grid() este de multe ori mai potrivită decât folosirea metodei pack(), deoarece așază componentele într-un tabel imaginar alcătuit din linii și coloane (ambele indexate de la 0).

Parametrii metodei grid() cei mai des utilizați sunt: ◗ row – linia pe care este plasat widgetul; ◗ column – coloana pe care este plasat widgetul; ◗ sticky – modul de aliniere în interiorul celulei (de exemplu, sticky = "w" aliniază widgetul spre latura din stânga a celulei ("w" provine de la "west"), iar sticky = "n" îl aliniază spre latura de sus ("n" provine de la "north"); ◗ columnspan – numărul de coloane pe care se întinde widgetul.

REȚINE! ◗ În aceeași fereastră sau în același cadru, nu este recomandată folosirea simultană a metodelor pack() și grid() pentru poziționarea widgeturilor care au același părinte.

7. Exemplu rezolvat – Formular pentru calculul mediei de admitere la liceu a unui elev Vom realiza o aplicație în care utilizatorul introduce numele unui elev și notele obținute de acesta la probele de limba română și matematică, iar programul afișează media lui de admitere la liceu, adică media celor două note fără rotunjire, astfel: ◗ programul conține 3 componente de tip Entry: una pentru numele elevului, una pentru nota sa la proba de limba română și una pentru nota la proba de matematică; ◗ la apăsarea butonului "Afișează media", valorile celor două note sunt preluate folosind metoda get(), se calculează media lor cu două zecimale fără rotunjire și apoi aceasta se afișează în eticheta medie_admitere; ◗ parametrul columnspan=2 al metodei grid() corespunzătoare butonului "Afișează media" determină extinderea sa pe două coloane, poziționându-l centrat în formular. import tkinter as tk from tkinter import messagebox

98

def afiseaza_media(): try: nota_r = float(nota_romana.get()) nota_m = float(nota_matematica.get()) if 1 <= nota_r <= 10 and 1 <= nota_m <= 10: medie = (nota_r + nota_m) / 2 medie = int(medie*100) / 100 medie_admitere.config(text=str(medie)) else: messagebox.showerror("Eroare!", "Notele trebuie să fie între 1 și 10!") except ValueError: messagebox.showerror("Eroare!", "Notele nu sunt valide!") def goleste_formular(): nume.delete(0, tk.END) nota_romana.delete(0, tk.END) nota_matematica.delete(0, tk.END) medie_admitere.config(text="") nume.focus_set() radacina = tk.Tk() radacina.title("Media de admitere la liceu") radacina.geometry("400x200") cadru = tk.Frame(radacina, padx=10, pady=10) cadru.pack()

REȚINE! Metoda focus_set() din Tkinter este folosită pentru a activa automat o casetă de text (sau orice alt widget), mutând cursorul direct în ea, fără ca utilizatorul să fie nevoit să dea click cu mouse-ul.

tk.Label(cadru, text="Nume elev:").grid(row=0, column=0, sticky="e") nume = tk.Entry(cadru) nume.grid(row=0, column=1, pady=5) tk.Label(cadru, text="Nota limba română:").grid(row=1, column=0, sticky="e") nota_romana = tk.Entry(cadru, width=20) nota_romana.grid(row=1, column=1, pady=5) tk.Label(cadru, text="Nota matematică:").grid(row=2, column=0, sticky="e") nota_matematica = tk.Entry(cadru, width=20) nota_matematica.grid(row=2, column=1, pady=5) tk.Label(cadru, text="Media de admitere:", fg="red").grid(row=3, column=0, sticky="e") medie_admitere = tk.Label(cadru, text="", fg="red") medie_admitere.grid(row=3, column=1, sticky="w") tk.Button(cadru, text="Afișează media", command=afiseaza_media).grid(row=4, column=0, pady=5) tk.Button(cadru, text="Golește formularul", command=goleste_formular).grid(row=4, column=1, pady=5) radacina.mainloop()

8. Diferența dintre Entry și Text Deși ambele componente sunt folosite pentru introducerea textului, ele au roluri diferite.

Componentă

Caracteristici

Utilizare recomandată

Entry

Un singur rând; get() fără parametri

Nume, cod, clasă, notă, mesaj scurt

Text

Mai multe rânduri; get("1.0", "end-1c")

Comentariu, observație, mesaj amplu

9. Greșeli frecvente ◗ Se uită folosirea metodei get(), iar programul lucrează cu widgetul, nu cu valoarea din el; ◗ Se folosește metoda get() pentru Text fără indici de poziție; ◗ Se încearcă efectuarea unui calcul folosind direct textul preluat dintr-un widget de tip Entry; ◗ Se confundă widgeturile de tip Entry cu cele de tip Text; ◗ Se omite validarea datelor înainte de conversie.

99

REȚINE! ◗ Un widget de tip Entry este utilizat pentru texte scurte, scrise pe un singur rând, iar unul de tip Text pentru texte mai lungi, scrise pe mai multe rânduri; ◗ Pentru ambele tipuri de widgeturi, valorile introduse se preiau folosind metoda get(); ◗ Pentru widgeturi de tip Entry metoda get() nu primește niciun parametru, iar pentru cele de tip Text metoda trebuie să primească poziția de început și poziția de sfârșit a textului pe care dorim să-l preluăm (sub forma unui șir de caractere "linie.coloană"); ◗ Datele citite din widgeturi de tip Entry sau Text sunt șiruri de caractere și trebuie convertite în valori numerice dacă dorim să le utilizăm în calcule matematice; ◗ Widgetul Frame permite gruparea componentelor și organizarea interfeței grafice; ◗ Metoda grid() este potrivită pentru poziționarea widgeturilor în formulare organizate pe linii și coloane. ◗ Datele introduse trebuie verificate înainte de prelucrare.

P ORTOFOLIU DIGITAL Carnetul de note – interfață grafică Organizare

Creează folderul: Portofoliu digital > Capitolul 4 > Carnetul de note > Tema 8 - Interfata grafica pentru carnet.

Cerința 1

Creează o interfață grafică, folosind Tkinter, care implementează aplicația "Carnetul de note".

Aplicația va fi salvată în fișierul carnet_note_tkinter.py.

Cerința 2

Fereastra principală va avea titlul "Carnetul de note", o etichetă de titlu, o etichetă de instrucțiuni și cel puțin două componente Entry: una pentru introducerea unei note și una pentru introducerea mediei dorite.

Cerința 3

Adaugă un buton "Verifică nota". La apăsarea butonului, programul citește nota din Entry, o validează și afișează într-o etichetă mesajul "În grafic" sau "Mai trebuie să înveți".

Cerința 4

Adaugă un buton "Verifică media". Programul citește media curentă și media dorită, apoi afișează mesajul "În grafic" sau "Mai trebuie să înveți". Valorile citite din Entry trebuie convertite la float. Validează datele introduse.

Cerința 5

Grupează componentele într-un Frame și organizează formularul cu grid().

Cerința 6

Adaugă un buton "Salvează rezultat". La apăsarea lui, aplicația va adăuga în fișierul rezultate_ tkinter.txt, folosind modul adăugare ("a"), ultimul rezultat calculat în interfață.

Cerința 7

Adaugă un buton "Golește formularul", care șterge conținutul câmpurilor Entry și etichetei pentru rezultat.

Salvează

carnet_note_tkinter.py, rezultate_tkinter.txt

Exersează!

1. Realizați o aplicație în care utilizatorul introduce într-un widget de tip Entry un număr natural, iar la apăsarea unui buton programul afișează pătratul lui.

2. Scrieți un program în care utilizatorul introduce două numere în două widget-uri de tip Entry, iar la apăsarea unui buton se afișează suma lor într-o casetă de dialog.

3. Realizați un formular grupat într-un Frame, cu două etichete, două componente Entry și un buton, pentru salvarea numelui și clasei unui elev într-un fișier text.

4. Explicați diferența dintre widget-urile Entry și Text și precizați în ce situații este recomandată utilizarea fiecăruia.

100

IV.5. Manageri de geometrie. Canvas În lecțiile anterioare am învățat cum se creează o fereastră, cum se afișează mesaje și cum se citesc date introduse de utilizator. În multe aplicații, aceste componente sunt completate de elemente grafice desenate direct în fereastră și de o organizare mai atentă a interfeței.

De exemplu, într-o aplicație educațională putem desena linii și forme geometrice. În același timp, trebuie să alegem și o metodă potrivită pentru așezarea componentelor în fereastră.

1. Manageri de geometrie (manageri de poziționare) Pentru a organiza widgeturile într-o fereastră, Tkinter oferă trei metode principale: pack(), grid() și place().

Aceste metode se numesc manageri de geometrie deoarece controlează poziția și așezarea componentelor în interfață.

Alegerea managerului potrivit influențează claritatea interfeței și adaptarea ferestrei la dimensiuni diferite.

2. Metoda pack() Metoda pack() este cea mai simplă modalitate de așezare a componentelor. Ea poziționează widgeturile unul după altul, vertical sau orizontal, fără a fi nevoie să precizăm linii și coloane.

Exemplul 1: Interfață simplă cu pack() import tkinter as tk fereastra = tk.Tk() fereastra.geometry("300x160") tk.Label(fereastra, text="Titlu").pack(pady=10) tk.Button(fereastra, text="Start").pack(pady=10) tk.Button(fereastra, text="Stop").pack(pady=10) fereastra.mainloop()

În acest exemplu, componentele sunt așezate pe rânduri diferite (una sub alta): mai întâi eticheta, apoi primul buton și apoi al doilea buton. Dacă dorim să afișăm componentele pe același rând, una după alta, atunci trebuie să adăugăm parametrul side="left" metodei pack(): import tkinter as tk fereastra = tk.Tk() fereastra.geometry("300x160") tk.Label(fereastra, text="Titlu").pack(padx=10, side="left") tk.Button(fereastra, text="Start").pack(padx=10, side="left") tk.Button(fereastra, text="Stop").pack(padx=10, side="left") fereastra.mainloop()

REȚINE! ◗ Metoda pack() este potrivită pentru ferestre simple, meniuri scurte sau interfețe în care elementele trebuie afișate una sub alta (vertical) sau una lângă alta (orizontal).

101

3. Metoda grid() Metoda grid() organizează componentele într-un tabel imaginar alcătuit din linii și coloane. Ea este foarte potrivită pentru formulare și pentru interfețe în care etichetele trebuie aliniate cu casetele de text.

Exemplul 2: Formular organizat cu grid() import tkinter as tk fereastra = tk.Tk() tk.Label(fereastra, text="Utilizator").grid(row=0, column=0, padx=5, pady=5) tk.Entry(fereastra).grid(row=0, column=1, padx=5, pady=5) tk.Label(fereastra, text="Parolă").grid(row=1, column=0, padx=5, pady=5) tk.Entry(fereastra, show="*").grid(row=1, column=1, padx=5, pady=5) fereastra.mainloop()

În acest exemplu, eticheta "Utilizator" și câmpul său de text se află pe linia 0, iar eticheta "Parolă" și câmpul ei se află pe linia 1. Parametrul show="*" maschează caracterele introduse și este util când lucrăm cu parole.

4. Metoda place() Metoda place() poziționează widgeturile folosind coordonate exacte. Ea oferă control direct asupra locului în care este așezată fiecare componentă.

Exemplul 3: Poziționare exactă cu place() import tkinter as tk fereastra = tk.Tk() fereastra.geometry("300x180") tk.Label(fereastra, text="Poziționare exactă").place(x=80, y=25) tk.Button(fereastra, text="OK").place(x=120, y=90) fereastra.mainloop()

Parametrul x indică distanța față de marginea stângă a ferestrei, iar parametrul y indică distanța față de marginea superioară.

5. Compararea managerilor de geometrie Cei trei manageri de geometrie răspund unor nevoi diferite. Alegerea corectă depinde de tipul de interfață pe care vrem să o construim.

Metodă

Organizare

Potrivită pentru

Atenție!

pack()

Ferestre simple, meniuri scurte, Widgeturile sunt așezate Mai puțin potrivit pentru componente dispuse orizontal unul după altul formulare complexe sau vertical

grid()

Widgeturile sunt așezate Formulare, etichete și câmpuri pe linii și coloane alăturate, interfețe ordonate

Nu se combină cu pack() în același container

place()

Widgeturile sunt plasate prin coordonate exacte

Se adaptează mai greu la redimensionare

Machete speciale, poziționări fixe

REȚINE! ◗ Pentru interfețe simple folosim de obicei pack(); pentru formulare și aliniere clară folosim grid(); pentru poziționare exactă, dar mai rigidă, folosim place().

102

6. Utilizarea coerentă a managerilor de geometrie În același container, de exemplu în aceeași fereastră sau în același Frame, nu este recomandat să folosim și pack(), și grid() pentru widgeturi diferite. Cei doi manageri încearcă să controleze același container și pot produce rezultate imprevizibile. # Variantă nerecomandată tk.Label(cadru, text="Nume").pack() tk.Entry(cadru).grid(row=0, column=1)

Corectarea constă în alegerea unui singur manager pentru toate widgeturile din același container. De exemplu, pentru un formular, ambele componente pot fi organizate cu grid().

OBSERVAȚIE Se pot folosi manageri diferiți în containere diferite. De exemplu, un Frame poate fi plasat cu pack(), iar componentele din interiorul lui pot fi organizate cu grid().

# Variantă corectă tk.Label(cadru, text="Nume").grid(row=0, column=0) tk.Entry(cadru).grid(row=0, column=1)

7. Suprafața de desen – clasa Canvas Widgetul Canvas este componenta Tkinter folosită pentru desenarea elementelor grafice. Pe un Canvas putem desena linii, dreptunghiuri, cercuri, elipse sau alte forme simple, respectiv putem scrie texte.

Această componentă este utilă în aplicații educaționale, mici jocuri, simulări simple sau reprezentări grafice care trebuie actualizate în timpul executării.

Exemplul 4: Vom desena mai multe forme geometrice pe un widget de tip Canvas, astfel: ◗ instrucțiunea zona = tk.Canvas(fereastra, width=260, height=160, bg="white") creează o suprafață de desen cu lățimea de 260 pixeli, înălțimea de 160 pixeli și fundal alb; ◗ metoda create_rectangle() desenează un dreptunghi caracterizat prin patru numere care reprezintă coordonatele colțurilor opuse ale acestuia: primul punct indică colțul din stânga-sus, iar al doilea punct indică colțul din dreapta-jos; ◗ metoda create_oval() desenează o formă ovală înscrisă într-un dreptunghi imaginar, iar dacă lățimea și înălțimea dreptunghiului sunt egale, atunci forma obținută este un cerc; ◗ metoda create_line() trasează o linie între două puncte, iar create_text() afișează un text într-o poziție dată din interiorul suprafeței Canvas. import tkinter as tk fereastra = tk.Tk() fereastra.title("Exemplu cu Canvas") zona = tk.Canvas(fereastra, width=260, height=160, bg="white") zona.pack(padx=10, pady=10) zona.create_rectangle(20, 20, 110, 90, outline="blue", width=2) zona.create_oval(140, 20, 230, 90, outline="red", width=2) zona.create_line(20, 120, 230, 120, fill="green", width=3) zona.create_text(130, 140, text="Forme geometrice") fereastra.mainloop()

REȚINE! ◗ Canvas nu este o imagine statică, ci o suprafață pe care programul poate desena, șterge și modifica elemente pe durata executării sale.

103

8. Sistemul de coordonate din Canvas Pentru a desena corect, trebuie să înțelegem modul în care sunt folosite coordonatele. În Canvas, originea sistemului de coordonate se află în colțul din stânga-sus al suprafeței de desen, astfel: ◗ coordonata x crește spre dreapta, de la 0 la lățimea canvasului (inițializată prin parametrul width al metodei tk.Canvas()); ◗ coordonata y crește în jos, de la 0 la înălțimea canvasului (inițializată prin parametrul height al metodei tk.Canvas()).

De exemplu, prin instrucțiunea zona = tk.

Canvas(fereastra, width=500, height=300, bg="white") se va crea canvasul alăturat:

OBSERVAȚIE În interfețele grafice, poziția verticală crește în jos deoarece coordonatele sunt raportate la suprafața ecranului, nu la sistemul de coor­ donate studiat în matematică.

9. Conturul și umplerea formelor La desenarea formelor este util să distingem între contur și interior. În Tkinter, aceste două aspecte pot fi controlate separat. zona.create_rectangle(20, 20, 100, 80, outline="black", fill="yellow", width=2)

În această secvență, parametrul outline stabilește culoarea conturului, parametrul fill stabilește culoarea din interior, iar width stabilește grosimea conturului.

Regulă practică: Dacă folosim doar outline, forma are doar contur. Dacă folosim și fill, forma este colorată și în interior.

10. Exemplu rezolvat – mică aplicație de desen Să realizăm o aplicație în care utilizatorul apasă un buton, iar programul desenează un semafor simplificat. import tkinter as tk def deseneaza_semafor(): canvas.delete("all") canvas.create_rectangle(60, 30, 140, 250, fill="black") canvas.create_oval(80, 50, 120, 90, fill="red") canvas.create_oval(80, 110, 120, 150, fill="yellow") canvas.create_oval(80, 170, 120, 210, fill="green") canvas.create_rectangle(90, 250, 110, 330, fill="gray") fereastra = tk.Tk() fereastra.title("Semafor")

104

fereastra.geometry("300x450") canvas = tk.Canvas(fereastra, width=200, height=350, bg="white") canvas.pack(pady=10) tk.Button(fereastra, text="Desenează", command=deseneaza_semafor).pack(pady=5) fereastra.mainloop()

Explicații: Instrucțiunea canvas.delete("all") șterge toate elementele existente în Canvas. Ea este utilă când desenul trebuie refăcut, pentru a evita suprapunerea formelor noi peste cele vechi.

Dreptunghiul negru reprezintă corpul semaforului, cele trei ovale colorate reprezintă luminile, iar dreptunghiul gri reprezintă stâlpul semaforului. Exemplul arată că o suprafață Canvas poate fi actualizată în timpul executării și poate răspunde la acțiunea utilizatorului.

11. Repere pentru identificarea și utilizarea altor clase și metode Pe măsură ce aplicațiile devin mai complexe, avem nevoie de alte componente sau metode. Nu este necesar să le cunoaștem pe toate de la început. Este mai important să înțelegem ce rol are o componentă, ce proprietăți și ce metode are.

Clasă / metodă

Rol principal

Exemplu de utilizare

Toplevel

Creează o fereastră suplimentară

Ferestre secundare de tip „Detalii” sau „Ajutor”

Checkbutton / Radiobutton

Permit selectarea opțiunilor

Alegerea unor setări sau a unei singure variante corecte

Listbox / Combobox

Permit alegerea unei valori dintr-o listă

Selectarea unei clase, a unui produs sau a unei culori

Scale

Alege o valoare numerică prin glisare

Reglarea volumului boxelor sau a luminozității

Când întâlnim o clasă sau o metodă nouă, este bine să răspundem întrebărilor: Ce rol are? Ce argumente primește?

Ce efect produce? Astfel, ne putem dezvolta o metodă de lucru aplicabilă și altor componente sau biblioteci grafice.

12. Exemplu rezolvat – combinarea unui Canvas cu un formular Interfețele reale combină adesea mai multe tipuri de componente. În exemplul următor, utilizatorul introduce o culoare într-un widget de tip Entry, iar programul desenează un dreptunghi în culoarea indicată. import tkinter as tk from tkinter import messagebox def deseneaza(): culoare = intrare.get() try: canvas.delete("all") canvas.create_rectangle(40, 30, 180, 100, fill=culoare) except tk.TclError: messagebox.showerror("Eroare", "Culoare necunoscută!") radacina = tk.Tk() radacina.title("Culori și Canvas") tk.Label(radacina, text="Introduceți o culoare în engleză:").pack(pady=5) intrare = tk.Entry(radacina) intrare.pack(pady=5) canvas = tk.Canvas(radacina, width=220, height=140, bg="white") canvas.pack(pady=10) tk.Button(radacina, text="Desenează", command=deseneaza).pack(pady=5) radacina.mainloop()

105

Explicații: Programul citește textul introdus de utilizator și îl folosește ca nume de culoare. Dacă numele este valid, dreptunghiul este desenat în culoarea indicată.

Dacă utilizatorul introduce un nume de culoare necunoscut, Tkinter produce o eroare de tip ­tk.TclError. Blocul try... except permite tratarea elegantă a acestei situații și afișarea unui mesaj clar prin messagebox.showerror().

OBSERVAȚIE Exemplul arată că o aplicație poate combina etichete, componente Entry, butoane, suprafață Canvas și ferestre de dialog într-o singură interfață coerentă.

13. Greșeli frecvente ◗ se confundă coordonatele din Canvas; ◗ se folosesc valori prea mari și formele ies din zona vizibilă; ◗ se amestecă pack() și grid() în același container; ◗ se omite ștergerea conținutului anterior din Canvas, iar desenele se suprapun; ◗ dacă suprafața Canvas este mică, figura nu va fi vizibilă integral, deci coordonatele trebuie alese în raport cu dimensiunile efective ale suprafeței de desen.

REȚINE! ◗ Componenta Canvas este folosită pentru desenarea elementelor grafice. ◗ Coordonatele sunt exprimate în pixeli și se raportează la colțul din stânga-sus. ◗ Metodele create_rectangle(), create_oval(), create_line() și create_text() desenează forme și texte. ◗ Metoda delete("all") șterge conținutul anterior al suprafeței de desen. ◗ Tkinter oferă și multe alte componente, care pot fi înțelese treptat pornind de la rolul lor.

Exersează!

1. Scrieți un program care creează un Canvas și desenează pe acesta un dreptunghi, un cerc și un text.

2. Realizați o interfață cu două etichete și două componente Entry, organizate cu grid().

3. Explicați diferența dintre pack(), grid() și place() și precizați câte o situație potrivită pentru fiecare.

4. Creați un program în care un buton desenează pe un Canvas o casă simplificată formată dintr-un pătrat și un acoperiș reprezentat prin linii.

5. Un elev a folosit pack() pentru un Label și grid() pentru un Entry în același Frame. Explicați de ce această alegere este nerecomandată și propuneți o corectare.

6. Realizați o aplicație în care utilizatorul introduce într-un widget de tip Entry numele unei culori în limba engleză, iar programul desenează un cerc folosind culoarea respectivă.

106

PROBLEME PROPUSE 1. Realizați o aplicație grafică folosind Tkinter care conține o etichetă, o casetă de text și un buton. Utilizatorul introduce un nume în caseta de text, iar la apăsarea butonului se afișează în etichetă mesajul "Salut, nume!".

Dacă nu se introduce niciun nume, se va afișa mesajul "Introduceți un nume". Exemplu: dacă utilizatorul introduce Ana, aplicația va afișa "Salut, Ana!" 2. Realizați o aplicație grafică folosind Tkinter care citește două numere naturale din două casete de text.

Aplicația va avea un buton care, la apăsare, afișează într-o etichetă suma celor două numere, diferența în valoare absolută și produsul celor două numere. Dacă valorile introduse nu sunt valide, se va afișa un mesaj de eroare folosind messagebox.showerror(). Exemplu: pentru valorile 8 și 3, aplicația va afișa suma 11, diferența 5 și produsul 24.

3. Orașul Numeriland și-a construit un termometru digital afișat pe un panou în centrul pieței. Cetățenii pot introduce temperatura curentă, iar panoul afișează un mesaj personalizat. Realizați o aplicație grafică în Tkinter care conține o etichetă, o casetă de text și un buton. Utilizatorul introduce o temperatură, număr întreg sau real, în caseta de text. La apăsarea butonului se afișează într-o etichetă un mesaj conform regulilor: dacă temperatura este negativă, se afișează un mesaj de atenționare; dacă este între 0 și 14.99, se afișează "Temperatură răcoroasă"; dacă este între 15 și 30, se afișează "Temperatură plăcută"; dacă depășește 30, se afișează un mesaj de atenționare pentru temperatură ridicată. Dacă valoarea introdusă nu este numerică, se afișează eroare cu messagebox.showerror(). Exemple: pentru 22.5, aplicația va afișa "Temperatură plăcută". Pentru -5, aplicația va afișa "Temperatură negativă. Îmbrăcați-vă gros!"

4. La alegerile din Numeriland, fiecare cetățean votează introducând codul numeric al candidatului preferat.

Cabina de vot digitală verifică dacă valoarea introdusă este validă și afișează un mesaj de confirmare. Realizați o aplicație grafică în Tkinter care conține o casetă de text, un buton "Votează" și o etichetă rezultat. Dacă nu s-a introdus nimic, se afișează "Introduceți un candidat". Dacă valoarea introdusă nu este un număr natural nenul, se afișează eroare cu messagebox. Dacă valoarea este validă, se afișează codul introdus și suma cifrelor acestuia. Suma cifrelor se calculează prin prelucrarea repetată a ultimei cifre cu operatorul %. Exemplu: pentru codul 2741, aplicația va afișa Vot înregistrat pentru codul: 2741. Suma cifrelor codului: 14.

5. Agenția secretă NumeriCode codifică mesajele prin numere. Agentul Rx are nevoie de un decodor rapid: introduce un număr natural nenul și vede imediat prima cifră, ultima cifră, oglinditul numărului și dacă acesta este palindrom. Realizați o aplicație grafică în Tkinter care conține o casetă de text și un buton "Decodifică".

La apăsarea butonului se afișează într-o etichetă prima cifră, ultima cifră, oglinditul numărului și mesajul "PALINDROM" sau "NU ESTE PALINDROM". Dacă valoarea introdusă nu este un număr natural nenul, se afișează eroare cu messagebox. Exemple: pentru 3872 se afișează prima cifră 3, ultima cifră 2, oglindit 2783, NU ESTE PALINDROM. Pentru 1221 se afișează PALINDROM 6. În fabrica de roboți NumeriBot, fiecare produs are două coduri: codul de fabricație a și codul de calitate b.

Dacă CMMDC(a, b) = 1, robotul trece testul de calitate. Realizați o aplicație grafică în Tkinter cu două casete de text, pentru a și b, și un buton Verifică. La apăsarea butonului se calculează CMMDC(a, b) folosind algoritmul lui Euclid. Dacă CMMDC = 1, se afișează CMMDC = 1. Robotul trece testul! În caz contrar, se afișează CMMDC = valoare. Robotul PICĂ testul. Dacă valorile nu sunt numere naturale nenule, se afișează eroare cu messagebox. Exemple: pentru a = 14 și b = 25, CMMDC = 1, aplicația va afișa Robotul trece testul.

Pentru a = 12 și b = 18, CMMDC = 6, aplicația va afișa Robotul PICĂ testul.

7. Fișierul senzori.in conține pe prima linie un număr natural n, iar pe următoarele n linii câte o valoare reală, reprezentând temperaturi măsurate într-o seră. Scrieți un program care citește datele din fișier și afișează în fișierul senzori.out câte temperaturi sunt în intervalul [18, 25], temperatura maximă citită și media temperaturilor din intervalul [18, 25], rotunjită la două zecimale. Dacă nu există nicio temperatură în interval, media afișată va fi 0. Dacă fișierul senzori.in conține valorile 5, 17.5, 20, 24.5, 28, 19, fiecare pe linie separată, atunci se vor afișa 3, 28.0 și 21.17

107

FIȘĂ DE EVALUARE FINALĂ DE CAPITOL Se acordă 10 puncte din oficiu. Timp de lucru recomandat: 50 de minute.

Pentru problemele cu fișiere, valorile sunt așezate pe linii separate și se citesc succesiv cu readline().

SUBIECTUL I 60 de puncte Alegeți varianta corectă. Fiecare item valorează 6 puncte.

1.

Instrucțiunea f = open("date.txt", "r") deschide fișierul: A. pentru scriere B. pentru citire C. pentru adăugare la final

2.

Metoda readline() citește: B. o singură linie din fișier A. tot fișierul

C. doar primul caracter

3.

Metoda write() primește ca argument: A. un număr întreg B. o valoare de tip float

C. un șir de caractere

D. o valoare citită numai cu input()

4.

Rolul metodei close() este: A. să șteargă fișierul B. să închidă fișierul

C. să citească o linie

D. să transforme textul în număr

5.

Instrucțiunea f = open("rezultat.txt", "a") deschide fișierul: A. pentru citire B. pentru scriere de la început C. pentru adăugare la final

6.

În Tkinter, pentru un buton care trebuie să apeleze funcția calculeaza la apăsare, forma corectă este: A. command=calculeaza() B. command=calculeaza C. command="calculeaza" D. command==calculeaza

7.

Metoda get() aplicată unei componente Entry returnează: A. un număr întreg B. un număr real C. un șir de caractere

8.

Pentru un widget Text, citirea conținutului se poate face, de regulă, cu: B. readline() C. get("1.0", "end-1c") D. write("1.0") A. get()

9.

În același Frame, nu este recomandat să amestecăm: A. Label și Button B. Entry și Label C. pack() și grid() D. title() și geometry()

D. pentru creare exclusivă D. doar numere întregi

D. pentru citire și ștergere

D. o listă de valori

10. Fișierul a.txt conține pe prima linie numărul 41. După executarea secvenței se va scrie în fișier: x = int(f.readline()) g.write(str(x + 9))

A. 419

B. 50

C. 41 9

D. 9

SUBIECTUL II 30 de puncte Rezolvați cerințele folosind fișiere text. Valorile din fișiere sunt pe linii separate.

1.

Fișierul echilibru.in conține pe prima linie un număr natural n, iar pe următoarele n linii câte un număr natural nenul. Un cod este echilibrat dacă în scrierea sa numărul cifrelor pare este egal cu numărul cifrelor impare. Scrieți un program care citește datele din fișier și scrie în fișierul echilibru.out câte coduri sunt echilibrate și cel mai mare cod echilibrat. Dacă nu există niciun cod echilibrat, a doua valoare scrisă va fi 0.

Exemplu: dacă fișierul echilibru.in conține valorile 5, 1234, 7052, 86, 1112, 9045, fiecare pe linie separată, atunci fișierul echilibru.out va conține valorile 3 și 9045, fiecare pe linie separată.

2.

Fișierul factori.in conține pe prima linie un număr natural n, iar pe următoarele n linii câte un număr natural mai mare decât 1. Un număr este pătrat factorial dacă, în descompunerea sa în factori primi, toți exponenții sunt pari. Scrieți un program care citește datele din fișier și scrie în fișierul factori.out câte numere sunt pătrate factoriale și cel mai mare dintre acestea. Dacă nu există niciun astfel de număr, a doua valoare scrisă va fi 0. Exemplu: dacă fișierul factori.in conține valorile 6, 36, 72, 100, 18, 144, 75, fiecare pe linie separată, atunci fișierul factori.out va conține valorile 3 și 144, fiecare pe linie separată.

108

CAPITOLUL V Modelul conceptual liniar. Clasa list.

Metode de sortare. Eficiența algoritmilor COMPETENȚE SPECIFICE VIZATE CS 1.1 Identifică principalele caracteristici ale organizării datelor în cadrul unor modele conceptuale fundamentale – date simple sau liste, pentru a structura și accesa date în vederea prelucrării acestora.

CS 2.1 Explică principiile de organizare a datelor în cadrul unor modele conceptuale fundamentale – date simple sau liste, pentru a le gestiona eficient.

CS 3.1 Utilizează modul de organizare și prelucrare a datelor în cadrul unor modele conceptuale fundamentale – date simple sau liste, pentru a rezolva probleme de gestionare a datelor.

CS 4.1 Analizează caracteristicile, modul de prelucrare, avantajele și dezavantajele utilizării unor modele conceptuale fundamentale - date simple sau liste, pentru a alege structura adecvată în rezolvarea unor probleme concrete.

CS 5.1 Argumentează alegerea unor modele conceptuale fundamentale – date simple sau liste – și a modurilor de prelucrare a acestora pentru rezolvarea unor probleme informatice concrete.

CS 5.2 Evaluează corectitudinea și eficiența soluțiilor cu algoritmi specializați pe clase de probleme pentru prelucrarea numerelor, sortarea sau generarea sistematică a unor secvențe de valori.

CS 5.5 Evaluează corectitudinea și eficiența programelor care utilizează subprograme, pentru a rezolva probleme informatice.

CS 6.1 Proiectează algoritmi personalizați care utilizează modele conceptuale fundamentale - date simple sau liste pentru organizarea și prelucrarea eficientă a datelor, utilizând algoritmi de bază, în vederea rezolvării unor probleme.

V.1. Modelul conceptual liniar: listă, stivă, coadă și listă de frecvențe În problemele studiate până acum, am lucrat frecvent cu un număr mic de variabile: una pentru un număr, alta pentru o sumă, alta pentru un maxim, un minim sau un contor. În multe situații, însă, datele nu apar izolat, ci sub forma unei colecții de valori, care pot fi procesate împreună. De exemplu, putem avea notele unui elev la mai multe teste, valorile măsurate de un senzor la momente succesive de timp, numerele citite dintr-un fișier, frecvențele de apariție ale cifrelor sau rezultatele obținute într-o serie de calcule. Pentru a descrie astfel de date, folosim modelul conceptual liniar, iar forma sa cea mai cunoscută este lista.

1. Definiția conceptului de listă O listă este o colecție finită de valori, așezate într-o ordine bine determinată. Fiecare element al listei are o poziție. Prin urmare, într-o listă contează nu doar ce valori apar, ci și ordinea în care acestea sunt așezate.

De exemplu, secvența numerică 7, 10, 8, 9 poate reprezenta notele unui elev la patru teste succesive. În această situație, lista REȚINE! conține 4 elemente, primul element este 7, al doilea este 10, al treilea este 8, iar al patrulea este 9. Dacă am schimba ordinea ◗ Pentru organizarea datelor într-o sucși am scrie 10, 7, 8, 9 am obține o listă diferită. cesiune clară, lista oferă un model conceptual simplu și intuitiv.

2. Caracteristici conceptuale ale unei liste Din punct de vedere conceptual, o listă are câteva caracteristici esențiale: ◗ elementele sunt ordonate, respectiv fiecare element ocupă o poziție precisă; ◗ un element poate fi accesat sau modificat folosind poziția sa; ◗ elementele pot fi parcurse unul câte unul, de la început spre sfârșit sau invers; ◗ caracterul dinamic este proprietatea unei liste de a-și modifica dimensiunea în funcție de datele inserate; ◗ asupra listei se pot aplica diferiți algoritmi, de exemplu: calculul sumei elementelor, a maximului sau minimului sau ordonarea elementelor.

109

3. Exemple de liste numerice Exemplul 1: Temperaturile măsurate de un senzor Un senzor transmite, la cinci momente succesive, temperaturile 14, 13, 15, 15, 12. Acestea formează o listă numerică. Putem determina temperatura maximă sau minimă, diferența dintre prima și ultima temperatură înregistrată sau numărul de apariții ale unei anumite temperaturi.

Exemplul 2: Frecvențele cifrelor Dacă dorim să aflăm de câte ori apare fiecare cifră într-un grup de numere, putem folosi o structură numerică de forma 2, 0, 3, 1, 0, 4, 1, 0, 0, 2.

Această listă poate reprezenta frecvențele cifrelor de la 0 la 9. De exemplu, cifra 0 apare de 2 ori, cifra 2 apare de 3 ori, iar cifra 5 apare de 4 ori.

OBSERVAȚIE În toate aceste exemple, lista grupează mai multe valori și permite prelucrări sistematice.

4. Parcurgerea elementelor unei liste Una dintre cele mai importante operații pe care o putem efectua asupra unei liste este parcurgerea sa, ceea ce presupune prelucrarea elementelor sale unul câte unul.

La nivel conceptual, lista 12, 7, 25, 9 poate fi parcursă astfel: mai întâi prelucrăm valoarea 12, apoi valoarea 7, apoi 25 și apoi 9. Această idee este foarte importantă, deoarece aproape toți algoritmii de bază pentru liste se bazează pe parcurgerea sa (determinarea sumei sau a maximului, numărarea aparițiilor unei valori sau căutarea elementelor cu o anumită proprietate).

5. Accesarea directă și accesarea secvențială a unui element din listă Nu toate structurile de date liniare sunt folosite în același mod. Din punctul de vedere al modului de accesare al datelor, distingem două variante importante: a) accesarea directă: un element poate fi identificat imediat folosind poziția sa în listă. De exemplu, în lista 5, 8, 3, 9, 4 al patrulea element poate fi accesat direct, acesta fiind 9. b) accesarea secvențială: presupune parcurgerea elementelor unei liste unul câte unul, în ordinea în care acestea sunt stocate, până la identificarea elementului dorit. De exemplu, în lista 5, 8, 3, 9, 4, pentru a găsi valoarea 9, elementele sunt analizate succesiv: mai întâi 5, apoi 8, apoi 3, iar în final 9.

6. Cazuri particulare de listă: stivă și coadă În cadrul structurilor de date liniare se evidențiază două tipuri particulare utilizate frecvent în practică, respectiv stiva și coada, fiecare având reguli specifice de acces și organizare a elementelor.

6.1. Stiva O stivă este o structură de date liniară în care ultimul element inserat este primul care se extrage.

Această regulă este cunoscută sub numele LIFO (Last In, First Out). De exemplu, să presupunem că introducem într-o stivă valorile 4, 7, 9 în această ordine. Dacă le extragem după regula stivei, vom obține mai întâi 9, apoi 7, apoi 4.

OBSERVAȚIE Stiva poate fi comparată cu un teanc de farfurii: ultima farfurie pusă deasupra este prima care va fi luată.

110

6.2. Coada O coadă este o structură de date liniară în care primul element introdus este primul care se extrage. Această regulă este cunoscută sub numele FIFO (First In, First Out). De exemplu, dacă introducem într-o coadă valorile 4, 7, 9 în această ordine, extragerea după regula cozii va produce mai întâi 4, apoi 7, apoi 9.

OBSERVAȚIE Coada poate fi comparată cu un șir de persoane care așteaptă la rând: cine ajunge primul va fi servit primul.

7. Listă de frecvențe O utilizare importantă a listelor o reprezintă listele de frecvențe, prin intermediul cărora se memorează, pentru fiecare valoare posibilă dintr-un anumit interval, numărul său de apariții.

Exemplul 3: Frecvențele notelor Să presupunem că un elev are la disciplina Informatică următoarele note: 7, 10, 5, 8, 7, 9, 10, 7. Putem construi o listă de frecvențe pentru toate notele de la 1 la 10, astfel: 0, 0, 0, 0, 1, 0, 3, 1, 1, 2 (nota 5 apare o dată, nota 7 apare de 3 ori, nota 8 apare o dată, nota 9 apare o dată, iar nota 10 apare de 2 ori).

8. Prelucrarea datelor organizate liniar cu sau fără memorarea lor Atunci când lucrăm cu mai multe valori, există două situații importante: a) prelucrarea fără memorare: datele sunt prelucrate pe măsură ce sunt citite, fără memorarea lor într-o listă.

De exemplu, pentru valorile 12, 7, 25 și 9, suma poate fi calculată succesiv astfel: inițial suma este 0, după citirea valorii 12 suma devine 12; după citirea valorii 7 suma devine 19; după citirea valorii 25 suma devine 44; iar după citirea valorii 9 suma finală este 53. Astfel, rezultatul este obținut fără memorarea tuturor valorilor într-o structură de tip listă. b) prelucrare cu memorare: datele sunt memorate mai întâi într-o listă, apoi sunt prelucrate. Această abordare este utilă atunci când avem nevoie de mai multe parcurgeri sau când vrem să ordonăm crescător valorile.

De exemplu, pentru a afișa toate pozițiile pe care apare valoarea maximă dintr-un șir de numere, trebuie ca prima dată să parcurgem șirul pentru a determina maximul valorilor sale, iar apoi este necesară o nouă parcurgere a șirului inițial pentru afișarea pozițiilor elementelor egale cu valoarea maximă, deci este necesar să memorăm șirul de numere într-o listă.

REȚINE! O listă este o colecție finită de valori dispuse într-o anumită ordine; Fiecare element al listei are o poziție (un indice); Asupra unei liste se pot aplica algoritmi de bază: parcurgere, sumă, maxim, minim sau numărare; Listele permit atât acces direct, cât și secvențial; Stiva și coada sunt cazuri particulare de organizare liniară a datelor; Lista de frecvențe este utilă pentru numărarea aparițiilor tuturor valorilor dintr-un interval restrâns și cunoscut în prealabil; ◗ Datele organizate liniar pot fi prelucrate cu memorare sau fără memorare.

◗ ◗ ◗ ◗ ◗ ◗

Exersează!

1. Precizați de ce secvențele 4, 7, 9 și 9, 7, 4 reprezintă două liste diferite.

2. Pentru lista numerică 6, 10, 8, 7, 10, precizați: a) primul element; b) ultimul element; c) câte elemente conține lista.

3. Explicați diferența dintre acces direct și acces secvențial.

4. O stivă S și o coadă C sunt memorate ca liste. Pentru stivă, add(x) adaugă la final, iar pop() elimină ultimul element. Pentru coadă, add(x) adaugă la final, iar pop() elimină primul element. Inițial: S = [10, 20, 30], unde 30 este vârful, și C = [40, 50], unde 40 este în față. Se execută, în ordine: S.pop(); C.add(60); C.pop(); S.add(70); S.pop(); C.add(80); S.add(90); C.pop(). Determinați conținutul final al stivei S și al cozii C. 5. Pentru valorile 7, 8, 7, 10, 8, 7, precizați frecvența valorii 7 și frecvența valorii 8.

111

V.2. Clasa list. Accesarea elementelor unei liste. Operatori specifici În lecția anterioară am studiat lista ca model conceptual liniar, iar în această lecție trecem de la nivelul conceptual la nivelul concret al limbajului Python și învățăm cum este reprezentată o listă într-un program. În Python, listele sunt gestionate prin intermediul clasei predefinite list. Aceasta permite gruparea mai multor valori într-o structură unitară, oferind posibilitatea de a accesa elementele prin poziție (indice), de a le modifica și de a extrage porțiuni din listă (slicing).

1. Caracteristicile clasei list În Python, o listă este o instanță a clasei predefinite list și are următoarele caracteristici: ◗ orice element ocupă o poziție bine determinată, pe baza căreia poate fi accesat direct; ◗ dimensiunea unei liste se modifică dinamic în momentul adăugării sau ștergerii unor elemente; ◗ elementele pot fi modificate după crearea listei (spunem că o listă este mutabilă); ◗ elementele pot fi de tipuri de date diferite; ◗ elementele pot fi parcurse secvențial, folosind instrucțiuni repe­ titive.

◗ Listele din Python sunt structuri de date ordonate, dinamice și mutabile, care permit stocarea și prelucrarea unei colecții de elemente atât prin accesare directă, cât și prin accesare secvențială.

2. Crearea unei liste prin constante Cel mai simplu mod de a crea o listă îl reprezintă inițializarea sa cu un șir de valori constante scrise între paranteze drepte și separate prin virgule:

Instrucțiunea print(note) afișează direct întreaga listă, elementele sale fiind incluse între paranteze pătrate.

Cod sursă # instanțiem o listă cu note note = [8, 10, 7, 9, 10]

Rezultatul executării Notele: [8, 10, 7, 9, 10]

OBSERVĂ

REȚINE! ◗ Lista este memorată ca un singur obiect, chiar dacă ea conține mai multe valori.

# afișăm întreaga listă print("Notele:", note)

3. Accesarea elementelor unei liste prin indici Accesarea elementelor unei liste se realizează folosind pozițiile lor, numite și indici. Primul element al unei liste are indicele 0, al doilea are indicele 1 ș.a.m.d.

Accesarea elementului aflat pe poziția k într-o listă L se realizează prin expresia L[k]. De exemplu, pentru lista L = [12, 5, 18, 9], avem L[0] este 12, L[1] este 5, L[2] este 18, iar L[3] este 9. În Python, putem accesa elementele unei liste folosind și indici negativi. Ultimul element al unei liste are indicele -1, penultimul are indicele -2 ș.a.m.d. De exemplu, pentru lista L = [12, 5, 18, 9], avem L[-1] este 9, L[-2] este 18, L[-3] este 5, iar L[-4] este 12.

112

REȚINE!

Indici pozitivi

0

1

2

3

Elementele listei L

12

5

18

9

Indici negativi

-4

-3

-2

-1

OBSERVĂ Indicii negativi sunt foarte utili atunci când vrem să lucrăm cu elementele de la sfârșitul listei fără să cunoaștem numărul elementelor listei.

REȚINE! ◗ Pentru o listă cu n elemente, indicii pozitivi au valori cuprinse între 0 și n-1, iar indicii negativi au valori cuprinse între -n și -1.

Exemplu: Pentru o listă numerică vom afișa primele două elemente și ultimele două elemente.

Cod sursă # creăm o listă numerică

L = [12, 5, 18, 9, 14, 10, 11]

# afișăm primul element print("Primul element este", L[0]) # afișăm al doilea element print("Al doilea element este", L[1]) # afișăm penultimul element print("Penultimul element este", L[-2]) # afișăm ultimul element print("Ultimul element este", L[-1])

Rezultatul executării Primul element este 12 Al doilea element este 5 Penultimul element este 10 Ultimul element este 11

4. Subliste (slice-uri) O sublistă (un slice) reprezintă o secvență de elemente dintr-o listă, extrasă folosind un interval de indici.

Considerând o listă L, atunci o sublistă a sa se extrage folosind o expresie de forma L[indice_1: indice_2:pas], unde oricare dintre cei 3 parametri este opțional. Sublista furnizată depinde de relațiile care există între parametrii indice_1, indice_2, pas și numărul elementelor listei, așa cum se poate observa din următorul exemplu în care considerăm lista L = [10, 20, 30, 40, 50, 60, 70] cu n = 7 elemente: Expresia

Sublista furnizată

Explicații

L[1:4]

[20, 30, 40]

Sublista conține elementele cuprinse între indicele 1 (inclusiv) și indicele 4 (exclusiv), deoarece indice_1 < indice_2, iar parametrul pas are valoarea implicită 1.

L[3:3]

[]

Sublista este vidă deoarece indice_1 = indice_2, iar parametrul pas are valoarea implicită 1.

L[3:1]

[]

Sublista este vidă deoarece indice_1 > indice_2, iar parametrul pas are valoarea implicită 1.

L[3:100]

[40, 50, 60, 70]

Deoarece indice_2 > n, atunci sublista conține elementele cuprinse între indicele 3 și indicele n-1, iar parametrul pas are valoarea implicită 1.

L[3:]

[40, 50, 60, 70]

Deoarece lipsește indice_2, atunci valoarea sa se consideră implicit ca fiind egală cu n, iar parametrul pas are valoarea implicită 1.

L[:3]

[10, 20, 30]

Deoarece lipsește indice_1, atunci valoarea sa se consideră implicit ca fiind egală cu 0, iar parametrul pas are valoarea implicită 1.

L[:]

[10, 20, 30, 40, 50, 60, 70]

Deoarece lipsesc indice_1, indice_2 și pas, atunci se consideră valorile lor implicite, respectiv 0, n și 1.

L[5:1:-1]

[60, 50, 40, 30]

Sublista conține elementele cuprinse între indicele 5 (inclusiv) și indicele 1 (exclusiv), dar cu pasul -1 (adică indicii 5, 4, 3 și 2).

L[1:5:-1]

[]

Sublista este vidă deoarece indice_1 < indice_2, dar parametrul pas are valoarea -1.

L[1:6:2]

[20, 40, 60]

Deoarece pas=2, atunci sublista conține elementele cuprinse între indicii 1 și 5, dar din 2 în 2 (adică indicii 1, 3 și 5).

L[::-1]

[70, 60, 50, 40, 30, 20, 10]

Deoarece lipsesc indice_1 și indice_2, dar pas = -1, atunci se consideră indice_1 = n-1 și indice_2 = -n-1 (un indice fictiv aflat înaintea indicelui -n corespunzător primului element din listă).

113

OBSERVĂ Sublistele (slice-urile) sunt utile când dorim să modificăm sau să extragem o porțiune dintr-o listă, respectiv să lucrăm cu o copie a acesteia, după cum se poate observa în următoarele exemple în care considerăm lista L = [10, 20, 30, 40, 50, 60, 70] cu n = 7 elemente: Instrucțiunea

Lista L modificată

Explicații

[10, 2, 3, 4, 5, 40, 50, 60, 70]

Se înlocuiesc elementele listei L cuprinse între indicii 1 și 2 (adică sublista [20, 30]) cu elementele listei [2, 3, 4, 5], deci se realizează o operație ștergere urmată de una inserare în urma cărora numărul elementelor din lista L crește.

L[2:6] = [3, 4]

[10, 20, 3, 4, 70]

Se înlocuiesc elementele cuprinse între indicii 2 și 5 (adică sublista [30, 40, 50, 60]) cu elementele listei [3, 4], deci se realizează o operație ștergere urmată de una inserare în urma cărora numărul elementelor din lista L scade.

L[2:4] = [3, 4]

[10, 20, 3, 4, 50, 60, 70]

Se înlocuiesc elementele listei L cuprinse între indicii 2 și 3 (adică sublista [30, 40]) cu elementele listei [3, 4], deci se realizează o operație ștergere urmată de una inserare în urma cărora numărul elementelor din lista L rămâne neschimbat.

L[2:6] = []

[10, 20, 70]

Se înlocuiesc elementele listei L cuprinse între indicii 2 și 5 (adică sublista [30, 40, 50, 60]) cu o listă vidă, deci se realizează doar o operație de ștergere a elementelor respective.

[10, 2, 3, 20, 30, 40, 50, 60, 70]

Sublista L[1:1] este vidă (deoarece indice_1 = indice_2, iar parametrul pas are valoarea implicită 1) și reprezintă spațiul vid dintre elementul L[1]=20 și predecesorul său (elementul L[0]=10), deci se va realiza doar o operație de inserare a elementelor listei [2,3] înaintea elementului L[1].

L[1:3] = [2, 3, 4, 5]

L[1:1] = [2, 3]

5. Operatori pentru liste În Python, listele pot fi prelucrate și cu ajutorul unor operatori: ◗ operatorul [] se numește operatorul de accesare a unui element (sau operatorul de indexare) și permite accesarea unui element al unei liste pe baza poziției sale. Astfel, dacă L este o listă cu n elemente, atunci expresia L[i] reprezintă elementul aflat pe poziția i dacă aceasta este validă (adică, fie este cuprinsă între 0 și n-1, fie între -n și -1, așa cum deja am văzut în lecția anterioară). În caz contrar, va fi lansată excepția IndexError. ◗ operatorii in și not in se numesc operatori pentru testarea apartenenței și permit verificarea faptului că o valoare apare sau nu într-o listă. De exemplu, pentru lista L = [8, 10, 7, 9] expresia 10 in L va avea valoarea True (deoarece valoarea 10 apare pe poziția 1 în lista L), iar expresia 6 not in L va avea tot valoarea True (deoarece valoarea 6 nu apare în lista L). ◗ operatorul + se numește operatorul de concatenare și realizează alipirea a două (sau mai multe) liste într-una nouă, care conține toate elementele listelor inițiale. De exemplu, dacă avem două liste L1 = [2, 4, 6] și L2 = [1, 3, 5, 4], atunci expresia L1 + L2 va fi egală cu lista [2, 4, 6, 1, 3, 5, 4], iar expresia L2 + L1 va fi egală cu lista [1, 3, 5, 4, 2, 4, 6].

REȚINE! ◗ Concatenarea nu amestecă valorile din cele două liste și nici nu le ordonează, ci doar le alipește în ordinea în care apar în cele două liste.

114

◗ operatorul += se numește operatorul de concatenare cu atribuire și realizează alipirea listei din membrul drept la lista din membrul stâng. De exemplu, dacă avem două liste L1 = [2, 4, 6] și L2 = [1, 3, 5], atunci, după executarea instrucțiunii L1 += L2, lista L1 va fi egală cu [2, 4, 6, 1, 3, 5].

REȚINE! ◗ Deși instrucțiunile L1=L1+L2 și L1+=L2 par identice, deoarece rezultatul lor este același (se alipește lista L2 la lista L1), modul în care se execută este complet diferit: în primul caz se creează o listă nouă care conține elementele listei L1 urmate de cele ale listei L2, iar în al doilea caz lista L1 este modificată direct, fără să se creeze o listă nouă, respectiv este mai întâi extinsă și apoi sunt adăugate la sfârșitul său elementele din L2. De aceea, prima variantă este mai lentă decât a doua, deci nu se recomandă utilizarea sa! ◗ operatorul * se numește operatorul de concatenare repetată și furnizează o listă nouă, obținută prin conca­ tenarea repetată a listei inițiale cu ea însăși, de numărul de ori indicat. De exemplu, pentru lista L = [2, 4, 6], expresia L * 3 va furniza lista [2, 4, 6, 2, 4, 6, 2, 4, 6].

REȚINE! ◗ Operatorul * este foarte util când dorim să creăm o listă numerică de o anumită lungime, ale cărei elemente au aceeași valoare. De exemplu, expresia L = [0] * 5 va inițializa lista L cu lista [0, 0, 0, 0, 0]. ◗ Operatorii ==, !=, <, >, <=, >= se numesc operatori relaționali și sunt utilizați pentru a compara lexicografic două liste. Compararea lexicografică a două liste se realizează prin analizarea elementelor aflate pe aceeași poziție în ambele liste, de la stânga la dreapta. Dacă elementele comparate sunt egale, atunci se trece la poziția următoare.

Rezultatul comparației este determinat de prima pereche de elemente diferite întâlnită. Dacă ambele liste se termină înainte de găsirea unei diferențe, atunci listele sunt considerate egale. Dacă una dintre liste se termină înainte de apariția unei diferențe, atunci lista mai scurtă este considerată mai mică în sens lexicografic.

Expresia

Rezultatul expresiei

Explicații

[1, 2, 3] == [1, 3, 2]

False

Cele două liste nu sunt egale deoarece nu au aceleași elemente pe aceleași poziții: pe poziția 1 în lista din stânga avem valoarea 2, iar în lista din dreapta avem valoarea 3.

[1, 2] == [1, 2, 3]

False

Cele două liste nu sunt egale deoarece nu au același număr de elemente (când se testează egalitatea a două liste, mai întâi se compară lungimile lor și dacă ele nu sunt egale atunci se furnizează direct rezultatul False, fără să se mai compare și elementele lor).

[1, 2, 3] <= [1, 3, 2]

True

Elementele de pe poziția 0 sunt ambele egale cu 1, deci se compară cele de pe poziția 1. Deoarece 2 < 3, rezultă că lista din stânga este mai mică lexicografic decât cea din dreapta.

[1, 2] <= [1, 2, 3]

True

Primele două perechi de elemente sunt identice în ambele liste, dar prima listă se termină înainte de a se găsi vreo pereche de elemente diferite, deci lista mai scurtă este considerată mai mică în sens lexicografic decât lista mai lungă.

[2, 1] < [1, 10, 10, 10]

False

Se compară prima pereche de elemente (cele de pe poziția 0) și deoarece 2 > 1, prima listă este considerată mai mare lexicografic decât a doua și compararea se termină cu rezultatul False.

115

REȚINE! ◗ Operatorii relaționali se pot utiliza doar pentru compararea listelor în care elementele aflate pe aceleași poziții sunt comparabile (de exemplu, ambele sunt valori numerice sau ambele sunt șiruri de caractere). În caz contrar, se va lansa o eroare de tipul TypeError.

6. Greșeli frecvente ◗ Se confundă poziția naturală cu indicele Python; ◗ Se încearcă accesarea unui element inexistent; ◗ Se uită că L[1:4] nu include elementul de pe poziția 4; ◗ Se confundă L[0], care este un element, cu L[0:1], care este o listă cu un element.

REȚINE! ◗ în Python, listele sunt instanțe ale clasei predefinite list; ◗ o listă se poate crea printr-un șir de constante, folosind paranteze pătrate; ◗ elementele unei liste se pot accesa prin indici pozitivi și negativi ◗ indicii pozitivi încep de la 0 din partea stângă a listei, iar cei negativi de la -1 din partea dreaptă; ◗ indicii negativi permit accesarea simplă a elementelor de la sfârșitul listei; ◗ un slice reprezintă o porțiune din listă.

Exersează!

1. Creați lista numerică [14, 7, 21, 9, 12] și afișați: a) primul element; b) al treilea element; c) ultimul element.

2. Se consideră lista L = [8, 10, 7, 9]. Modificați al doilea element astfel încât lista să devină [8, 6, 7, 9].

3. Pentru lista L = [3, 6, 9, 12, 15, 18] precizați ce se afișează pentru: A. print(L[2])

B. print(L[-1])

C. print(L[1:4])

D. print(L[:3])

4. Explicați diferența dintre L[2] și L[2:3].

5. Se consideră secvența: L = [10, 20, 30, 40] for i in range(len(L)): print(L[i], end=" ")

Precizați ce se afișează.

6. Se consideră lista L = [6, 8, 10, 12, 14]. Afișați primele două elemente și ultimele trei elemente, folosind slice-uri.

116

V.3. Crearea unei liste prin citire. Funcții predefinite pentru liste În lecția anterioară am învățat că, în Python, listele sunt obiecte ale clasei predefinite list și că ele pot fi create direct prin inițializarea cu un șir de constante, scrise între paranteze pătrate. De asemenea, am învățat despre operatori care pot fi utilizați pentru prelucrarea listelor. În continuare, vom studia mai multe funcții predefinite care pot fi utilizate în prelucrarea listelor, precum și modalități de construire a acestora prin citirea elementelor de la tastatură sau dintr-un fișier.

1. Caracteristici și repere de utilizare a unor subprograme predefinite pentru manipularea listelor Limbajul Python oferă mai multe funcții predefinite care sunt foarte utile pentru manipularea simplă și eficientă a listelor: ◗ funcția len() furnizează numărul de elemente dintr-o listă. De exemplu, len([8, 10, 7, 9]) = 4. ◗ funcția min() returnează valoarea minimă dintr-o listă. De exemplu, min([8, 10, 7, 9]) = 7. ◗ funcția max() returnează valoarea maximă dintr-o listă. De exemplu, max([8, 10, 7, 9]) = 10. ◗ funcția sum() returnează suma elementelor dintr-o listă numerică. De exemplu, sum([8, 10, 7, 9]) = 34. ◗ funcția sorted() returnează o listă nouă formată din elementele listei inițiale reașezate în ordine crescătoare, iar lista inițială rămâne nemodificată: Cod sursă # creăm o listă L cu note și o afișăm L = [9, 8, 7, 10, 8] print(f"Lista L: {L}\n")

Rezultatul executării Lista L: [9, 8, 7, 10, 8] Lista S: [7, 8, 8, 9, 10] Lista L: [9, 8, 7, 10, 8]

# creăm o listă nouă S din # elementele listei L sortate crescător S = sorted(L) # afișăm noua listă S print(f"Lista S: {S}")

REȚINE! ◗ Funcțiile min(), max(), sum() și sorted() oferă rapid rezultate care pot fi obținute și prin algoritmi clasici. În multe situații, ele fac programul mai scurt și mai clar.

# reafișăm lista L și observăm că # a rămas nemodificată) print(f"Lista L: {L}")

2. Crearea unei liste prin citirea valorilor elementelor sale În multe situații, elementele unei liste nu sunt cunoscute de la începutul programului (nu sunt constante), ci ele trebuie citite de la tastatură sau dintr-un fișier text și adăugate treptat în listă.

O primă variantă de construire a unei liste L prin citirea a n valori de tastatură constă în inițializarea sa cu lista vidă [], iar apoi fiecare valoare x citită de la tastatură se adaugă la sfârșitul listei L curente, folosind operatorul de concatenare cu atribuire (+=): # citim numărul n de valori din care vom crea lista L n = int(input("Numărul de elemente din listă: ")) # inițializăm lista L cu lista vidă L = [] # citim fiecare valoare dintre cele n dorite în variabila x # și o adăugăm la sfârșitul listei L

OBSERVĂ Valoarea x citită ar putea fi adăugată la sfârșitul listei curente L și înlocuind instruc­țiunea L += [x] cu instrucțiunea L = L + [x], dar aceasta variantă ar fi mai lentă așa cum s-a precizat în lecția anterioară!

117

for i in range(n): x = int(input("Valoare: ")) L += [x]

# afișăm lista L print(f"Lista citită de la tastatură: {L}") O altă variantă de construire a unei liste L prin citirea a n valori de tastatură constă în inițializarea sa cu o listă formată din n valori egale cu 0 (sau orice altă valoare), iar apoi se va citi valoarea dorită pentru fiecare dintre elementele L[0], L[1],…, L[n-1] ale listei. Deoarece crearea unei liste prin citirea valorilor elementelor sale este o operație care apare foarte des în programe, se recomandă implementarea sa ca o funcție într-un modul dedicat operațiilor cu liste (alături de alte funcții des utilizate, cum ar fi o funcție pentru afișarea elementelor unei liste), astfel încât să o putem ulterior reutiliza în alte programe: def citire_lista_tastatura():

# citim numărul n de valori din care vom crea lista L

n = int(input("Numărul de elemente din listă: "))

# inițializăm lista L cu o listă # formată din n valori egale cu 0 L = [0] * n # citim valoarea dorită pentru fiecare element L[i], # unde indicele i ia valori de la 0 la n-1 for i in range(n): L[i] = int(input(f"Valoarea elementului {i}: ")) return L

OBSERVĂ Funcția de mai sus se va apela printr-o instrucțiune de forma L = citire_lista_tastatura().

De asemenea, în același modul putem să implementăm și o funcție care să citească elementele listei dintr-un fișier text care conține câte un număr natural pe fiecare linie (în acest caz, nu trebuie neapărat să cunoaștem de la început numărul valorilor din fișier, ci îl putem parcurge linie cu linie): def citire_lista_fisier(nume_fisier):

# tratăm erorile care pot să apară la citirea unor valori dintr-un fișier text: # fișier inexistent sau valorile de pe linii nu sunt numere întregi try: # încercăm să deschidem fișierul text cu numele dat prin parametrul nume_fisier fisier = open(nume_fisier, "r") L = [] # parcurgem fișierul linie cu linie for linie in fisier: # încercăm să transformăm șirul de caractere citit de pe linia curentă # într-un număr întreg pe care să îl adăugăm la sfârșitul listei L x = int(linie) L += [x] return L except: # dacă apare o eroare, afișăm un mesaj și returnăm o listă vidă print("Eroare la citirea numerelor din fișier!") return []

OBSERVĂ Dacă dorim să citim valorile elementelor listei din fișierul text numere.txt, atunci vom apela funcția de mai sus printr-o instrucțiune de forma L = citire_lista_fisier("numere.txt").

118

3. Parcurgerea unei liste Parcurgerea unei liste L se poate realiza în două moduri: a) iterând prin mulțimea indicilor săi (de la 0 la len(L)-1) și accesând direct fiecare element L[i] prin indicele său i; b) iterând direct prin elementele listei, folosind o instrucțiune for.

Cod sursă – varianta a)

Cod sursă – varianta b)

# funcție care afișează lista L def afisare_lista(L): # afișăm lista element cu element for i in range(len(L)): print(f"Elementul de pe poziția {i} " f"este {L[i]}")

# funcție care afișează lista L def afisare_lista(L): # afișăm lista element cu element print("Lista: ") for element in L: print(element, end=" ")

# creăm o listă cu note L = [7, 10, 8, 10] # afișăm lista de note apelând funcția afisare_lista(L)

# creăm o listă cu note L = [7, 10, 8, 10] # afișăm lista de note afisare_lista(L)

Rezultatul executării Elementul de pe poziția 0 este 7 Elementul de pe poziția 1 este 10 Elementul de pe poziția 2 este 8 Elementul de pe poziția 3 este 10

Rezultatul executării Lista: 7 10 8 10

REȚINE! ◗ Prima variantă de parcurgere a unei liste este utilă atunci când avem nevoie simultan și de poziția unui element și de valoarea sa. De asemenea, această variantă permite modificarea elementelor listei, deoarece acestea sunt accesate direct prin indicii lor. ◗ A doua variantă de parcurgere a unei liste este mai concisă, dar nu permite modificarea elementelor listei deoarece, la fiecare iterație, variabilei element îi este atribuită o copie a valorii elementului curent din listă.

4. Exemplu: determinarea valorii maxime dintr-o listă și a mediei aritmetice a elementelor sale În continuare, vom prezenta două funcții: una care calculează valoarea maximă dintr-o listă și una care calculează media aritmetică a valorilor dintr-o listă numerică: Funcție care calculează Funcție care calculează media aritmetică valoarea maximă dintr-o listă a valorilor dintr-o listă numerică def maxim_lista(L): def medie_aritmetica_lista(L): # inițial, considerăm primul element # inițializăm suma valorilor # din listă ca fiind maximul # din listă cu 0 maxim = L[0] # parcurgem restul elemensuma = 0 telor din listă # parcurgem elementele listei și for i in range(1, len(L)): # adăugăm elementul curent în suma # dacă elementul curent este for i in range(len(L)): # strict mai mare decât maximul suma = suma + L[i] # calculat până acum, îl actualizăm if L[i] > maxim: # returnăm media aritmetică maxim = L[i] return suma / len(L) # returnăm maximul determinat return maxim

119

import operatii_liste as ol

# apelăm funcțiile definite în modulul operatii_liste L = ol.citire_lista_tastatura() print("\nLista citită:") ol.afisare_lista(L) val_max = ol.maxim_lista(L) print(f"\nMaximul din listă: {val_max}") medie_lista = ol.medie_aritmetica_lista(L) print(f"\nMedia aritmetică a valorilor " f"din listă: {medie_lista}")

# apelăm funcții predefinite val_min = min(L) print(f"\nMinimul din listă: {val_min}") S = sorted(L) print(f"\nLista sortată crescător: {S}")

REȚINE! ◗ Dacă am salva funcțiile afisare_lista(), ­citire_ l i s t a _ t a s t a t u r a (), ­ itire_lista_fisier(), c maxim_lista() și medie_ aritmetica_lista(), prezentate anterior în această lecție, într-un modul cu denumirea operatii_liste. py, atunci am putea să le utilizăm foarte simplu ­într-un program clar și concis, alături de alte funcții predefinite.

5. Greșeli frecvente În lucrul cu liste apar frecvent următoarele greșeli: ◗ se confundă instrucțiunea L = L + [x] cu L = L + x, care este greșită (nu se poate concatena o listă cu un număr); ◗ funcția len(L) returnează numărul de elemente și nu ultimul indice din listă care este len(L)-1; ◗ se apelează funcția sum() pentru liste care nu sunt numerice.

REȚINE! ◗ O listă poate fi construită prin citire, pornind de la o listă vidă; ◗ Operatorul in verifică apartenența unei valori la o listă, iar operatorul not in verifică non-apartenența; ◗ Operatorul + concatenează liste; ◗ Operatorul * creează o listă prin concatenări repetate; ◗ Listele pot fi comparate lexicografic; ◗ Funcțiile len(), min(), max(), sum() și sorted() sunt utile pentru prelucrarea listelor numerice.

Exersează!

1. Se citește un număr natural n, apoi se citesc n valori numerice. Memorați valorile într-o listă și afișați-le în ordine inversă. De exemplu, pentru n = 4 și numerele 10, 7, 22, 5 se va afișa 5, 22, 7, 10.

2. Se citește o listă numerică. Să se afișeze dacă valoarea 7 apare sau nu în listă.

3. Indicați instrucțiunea care poate înlocui punctele de suspensie astfel încât să se obțină lista L = [2, 4, 6, 8, 10].

L1 = [2, 4, 6] L2 = [8, 10] L = ................... print(L)

4. Se consideră lista L = [5, 9]. Construiți lista obținută prin concatenarea repetată a listei cu ea însăși, de 4 ori.

5. Se citește o listă numerică. Să se afișeze numărul de elemente, suma lor, valoarea minimă și cea maximă.

120

V.4. Metode ale clasei list pentru adăugarea, inserarea, ștergerea și căutarea unui element În lecțiile anterioare am învățat că listele sunt instanțe ale clasei predefinite list, că pot fi create direct cu elemente constante sau prin citire și că asupra lor se pot aplica operatori și funcții predefinite. Începând cu această lecție, vom studia metodele specifice clasei list, adică operațiile care pot fi aplicate direct asupra unui obiect de tip list.

1. Metodele clasei list În Python, metodele unui obiect se apelează folosind operatorul . (punct) care permite accesarea membrilor unui obiect (atribute și metode): lista.metoda(parametri). Dacă L este o listă, atunci putem scrie, de exemplu, L.append(7) sau x = L.count(10) sau L.sort(). Este important să observăm că nu toate metodele se comportă la fel: unele modifică direct lista (de exemplu, instrucțiunea L.append(7) adaugă numărul 7 la sfârșitul listei L), iar altele doar returnează un rezultat (de exemplu, după executarea instrucțiunii x = L.count(10) variabila x va conține numărul de apariții ale valorii 10 în lista L).

REȚINE! ◗ O funcție este un bloc de cod independent, definit pentru a realiza o anumită operație, care se apelează direct prin numele său și poate primi parametri și returna rezultate. O metodă este o funcție asociată unui obiect, care operează asupra datelor acelui obiect și se apelează folosind operatorul . (punct).

Astfel, diferența principală la apelare este următoarea: ◗ apelarea unei funcții: funcție(parametri)

◗ apelarea unei metode: obiect.metodă(parametri)

De exemplu, dacă L este o listă numerică, atunci o putem sorta crescător în două moduri: ◗ folosind funcția sorted(): S = sorted(L) ◗ folosind metoda sort(): L.sort() Observați faptul că în primul caz funcția sorted() primește ca parametru de intrare lista pe care dorim să o sortăm (L), dar nu o modifică direct, ci furnizează o altă listă (S) care conține elementele din lista L în ordine crescătoare, iar lista L va rămâne nemodificată. În al doilea caz, metoda sort() nu mai primește ca parametru lista L deoarece metoda este implicit asociată cu datele membre ale obiectului L de tip list și sortează direct lista L.

2. Metoda append() Metoda append(x) adaugă o valoare x la sfârșitul unei liste. De exemplu, dacă L = [8, 10, 7] și se execută instrucțiunea L.append(9), atunci lista L va deveni [8, 10, 7, 9].

OBSERVĂ Metoda append() modifică direct lista L și nu trebuie folosită împreună cu o atribuire de tipul L = L.append(x).

Mai mult, o instrucțiune de tipul L = L.append(x) reprezintă o gravă greșeală de programare, deoarece în limbajul Python funcțiile și metodele care nu returnează nicio valoare returnează, de fapt, valoarea None în mod implicit, deci lista L va deveni egală cu None, iar conținutul său inițial se va pierde!

3. Utilizarea metodei append() pentru crearea unei liste prin citirea valorilor elementelor În lecția anterioară am studiat două metode de construire a listelor folosind valori citite de la tastatură: una bazată pe concatenarea listelor și alta pe citirea directă a valorilor elementelor. În continuare, putem utiliza o variantă mai simplă și mai naturală pentru adăugarea elementelor într-o listă, respectiv metoda append().

121

Exemplu: Vom citi un număr natural n și apoi n valori numerice pe care le vom memora într-o listă. # citim numărul de elemente n = int(input("Numărul de elemente: ")) # inițial lista L este vidă L = [] # citim, pe rând, cele n numere întregi # și le adăugăm la sfârșitul listei folosind metoda append() for i in range(n): x = int(input("x = ")) L.append(x) # afișăm lista obținută print(L)

4. Metoda insert() Metoda insert(poz, x) inserează elementul x într-o listă înaintea elementului aflat pe poziția poz. Pentru a face loc noului element, toate elementele cu indice mai mare sau egal cu poz sunt deplasate cu o poziție spre dreapta în listă. De exemplu, dacă L = [8, 10, 7, 8] și se execută instrucțiunea L.insert(2, 9), atunci lista L va deveni [8, 10, 9, 7, 8].

Dacă valoarea parametrului poz este mai mare sau egală decât numărul de elemente din listă (adică len(L)), atunci noua valoare x va fi adăugată la sfârșitul listei, după ultimul element. De exemplu, după executarea instrucțiunii L.insert(10, 100) lista L va deveni [8, 10, 7, 8, 100].

Dacă valoarea parametrului poz este 0 sau mai mică strict decât -len(L), atunci noua valoare x va fi adăugată la începutul listei, înaintea primului element. De exemplu, după executarea instrucțiunii L.insert(0, 100) sau a instrucțiunii L.insert(-10, 100) lista L va deveni [100, 8, 10, 7, 8].

REȚINE! ◗ Metoda insert() modifică direct lista și nu înlocuiește un element, ci adaugă unul nou (eventual, va deplasa spre dreapta o parte din elementele listei). ◗ Operația de modificare a unui element al unei liste și operația de inserare a unei valori într-o listă sunt diferite. De exemplu, considerând o listă L = [4, 8, 12, 16], atunci după executarea instrucțiunii L[2] = 10 ea ar deveni [4, 8, 10, 16] (nu s-ar modifica numărul de elemente), în timp ce după executarea instrucțiunii L.insert(2, 10) ea ar deveni [4, 8, 10, 12, 16] (numărul de elemente ar crește cu 1).

5. Metoda pop() Metoda pop(poz) șterge dintr-o listă elementul aflat pe poziția poz și apoi îi returnează valoarea, dacă poziția poz este un indice valid al listei (pozitiv sau negativ).

Dacă poziția poz nu este un indice valid al listei, respectiv poz ≥ len(L) sau poz < -len(L), atunci va fi lansată eroarea IndexError. Dacă parametrul poz lipsește, atunci metoda va șterge și va returna ultimul element din listă.

Deoarece apelarea acestei metode poate genera erori care să ducă la întreruperea neașteptată a programului, se recomandă utilizarea ei într-un bloc try...except, pentru a gestiona corespunzător eventualele excepții (erori).

122

Exemplu: Cod sursă L = [12, 7, 10, 18, 23, 9] print(f"Lista inițială: {L}\n") try:

Rezultatul executării Lista inițială: [12, 7, 10, 18, 23, 9]

x = L.pop() print(f"Valoarea ștearsă: {x}") print(f"Lista modificată: {L}\n")

Valoarea ștearsă: 9 Lista modificată: [12, 7, 10, 18, 23]

x = L.pop(3) print(f"Valoarea ștearsă: {x}") print(f"Lista modificată: {L}\n")

Valoarea ștearsă: 18 Lista modificată: [12, 7, 10, 23]

x = L.pop(10) print(f"Valoarea ștearsă: {x}") print(f"Lista modificată: {L}") except IndexError: print("Indice incorect!")

Instrucțiunea x = L.pop(10) va genera o eroare, deci restul instrucțiunilor nu se vor mai executa!

Indice incorect!

OBSERVĂ După ștergerea unui element din listă, elementele aflate după poziția respectivă se deplasează spre stânga cu o poziție.

6. Metoda remove() Metoda remove(x) șterge prima apariție a valorii x dintr-o listă, dacă valoarea x există în cadrul acesteia. Dacă valoarea x nu există în listă, atunci va fi lansată eroarea ValueError.

Exemplu: Cod sursă L = [12, 7, 10, 18, 10, 9, 10] print(f"Lista inițială: {L}\n") try:

x = 10 L.remove(x) print(f"Lista modificată: {L}\n")

x = 1000 L.remove(x) print(f"Lista modificată: {L}") except ValueError: print(f"Valoarea {x} nu apare în L!")

Rezultatul executării Lista inițială: [12, 7, 10, 18, 10, 9, 10]

Lista modificată: [12, 7, 18, 10, 9, 10] Instrucțiunea L.remove(x) va genera o eroare pentru x = 1000, deci lista nu va mai fi afișată!

OBSERVĂ Metoda remove(x) șterge cel mult prima apariție a valorii x în lista respectivă.

123

Pentru a șterge toate aparițiile unei valori x într-o listă L, vom apela repetat metoda remove(x) până când se va lansa eroarea ValueError (care indică faptul că valoarea x nu mai apare în listă):

REȚINE! ◗ Este important să distingem clar diferența dintre metodele pop(pozitie) și remove (valoare): prima dintre ele șterge după poziție și returnează elementul șters, iar cea de-a doua șterge după valoare și returnează None.

L = [12, 7, 10, 18, 10, 9, 10] print(f"Lista inițială: {L}\n") x = 10 while True: try: L.remove(x) print(f"Lista modificată: {L}") except ValueError: break print(f"Lista finală: {L}")

7. Metoda index() Metoda index(x) returnează prima poziție dintr-o listă pe care apare valoarea x sau lansează eroarea ValueError dacă valoarea x nu există în listă.

Exemplu: Cod sursă L = [12, 7, 10, 18, 10] print(f"Lista inițială: {L}\n") try:

x = 10 p = L.index(x) print(f"Valoarea {x} apare " f"pe poziția {p} în L!")

x = 1000 p = L.index(x) print(f"Valoarea {x} apare " f"pe poziția {p} în L!") except ValueError: print(f"Valoarea {x} nu apare în L!")

Rezultatul executării Lista inițială: [12, 7, 10, 18, 10]

Valoarea 10 apare pe poziția 2 în L! Instrucțiunea p=L.index(x) va genera o eroare pentru x = 1000, instrucțiunea print nu se va mai executa!

Valoarea 1000 nu apare în L!

OBSERVĂ Dacă valoarea x apare de mai multe ori în listă, metoda index(x) nu va returna toate pozițiile, ci doar pe prima.

8. Metoda count() Metoda count(x) determină de câte ori apare valoarea x în listă. De exemplu, pentru lista L = [7, 10, 7, 9, 7, 8], instrucțiunea print(L.count(7)) va afișa valoarea 3.

OBSERVĂ Metoda count() este foarte utilă pentru a afla numărul aparițiilor unei valori într-o listă, fără să scriem noi o parcurgere completă.

124

9. Greșeli frecvente În lucrul cu metodele clasei list apar frecvent următoarele greșeli: ◗ se scrie L = L.append(x), deși append() modifică direct lista și returnează valoarea None; ◗ se confundă pop() cu remove(); ◗ se presupune că remove(x) șterge toate aparițiile lui x.

REȚINE! ◗ Metoda append(x) adaugă valoarea x la sfârșitul listei; ◗ Metoda insert(poz, x) inserează valoarea x înaintea poziției poz; ◗ Metoda pop() șterge și returnează ultimul element al listei, iar metoda pop(poz) șterge și returnează elementul de pe poziția poz; ◗ Metoda remove(x) șterge prima apariție a valorii x; ◗ Metoda index(x) returnează poziția primei apariții a valorii x; ◗ Metoda count(x) returnează numărul de apariții ale valorii x; ◗ Unele metode modifică lista, iar altele doar returnează informații despre aceasta; ◗ O metodă care modifică direct o listă, în general, returnează valoarea None, deci nu trebuie utilizată într-o instrucțiune de atribuire.

P ORTOFOLIU DIGITAL Carnetul de note – listă de note în interfață grafică Organizare

Creează folderul: Portofoliu digital > Capitolul 5 > Carnetul de note > Tema 9 - Lista de note in interfata grafica.

Cerința 1

Pornește de la aplicația carnet_note_tkinter.py realizată la Tema 8 și creează o versiune nouă: carnet_note_liste_tkinter.py.

Cerința 2

Aplicația va avea o fereastră Tkinter cu titlul Carnetul de note - liste, o etichetă de titlu, o casetă Entry pentru introducerea unei note și o etichetă în care se afișează lista curentă de note.

Cerința 3

Adaugă un buton Adauga nota. La apăsarea lui, nota introdusă este preluată cu get(), validată ca număr între 1 și 10 și adăugată într-o listă Python folosind metoda append().

Cerința 4

După fiecare adăugare, aplicația va actualiza eticheta de rezultat și va afișa lista notelor introduse până în acel moment.

Cerința 5

Cerința 6

Cerința 7 Cerința 8 Salvează Document

Adaugă un buton Analizeaza lista, la apăsarea lui, aplicația va afișa: numărul de note, suma notelor, media, nota minimă, nota maximă, numărul notelor de promovare și numărul notelor sub 5.

Adaugă un buton Sterge ultima nota. La apăsarea lui, dacă lista nu este vidă, se elimină ultima notă folosind pop(). Dacă lista este vidă, se afișează un mesaj de eroare folosind messagebox. showerror().

Adaugă un buton Goleste lista , care șterge toate notele memorate în lista curentă și actualizează eticheta de afișare.

Organizează componentele într-un Frame și folosește grid() pentru formular. carnet_note_liste_tkinter.py Realizează un document scurt în care explici ce ai adăugat față de aplicația Tkinter din Tema 8, cum ai folosit lista de note și ce rol au metodele append() și pop(). Adaugă o captură de ecran sau descrie aspectul aplicației. Nume recomandat: tema9_prezentare.docx.

125

Exersează!

1. Numim o „rotație spre stânga” a elementelor unei liste, mutarea primului element la sfârșitul listei. Indicați instrucțiunea care poate înlocui punctele de suspensie astfel încât după două rotații la stânga, lista v să devină [3, 4, 5, 1, 2]. v = [1, 2, 3, 4, 5] for i in range(2): # Scoatem primul element din listă (de la indexul 0) primul = v.pop(0) # Îl adăugăm înapoi la sfârșitul listei …………. print(v)

# Trebuie să afișeze: [3, 4, 5, 1, 2]

A) v.insert(0, primul)

B) v.append(i)

C) v.append(primul)

D) v.insert(-1, primul)

2. Un autobuz școlar are lista opririlor memorată prin coduri numerice. Din greșeală, o oprire nouă nu a fost trecută la poziția corectă. Se consideră lista: opriri = [12, 18, 25, 40]. Inserați codul 22 pe poziția potrivită, astfel încât lista să rămână ordonată crescător. Afișați lista obținută.

3. Într-o aplicație de livrări, comenzile sunt memorate într-o listă, în ordinea în care au fost primite. Ultima comandă introdusă trebuie anulată, iar codul ei trebuie afișat separat. Se consideră lista comenzi = [301, 318, 325, 340, 356]. Eliminați ultima comandă folosind metoda potrivită și afișați codul comenzii anulate și lista comenzilor rămase.

4. Un sistem de monitorizare primește o listă de coduri de alertă. Codul 404 a fost introdus greșit o singură dată și trebuie eliminat din listă. Dacă apare de mai multe ori, se elimină doar prima apariție. Se consideră lista alerte = [200, 404, 301, 404, 500]. Eliminați prima apariție a codului 404 și afișați lista rămasă.

5. Într-o platformă educațională, un elev rezolvă mai multe exerciții. Fiecare exercițiu are un cod numeric. Unele exerciții pot fi încercate de mai multe ori. Se citește un număr natural n, apoi n coduri de exerciții. Se mai citește un cod c. Construiți lista codurilor citite, apoi afișați: ◗ de câte ori apare codul c; ◗ poziția primei apariții a codului c, dacă acesta apare în listă; ◗ mesajul "Cod absent", dacă valoarea c nu apare în listă.

Exemplu: pentru n = 6, codurile 12, 15, 12, 20, 18, 12 și c = 12, se afișează: Codul apare de 3 ori.

Prima apariție este pe poziția 0.

126

V.5. Generarea sistematică a elementelor unei liste.

Alte metode ale clasei list În lecția anterioară am studiat primele metode importante ale clasei list: append(), insert(), pop(), remove(), index() și count(). Am observat că unele metode modifică direct lista, iar altele oferă informații despre aceasta. În această lecție vom continua studiul metodelor clasei list și vom introduce o idee foarte

importantă pentru problemele algoritmice: generarea sistematică a elementelor unei liste.

1. Metoda copy() Metoda copy() creează o copie a unei liste.

Aceasta este utilă atunci când dorim să păstrăm lista inițială, să lucrăm separat pe o copie sau să comparăm lista inițială cu o variantă modificată.

Exemplu: Cod sursă # instanțiem lista inițială L1 = [8, 10, 7, 9] # construim o copie a listei L2 = L1.copy() # modificăm copia L2[1] = 6 # afișăm cele două liste print(" Lista inițială:", L1) print("Copia modificată:", L2)

Explicații: Instrucțiunea L2 = L1.copy() creează o nouă listă, cu aceleași elemente ca lista L1. După această instrucțiune, listele L1 și L2 conțin aceleași valori, dar sunt distincte. Când modificăm L2[1] = 6, se schimbă doar lista L2, nu și lista L1.

Rezultatul executării Lista inițială: [8, 10, 7, 9] Copia modificată: [8, 6, 7, 9]

2. Metoda sort() Metoda sort() ordonează elementele unei liste în ordine crescătoare. Dacă se dorește sortarea listei în ordine descrescătoare, atunci se setează parametrul reverse la valoarea True (implicit, acest parametru are valoarea False).

OBSERVĂ Metoda copy() este utilă când vrem să păstrăm datele inițiale și să lucrăm pe o variantă separată.

De exemplu, în unele probleme, dorim să sortăm o listă, dar să o păstrăm și în forma inițială.

Explicații: Dacă dorim să sortăm o listă, dar și să o păstrăm în varianta inițială, putem utiliza metoda copy() pentru a crea o copie a listei inițiale pe care să o sortăm.

Exemplu: Cod sursă # lista inițială L = [7, 10, 8, 9, 6, 10, 8] # construim două copii ale listei L C1 = L.copy() C2 = L.copy() # ordonăm crescător copia C1 C1.sort() # ordonăm descrescător copia C2 C2.sort(reverse=True) # afișăm cele 3 liste print(f" Lista L: {L}\n") print(f"Copia C1: {C1}\n") print(f"Copia C2: {C2}")

Rezultatul executării Lista L: [7, 10, 8, 9, 6, 10, 8] Copia C1: [6, 7, 8, 8, 9, 10, 10] Copia C2: [10, 10, 9, 8, 8, 7, 6]

REȚINE! ◗ Metoda sor t() modifică direct lista și returnează valoarea None, deci nu trebuie folosită cu o atribuire de forma L = L.sort().

127

3. Metoda reverse() Metoda reverse() inversează ordinea elementelor unei liste.

De exemplu, considerând lista L = [3, 9, 6, 1, 5], după executarea instrucțiunii L.reverse() aceasta va deveni [5, 1, 6, 9, 3].

REȚINE! ◗ Metoda reverse() nu sortează o listă, ci doar inversează ordinea actuală a elementelor.

4. Repere pentru alte metode ale clasei list Pe măsură ce lucrăm mai mult cu liste, vom întâlni și alte metode utile. Nu este necesar să le învățăm toate deodată, dar este important să știm cum le identificăm, ce întrebări trebuie să ne punem despre ele și cum le putem integra într-o problemă. În ultimele două lecții am studiat deja metodele append(), insert(), pop(), remove(), index(), count(), copy(), sort() și reverse(). Aceste metode sunt suficiente pentru rezolvarea multor probleme de nivel mediu.

Atunci când întâlnim o metodă nouă a clasei list, este bine să răspundem la următoarele întrebări: 1. Metoda modifică lista sau doar returnează un rezultat?

2. Ce argumente primește metoda?

3. Ce efect are metoda asupra elementelor listei?

4. În ce tip de probleme este utilă metoda respectivă?

De exemplu, metoda count(x) nu modifică lista, primește o valoare x, returnează numărul de apariții ale valorii x în listă și este utilă în probleme de numărare.

Fără a insista acum asupra lor, este util să știm că există și alte metode ale clasei list, cum ar fi clear() și extend(). Metoda clear() șterge toate elementele listei, iar metoda extend() adaugă la sfârșitul listei toate elementele unei alte liste date ca parametru.

Exemplul 1:

Metoda clear() L = [4, 7, 9] L.clear() print(L) # []

Metoda extend() L1 = [2, 4, 10] L2 = [6, 8] L1.extend(L2) print(L1)

#[2, 4, 10, 6, 8]

Generarea sistematică a elementelor unei liste În multe probleme, lista nu este citită din exterior, ci este construită după o regulă clară. Această construcție poartă numele de generare sistematică.

Vom studia trei tipuri frecvente de generare: liste construite din valori cu proprietăți date, liste construite din expresii matematice și liste construite recurent.

5. Generarea unei liste folosind expresii matematice Putem construi o listă ale cărei elemente sunt valori calculate printr-o formulă.

Exemplul 2: Pătratele numerelor de la 1 la n Se citește un număr natural nenul n . Să se construiască lista pătratelor numerelor de la 1 la n.

Cod sursă # citim numărul natural nenul n n = int(input("n = ")) # inițial, lista L este vidă L = [] # generăm pătratele numerelor de la 1 la n # și le adăugăm în lista L for i in range(1, n + 1): L.append(i * i) # afișăm lista print(L)

128

Explicații Pentru n = 7 se va afișa lista [1, 4, 9, 16, 25, 36, 49]

6. Generarea unei liste având elemente cu proprietăți date Uneori dorim să construim doar valorile care respectă o anumită proprietate.

Exemplul 3: Numerele cuprinse între 1 și n care se divid cu 6, dar nu se divid cu 7 Se citește un număr natural n ≥ 6. Să se construiască lista numerelor naturale cuprinse între 1 și n cu proprietatea că se divid cu 6, dar nu se divid cu 7.

De exemplu, pentru n = 50 lista va fi [6, 12, 18, 24, 30, 36, 48].

Rezolvare: n = int(input("n = ")) lista = [] for x in range(1, n+1): if x % 6 == 0 and x % 7 != 0: lista.append(x) print(f"Lista: {lista}")

OBSERVĂ 7. Generarea unei liste pe baza cifrelor unui număr O listă poate fi construită și din cifrele unui număr.

Exemplul 4: Cifrele unui număr, în ordinea lor naturală Se citește un număr natural nenul. Să se construiască lista cifrelor sale, în ordinea în care apar în scrierea numărului. De exemplu, pentru n = 21537446 se va construi lista [2, 1, 5, 3, 7, 4, 4, 6].

Explicații: Cifrele sunt obținute inițial de la dreapta la stânga: ultima cifră, penultima cifră și așa mai departe. De aceea, după construire, lista trebuie inversată pentru a corespunde ordinii naturale a cifrelor în număr.

Aici nu mai generăm toate valorile, ci doar pe cele care respectă o condiție.

Rezolvare: # citim numărul n = int(input("n = ")) # listă pentru cifrele numărului L = [] # extragem cifrele de la dreapta la stânga while n != 0: c = n % 10 L.append(c) n = n // 10 # inversăm lista pentru a obține ordinea naturală L.reverse() # afișăm lista print(L)

8. Generarea unei liste folosind un șir recurent Unele liste pot fi construite astfel încât fiecare termen să depindă de termeni anteriori. Un șir recurent este un șir de numere în care termenii se calculează pe baza unor termeni anteriori. Pentru un astfel de șir, trebuie să știm valorile de pornire și regula după care obținem termenii următori. Un exemplu cunoscut este șirul lui Fibonacci.

Acesta pornește cu termenii 0 și 1, iar fiecare termen următor se obține adunând cei doi termeni dinaintea lui.

Exemplul 5: Un șir recurent simplu Se citesc numerele naturale n , x și y (n≥3). Să se construiască o listă cu n elemente care se obțin astfel: primele două elemente sunt x și y, iar orice alt element este suma celor două elemente anterioare.

De exemplu, pentru n = 8, x = 6 și y = 7 se va construi lista [6, 7, 13, 20, 33, 53, 86, 139].

Explicații: Lista începe cu cele două elemente cunoscute.

Pentru fiecare element nou, folosim elementele anterioare din listă: L[i - 2] și L[i - 3]. Considerând x = 0 și y = 1, lista va conține chiar primii n termeni ai șirului lui Fibonacci!

Rezolvare: # citim datele de intrare

n = int(input("n = ")) x = int(input("x = ")) y = int(input("y = "))

# construim lista cu primii doi termeni L = [x, y] # generăm termenii următori for i in range(3, n + 1): element = L[i - 2] + L[i - 3] L.append(element) # afișăm lista obținută print(f"Lista: {L}")

129

9. Exemplu aplicativ – Generare și prelucrare Se citește un număr natural nenul n. Să se con­ struiască lista divizorilor săi, apoi să se determine suma elementelor acestei liste.

OBSERVĂ În multe probleme, generarea listei este doar primul pas al algoritmului. După aceea urmează prelucrarea propriu-zisă a elementelor listei generate.

Explicații: Pentru ca algoritmul să fie mai eficient, am verificat doar posibilii divizori cuprinși între 1 și n//2, iar la sfârșit am adăugat și valoarea n în listă.

Rezolvare: # citim numărul n n = int(input("n = ")) # construim lista divizorilor L = [] for d in range(1, n//2 + 1): if n % d == 0: L.append(d) L.append(n) # calculăm suma elementelor listei s = sum(L) # afișăm rezultatele print(f"Lista obtinuta: {L}") print(f"Suma elementelor listei: {s}")

10. Greșeli frecvente În utilizarea metodelor specifice listelor și în generarea acestora apar frecvent următoarele greșeli: ◗ se scrie L = L.sort(), deși metoda sort() modifică direct lista și returnează None; ◗ se presupune că funcția sorted() modifică lista inițială; ◗ se confundă metoda reverse() cu sort(reverse=True); ◗ se folosesc în mod inadecvat metode care modifică o listă, deși lista inițială trebuia păstrată; ◗ se încearcă folosirea unor indici inexistenți când se generează recurent elementele unei liste.

REȚINE! ◗ Metoda copy() creează o copie a listei; ◗ Metoda sort() este o metodă a clasei list care sortează direct o listă; ◗ Funcția sorted() este o funcție predefinită care returnează o listă nouă obținută prin sortarea elementelor altei liste, iar lista inițială rămâne nemodificată; ◗ Atât metoda sort(), cât și funcția sorted() pot ordona elementele unei liste atât crescător (implicit), cât și descrescător; ◗ Este important să distingem între metodele clasei list și funcțiile predefinite care lucrează cu liste.

Exersează!

1. Se consideră lista: L = [12, 5, 18, 9]. Realizați o copie a listei și modificați primul element al copiei cu valoarea 100. Afișați ambele liste.

2. Se consideră lista: L = [8, 3, 10, 5]. Ordonați lista și apoi inversați ordinea elementelor.

3. Se citește un număr natural nenul n. Construiți lista numerelor impare din intervalul [1, n].

4. Un sistem de acces primește un cod numeric n. Pentru verificare rapidă, tehnicianul vrea să extragă doar cifrele pare ale codului, păstrate în ordinea în care apar. Se citește un număr natural nenul n. Construiți lista cifrelor pare ale lui n, în ordinea lor naturală, și afișați lista. Exemplu: pentru n = 583204, lista obținută este [8, 2, 0, 4].

5. Se citesc de la tastatură trei numere naturale nenule n, a1 și a2. Construiți o listă cu n termeni, unde primii doi termeni sunt a1 și a2, iar fiecare termen următor se calculează după regula: pentru orice poziție i≥3, termenul ai se calculează după relația ai=2.ai−1−ai−2. Afișați lista obținută, apoi afișați și o copie a ei în ordine inversă, fără să modificați lista inițială. Exemplu: pentru n = 5, a1 = 3, a2 = 5, lista este [3, 5, 7, 9, 11].

130

V.6. Metode de sortare a elementelor unei liste În lecțiile anterioare am învățat cum se construiesc și se prelucrează liste numerice. Am văzut cum pot fi citite, modificate, copiate și generate sistematic. În multe probleme, însă, nu este suficient să cunoaștem elementele unei liste. Este important și să le putem așeza într-o anumită ordine.

Operația de sortare reprezintă procesul de reorganizare a elementelor unei liste într-o anumită ordine, pe baza unui criteriu stabilit. Cel mai frecvent, elementele sunt ordonate crescător sau descrescător, pentru a facilita căutarea, compararea și prelucrarea datelor.

De exemplu, lista [12, 5, 18, 9, 14] poate fi sortată crescător și devine [5, 9, 12, 14, 18] sau poate fi sortată descrescător și devine [18, 14, 12, 9, 5]. În această lecție vom lucra în principal cu sortarea crescătoare.

Sortarea unei liste este un pas important în multe probleme de informatică, fiind utilă în următoarele cazuri: ◗ realizarea unui clasament sau a unui top pe baza unor criterii (clasamentul participanților la un concurs, top 10 al celor mai bine vândute produse într-un magazin online etc.); ◗ identificarea celor mai bune sau celor mai slabe rezultate (primii și ultimii 3 elevi clasați la un concurs); ◗ interpretare unor date și realizarea unor statistici; ◗ compararea unor liste; ◗ căutarea eficientă a unor valori.

Ideea generală a sortării Dacă lista nu este ordonată, elementele ei trebuie mutate în poziții noi. În cazul unei liste numerice, sortarea crescătoare urmărește ca elementele mai mici să ajungă spre începutul listei, iar elementele mai mari să ajungă spre finalul listei. Acest lucru se obține printr-o succesiune de comparații și interschimbări.

1. Sortarea prin selecția minimului Ideea metodei În algoritmul de sortare prin selecția minimului, lista se împarte la fiecare pas în două părți: partea sortată și partea nesortată. Partea sortată conține elementele care au fost deja așezate în ordine și nu mai trebuie modificate, iar partea nesortată conține elementele care urmează să fie analizate și ordonate.

La fiecare pas, algoritmul caută cel mai mic element din partea nesortată și îl mută la începutul acesteia, adică imediat după partea deja sortată. Astfel, după fiecare etapă, partea sortată crește cu un element, iar partea nesortată se micșorează până când întreaga listă devine ordonată.

Exemplul 1: Considerăm lista de numere întregi L = [4, 2, 5, 1] și urmărim fiecare pas al algoritmului de sortare prin selecția minimului: Pas

Partea nesortată

Minimul găsit

Operația efectuată

Partea sortată

Lista curentă

0

[4, 2, 5, 1]

―

―

[]

[4, 2, 5, 1]

1

[4, 2, 5, 1]

1

se interschimbă 4 cu 1

[1]

[1, 2, 5, 4]

2

[2, 5, 4]

2

se interschimbă 2 cu 2

[1, 2]

[1, 2, 5, 4]

3

[5, 4]

4

se interschimbă 5 cu 4

[1, 2, 4]

[1, 2, 4, 5]

OBSERVĂ Pentru o listă cu n elemente (în exemplul de mai sus avem n=4), algoritmul efectuează mereu n-1 pași (respectiv 3 pași în exemplul de mai sus ). Ultimul element rămas (elementul cu valoarea 5) va fi poziționat automat pe poziția corectă.

131

Program Python – sortarea prin selecția minimului # citim numărul de elemente din listă n = int(input("n = ")) # citim elementele listei L = [] for i in range(n): x = int(input(f"L[{i}] = ")) L.append(x) # afișăm lista inițială print(f"Lista inițială: {L}") # parcurgem pozițiile pe care trebuie așezate valorile minime for i in range(n - 1): # presupunem că elementul de pe poziția i este minimul poz_min = i # căutăm poziția minimului din partea nesortată

for j in range(i + 1, n): if L[j] < L[poz_min]: poz_min = j

# interschimbăm elementul curent cu minimul găsit

L[i], L[poz_min] = L[poz_min], L[i]

# afișăm lista sortată print(f"Lista sortată crescător: {L}")

Caracteristicile metodei Sortarea prin selecția minimului are avantajul că este ușor de înțeles și implementat. Totuși, chiar dacă lista este aproape ordonată, metoda continuă să caute minimul în partea rămasă. De aceea, nu este întotdeauna cea mai rapidă metodă.

2. Metoda bulelor (Bubblesort) Ideea metodei Metoda bulelor pentru sortarea crescătoare a unei liste L se bazează pe comparații între elemente vecine, astfel: ◗ la fiecare pas presupunem că lista a devenit sortată (o variabilă booleană sortata = True); ◗ parcurgem lista L și comparăm fiecare pereche de elemente alăturate din listă, respectiv L[i] și L[i+1]; ◗ dacă ele nu sunt în ordinea corectă, adică L[i] > L[i+1], atunci le interschimbăm, iar variabila sortata=False, deoarece am efectuat o interschimbare (deci presupunerea că lista L era sortată nu este adevărată); ◗ dacă la sfârșitul unei parcurgeri a listei L variabila sortata are valoarea False, atunci reluăm pașii de mai sus deoarece lista nu era sortată, altfel (variabila sortata are valoarea True) algoritmul se termină deoarece nu s-a mai efectuat nicio interschimbare, deci lista este sortată.

După o parcurgere completă, cel mai mare element „urcă” spre sfârșitul listei, asemenea unei bule care se ridică la suprafața apei. De aici vine numele metodei.

Exemplul 2: Considerăm lista de numere întregi L = [12, 5, 18, 9, 14] și urmărim fiecare pas al algoritmului Bubblesort: ◗ La prima parcurgere lista este L = [12, 5, 18, 9, 14]. Elementele alăturate sunt comparate două câte două. Se fac interschimbări între 12 și 5, apoi între 18 și 9, respectiv 18 și 14. La finalul acestei parcurgeri, lista devine [5, 12, 9, 14, 18], iar cel mai mare element, 18, ajunge pe ultima poziție. ◗ La a doua parcurgere, lista L = [5, 12, 9, 14, 18] este verificată din nou. Singura interschimbare necesară este între 12 și 9, iar lista devine [5, 9, 12, 14, 18]. Chiar dacă lista a devenit sortată, algoritmul mai are nevoie de încă o parcurgere pentru a verifica acest lucru.

132

◗ La a treia parcurgere, lista este [5, 9, 12, 14, 18] și nu mai are loc nicio interschimbare, deoarece toate elementele sunt deja în ordine crescătoare. Variabila sortata rămâne True, ceea ce arată că lista este sortată, iar algoritmul se oprește. Rezultatul final este [5, 9, 12, 14, 18].

Program Python – metoda bulelor # citim lista n = int(input("n = ")) L = [0] * n for i in range(n): L[i] = int(input(f"L[{i}] = ")) print(f"Lista inițială: {L}") sortata = False # presupunem că lista nu este sortată # parcurgem lista cât timp nu este sortată while not sortata: # la fiecare parcurgere presupunem că lista este sortată sortata = True for i in range(n - 1): # dacă două elemente alăturate nu sunt în ordine # le interschimbăm și variabila sortata devine False if L[i] > L[i + 1]: L[i], L[i + 1] = L[i + 1], L[i] sortata = False print(f"Lista sortată crescător: {L}")

3. Compararea celor două metode de sortare prezentate Sortarea prin selecția minimului ◗ caută cel mai mic element din partea nesortată; ◗ la fiecare pas plasează minimul pe poziția corectă; ◗ este intuitivă și ușor de implementat.

Metoda bulelor

REȚINE! ◗ Ambele metode de sortare prezentate sunt utile pentru învățare, deoarece dezvoltă gândirea algoritmică și înțelegerea prelucrării listelor.

◗ compară elemente vecine; ◗ la fiecare parcurgere, împinge elementele mari spre final; ◗ este intuitivă și ușor de implementat.

Exemplul 3: Clasamentul participanților la un concurs de informatică Vom scrie un program care citește de la tastatură punctajele obținute de n elevi la un concurs de informatică și un număr natural k (1 ≤ k ≤ [n/2]), iar apoi afișează cele mai mari k punctaje și cele mai mici k punctaje.

De exemplu, dacă punctajele elevilor sunt 85, 40, 92, 67, 100, 55, 73, 30, 96, 61 și k = 3, atunci cele mai mari 3 punctaje sunt 100, 96, 92, iar cele mai mici 3 punctaje sunt 55, 40, 30.

Rezolvare: Vom sorta crescător lista cu punctaje, după care vom afișa primele 3 valori (cele mai mici) și ultimele 3 valori (cele mai mari).

133

# citim numărul de elevi participanți nr_elevi = int(input("Numarul de elevi: ")) # citim punctajele elevilor punctaje = [] for i in range(nr_elevi): p = int(input(f"Punctajul elevului {i+1}: ")) punctaje.append(p) nr_elevi = len(punctaje) k = int(input("k = "))

# sortăm lista folosind metoda selecției minimului for i in range(nr_elevi - 1): poz_min = i for j in range(i + 1, nr_elevi): if punctaje[j] < punctaje[poz_min]: poz_min = j punctaje[i], punctaje[poz_min] = punctaje[poz_min], punctaje[i] print(punctaje) # afișăm punctajele cerute print(f"Cele mai mari {k} punctaje: {punctaje[-k:][::-1]}") print(f"Cele mai mici {k} punctaje: {punctaje[:k]}")

OBSERVĂ Sortarea unei liste este adesea doar un pas intermediar într-o problemă mai complexă.

4. Greșeli frecvente ◗ Se confundă poziția minimului cu valoarea minimă; ◗ Se omite interschimbarea; ◗ Se compară greșit elementele vecine în metoda bulelor; ◗ Se parcurge greșit intervalul indicilor; ◗ Se folosește sort() în locul algoritmului cerut, atunci când problema solicită explicit o metodă de sortare.

REȚINE! ◗ ◗ ◗ ◗ ◗

134

Sortarea așază elementele listei într-o anumită ordine; Sortarea prin selecția minimului fixează la fiecare pas minimul pe poziția corectă; Metoda bulelor compară elemente vecine și interschimbă valorile care nu sunt în ordinea corectă; Ambele metode folosesc parcurgeri repetate ale listei; Sortarea este o prelucrare fundamentală și apare frecvent în probleme practice.

P ORTOFOLIU DIGITAL Carnetul de note – salvarea și încărcarea listei din fișier Organizare

Creează folderul: Portofoliu digital > Capitolul 5 > Carnetul de note > Tema 10.

Cerința 1

Pornește de la aplicația carnet_note_liste_tkinter.py realizată la Tema 9 și creează versiunea carnet_note_liste_fisiere.py.

Cerința 2

Adaugă un buton Salveaza lista. La apăsarea lui, toate notele din lista curentă vor fi scrise în fișierul note_curente.txt, câte o notă pe fiecare linie.

Cerința 3

Adaugă un buton "Adauga in istoric". La apăsarea lui, programul va deschide fișierul istoric_note.txt în modul „a” și va adăuga o înregistrare nouă cu lista notelor, media, minimul, maximul și mesajul "promovat" sau "nepromovat".

Cerința 4

Adaugă un buton "Incarca note". La apăsarea lui, programul va citi notele din fișierul note_curente.txt, le va memora într-o listă și va actualiza afișarea din interfață.

Cerința 5 Cerința 6

Cerința 7 Cerința 8 Salvează Document

Valorile din fișier vor fi citite linie cu linie. Fiecare valoare citită va fi convertită la float sau int, după caz, apoi adăugată în listă cu append().

Programul va trata erorile de fișier, de exemplu situația în care note_curente.txt nu există, folosind try...except și messagebox.showerror().

Adaugă un buton "Afișează istoric", care citește conținutul fișierului istoric_note.txt și îl afișează într-o zonă Text sau într-o fereastră de mesaj.

Organizează codul în funcții. Poți folosi funcții pentru: salvarea listei, încărcarea listei, calcularea raportului, adăugarea în istoric și afișarea istoricului. carnet_note_liste_fisiere.py, note_curente.txt, istoric_note.txt Realizează un document scurt în care explici cum ai combinat listele cu fișierele text. Precizează diferența dintre scrierea cu „w” și adăugarea cu „a”. Adaugă un exemplu de conținut pentru note_curente.txt și un exemplu de înregistrare din istoric_note.txt.

Exersează!

1. Se citesc n timpi, exprimați în secunde, realizați de concurenții de la un concurs de alergare. Memorați timpii într-o listă și sortați lista crescător prin selecția minimului. Afișați lista sortată și cel mai bun timp.

Exemplu: pentru n = 5 și valorile 58, 51, 63, 49, 55, se afișează lista [49, 51, 55, 58, 63], iar cel mai bun timp este 49.

2. O aplicație de livrări primește n durate de livrare, exprimate în minute. Memorați valorile într-o listă și sortați-le crescător prin metoda bulelor. Afișați lista sortată și numărul de parcurgeri efectuate.

Exemplu: pentru n = 5 și valorile 20, 18, 18, 25, 21, lista sortată este [18, 18, 20, 21, 25].

3. Într-un joc educațional, se citesc n scoruri. Sortați lista descrescător folosind o adaptare a selecției maximului și afișați primele 3 scoruri. Dacă sunt mai puțin de 3 scoruri, afișați toate scorurile.

Exemplu: pentru n = 6 și scorurile 120, 95, 150, 150, 80, 110, se afișează 150 150 120.

4. La un festival, fiecare stand primește un număr de vizitatori. Se citesc n valori într-o listă. Sortați lista crescător printr-o metodă la alegere dintre cele studiate și afișați diferența dintre cea mai aglomerată și cea mai puțin aglomerată zonă.

Exemplu: pentru n = 5 și valorile 240, 180, 310, 220, 180, se afișează 130.

5. Un profesor citește n note obținute la un test. Sortați lista crescător prin metoda bulelor, apoi afișați lista fără nota minimă și fără nota maximă. Dacă lista are mai puțin de 3 elemente, afișați mesajul "Date insuficiente".

Exemplu: pentru n = 6 și notele 8, 5, 10, 7, 9, 5, după eliminare se afișează [5, 7, 8, 9].

135

V.7. Liste de frecvențe. Sortarea cu listă de frecvențe În lecțiile anterioare am studiat clasa list, metodele sale și doi algoritmi clasici de sortare: sortarea prin selecția minimului și metoda bulelor. În această lecție introducem o idee foarte importantă pentru prelucrarea datelor numerice dintr-un interval cunoscut: lista de frecvențe.

O listă de frecvențe este utilă atunci când valorile posibile sunt numere naturale dintr-un interval relativ restrâns și cunoscut de la început. În acest caz, în loc să căutăm sau să comparăm elementele între ele de foarte multe ori, putem memora de câte ori apare fiecare valoare.

O listă de frecvențe este o listă în care fiecare poziție corespunde unei valori posibile, iar pe acea poziție memorăm de câte ori apare valoarea respectivă.

De exemplu, să considerăm lista numerică [3, 1, 4, 3, 2, 4, 3]. Valorile care apar sunt numere naturale din intervalul [1, 4]: ◗ ◗ ◗ ◗

valoarea 1 apare o dată; valoarea 2 apare o dată; valoarea 3 apare de 3 ori; valoarea 4 apare de 2 ori.

Dacă folosim o listă F astfel încât F[x] să memoreze frecvența valorii x, atunci F[1] = 1, F[2] = 1, F[3] = 3 și F[4] = 2.

OBSERVĂ Lista de frecvențe nu păstrează ordinea inițială a elementelor, ci doar informații despre numărul de apariții ale fiecărei valori.

REȚINE! Lista de frecvențe este utilă atunci când valorile sunt numere naturale, cunoaștem intervalul în care se află, intervalul este restrâns și avem nevoie să cunoaștem numărul de apariții ale fiecărei valori din interval.

De exemplu, câteva situații în care se utilizează liste de frecvență sunt următoarele: ◗ notele unui elev, deoarece sunt numere naturale cuprinse între 1 și 10; ◗ cifrele unui număr, deoarece sunt numere naturale cuprinse între 0 și 9; ◗ frecvențele unor numere naturale formate din maxim 4 cifre (de exemplu, codurile unor produse pentru a monitoriza vânzările sau stocurile); ◗ eliminarea rapidă a duplicatelor dintr-o listă cu numere naturale formate din maxim 4 cifre.

Dacă valorile ar putea fi foarte mari, de exemplu între 1 și 1.000.000, atunci o listă de frecvențe ar ocupa prea mult spațiu de memorie și nu ar mai fi convenabilă.

1. Construirea unei liste de frecvențe Pentru a construi o listă de frecvențe, parcurgem lista dată element cu element și actualizăm în lista de frecvențe numărul aparițiilor elementului curent.

Exemplul 1: Frecvențele unor note Se consideră lista L = [7, 10, 8, 7, 9, 10, 7]. Deoarece notele sunt numere naturale cuprinse între 1 și 10, utilizăm o listă de frecvențe F (în care F[x] reprezintă numărul aparițiilor notei x în lista L) cu pozițiile 0, 1, 2, ..., 10.

Deși notele utile sunt de la 1 la 10, este mai simplu să folosim direct poziția egală cu nota. # citim numărul de note n = int(input("Numarul de note: ")) # citim cele n note L = [] for i in range(n): x = int(input("Nota: ")) L.append(x)

136

# creăm o listă de frecvențe F formată din 11 valori egale cu 0, # deoarece, inițial, toate notele au frecvența 0 F = [0] * 11 # parcurgem lista de note element cu element și # actualizăm numărul de apariții ale notei curente for nota in L: F[nota] += 1

OBSERVĂ Dacă avem mai multe întrebări de tipul „De câte ori apare nota x?”, atunci o listă de frecvențe ar fi foarte convenabilă.

# afișăm frecvențele notelor de la 1 la 10 # care apar cel puțin o dată în lista L for nota in range(1, 11): if F[nota] > 0: print(f"Nota {nota} apare de {F[nota]} ori") Exemplul 2: Valorile distincte ale unei liste Într-un magazin, fiecare produs are un cod numeric de la 1 la 9. În fișierul vanzari.txt se află, pe prima linie, un număr natural n, iar pe următoarele n linii se află codurile produselor vândute într-o zi. Să se scrie un program care citește datele din fișier și afișează codurile produselor care nu s-au vândut deloc în acea zi sau un mesaj corespunzător dacă s-au vândut toate produsele.

De exemplu, dacă fișierul vanzari.tx t conține numerele 8, 3, 5, 7, 3, 8, 2, 7, 3, fiecare pe câte un rând, atunci se va afișa mesajul Produsele nevândute: 1 4 6 9.

Rezolvare: # Deschidem fișierul pentru citire f = open("vanzari.txt", "r") # Citim numărul de vânzări înregistrate n = int(f.readline()) # Inițializăm lista de frecvențe cu 10 valori egale cu 0 # Vom folosi doar pozițiile 1, 2, ..., 9 pentru codurile produselor. frecventa = [0] * 10 # Citim pe rând codurile produselor vândute for i in range(n): cod = int(f.readline()) # Creștem frecvența produsului cu codul citit

frecventa[cod] += 1

# Închidem fișierul după ce am terminat citirea f.close() Explicații: Lista frecventa memorează numărul de apariții pentru fiecare cod de produs. După citirea tuturor codurilor din fișier, parcurgem codurile posibile de la 1 la 9, iar dacă frecventa[cod] == 0, produsul respectiv nu apare în fișier, deci nu a fost vândut în acea zi.

# Dacă nicio frecvență nu a rămas egală cu 0, # înseamnă că s-au vândut toate produsele if frecventa[1:10].count(0) == 0: print("Toate produsele au fost vândute!") else: # Afișăm produsele care nu s-au vândut deloc print("Produsele nevândute:", end=" ") for cod in range(1, 10): if frecventa[cod] == 0: print(cod, end=" ")

2. Sortarea cu listă de frecvențe Caracteristicile metodei Sortarea cu listă de frecvențe se aplică atunci când valorile sunt numere naturale și aparțin unui interval mic și cunoscut.

Metoda are două etape: construim lista de frecvențe și reconstruim lista sortată, scriind fiecare valoare de câte ori apare.

Să considerăm lista: [3, 1, 4, 3, 2, 4, 3]. Frecvențele numerelor sunt: 1 pentru valoarea 1, 1 pentru 2, 3 pentru 3, respectiv 2 pentru 4.

Lista sortată crescător va fi: [1, 2, 3, 3, 3, 4, 4]

OBSERVĂ Nu mai comparăm elementele între ele, ci folosim direct informația din frecvențe.

137

Exemplul 3: Sortarea codurilor promoționale Un magazin online organizează o campanie de reduceri. Fiecare produs vândut primește un cod numeric de verificare. Codurile pot avea cel mult 4 cifre. Codurile cu exact două cifre reprezintă produse aflate într-o promoție specială. Se citește un număr natural n, apoi o listă cu n coduri de produse. Să se afișeze, în ordine crescătoare, doar codurile promoționale, adică numerele care au exact două cifre.

De exemplu, pentru: n = 8 și codurile 104, 25, 7, 91, 1000, 13, 8, 25 se vor afișa codurile promoționale 13 25 25 91 sau un mesaj corespunzător dacă nu există niciun cod promoțional.

Cod sursă # citim numărul de coduri n = int(input("n = ")) # inițializăm lista de frecvențe # cu 100 de valori egale cu 0 F = [0] * 100 # citim, pe rând câte un cod # și actualizăm frecvența sa for i in range(n): cod = int(input("Cod: ")) if 10 <= cod <= 99: F[cod] += 1 # verificăm dacă s-a citit cel puțin un cod # promoțional, respectiv există o frecvență nenulă if sum(F[10:100]) == 0: print("Niciun cod promoțional!") else: # afișăm crescător codurile promoționale print("Codurile promoționale:") for cod in range(10, 100): for frecventa in range(F[cod]): print(cod, end=" ")

Explicații În această problemă, codurile de produse sunt citite unul câte unul, fără să le memorăm într-o listă. Sunt contorizate doar codurile promoționale, adică cele formate din exact două cifre.

Pentru sortare, folosim o listă de frecvențe F. Valoarea F[cod] reține de câte ori apare codul respectiv.

După construirea listei de frecvențe, parcurgem codurile posibile de la 10 la 99. Această parcurgere se face deja în ordine crescătoare, deci valorile afișate vor fi sortate crescător.

Dacă un cod are frecvența 0, nu se afișează. Dacă are frecvența 1, se afișează o dată. Dacă are frecvența mai mare decât 1, se afișează de mai multe ori.

3. Avantajele și limitele metodei Avantaje: ◗ este foarte potrivită pentru valori dintr-un interval mic; ◗ nu necesită comparații repetate între elemente; ◗ oferă direct informații despre numărul de apariții; ◗ este utilă și pentru sortare, și pentru analiză statistică simplă.

OBSERVĂ Sortarea cu listă de frecvențe nu înlocuiește celelalte metode de sortare, ci este utilă în anumite situații particulare.

Limite: ◗ nu este convenabilă din punct de vedere al memoriei utilizate dacă valorile pot fi foarte mari; ◗ necesită cunoașterea sau estimarea intervalului valorilor; ◗ nu este potrivită dacă lista conține valori foarte dispersate.

4. Greșeli frecvente ◗ lista de frecvențe este prea scurtă pentru valorile folosite; ◗ se confundă valoarea cu frecvența ei; ◗ se uită inițializarea cu 0 a tuturor elementelor listei de frecvențe; ◗ se încearcă folosirea metodei pentru valori care nu se află într-un interval restrâns; ◗ la reconstrucția listei, se adaugă valoarea x o singură dată, în loc de F[x] ori.

138

REȚINE! ◗ ◗ ◗ ◗ ◗ ◗

Lista de frecvențe memorează de câte ori apare fiecare valoare.

Poziția din lista de frecvențe corespunde valorii analizate.

Lungimea listei de frecvențe trebuie aleasă în funcție de valoarea maximă posibilă.

Lista de frecvențe este utilă pentru numere naturale dintr-un interval mic.

Cu ajutorul ei putem afla rapid frecvențe, valori distincte și valoarea cu frecvență minimă/maximă.

Sortarea cu listă de frecvențe reconstruiește lista ordonată pe baza frecvențelor elementelor.

Exersează!

1. Asociați fiecare element din coloana A cu explicația potrivită din coloana B. Coloana A

Coloana B

1. F[x]

a. listă în care memorăm de câte ori apare fiecare valoare

2. listă de frecvențe

b. valoarea analizată din lista inițială

3. F[x] == 0

c. numărul de apariții ale valorii x

4. x

d. valoarea x nu apare în lista inițială

2. Se citește șirul de valori 2, 4, 2, 5, 4, 2, 0, 3. Valorile sunt numere naturale din intervalul [0, 5]. Construiți lista de frecvențe F corespunzătoare șirului dat, unde F[x] reprezintă numărul de apariții ale valorii x.

3. La un concert, lojele teatrului sunt numerotate de la 1 la 9. Organizatorii memorează într-o listă numerele lojelor pentru care au fost scanate bilete pe parcursul serii. Scrieți un program care citește de la tastatură un număr natural n și apoi cele n numere înregistrate, după care afișează numerele lojelor care au rămas goale sau un mesaj corespunzător dacă nu a rămas nicio lojă goală. De exemplu, pentru n = 10 și numerele 3, 1, 7, 1, 6, 2, 8, 7, 8, 3 se vor afișa lojele 4 5 9.

4. Într-un joc educațional, fiecare exercițiu are un nivel de dificultate de la 1 la 5. Se citește un număr natural n, apoi o listă cu n niveluri ale exercițiilor rezolvate de un elev. Să se determine nivelul de dificultate care apare cel mai des. Dacă există mai multe niveluri cu aceeași frecvență maximă, se va afișa cel mai mic dintre ele.

Exemplu: pentru n = 8 și lista [2, 4, 2, 5, 4, 2, 4, 1], se va afișa valoarea 2.

5. Într-un centru de suport tehnic, fiecare cerere primește un cod de prioritate de la 1 la 9, unde 1 înseamnă prioritate mică, iar 9 prioritate mare. Se citește un număr natural n, apoi o listă cu n coduri de prioritate. Să se afișeze codurile în ordine descrescătoare, folosind o listă de frecvențe.

Exemplu: pentru n = 7 și lista [5, 3, 5, 2, 9, 3, 5], se va afișa: 9 5 5 5 3 3 2

139

V.8. Eficiența algoritmilor Până acum, principala noastră grijă a fost ca programele pe care le scriem să fie corecte, adică să ruleze fără erori și să furnizeze rezultatul corect. În cazul în care pentru o problemă avem mai mulți algoritmi (mai multe programe) care furnizează soluția corectă, pe care îl alegem ca fiind cel mai bun? Complexitatea unui algoritm ne ajută să estimăm eficiența sa, analizând resursele consumate, în special timpul de executare și memoria necesară, în funcție de dimensiunea datelor de intrare.

Exemplu: Doi curieri, Andrei și Bogdan, trebuie să livreze câte un pachet la o adresă din oraș. ◗ Andrei pleacă la drum fără să se uite pe hartă. Merge pe prima stradă, se blochează, se întoarce, caută din aproape în aproape și, după 2 ore, găsește casa. ◗ Bogdan deschide GPS-ul, vede traseul cel mai scurt și ajunge la destinație în 15 minute.

Amândoi au rezolvat problema (pachetul a fost livrat), dar algoritmul lui Bogdan a fost mult mai eficient. În informatică, nu ne dorim doar să ajungem la rezultat, ci vrem să ajungem acolo consumând cât mai puține resurse.

Analiza eficienței unui algoritm presupune evaluarea acestuia după următoarele criterii: ◗ Complexitatea temporală (timpul de executare): Nu se estimează efectiv timpul de executare (în secunde), deoarece un calculator mai performant va rula mereu mai repede decât unul vechi. Din acest motiv vom estima numărul de operații elementare (operația de atribuire, operațiile aritmetice de bază, operația de decizie, operații de citire/scriere) pe care le efectuează algoritmul în raport cu dimensiunile datelor de intrare. ◗ Complexitatea spațială (memoria): Estimează spațiul de memorie RAM necesar unui algoritm (program) pentru a-și duce executarea la bun sfârșit. De exemplu, dacă salvăm datele în variabile simple, ocupăm spațiu foarte mic, iar dacă creăm liste de mari dimensiuni, începem să consumăm din memoria calculatorului.

Pentru a exprima eficiența, informaticienii folosesc o notație specială numită notația Big-O, respectiv O(expresie), unde expresia estimează numărul maxim de operații elementare efectuate de algoritmul respectiv în raport de dimensiunile datelor de intrare. De exemplu, dacă un algoritm are complexitatea temporală O(n2) înseamnă că dimensiunea datelor sale de intrare este egală cu n (variabila din expresie) și algoritmul efectuează aproximativ n2 operații elementare (expresia) pentru a rezolva problema respectivă.

Criteriile principale pentru determinarea ordinului de complexitate al unui algoritm (polinomial) sunt: ◗ identificarea dimensiunilor datelor de intrare REȚINE! ◗ estimarea numărului de operații elementare efectuate de algoritm, în funcție dimensiunile ◗ Pentru instrucțiuni repetitive consecutive, datelor de de intrare adunăm complexitățile, iar pentru instrucțiuni ◗ simplificarea expresiei obținute la pasul anterior repetitive imbricate, înmulțim complexitățile. prin eliminarea constantelor și păstrarea termenului dominant În continuare vom prezenta câteva clase de complexitate temporală, frecvent utilizate: a) Complexitatea constantă: O(1) ◗ Este algoritmul ideal, „formula magică”. Indiferent dacă avem 5 date sau 5 milioane, calculatorul face un singur pas (sau un număr fix de pași) și dă răspunsul pe loc. ◗ Exemplu: Să afișăm primul element dintr-o listă. Nu contează câte elemente are lista, ne interesează doar elementul de pe poziția 0. b) Complexitatea liniară: O(n) ◗ Numărul de pași crește exact în același ritm cu dimensiunea datelor de intrare n. Dacă volumul de date crește de 10 ori, atunci și calculatorul muncește de 10 ori mai mult. ◗ Exemplu: Determinarea valorii maxime dintr-un fișier. Trebuie să deschidem fișierul și să analizăm, rând pe rând, fiecare dintre cele n numere. Dacă avem n numere, facem n pași.

140

c) Complexitatea pătratică: O(n2) ◗ Numărul de pași crește spectaculos de repede. Dacă volumul de date crește de 10 ori, calculatorul muncește de 102 = 100 ori mai mult. ◗ Exemplu: Algoritmii simpli de sortare (aranjare în ordine crescătoare) unde comparăm fiecare element cu toate celelalte din listă (folosind două instrucţiuni for imbricate).

REȚINE! ◗ Un programator bun este unul ce scrie cod care doar „funcționează”. Un programator excelent este unul care anticipează volumul de date și alege algoritmul care consumă cel mai puțin timp și cea mai puțină memorie.

Exemplul 1: Se citeşte de la tastatură un număr natural nenul n. Să se calculeze S=1+2+3+...+n.

Varianta 1 Matematicianul Carl Friedrich Gauss a descoperit că nu trebuie să adunăm numerele unul câte unul, ci putem folosi o formula: S = (n * (n + 1)) / 2 Cod sursă n = int(input("n= ")) suma = n * (n + 1) // 2 print("Suma este:", suma)

Analiza eficienței ◗ Complexitate temporală: O(1) (timp constant) Indiferent dacă n = 10 sau n = 1.000.000.000, calculatorul efectuează o citire, 3 operații aritmetice (o adunare, o înmulțire și o împărțire) și o afișare. ◗ Complexitate spațială: O(1) (spațiu constant) Se folosesc două variabile întregi: n și suma.

Varianta 2 Cod sursă n = int(input("n= ")) suma = 0 for i in range(1, n + 1): suma = suma + i print("Suma este:", suma)

Analiza eficienței ◗ Complexitate temporală: O(n) (liniară) Numărul de pași crește proporțional cu n.

Pentru n = 100, execută 100 de adunări.

Pentru n = 1.000.000, execută 1 milion de adunări. ◗ Complexitate spațială: O(1) (constantă) Programul folosește 3 variabile (n, suma, i). Memoria RAM ocupată rămâne constantă, indiferent de valoarea lui n.

Varianta 3 Cod sursă n = int(input("n= ")) suma = sum(range(1, n + 1)) print("Suma este:", suma)

Analiza eficienței ◗ Complexitate temporală: O(n) (liniară) Deși instrucțiunea for nu apare în cod, funcția sum() o utilizează intern (parcurge numerele pe rând și le adună unul câte unul). Deci, pentru n = 1.000.000, calculatorul efectuează tot 1 milion de adunări. ◗ Complexitate spațială: O(1) (constantă) Funcția range() nu generează toate numerele deodată în memorie (nu creează o listă), ci le generează „din mers”, pe măsură ce funcția sum() are nevoie de ele. Prin urmare, memoria RAM ocupată rămâne constantă, indiferent de valoarea lui n.

141

Exemplul 2: Se citește de la tastatură un număr natural n. Să se verifice dacă n este număr prim.

Varianta 1 Cod sursă n = int(input("n = ")) prim = True if n < 2: prim = False else: for d in range(2, n): if n % d == 0: prim = False if prim: print("Da") else: print("Nu")

Analiza eficienței ◗ Complexitate temporală: O(n) (liniară) În cel mai nefavorabil caz, algoritmul verifică toți divizorii posibili de la 2 până la n - 1. Numărul de verificări crește proporțional cu valoarea lui n. De exemplu, pentru n = 101, se verifică valorile 2, 3, 4, ..., 100. ◗ Complexitate spațială: O(1) (constantă) Programul folosește un număr fix de variabile, două de tip întreg și una booleană. Memoria ocupată nu crește odată cu valoarea lui n.

Varianta 2 Cod sursă

Analiza eficienței

n = int(input("n = ")) prim = True if n < 2: prim = False else: d = 2 while d * d <= n and prim: if n % d == 0: prim = False d = d + 1 if prim: print("Da") else: print("Nu")

◗ Complexitate temporală: O(√n) Instrucțiunea while nu verifică toate valorile până la n, ci doar valorile d pentru care d * d <= n.

De exemplu, pentru n = 100, verificăm cel mult până la 10, deoarece 10 * 10 = 100. Pentru n = 1.000.000, verificăm cel mult până la 1000, nu până la 1.000.000. ◗ Complexitate spațială: O(1) (constantă) Programul folosește un număr fix de variabile: n, prim și d. Nu se construiesc liste sau alte structuri de date auxiliare.

Exemplul 3: Se consideră fișierul text date.in care conține pe prima linie un număr natural nenul n și pe următoarele n linii câte un număr natural. Să se determine valoarea maximă din fișier.

Varianta 1 Cod sursă f = open("date.in") n = int(f.readline()) maxim = int(f.readline()) for i in range(n - 1): x = int(f.readline()) if x > maxim: maxim = x print("Maxim:", maxim) f.close()

142

Analiza eficienței ◗ Complexitate temporală: O(n) (liniară) Acest algoritm este considerat optim pentru determinarea maximului dintr-un fișier, deoarece analizează o singură dată fiecare număr din fișier. Numărul de operații elementare este direct proporțional cu numărul de elemente n din fișier. ◗ Complexitate spațială: O(1) (constantă) Programul folosește un număr fix și foarte mic de variabile în memoria RAM (f, n, maxim, i, x), indiferent de numărul valorilor din fișier. Când se citește un număr nou în variabila x (x = int(f.readline())), valoarea citită anterior în x este suprascrisă.

Varianta 2 Cod sursă f = open("date.in") n = int(f.readline()) lista = [] for i in range(n): x = int(f.readline()) lista.append(x) maxim = lista[0] for x in lista: if x > maxim: maxim = x print("Maxim:", maxim) f.close()

Analiza eficienței ◗ Complexitate temporală: O(n) (liniară) Prima instrucțiune for citește cele n numere din fișier și le adaugă în listă, deci are complexitatea O(n). A doua instrucțiune for parcurge toate elementele din listă pentru a găsi maximul, deci are tot complexitatea O(n). Complexitatea totală este O(n) + O(n) = O(2n). Deoarece în estimarea complexității ignorăm constantele (numărul 2 nu schimbă comportamentul general), complexitatea totală rămâne O(n).

Observație: Deși ca notație este tot O(n) (la fel ca varianta fără liste), în realitate efortul computațional este dublu, deoarece numerele sunt parcurse de două ori: o dată la citire și o dată la determinarea maximului. ◗ Complexitate spațială: O(n) (liniară) Spațiul de memorie ocupat de listă în RAM crește direct proporțional cu numărul n de elemente din fișier.

Exemplul 4: Se consideră o listă care conţine n numere naturale. Să se ordoneze crescător elementele listei prin metoda bulelor.

Cod sursă def bubble_sort(L): n=len(L) sortata = False while not sortata: sortata = True for i in range(0, n - 1): if L[i] > L[i + 1]: L[i], L[i + 1] = L[i + 1], L[i] sortata = False n = n-1

Analiza eficienței ◗ Complexitate temporală: O(n2) (pătratică) Complexitatea depinde direct de ordinea inițială a valorilor elementelor din listă. Din acest motiv, analizăm două cazuri distincte: a) Cazul cel mai favorabil: O(n). Acest caz apare atunci când lista este deja sortată crescător (de exemplu: [1, 2, 3, 4, 5]). Instrucţiunea while se oprește imediat după prima parcurgere a listei. Numărul de operații elementare este direct proporțional cu numărul de elemente din listă. b) Cazul cel mai nefavorabil: O(n2). Acest caz apare atunci când lista este ordonată descrescător (de exemplu: [5, 4, 3, 2, 1]). La fiecare parcurgere a listei, variabila booleană este setată pe False deoarece se fac interschimbări la fiecare pas. Pentru a duce fiecare element la locul său, instrucţiunea for se execută de cel mai mare număr posibil de ori pentru această metodă. Numărul total de comparări este o sumă Gauss: (n-1) + (n-2) + ... + 1 = n(n-1)/2 = (n2-n)/2. În analiza complexității, dintr-o expresie, după eliminarea constantelor, păstrăm doar termenul cel mai mare, respectiv n2. ◗ Complexitate spațială: O(n) (liniară) Algoritmul este de tip „in-place” (sortare pe loc) şi modifică lista direct în spațiul ei de memorie, fără să creeze o listă copie sau o listă nouă. Variabilele suplimentare utilizate (sortata, n, i) ocupă un spațiu fix neglijabil, iar lista în sine ocupă un spațiu în memorie direct proporțional cu numărul n de elemente stocate în ea.

143

Eficiența temporală Tip complexitate

Exemplu

O(1) (constantă): complexitatea nu crește odată cu dimensiunea x=2**7/5//10 datelor de intrare.

O(√n): complexitatea este direct proporțională cu √n, unde n este n = int(input("n = ")) d = 1 dimensiunea datelor de intrare while d * d <= n: print(d*d) d = d + 1 O(n) (liniară): complexitatea este direct proporțională cu dimen­ n=int(input("n= ")) for i in range(1, n + 1): siunea datelor de intrare. print(i) O(n2) (pătratică): complexitatea este direct proporțională cu pătratul n=int(input("n= ")) for i in range(1, n + 1): dimensiunii datelor de intrare. for j in range(1, n + 1): print(i*j, end=" ") Eficiența spațială Tip complexitate

Exemplu

O(1) (constantă): algoritmul modifică datele direct în structura pri­ x=2**7/5//10 mită, consumând doar câteva variabile auxiliare.

O(n) (liniară): algoritmul necesită alocarea de memorie RAM pentru n=int(input("n = ")) L = [] a stoca sau copia n elemente (crearea de liste). for i in range(n): x = int(input("x = ")) L.append(x)

P ORTOFOLIU DIGITAL Carnetul de note – frecvențe, sortare și raport final Organizare

Creează folderul: Portofoliu digital > Capitolul 5 > Carnetul de note > Tema 11 - Frecvente sortare si raport final.

Cerința 1

Pornește de la aplicația carnet_note_liste_fisiere.py realizată la Tema 10 și creează versiunea finală pentru Capitolul 5: carnet_note_final_liste.py.

Cerința 2

Adaugă un buton "Frecventa notelor". Programul va construi o listă de frecvențe pentru notele întregi de la 1 la 10 și va afișa câte apariții are fiecare notă prezentă în lista curentă.

Cerința 3

Adaugă un buton "Nota cea mai frecventă". Programul va determina nota care apare de cele mai multe ori. Dacă există mai multe note cu aceeași frecvență maximă, se va afișa cea mai mare dintre ele.

Cerința 4

Adaugă un buton "Sorteaza crescator", care afișează lista notelor în ordine crescătoare, fără să modifice lista inițială. Se va folosi funcția sorted().

Cerința 5 Cerința 6

144

Adaugă un buton "Sorteaza descrescator", care afișează lista notelor în ordine descrescătoare, fără să modifice lista inițială. Se va folosi lista de frecvențe sau sorted(lista, reverse=True).

Adaugă un buton "Raport final", care afișează în interfață: lista inițială, lista sortată crescător, lista sortată descrescător, media, minimul, maximul, frecvențele notelor și nota cea mai frecventă.

Cerința 7

Adaugă un buton "Salvează raport final". La apăsarea lui, programul va scrie raportul complet în fișierul raport_final_note.txt. Dacă fișierul există deja, raportul nou poate fi adăugat la finalul său folosind modul adăugare (”a”).

Cerința 8

Programul trebuie să verifice dacă lista de note este vidă înainte de orice prelucrare. Dacă nu există note memorate, se va afișa mesajul "Nu exista note pentru prelucrare".

Cerința 9 Salvează

Organizează codul în funcții. Poți folosi funcții precum: construieste_frecvente, nota_frecventa_ maxima, lista_sortata_crescator, lista_sortata_descrescator, genereaza_raport_final, salveaza_raport_final. carnet_note_final_liste.py raport_final_note.txt

Realizează un document scurt în care explici ce este o listă de frecvențe, cum ai folosit sorted() fără să modifici lista inițială și cum ajută raportul final la analiza notelor. Adaugă un exemplu Document complet: lista inițială, frecvențele, lista sortată și raportul final obținut. Nume recomandat: tema11_prezentare.docx.

Exersează!

1. Dați câte un exemplu de algoritm cu complexitate temporală: O(1), O(n), O(n²).

2. Indicaţi complexitatea temporală a următoarei secvențe de cod. n = int(input()) s = 0 for i in range(n): s = s + i for j in range(n - 1, -1, -1): s = s + j

A. O(1)

B. O(n)

C. O(n²)

D. O(√n)

3. Indicaţi complexitatea temporală a următoarei secvențe de cod. n = int(input()) cnt = 0 for i in range(1, n + 1): for j in range(1, i + 1): cnt = cnt + 1

A. O(n)

B. O(n + 1)

C. O(n²)

D. O(√n5)

4. Indicaţi complexitatea temporală a funcției de mai jos: def calculeaza_suma(n): return (n * (n + 1)+n*5) // 2

A. O(n2)

B. O(n)

C. O(1)

D. O(2*n)

5. Dacă rularea unui algoritm cu complexitatea O(n2) durează 4 secunde pentru o listă de 1000 de numere, aproximativ cât va dura rularea acestuia pentru o listă de 2000 de numere?

A. 8 secunde

B. 16 secunde

C. 40 secunde

D. 4 secunde

145

PROBLEME PROPUSE 1. Un senzor înregistrează temperaturile măsurate în timpul unei ore de lucru. Valorile sunt numere întregi.

Scrieți un program care citește un număr natural nenul n, apoi n temperaturi, le memorează într-o listă și afișează lista temperaturilor, temperatura minimă, temperatura maximă și diferența dintre temperatura maximă și temperatura minimă. Exemplu: dacă se citește n = 5 și valorile 22 24 21 25 23, atunci se va afișa minimul 21, maximul 25, iar diferența 4.

2. La un eveniment al liceului, voluntarii primesc insigne numerotate. Coordonatorul dorește să știe câte insigne au coduri pare și câte au coduri impare. Scrieți un program care citește un număr natural nenul n, apoi n coduri numerice, le memorează într-o listă și afișează numărul codurilor pare, numărul codurilor impare și lista codurilor pare, în ordinea în care au fost citite. Exemplu: dacă se citește n = 6 și codurile 12 7 30 45 18 9, atunci se vor afișa 3 coduri pare, 3 coduri impare, iar lista codurilor pare este [12, 30, 18].

3. La un concurs de logică, fiecare elev obține un punctaj. Organizatorii doresc să afișeze punctajele în ordine crescătoare, dar și să păstreze lista inițială pentru arhivă. Scrieți un program care citește un număr natural nenul n, apoi n punctaje, le memorează într-o listă și afișează lista inițială, lista ordonată crescător și lista ordonată descrescător. Exemplu: dacă se citește n = 5 și punctajele 80 65 100 90 75, atunci lista crescătoare este [65, 75, 80, 90, 100], iar lista descrescătoare este [100, 90, 80, 75, 65].

4. Un magazin notează vânzările zilnice pe parcursul unei perioade. Managerul dorește să afle în ce zile vânzările au depășit un anumit prag. Scrieți un program care citește un număr natural nenul n, apoi n valori naturale reprezentând vânzările zilnice și un prag p. Programul va afișa lista pozițiilor zilelor în care vânzarea a fost strict mai mare decât p. Zilele se numerotează de la 1. Dacă nu există nicio astfel de zi, se va afișa mesajul "NU EXISTA". Exemplu: dacă se citește n = 5, vânzările 120 90 150 60 180 și p = 130, atunci se va afișa lista [3, 5].

5. Într-un catalog digital, notele elevilor sunt memorate într-o listă. Profesorul dorește să afle de câte ori apare nota 10 și poziția primei apariții. Scrieți un program care citește un număr natural nenul n, apoi n note întregi între 1 și 10. Programul va afișa numărul aparițiilor notei 10 și poziția primei apariții a notei 10, numerotată de la 0. Dacă nota 10 nu apare, se va afișa mesajul "NU EXISTA". Exemplu: dacă se citește n = 7 și notele 8 10 7 9 10 6 10, atunci se va afișa că nota 10 apare de 3 ori, iar prima apariție este pe poziția 1.

6. Un sistem de acces memorează codurile cardurilor într-o listă. Administratorul trebuie să adauge un cod nou la final și apoi să insereze un cod de urgență pe o poziție dată. Scrieți un program care citește un număr natural nenul n, apoi n coduri naturale, un cod x care se adaugă la final, un cod y și o poziție p. Programul va afișa lista după adăugarea lui x la final și inserarea lui y pe poziția p. Exemplu: dacă lista inițială este [101, 205, 310], se adaugă 450, apoi se inserează 999 pe poziția 1, lista finală devine [101, 999, 205, 310, 450].

7. La intrarea într-un festival, fiecare bilet primește un cod numeric din intervalul 1..50, în funcție de categoria de acces. Organizatorii vor să identifice rapid categoriile folosite rar și categoriile care apar de mai multe ori. În fișierul bilete.in se află pe prima linie numărul natural nenul n, iar pe următoarele n linii câte un cod de bilet.

Scrieți un program care citește codurile într-o listă, construiește lista de frecvențe și scrie în fișierul bilete.out lista codurilor care apar exact o dată, codul cu frecvență maximă și numărul total de apariții suplimentare ale codurilor repetate. Dacă mai multe coduri au frecvență maximă, se va afișa cel mai mic cod. Exemplu: dacă fișierul bilete.in conține valorile 8, 12, 7, 12, 5, 7, 7, 20, 5, fiecare pe linie separată, atunci codurile care apar exact o dată sunt [20], codul cu frecvență maximă este 7, iar numărul aparițiilor suplimentare este 4.

8. Într-un concurs de drone, nivelul bateriei fiecărei drone este măsurat după fiecare tură. Organizatorii vor să identifice cea mai lungă perioadă consecutivă în care nivelul bateriei scade strict de la o măsurare la următoarea. În fișierul baterii.in se află pe prima linie numărul natural nenul n, iar pe următoarele n linii câte un nivel al bateriei. Scrieți un program care citește valorile într-o listă și scrie în fișierul baterii.out lungimea celei mai lungi secvențe strict descrescătoare, poziția de început a primei astfel de secvențe și lista valorilor din secvență. Pozițiile se numerotează de la 1. Exemplu: dacă fișierul baterii.in conține valorile 8, 98, 94, 90, 92, 88, 80, 75, 76, fiecare pe linie separată, atunci cea mai lungă secvență strict descrescătoare are lungimea 4, începe pe poziția 4 și este [92, 88, 80, 75].

146

FIȘĂ DE EVALUARE FINALĂ DE CAPITOL Indicații: Rezolvați clar și ordonat. Pentru programe se acceptă orice variantă corectă în Python. În fișiere, valorile sunt pe linii separate.

SUBIECTE 1. Indicați complexitatea temporală a algoritmului de sortare prin selecția minimului a celor n elemente ale unei liste: ................................................................................................................................................................... 4p A. O(n)

B. O(n2)

C. O(n+m)

D. O(1).

2. Se consideră lista L = [4, 7, 4, 9]. Precizați lista obținută după executarea instrucțiunii L.remove(4). ............... 4p A. [7, 4, 9]

B. [4, 7, 9]

C. [4, 7, 4]

D. [7, 9].

3. Alegeți instrucțiunea care ordonează descrescător elementele listei L fără a o modifica: ............................... 5p A. L.sort(reverse=True) B. L.reverse() C. S = sorted(L, reverse=True) D. S = L.sort().

4. Scrieți asocierile corecte dintre elementele coloanei E (expresie) și elementele coloanei R (rezultat): ...................................................... 8p

E

R

1. [2,4]+[6]

A. True

2. [3]*3

B. [2,4,6]

3. 5 in [1,5,9]

C. [3,3,3]

4. len([7,8])

D. 2

5. Pentru lista L = [6, 9, 12, 15] indicați valoarea expresiei L[2]: ............................................................................... 5p B. 9 C. 12 D. 15.

A. 6 6. Selectați afirmația corectă despre sort() sau sorted(): (5p) A. sort() returnează o listă nouă; B. sorted() modifică lista inițială; C. sort() modifică lista asupra căreia se aplică; D. sorted() sortează doar descrescător.

7. Pentru lista L = [5, 2, 9], în urma executării instrucțiunilor L.append(4) și L.pop(0), indicați elementele lui L. ... 5p B. [5, 2, 9, 4] C. [4, 2, 9] D. [2, 5, 9].

A. [2, 9, 4] 8. Se consideră secvența Python. Precizați ce se afișează: (10p) L = [8, 3, 5, 3] L.append(6) L.pop(1) C = sorted(L) print(L); print(C); print(L.count(3))

9. Pentru L = [20, 18, 18, 13, 21], aplicați metoda bulelor pentru sortare crescătoare. Scrieți listele obținute după fiecare parcurgere completă până când lista devine ordonată. ....................................................................... 12p 10. Fișierul coduri.in conține un număr natural nenul n și apoi n coduri (numere naturale), fiecare pe câte o linie.

Scrieți un program care citește codurile într-o listă, le sortează crescător după suma cifrelor, iar la sume egale – crescător după valoare, apoi le scrie în fișierul coduri.out, câte unul pe linie. ................................... 16p Exemplu: pentru valorile 5, 302, 41, 120, 88, 23, rezultatul este 120, 23, 41, 302, 88 (pe linii separate).

11. Fișierul voturi.in conține un număr natural nenul n și apoi n valori (numere naturale) din intervalul [1,10].

Construiți lista de frecvență F și scrieți în fișierul voturi.out: pe prima linie punctajul cu frecvență maximă (la punctaje egale, punctajul cel mai mic), iar pe a doua linie lista punctajelor sortate crescător. .............. 26p Exemplu: pentru 8 valori 4, 10, 7, 4, 7, 4, 10, 7, frecvența maximă este 3, punctajul ales este 4, iar lista sortată este [4, 4, 4, 7, 7, 7, 10, 10].

TOTAL: 90 DE PUNCTE. Se acordă 10 puncte din oficiu.

147

Indicații și rezolvări scurte – EXERSEAZĂ p.9 1. analiză, structurare, automatizare. 2.D 3.D 4.C. p.14 1.A S←S+i. 2.B 3.C 4.A decizie; B rep. test inițial; C rep. nr. cunoscut; D rep. test final. 5.D: 3. p.18 1. y←x*x; scrie y. 2. 1-e,2-c,3-a,4-d,5-b. 3. Ind.: total←0; i=1..n; dacă i par adaugă 2*x, altfel x.

4. Ind.: total și distanță curentă; după fiecare n zile dist←dist*(1+p/100). 5. Ind.: ora=0,pers=1; afișează dacă pers∈[a,b], apoi pers←3*pers. p.25 1.B 2.C 3.C 4.B 5.C. p.31 1.C 2.B 3.C 4.A. p.35 1.A: 531. 2. Ind.: u=n%10; dacă u par n←10*n+4, altfel n←10*n+7. 3. Ind.: if/elif/else: u<3, u≤6, altfel.

4. Ind.: u=0, u=5, apoi u par; altfel +1. p.38 1. Ind.: sumați cifrele 2,3,5,7. 2. Ind.: păstrați cifrele din [2,5] cu m=c*p+m, p*=10. 3. 6,7,8,9.

4. Ind.: cifră impară → perechea 11*c, p*=100.

5. n//=10 elimină cifra și evită bucla infinită. p.42 1. ≈3162 ori. 2. Ind.: numărați divizorii. 3. Ind.: pătrat perfect ⇔ nr. impar de divizori. 4. Ind.: sd(n)<n deficitar, = perfect, > abundent. 5.C. p.45 1. Ind.: prima cifră pară de la dreapta; altfel „nu exista”. 2. Ind.: sumați cifrele ≠5. 3. Ind.: căutați 9; gasit/negasit. 4. Ind.: prima cifră >5 de la dreapta; altfel „nu exista”. p.49 1. Ind.: factor cu exponent maxim; la egalitate cel mai mic. 2. Ind.: CMMDC(a,b)=1. 3. Ind.: num=a*d+c*b, numitor=b*d, simplificați. 4. Ind.: multiplii lui n din [a,b]; indicator. 5.C: 36. p.58 1. antet def afisare():; corp cele două print-uri.

2. 8,30. 3. afișează: 64, None. 4. Ind.: n%2.

5. Ind.: ogl=ogl*10+n%10. 6. Ind.: contor cifre.

7. Ind.: suma divizorilor. p.64 1. formali a,b; efectivi 4,7. 2. In functie:20; In program:50. 3. Ind.: numărați cifrele pare; apel fără argument→1. 4. Ind.: minim/maxim pe cifre.

5. Ind.: toate cifrele egale ⇔ min=max. p.69 1.A: 19 12 28.0. 2.C: Modul încărcat / 10. 3. Ind.: min,max,round(media,2). 4. Ind.: ip=sqrt(a*a+b*b); întreg dacă ip==int(ip). 5. Ind.: factorial, sqrt(sum(range(1,n+1))), round(E,4). 6. 18; 5.7; 9; 7.25; 10. p.72 1. clase: int,float,Fraction; obiecte: int(25), float("7.5"), Fraction(3,4). 2. True, False. 3. Ind.: Fraction(12,18), numerator/denominator.

4. x=float(6.0); x.is_integer(). 5. 94/105 și 11/105.

148

p.83 1.C 2.C: 50100. 3. Ind.: numărați cifrele și scrieți str(cnt). 4. Ind.: citiți numărul și sumați cifrele.

5. Ind.: păstrați cifrele >4 cu m=c*p+m; scrieți în rezultat.txt. p.89 1. Ind.: CMMMC pentru 3 durate; append în fișier.

2. Ind.: primul element=maxim; contor apariții.

3. Ind.: sumă cumulată linie cu linie; oprire când suma>p. 4. Ind.: variația maximă |curent-anterior|. p.93 1. Ind.: Tk, Label, Button; config(). 2. Ind.: messagebox.showinfo(). 3. mainloop menține fereastra activă. 4. Ind.: două funcții, două butoane, două mesaje. p.100 1. Ind.: get(), int(), n*n. 2. Ind.: două Entry, conversie, showinfo. 3. Ind.: Frame + grid. 4. Entry: un rând; Text: mai multe rânduri. p.106 1. Ind.: Canvas + rectangle/oval/text. 2. Ind.: Frame + grid. 3. pack automat; grid tabelar; place coordonate. 4. Ind.: pătrat + linii. 5. Nu amestecați pack și grid în același container. 6. Ind.: create_ oval(fill=culoare), try/except. p.111 1. ordinea contează. 2. primul 6; ultimul 10; 5 elem. 3. direct=indice; secvențial=parcurgere.

4. S=[10,20,90], C=[60,80]. 5. f(7)=3, f(8)=2. p.116 1. 14,21,12. 2. L[1]=6. 3. A 9; B 18; C [6,9,12]; D [3,6,9]. 4. L[2]=element; L[2:3]=listă. 5. 10 20 30 40.

6. L[:2], L[-3:]. p.120 1. Ind.: append și inversare/L[::-1]. 2. Ind.: 7 in L. 3. L=L1+L2. 4. [5,9]*4=[5,9,5,9,5,9,5,9].

5. len,sum,min,max. p.126 1.C 2. insert(2,22) → [12,18,22,25,40]. 3. pop() → 356 și [301,318,325,340]. 4. remove(404) → [200,301,404,500]. 5. Ind.: count(c), index(c); altfel „Cod absent”. p.130 1. Ind.: C=L.copy(); C[0]=100. 2. sort(); reverse() → [10,8,5,3]. 3. Ind.: imparele din 1..n. 4. Ind.: extrageți cifre pare, inversați lista. 5. Ind.: L=[a1,a2]; adăugați 2*L[i-1]-L[i-2]; copie L[::-1]. p.135 1. Ind.: selecția minimului; cel mai bun=L[0].

2. Ind.: bule; contor parcurgeri. 3. Ind.: selecția maximului; primele min(3,n). 4. Ind.: sortare; L[1]-L[0]. 5. Ind.: n<3→Date insuficiente; altfel L[1:-1]. p.139 1. 1-c,2-a,3-d,4-b. 2. F=[1,0,3,1,2,1]. 3. Ind.: F cu 10 poziții; afișați i=1..9 cu F[i]==0. 4. Ind.: frecvențe 1..5; frecvență maximă, primul nivel.

5. Ind.: frecvențe 1..9; afișați descrescător. p.145 1. O(1): L[0]; O(n): parcurgere; O(n²): două bucle imbricate. 2.B 3.C 4.C 5.B: 16 secunde.