Ministerul Educaţiei Culturii și Cercetării al Republicii Moldova

Universitatea Tehnică a Moldovei

Facultatea Calculatoare, Informatică și Microelectronică

Departamentul Informatică și Ingineria Sistemelor

REFERAT
la lucrarea de laborator nr.4
Tema: „Operații asupra fișierelor, tuplurilor și
dicționarelor.”
Disciplina: „Programarea interactivă”

A elaborat st. gr. IA-191, Zastavnețchi Alexandru

A verificat a. u. Strună Vadim

Chişinău – 2020
Lucrarea de Laborator Nr. 4 Programare Interactivă

Tema: Operații asupra Fișierelor, Tuplurilor și Dicționare.

Cerințe:
 Rezolvați în timpul laboratorului problemele de la punctul I.

I Probleme

"""
Scrieți un program care adaugă două numere primite de la utilizator (de la consolă)
cu verificare de erori. Scrieți codul astfel încît să ceară utilizatorului un număr
întreg și apoi verifică dacă ce a introdus utilizatorul e un număr valid. Afișează un
mesaj de eroare în caz că numărul nu e valid și continuă afișarea mesajului ce
promptează utilizatorului să introducă un număr pînă cînd introduce unul valid.
Sfat: Folosiți input pentru a citi numărul ca un șir de caractere și apoi folosiți
instrucțiunea while pentru a verifica că fiecare caracter este o cifră. Realizați
același lucru și pentru al doilea număr și apoi adunați-le.
"""
from colorama import Fore,Back,Style
print(Fore.BLUE+"Introduceți numerele")
x1=input(Fore.GREEN+"I numar ---> ")
x2=input("II numar --> ")
while(x1.isdigit() and x2.isdigit())!=True:
#isdigit()--->verifică dacă elementele șirului sunt cifre
print(Back.RED+Fore.WHITE+"\nIntroducerea a eșuat!"+Style.RESET_ALL)
print(Fore.BLUE+"\nVerificați numerele și introduceți din nou!")
x1=input(Fore.GREEN+"I numar ---> ")
x2=input("II numar --> ")
print(Fore.GREEN+"\nOperație cu succes!"+Style.RESET_ALL)
print(Fore.CYAN+"\nSuma numerelor: ",int(x1) + int(x2), Style.RESET_ALL)
Lucrarea de Laborator Nr. 4 Programare Interactivă

"""
Scrieți o funcție care ar face liniarizarea unei liste. Aveti o listă imbricată
(adică listă în listă) și creați o listă nouă.
"""
from colorama import Fore,Back,Style
x = ['V', 'a', ['d',['i','m',['S','t', 'r'],'u'],['n','a'],'2'],'0']
if(x!=0):
aux = []#Lista noua initializata cu 0
c= True
print(Fore.BLUE+"Lista inițială este:\n",Fore.GREEN,x)
else:
print(Back.RED+Fore.WHITE+"Sa produs eroare, imposibil de generat
lista"+Style.RESET_ALL)

while(c):
for i in list(x):#----------------->Parcurgerea listei x
if len(i) > 1:#---------------->Lungimea listei x > 1
for small_list in list(x):
for elem in small_list:
aux.append(elem)#-->Append() adaugă elementul la sf. listei
x = aux.copy()#------------>Copy() copie lista veche în una nouă
aux.clear()#--------------->Clear() elimină toate înscrierile din listă
c=True
break
else:
c=False

print(Fore.BLUE+"\nLista prelucrată este:\n",Fore.GREEN,x,"\n")

for val in list(x):#Printarea elementelor listei ca 1 întreg

print(Fore.CYAN,end = ''+val+Style.RESET_ALL)
print("\n")

"""
Lucrarea de Laborator Nr. 4 Programare Interactivă

Scrieți un program pentru a găsi anagrame într-o anumită listă de cuvinte.

Două cuvinte sunt numite anagrame dacă un cuvînt poate fi format prin rearanjarea
literelor primului cuvînt.
"""
from colorama import Fore,Back,Style
m=True
#Funcția verifică dacă 2 șiruri sunt anagrame sau nu
def check(s1, s2):
#Sortează tablourile și verifică elementele
if(sorted(s1)== sorted(s2)):#sorted() sortează elementele fără a le modifica
print(Fore.BLUE+"\nCuvintele"+Fore.GREEN,s1,s2,Fore.BLUE+"sunt anagrame!\n")
else:
print(Back.RED+Fore.WHITE+"\nCuvintele"+Fore.BLACK,s1,s2,Fore.WHITE+"nu
sunt anagrame!\n"+Style.RESET_ALL)

#Introducem elementele
while m:
print(Fore.BLUE+"Alege butonul:")
m=input(Fore.YELLOW+"1.Continuă rularea!\n2.Oprește programul!\n>")
if m=="1":
s1=input(Fore.BLUE+"\nIntroduceți I cuvânt-----> "+Fore.GREEN)
s2=input(Fore.BLUE+"\nIntroduceți II cuvânt----> "+Fore.GREEN)
check(s1, s2)
elif m=="2":
exit(Style.RESET_ALL+Back.RED+"\nSTOP"+Style.RESET_ALL+Fore.RED)
elif m!="":
print(Back.RED+Fore.WHITE+"\nButonul nevalabil\n"+Style.RESET_ALL)

"""
Scrieți o funcție invertdict care ar interschimba cheile și valorile într-un dicționar.
Pentru simplificare, presupunem că toate valorile sunt unice.
Lucrarea de Laborator Nr. 4 Programare Interactivă

"""
from colorama import Fore
def invertdict(x):
#Are loc inversarea cheie->valoare.
#items()- returnează toate cheile din dictionar
inversat = { el: k for k, el in x.items()}
print(Fore.CYAN+"Dictionar initial"+Fore.GREEN,x,"\n")
print(Fore.CYAN+"Dictionar inversat",Fore.YELLOW,inversat)

y = {99 : 'alex', 3 : 'ion', 100 : 'vasile'}

invertdict(y)

"""
Scrieți o funcție mult_lists(a,b) care va lua ca parametri două liste de aceeași
lungime și va returna suma produselor elementelor corespunzătoare a fiecărei liste
"""
from colorama import Fore
def mult_lists(a, b):
p=0
for i in range(0,len(a)): p += a[i] * b[i]
print(Fore.CYAN+"\nSuma produselor este: "+Fore.GREEN,p)
return p

a = [1,1,1]
print(Fore.CYAN+"Lista 1 este--->"+Fore.YELLOW,a)
b = [1,1,1]
print(Fore.CYAN+"\nLista 2 este--->"+Fore.YELLOW,b)
mult_lists(a, b)

"""
Se dă câteva tupluri care reprezintă persoane care folosesc laboratorul Visio, folosind
numele și prenume:
Lucrarea de Laborator Nr. 4 Programare Interactivă

brendan = ("Brendan", "McCane")

sandy = ("Sandy", "Garner")
nick = ("Nick", "Meek")
student1 = ("Allan", "Anderson")
student2 = ("Barry", "Byars")
student3 = ("Christine", "Carver")
student4 = ("Delia", "de Wattinger")
(a) Pune tuplele într-o listă, apoi utilizați un ciclu pentru a afișa doar fiecare prenume.
(b) Atribuie toate numele unei variabile de tip set numit Visio.
(c) Atribuie primele 3 tupluri unei variabile de tip set numit profesori.
(d) Atribuie restul la o variabilă set numit studenți.
(e) utilizează for pentru a imprima numele fiecărui elev, de exemplu corect formatat
Allan Anderson
(f) Utilizați un ciclu pentru a imprima numele fiecărui profesor folosind doar prima literă a
prenumelui de ex B.
"""
from colorama import Fore, Style
brendan = ("Brendan", "McCane")
sandy = ("Sandy", "Garner")
nick = ("Nick", "Meek")
student1 = ("Allan", "Anderson")
student2 = ("Barry", "Byars")
student3 = ("Christine", "Carver")
student4 = ("Delia", "de Wattinger")

print(Fore.YELLOW+"(a) Pune tuplele într-o listă, apoi utilizați un ciclu pentru a afișa doar
fiecare prenume.\n")
print(Fore.RED+"####################")
lista = [brendan, sandy, nick, student1, student2, student3, student4]
for i,j in lista:
print(Fore.CYAN,j)

# (b) Atribuie toate numele unei variabile de tip set numit Visio.
visio = set()
for i,j in lista:
visio.add(i)#-->Adauga elementele la set

# (c) Atribuie primele 3 tupluri unei variabile de tip set numit profesori.
# (d) Atribuie restul la o variabilă set numit studenți.
profesori = set()
studenti = set()
for i in range(3):
profesori.add(lista[i])
Lucrarea de Laborator Nr. 4 Programare Interactivă

for i in range(3, 7):

studenti.add(lista[i])

print(Fore.YELLOW+"\n(e) utilizează for pentru a imprima numele fiecărui elev, de exemplu

corect formatat Allan Anderson")
print(Fore.RED+"\n####################")
for m,n in studenti:
print(Fore.GREEN,m, n)

print(Fore.YELLOW+"\n(f) Utilizați un ciclu pentru a imprima numele fiecărui profesor

folosind doar prima literă a prenumelui de ex B.")
print(Fore.RED+"\n####################")
for i in profesori:
print(Fore.BLUE,i[0][0],Style.RESET_ALL)

"""
Scrieți un program care să citească un fișier ce conține un text. Programul va
crea și va afișa pe ecran un dicționar în care vor fi stocate cuvintele și numărul
de apariții ale acestora în textul din fișier. Îmbunătățește programul prin imprimarea
cuvintele în ordinea descrescătoare a numărului de apariții.
"""
from colorama import Fore,Style
f = open('file.txt', 'r')
Lucrarea de Laborator Nr. 4 Programare Interactivă

now = []
now_arr = []
now_check = []
final = {}
v=0
i=0
for j in f:
s = len(j)
while(s > 0):
if (j[i] != " ") and (j[i] != ".") and (j[i] != "\n"):
now.append('')#adauga elementul la sfarsit de lista
now[v] += j[i]
i += 1
else:
i += 1
v += 1
s -= 1

for i in range(len(now)):
if now[i] not in now_check and now[i] != '':
now_check.append(now[i])

for i in range(len(now_check)):
now_arr.append(0)
for j in range(len(now)):
if now_check[i] == now[j] and now[j] !='':
now_arr[i] += 1

for i in range(len(now_arr)):
final[now_arr[i]] = now_check[i]

print(Fore.CYAN+"Rezultatul cautarii: ",final,Style.RESET_ALL)

Lucrarea de Laborator Nr. 4 Programare Interactivă

"""
Se dă un șir de caractere. Șirul de caractere de împărțit în fragmente a câte
trei simboluri consecutive. În fiecare fragment simbolul de mijloc se înlocuiește
cu un caracter aleatoriu care nu coincide cu oricare dintre caracterele acestui
fragment. Fragmentele să fie sortate în ordine alfabetică.
"""
import random
import string
x = 'alexandru'
ascii = string.ascii_letters
arr = []
k = ''

for i in range(len(x) // 3):

arr.append(x[i * 3: i * 3 + 3])#adauga la sfarsit de lista

for i in range(len(arr)):
k += random.choice(ascii)#alegerea unui element random

while(k == arr[i][1]):
k += random.choice(ascii)
y = arr[i][1]
print(arr[i], "Caracterul: ",y, " Se schimba cu: ", k)
arr[i] = arr[i].replace(y, k)#schimbarea unui cuvant cu altul
k = ''

arr.sort()#sortare in ordine alfabetica

print(arr)

"""
Scrieți o funcție care are un dicționar d{int: int} ca intrare, și șterge din
acest dicționar toate intrările căror chei sunt mai mari decît cel puțin una
dintre valorile asociate cu celelalte chei din d, și returnează numărul de intrări
care au fost eliminate.
"""
def fuct(dict):
for keys in dict.keys():
for values in dict.values():
if (keys > values):
d2.append(keys)
Lucrarea de Laborator Nr. 4 Programare Interactivă

k=0
for i in d2:
if i in dict:
dict.pop(i)
k += 1
print(dict)
print("Sterese: ",k," chei")

d = {1 : 10,
2 : 20,
3 : 30,
4 : 40,
20 : 50}
d2 = []
fuct(d)

Concluzie: prin lucrarea respectivă am putut aplica diferite cunoștințe în

elaborarea algritmilor optimi de soluționare a problemelor propuse. Aplicând
bibliotecile Python, am stilizat textul la ieșire prin consolă, respectiv, aplicând
bibliotecile implicite și diferite funcții care se conțin în înterpretator, am putut
simplifica cardinal scrierea codului și numărului de rânduri a acestuia. Am
analizat posibilitățile limbajului de interpretare Python cu alte limbaje și mai
concret cu limbaje de nivel înalt (C++, C) prin care am ajuns la diferite concluzii
în ce ține complexitatea și funcționalitatea programelor în raport
eficiență/funcțional. Elaborarea acestui laborator mi-a permis să măresc baza de
cunoștințe pe care le posed și aplicarea materialelor teoretice în practică.