LIMBAJUL DE PROGRAMARE PYTHON ---Instrucţiuni Utile--- Vol. 1 OpenBooklet padre_cosmin

INTRODUCERE

Python este un limbaj de programare iniţial creat de olandezul Guido van Rossum în 1989 şi dezvoltat în continuu de atunci. Este foarte folosit în prezent pentru sintaxa uşoară şi posibilitatea de a crea aplicaţii complicate în puţine linii de cod.

Python este un limbaj interpretat, asta înseamnă că vom scrie codul sursă intr-un editor de text, ex. notepad, după care vom intra in linia de comandă şi vom scrie > python FisierSursa.py . python sau python.exe(pentru Windows) este interpretorul, un fişier sursă python are extensia .py. Este de asemenea un limbaj dinamic şi are management de memorie automatizat(garbage collecting), asta înseamnă că putem declara variabilele fără a le specifica tipul, interpretorul se ocupă cu stabilirea tipului şi de asemenea nu trebuie să ne ocupăm cu eliberarea memoriei când nu mai avem nevoie de o variabilă, interpretorul dealocă spaţiul ocupat de acea variabilă când nu mai e nici o referire la ea. Un dezavantaj la acest lucru este faptul că nu există operator cast, nu putem să schimbăm tipul variabilei, cu excepţia trecerii de la integer la float.

Paradigmele abordate de limbaj sunt: imperativă, orientare spre obiecte şi funcţională.

Blocurile de cod se delimitează prin indentări. Nu vom mai folosi {} sau begin ... end; ca in alte limbaje de programare.

C++ Python .....cod..... for(i=0; i<3; i++) { instructiunea1; instructiunea 2; } .....cod....

....cod... for i in [0, 1, 2]: instructiunea1 instructiunea2 ....cod...

Punctul şi virgula de la finalul instrucţiunilor sunt opţionale. Alte tipuri de date sunt tuplurile şi dicţionarele. Tuplurile sunt liste

care au un număr prestabilit de elemente şi nu pot fi modificate parţial. Se utilizează când este nevoie de o anumită structură de date specializată. Dicţionarele sunt liste neordonate in care fiecare element are asociat o cheie, care poate fi un număr sau şir de caractere.

Python este un limbaj case sensitive – aveţi grijă la minuscule şi majuscule

În urma instalării aplicaţiilor de dezvoltare python, vom avea un folder numit Pythonxx (xx reprezintă versiunea eu am versiunea 3.1 – directorul de pe calculatorul meu se numeşte Python31). Aici pot găsi interpretorul python.exe, folderul include cu biblioteci .h(asemănătoare fişierelor header pentru compilatoarele C/C++), folderul Lib cu diverse librării ce pot fi importate in programele pe care le creăm, folderul Doc cu un fişier documentaţie, etc.

Alte biblioteci pe care le putem descărca de pe net sunt: - NumPy – funcţii pentru calcule numerice - SciPy – rutine specifice pentru rezolvarea de ecuaţii, integrale, ecuaţii

diferenţiale - PyGame – pentru desvoltarea de interfeţe grafice şi evenimente - PIL(Pithon Image Library) – pentru manipularea şi procesarea de

imagini - Biopython – utilitar pentru citirea fişierelor utlilizate în Bioinformatică PRIMUL PROGRAM

PrimulProgram.py File | Edit | View | Help import msvcrt #acesta este un comentariu """ acesta e un comentariu pe mai multe rânduri """ ''' acesta e tot un comentariu pe mai multe rânduri ''' a = 3; #am atribuit variabilei a val. 3 print (1 + 2 \ + 3) print ('Salut Planeta') print ("Salut 'Planeta' ") print ('Salut "Planeta" ') print ("Salut \ Planeta") print (""" Salut Planeta """) ch = msvcrt.getch()

Salvăm fişierul cu extensia .py

Deschidem consola, cmd.exe sau terminalul şi scriem � python PrimulProgram.py $ python PrimulProgram.py Observaţii: 0) Pentru a putea folosi comenzile de mai sus trebuie să aveţi calea

către interpretorul python salvată in variabila environment PATH. În Windows PATH conţine o înşiruire de căi despărţite prin „;” şi se accesează din Start->ControlPanel->System->Advanced->Environment Variables->System Variables şi căutăm variabila Path, apăsăm butonul Edit şi adăugăm noua cale după ce am pus „;” după ultima din coadă 1) Programul scris pe pagina anterioară nu va merge decât pentru

Windows. De ce: Echivalentul lui getch() în python:

Windows Unix import msvcrt ........ ch = msvcrt.getch()

import sys, tty, termios

fd = sys.stdin.fileno()

old_settings =

termios.tcgetattr(fd)

tty.setraw(sys.stdin.fileno())

ch = sys.stdin.read(1)

2) Comentariile pe o linie se scriu după caracterul # Comentariile pe mai multe linii se încadrează intre """.....""" sau '''...''' 3) bibliotecile se introduc cu instrucţiunea import 4) ; - punct şi virgula după liniile de instrucţiuni e optională 5) Dacă dorim continuarea unei linii de cod pe linia următoare folosim caracterul „\” print (``Salut\ Planeta``) 6) import time time.sleep(nr_sec) #funcţia de pauză, nr_sec poate avea zecimale

INTRĂRI DE LA CONSOLĂ row_input() #versiuni mai vechi de Python input() #de la versiunea Python 3.1 sir = row_input("Introduceti sir de char: ") nr = int(row_input("Introduceti numar = ")) nrFloat = float(input("Indtroduceti nr float= ")) IEŞIREA LA CONSOLĂ IN PYTHON Se face cu funcţia print. print afişează mesajul sau valoarea variabilei şi trece la linie nouă. print"..." #pentru versiunei mai vechi de Python print("...") #începând cu versiunea Python 3.1 print ("Salut Planeta") a = 3 print (a) print ("Salut Planeta") Pentru a afişa mai multe lucruri pe acelaşi rând cu instrucţiuni print consecutive punem virgulă după print-ul anterior print ("Ana avea",) print (varsta,) print ("cand a fost la mare") print ("Ana are ",14,"ani") Instrucţiunea sys.stdout.write import sys sys.stdout.write("Salut ") sys.stdout.write("Planeta") #nu mai trece la linie nouă

IEŞIRE FORMATATĂ Ieşirea pe un anumit număr de caractere

print(repr(x).rjust(nr)) repr(...) – generează o reprezentarecare este citită doar de interpretor, inutilă atunci când obiectule este un string str, atunci merge sir.rjust(...) rjust(nr) – foloseşte la afişarea reprezentării pe un număr de caractere, dacă reprezentarea propriu-zisă are mai putine caractere, atunci se completează cu caractere în faţa ei for i in range(1, 10): print(repr(i).rjust(2), repr(i*i).rjust(3)) echivalent cu: for i in range(1, 10): print('{0:2d} {1:3d}'.format(i, i*i)) ieşirea: 1 1 2 4 3 9 4 16 5 25 6 36 7 49 8 64 9 81

.zfill() – în loc de spaţii albe ca rjust(), adaugă zerouri `12`.zfill(5) returneaază `00012` .ljust(), center() print(`{0} are {1}`.format(`Ana`, `mere`)) #pune ‚Ana’ în loc de {0} şi ‚mere’ în loc de {1} print(`Numarul PI = {0:.3f}`.format(math.pi)) #afişează numărul pi cu 3 zecimale CARACTERE EXCAPE Caracter Nume Exemplu \’ apostrof print(`Don\’t say that’) \” ghilimele \\ Backspace \n linie nouă print(`O linie\nAdoua linie`) \r return de car \t tab \b backspace \uxxxx unicode pe 16b \Uxxxxxxxx unicode pe 32b

ALTE FUNCŢII DE LUCRU CU CONSOLA SI SISTEMUL DE OPERARE: import os os.system(`comanda_DOS_sau_UNIX`) Curăţirea consolei:

Windows Unix import os os.system(‘cls’)

import os os.system('clear')

Alte componente ale serviciului os os.name – returnează `posix`, `nt`, `os2`, `ce`, `java`, `riscos` funcţie de platforma pe care rulează python os.getpid() – returnează pid-ul curent os.getenv(numevar[valoare]) – returnează valoarea variabilei de sistem dacă aceasta există. Dacă variabila nu există value este none os.putenv(numevar, valoare) – setează valoarea variabilei de sistem numevar la valoarea value. Afectează subprocesele startate cu os.system(), popen(), fork() sau execv() os.umask(mask) – setează masca şi returnează masca anterioară os.unsetenv(numevar) – şterge variabila numevar os.fdopen(fd[,mod[,bufsize]]) – returnează un obiect conectat la descriptorul de fişier fd. mode şi bufsize corespund argumentelor funcţiei open() os.popen(command[,mod,[,bufsize]]) – deschide un canal pipe către sau dinspre command. Returnează un obiect conectat la pipe. Dacă e de scriere sau citire depinde de mod = `r` - citire, `w` - scriere os.close(fd) – închide un un descriptor fd os.fchmod(fd, mode) – pe Unix, schimbă priorităţile de acces ale fd la modul numeric mode. os.fchown(fd, uid, gid) – schimbă proprietarul şi grupul pentru fisierul dat de fd la valorile numerice uid, gid. Pentru a lasa uid sau gid nemodificate, se pune in dreptul lor valoarea -1

VARIABILE – TIPURI DE VARIABILE Deşi nu trebuie neapărat declarat tipul unei variabile, în Python există 10 tipuri de variabile. tip descriere exemplu str secvenţă nemutabilă de caractere.

În Python2 str sunt caractere, şirurile Unicode trebuiau predecate de litera u, în Python3 şirurile sunt Unicode implicit

sir = `Salut Planeta` sir2 = `Salut Planeta` print("""Ana are mere""")

bytes secvenţă nemutabil de bytes b’niste caractere ASCII’ b"CaractereASCII"

list mutabil, nu pot fi mixate tipuri [4.0,'string',True]

tuple mutabil, poate conţine mixuri de tipuri

(4.0,`string`,True)

set neordonate, nu conţine duplicatii. Este nemutabil

{4.0, `string`, True} frozenset ([4.0, `string`], True)

dict grup mutabil de chei şi valori ataşate

{`keie`: 1, 123: False}

int intreg nemutabil de lungime variabilă

2345

float valoare în virgulă mobilă de precizie fixă

2.71

complex număr complex 2+3.5j bool conţine o valoare de adevăr True, False Operatorul CAST Numeric �������� Şir de Caractere a = 123 sir = str(a) a2 = int(sir) a3 = float(sir) print("a= ", a, "| sir: ", sir, "| a2= ", a2, "| a3= ", a3) Rezultatul este: a= 123 | sir: 123 | a2= 123 | a3= 123.0 Bool �������� Şir de Caractere a = True sir = str(a) a2 = bool(a) print("| a= ", a, "| sir= ", sir, "| a2= ", a2) | a= True | sir= True | a2= True

ALTE OBSERVAŢII: Toate variabilele sunt obiecte.

- două variabile nu pot avea acelaşi nume, dacă folosim un nume dat pentru o variabilă pentru a înscrie în ea alt tip de dată, prima variabilă se pierde şi se creează o altă variabilă care acceptă acel tip de dată

- se pot utiliza asignările multiple a=b=c=3 - altă formă de asignare multiplă a,b,c = 1, 2, ``sir de car`` #lui a i se dă 1, lui b valoarea 2, lui c valoarea ``sir de car`` - ştergerea unei variabile del numevar #memoria e dealocată,

variabila nu mai poate fi folosită - valorile hexazecimale sunt precedate de prefixul 0x 0x123A3 - valorile octale sunt precedate de prefixul 0o 0o3452 - type(var) #returnează tipul variabilei trimise ca param. - id(var) #returnează identificatorul numeric al variabilei - is compară identitatea a două obiecte

OPERAŢII Operaţii aritmetice

Operator Descriere Exemplu + adunare a = 1+2 - scadere a = 1-3 / împărţire a = 2/3 // împărţire întreagă a = 4//2 * înmulţire a = 3*2 % modulo a = 4%2 ** putere a = 2**3

Operatori de comparaţie

Operator Descriere Exemplu > mai mare i<100 < mai mic i>200 >= mai mare sau egal i>=210 <= mai mic sau egal i<=a == testarea egalităţii a == b != diferit a != c

Operatori logici Operator Descriere Exemplu not negare logică not b and şi logic (i<=100)and(c==True) or sau logic (i<100)or(f>100)

Operatori pe biti Operator Descriere Exemplu ~ Complement ~b << shiftare stânga b<<1 >> shiftare dreapta b>>1 & şi pe biţi b&0x02 ^ sau exclusiv pe biţi b^0x02 | sau pe biti b | 0x02

TIPUL int, long, float În versiunile mai vechi existau două tipuri integer. int – era limitat la 32 de biţi, ex.: a = 123, b = int(``234``) long – era limitat la cât poate duce memoria se forma prin sufixul „L” plasat la capătul valorii date unei variabile a = 123456789L b = long(``987654321``) Long nu mai apare în Python3.1 şi int a preluat proprietăţile acestuia. Float este echivalent tipului double din C şi are precizie fixată a = 3 a = a/4 # interpretorul face singur conversia, a devine var float Cu variabilele întregi se pot face operaţii aritmetice, de comparare, pe biţi. TIPUL complex Variabilele definite complex conţin valori complexe(formate din parte reală şi parte imaginară). Unitatea imaginară este notată „j” a = 12+21j b = complex(``2+3j``) TIPUL bytes Conţine o înşiruire de octeţi a = b”Abracadabra” b = b’A0BC23eFXsWG’ print(a) #afişează toată înşiruirea de octeţi print(a[3])#afiseaza valoarea ASCII a caracterului de pe poziţia 3, #primul caracter, cel mai din stânga, are indicele 0 a[4]=”D” #va da eroare, nu putem să mai schimbăm ceva în a TypeError: 'bytes' object does not support item assignment

CLASA MATH şi funcţiile conţinute de aceasta: import math #pentru numere reale import cmath #pentru numere complexe Funcţiile de mai jos au două echivalente, math.functie() – pentru numere reale, cmath.functie()- pentru numere complexe math.ceil(x) - returnează cea mai mica valoare intreagă mai mare decât x(aproximare în adaus) math.copysign(x, y) – returnează x cu semnul lui y math.fabs(x) – returnează modulul lui x math.factorial(x) – x factorial sau ValueError dacă x este întreg sau negativ math.floor(x) – returnează valoarea întreagă a lui x math.fmod(x, y) – returnează modul între x şi y, x%y math.frexp(x) – returnează mantisa şi exponentul lui x ca pereche (m,e) x = m*2**e math.fsum(iterable) – returnează o sumă în virgulă mobilă a valorilor din parametrul iterabil. math.isinf(x) – cercetează dacă x este infinit negativ sau pozitiv math.isnan(x) – cercetează dacă x este NaN(not a number) math.ldexp(x, i) - returnează x*(2**i) math.modf(x) – returnează partea fracţionară şi cea întreagă a părţii lui x math.trunc(x) – returnează partea reală a lui x trunchiata la întreg Puteri şi logaritmi: math.exp(x) – returnează e**x math.expm1(x) – returnează e**x-1 adică math.exp(x)-1 math.log(x[,baza]) – returnează logaritm natural din x daca nu specificăm nicio bază. Cu două argumente, baza ia valori întregi, se returnează ln(x)/ln(baza) math.log1p(x) – returnează ln(1+x), baza = e math.log10(x) – returnează lg(x), baza = 10 math.pow(x, y) – returnează x**y, ( x la puterea y)

math.sqrt(x) – returnează radical din x, x

Funcţii trigonometrice: math.acos(x) – returnează arccosinus(x) în radiani math.asin(x) – returnează arcsinus(x) în radiani math.atan(x) – returnează arctangentă(x) în radiani math.atan2(y, x) – returnează atan(y/x) în radiani math.cos(x) – returnează cosinus(x) în radiani math.sin(x) – returnează sinus de x, x în radiani math.tan(x) – returnează tangenta de x, x în radiani math.acosh(x) – returnează inversa cosinusului hiperbolic math.asinh(x) – returnează inversa sinusului hiperbolica math.atanh(x) – returnează inversa tangentei hiperbolice math.cosh(x) – returnează cosinus hiperbolic de x math.sinh(x) – returnează sinus hiperbolic de x math.tanh(x) – returnează tangenta hiperbolica a lui x

math.hypot(x, y) – returnează norma euclidiană, yyxx ** +

Conversii între unghiuri: math.degrees(x) – converteşte unghiul x din radiani în grade math.radians(x) – converteşte unghiul x din grade în radiani Functii speciale: math.erf(x) – returnează funcţia la x math.erfc(x) – returnează funcţia complementară eroare la x math.gamma(x) – returnează funcţia gamma la x math.lgamma(x) – returnează logaritm natural de valoare absolută a ceea ce returnează funcţia Gamma Numere aleatoare import random seek() returnează generatorul de numere aleatoare random(a, b) returnează a<=N<=b random() returnează nr random între 0.0 şi 1.0 Constante: math.pi = 3.14159265359 math.e = 2.71828182846 (constanta lui Euler)

ŞIRURI DE CARACTERE Stringurile sunt imutabile, elementele unui string nu pot fi modificate. Sunt vectori de caractere, indicele vectorului porneşte de la 0(zero). Funcţia len(sir) – returnează lungimea şirului de caractere primit ca parametru, numărul de caractere Concatenarea şirurilor de caractere se face cu operatorul „+” Şirurile se pot compara cu operatorii ==,>,<, >=, <=, != sir = ``Ana ``+ ``are mere`` sir2 = `Mara are pere` sir3 = ``` Ana are mere``` #se reţin şi caracterele newline sir4 = sir * 3 #pune în sir4 şirul sir multiplicat de 3 ori Accesarea unui element din şir print(sir[2]) #returnează al 3-lea element din şir, idnexarea se face de la elementul cel mai din stânga începând cu indexul 0 sir[4] = `A` #ERROARE nu putem modifica înregistrările dintr-un şir, şirurile de caractere sunt imutabile sir = `Ana nu are mere` #putem însă asigna cu totul o altă înregistrare şirului, practic variabila sir iniţială se şterge şi se creează alta nouă cu o nouă înregistrare sir[:nr] – accesează nr elemente de la începutul şirului,practic afişează toate elementele din şir până la indexul nr-1 print(sir[:2]) va genera „An” sir[index:] – accesează toate elementele începând cu index până la capătul şirului sir[i1:i2] – accesează toate elementele începând cu indexul i1 şi terminând cu indexul i2-1 sir[::i] – accesează toate elementele de pe indexurile care se divid cu i Observaţii: sir[-2:] �� sir[-2::] – accesează 2 elemente de la capătul şirului, în cazul acesta „re” din cuvântul „mere” sir[:-3] – accesează toate elementele din şir mai puţin ultimele 3 („Ana are m”) sir[::-2] – accesează toate elementele din şir care se divid cu 2 dar parcurge şirul de la coadă spre capăt print(sir1==sir2) #returnează valoarea de adevăr(True sau False) a comparaţiei între şiruri

Nu putem schimba elementul un singur element într-un şir de caractere(sir[2]=”B” #eroare) dar putem crea un nou şir cu acelaşi nume şi să punem pe poziţia unde dorim un alt element: sir = ``Ana are mere`` sir = sir[:4] + ``nu are `` + sir[8:] #prima variabilă sir se distruge şi se creează alta cu noul conţinut dorit de noi LISTE:

- sunt mutabile, elementele pot fi modificate; - pot conţine elemente de diferite tipuri - len(lista) – returnează lungimea listei - indicii pornesc de la valoarea 0(zero), elementele având indicii 0-:-

len(lista)-1 - lista[0:len(lista)] – conţine lista cu elemente de la 0 la len(lista)-1

lista = [`Ana`, 234, `mere`, 3.4, [23, `abecedar`]] Accesarea unui element din listă se poate face: lista[indice] ex: print(lista[1]) #va returna 234 Listă de liste: lista2 = [[1, 3, 5], [`A`, 2, `C`]] Accesarea unui element dintr-o listă de liste se face: lista[i1][i2] #accesează elementul de pe linia i1, coloana i2 contează ca elementul respectiv să existe print(lista2[1][2]) #va returna valoarea C print(lista2[1]) #va returna [`A`, 2, `C`] lista3 = [[1, 3, 5], ['A', 2, 'C'], "abracadabra"] print(lista3[2]) #returnează abracadabra print(lista3[2][1]) #returnează `b` Listele sunt mutabile deci: lista[1] = `Mara` lista va deveni lista = [`Ana`, `Mara`, `mere`, 3.4, [23, `abecedar`]] lista[4][1] = lista[4][1][:3] + `X`+ lista[4][1][4:] lista va deveni lista = [`Ana`, `Mara`, `mere`, 3.4, [23, `abeXedar`]] # şirurile de caractere sunt in continuare imuabile chiar dacă fac parte ditr-o listă

lista4 = lista[0]*3 # lista4 = AnaAnaAna lista5 = lista[3] * 3 #lista4 = 3.4 * 3 = 10.2 lista6 = lista[4]*2 #lista6 = [23, 'abecedar', 23, 'abecedar'] Lista cu un singur element şi acela 0(zero) m = [[0]] n = m * 2 #n = [[0], [0]] Concatenarea listelor: Se face cu operatorul „+” lista5 = lista + lista2 #lista5 = ['Ana', 234, 'mere', 3.4, [23, 'abecedar'], [1, 3, 5], ['A', 2, 'C']] Accesare avansată a elementelor unei liste lista[indice] #accesează elementul cu indicele specificat lista[i1:i2] #accesarea elementelor de la i1 la i2-1 lista[i:] #afişează elementele începând de la al i-lea până la capăt lista[:i] #afişează elementele de la primul la al i-lea-1 lista[::i] #afişează elementele ale căror indice se divide cu i Funcţii membru lista.append(element) #adaugă elementul specificat la listă lista2.append(`branza`) #lista2 devine lista2 = [[1, 3, 5], [`A`, 2, `C`], `branza`] lista.extend(lista) #adaugă elemente din lista specificată ca param lista.insert(index, element) #pune element în listă pe indexul specificat lista.remove(index) #elimină element din listă, lungimea listei scade list.pop([i]) #scoate element din listă şi îl returnează, parametrul i este opţional, lista.sort() #sortează elementele din listă list.reverse() #inversează elementele din listă

TUPLURI - Un tuplu este o secventă de date similară cu listele. - Un tuplu constă într-un număr de valori separate prin virgulă - tuplurile sunt închise în paranteze - faţă de liste, tuplurile sunt imutabile - indexarea începe de asemenea de la indexul 0(zero) - len(tuplu) #returnează dimensiunea unui tuplu tuplu1 = (`Ana`, 345, 4.6, `mere`, `Bucuresti`) tuplu2 = (234, `Vasile`) tuplu3= (3,) #aşa se defineşte un tuplu cu un singur element! observaţi virgula după element print(tuplu1) #afişează tot tuplul Accesarea unui element din tuplu tuplu[indice] #observaţi parantezele pătrate tuplu[i1:i2] #accesează elementele de la i1 la i2-1 tuplu[i:] #afişează elementele începând de la al i-lea până la capăt tuplu[:i] #afişează elementele de la primul la al i-lea-1 tuplu[::i] #afişează elementele ale căror indice se divide cu i print(tuplu[0]) #afişează Ana Atenţie – tuplurile nu sunt mutabile tuplu[3] = `pere` #ERROARE de sintaxa, nu putem schimba elementele unui tuplu dar putem crea un nou tuplu cu acelaşi nume dar care tuplu1 = tuplu1[:2]+(`pere`, tuplu1[4]) #tuplul tuplu1 devine tuplu1 = ('Ana', 345, 'pere', 'Bucuresti') Tuplu in tuplu tuplu4 = ((`casa`, `masa`, 2), 987, 789, `Dana`) tuplu5 = (tuplu, 3.1416, 2.71) Accesarea elementelor într-un tuplu compus tuplu4 = ((`casa`, `masa`, 2), 987, 789, `Dana`) print(tuplu4[0][1]) #returnează „masa”

SETURI si SETURI ÎNGHEŢATE(FROZENSETS) - constau într-o colecţie neordonată de elemente care nu se repetă - operaţiile posibile sunt: reuniunea, intersecţia, diferenţa, diferenţa

simetrică - un set se creează cu {} sau set(), - set() creează un set fără elemente duplicate set0 = set() #am definit un set vid set1 = {123, 'Vasile', 2.71, 'Vasile'} #am definit un set, după cum observaţi avem elemente care se repetă, în procesul de creare a lui set1, al doilea „Vasile” este eliminat iar elementele setului sunt reordonate print(set1) #genereză {'Vasile', 123, 2.71} set2 = set(set1) # generează un set cu aceleaşi elemente ca set1 Seturile NU suportă indexarea print(set1[2]) #ERROARE Nu este suportat nici operatorul de concatenare „+” DIOCŢIONARE - dicţionare sunt liste de perechi cheie: valoare - sunt mutabile - cheile sunt unice - cheia trebuie să fie imutabilă - len(dictionar) returnează lungimea dictionarului - operatorul in testează dacă o cheie este în dicţionar dictionar = {cheie1: valoare1, cheie2: valoare2,...} Ex: dictionar = {1: 1234, `pi`: 3.1416, `fata`: `Ana`, 21: `Slatina`} dictionarGol = {} Accesarea unui element din dicţionar dictionar[cheie] print(dictionar[`fata`]) #returnează ‚Ana’ Adăugarea unui nou element în dictionar dictionar[cheie] = valoare #daca cheia este diferită de cele deja folosite in dicţionar, se adaugă o nouă valoare, dacă nu, atunci valoarea cheii din dicţionar se înlocuieşte cu noua valoare dictionar[`baiat`]=`Vasile` #dictionar devine: {1: 1234, 'fata': 'Ana', 'pi': 3.1416, 21: 'Slatina', 'baiat': 'Vasile'}

Alte operatii cu dicţionare dictionar.keys() #returnează toate cheile dictionar.values()#returnează toate valorile list(dictionar.keys()) #returnează o listă cu cheile folosite în dicţionar sorted(dictionar.keys())# ordonează dicţionarul după chei, cheile trebuie să fie de acelaşi tip del dictionar[cheie] #şterge elementul din dicţionar cu cheia specificată dict([(`a`, 1234), (1: 3.14), (`fata`, `Ana`)]) #returnează un dicţionar din perechile primite ca parametru, se mai poate folosi: >>> dict(sape=4139, guido=4127, jack=4098)

{'sape': 4139, 'jack': 4098, 'guido': 4127}

OPERATOR CAST int(x, [,baza]) – converteşte pe x în întreg in baza specificata, parametrul baza este opţional long(x, [,baza]) – converteşte pe x în întreg lung în baza specificată, parametrul baza este opţional float(x) – converteşte x în float complex(real [,imag]) – creează un obiect complex din parametrii primiti, imag poate să lipsească str() – converteşte obiectul x la o reprezentare string repr(x) – converteşte obiectul x la o expresie string tuple(x) – converteşte c la un tuplu list(x) – converteşte x la o listă set(x) – converteşte x la un set dict(x) – crează un dicţionar, d trebuie să fie o secvenţă de (cheie, valoare) frozenset(x) – converteşte x la un set îngheţat chr(x) – converteşte un intreg la caracter unichr(x) – converteşte un intreg la un caracter Unicode ord(x) – converteşte un singur caracter la o valoare intreagă hex(x) – converteşte un întreg la un string din cifre hexazecimale oct(x) – converteşte un întreg la un string din cifre octale OPERATORUL IN val in lista - returnează true dacă valoarea este in listă, tuplu, dicţionar, etc. false dacă nu este

ALTE FUNCŢII ŞI OBSERVAŢII IMPORTANTE - dir() afişează toate simbolurile definite in mediul de rulare in

momentul apelării - all(iterable) – întoarce True daca toate elementele listei sunt True - any(iterable) – întoarce True dacă cel putin un element al liste este

True - sum(iterable) – returnează suma elementelor unui obiect

secvenţacare are elemente numerice - min(iterable) – returnează minimul unui obiect de tip secvenţă - max(iterable) – returnează maximul unui obiect de tip secvenţă - range([start,] stop[,step]) – întoarce o listă care conţine elemente

aflate in progresie aritmetică, cu primul termen start, raţia step şi fără a depăşi valoarea stop

- map(f, secventa) – aplica f pe fiecare element al secvenţei şi întoarce o listă cu rezultate

- zip(iterable1, iterable2,…) – întoarce o listă de tupluri, în care tuplul I conţine al i-lea element din fiecare secvenţă, pentru a obtine secvenţele initiale se poate utiliza zip(*zipped), unde zippled este lista de tupluri obţinută la apelul zip(iterable1, iterable2)

- reduce(f, secventa) – întoarce un singur rezultat obtinut în urma aplicării funcţiei f

•••• range(nr) #returnează o listă elemente consecutive de la 1 la nr cu

pas de iteraţie 1 [1, 2, 3,.......,nr] •••• range(nr1, nr2) #returnează o lista de elemente începând de la nr1 la

nr2 cu pas de iteraţie 1 •••• range(nr1, nr2, pas) #returnează o listă de elemente începând de la

nr1 la nr2 cu pasul de iteraţie specificat. Putem să dăm şi pas de iteraţie negativ, numărătoare făcându-se invers

range(10, 1, -2) #generează [10, 8, 6, 4, 2]

ELEMENTE DE PROGRAMARE STRUCTURATĂ CONDIŢIA CONDIŢIA --- IF if expresie: instructiune1 instructiune2 ……… restul codului if expresie: instructiuni else: instructiuni restul codului if expresie: instructiuni elif expresie: instructiuni else: instructiuni restul codului

var = 100

if var == 200:

print "1 - Got a true expression value"

print var

elif var == 150:

print "2 - Got a true expression value"

print var2

elif var == 100:

print "3 - Got a true expression value"

print var

else:

print "4 - Got a false expression value"

print var

Nu se mai folosesc acoladele pentru a delimita blocurile, blocurile se delimitează folosind indentările, aveti grijă la ele!!!

CONDIŢIONALA SWITCH-CASE: Python nu are condiţională switch-case dar se poate folosi un cod echivalent: result = {

'a': lambda x: x * 5,

'b': lambda x: x + 7,

'c': lambda x: x - 2

}[value](x)

to catch an error if no key found

try:

{'option1': function1,

'option2': function2,

'option3': function3,

'option4': function4}[value]()

except KeyError:

# default action

I would probably use

switch = {'option1': function1,

'option2': function2,

'option3': function3,

'option4': function4}

if value in switch:

switch[value]()

else:

pass

#default

#COD netestat

CICLURI CICLUL FOR for var in […lista/tuplu/dictionar/sir car/etc…] : instructiuni var – variabila contor ia toate valorile din listă, una câte una executându-se toate instrucţiunile din blocul for pentru fiecare element din listă for animal in ['cal', 'magar', 'vitel']: print('Ana paste '+animal+"ul") for nr in range(0, 100): print('In dulap sunt '+ str(100-nr) +' sticle de bere') print('Ia o sticla de bere din dilap, ',) print('in dulap mai sunt '+str(100-nr-1)+' sticle de bere') print() for nr in range(0, 100): print('In dulap sunt ', 100-nr,' sticle de bere') print('Ia o sticla de bere din dilap, ',) print('in dulap mai sunt ', 100-nr-1, ' sticle de bere') print() #nu am mai folosit concatenarea pentru a genera mesaje for nr in range(0, 100, 10) print(nr) #for cu loop peste 10 for litera in `abracadabra` print(`litera= `, litera)

fruits = ['banana', 'apple', 'mango']

for index in range(len(fruits)):

print 'Current fruit :', fruits[index]

CICLUL WHILE: while expresie : instrucţiuni Python NU are instrucţiunea do-while. Exemplu: count=0 while (count < 9):

print('The count is:', count)

count = count + 1

while not contor > 100:

instructiuni…

Operatori utilizaţi in lucrul cu ciclurile for, conditionale break – forţează ieşirea din cel mai apropiat ciclu for sau while continue – forţează trecerea la următoarea iteraţie a ciclului pass – nu face nimic, utilă când e necesară o instructiune care să nu facă nimic while True: pass #asteaptă o intrerupere, ex: CTRL+C CTRL+C #forţează ieşirea din execuţia scriptului din exterior import sys sys.exit(cod_eroare) #ieşire necondiţionată din script return valoare #ieşire dintr-un modul(funcţie), parametrul valoare lipseşte dacă funcţia nu returnează nicio valoare

MODULE --- FUNCŢII def numeFunctie(param1, param2,...) : ...instructiuni... return valoare numeFunctie(val1, val2,...) #utilizarea functiei def Functie(x): print(x) print(Functie(4)) ---------------------------------------- def Fibonacci(x): if (x==0) or (x==1): return x return Fibonacci(x-1)+Fibonacci(x-2) print(Fibonacci(7)) #recursivitate ---------------------------------------------------- def suma(a, b=4): return a+b print(suma(3)) #funcţie cu parametru cu valoare implicită, dacă nu dăm nicio valoare pentru respectivul parametru se consideră valoarea precizată în definiţia funcţiei ------------------------------------------------------------------ x = 10 def Functie(): global x print('x= ', x) x=5 print('x= ', x) print(Functie()) print('\nx= ', x) Funcţia returnează: x= 10 x= 5 None x= 5 Deci în Python variabilele globale se pot modifica din interiorul unei funcţii.

Observaţii: - funcţiile întorc ceva, dacă nu există nici un return în corpul funcţiei

se întoarce None - funcţiile sunt obiecte - funcţia şi corpului funcţiei trebuie scrise deasupra codului care le

utilizează Importarea unui fişier cu funcţii

Funcţii.py File | Edit| View | Help | def Functie1(a, b): return a+b def Functie2(a, b): return a-b

şi îl salvăm în acelaşi director cu scriptul care îl utlilizează

Script.py File | Edit | View | Help| import Functii print(Functii.Functie1(7,3)) print(Functii.Functie2(7,3))

import NumeFisierImportat #importă tot fişierul NumeFisierImportat.Functie() #foloseşte acea funcţie in fisierul care importă fisierul 2 from NumeFisier import Functie1, Functie2 #importă doar anumite funcţii din fişierul importat from NumeFisier import * #importă toate funcţiile din fişierul importat afară de cele ale căror nume încep cu „_” Python interpretează liniile de cod „import NumeFisier” căutând fişierul NumeFisier.py în directorul curent apoi in variabila environment PYTHONPATH apoi, dacă fişierul nu e găsit nici aici, caută fişierul in directorul de instalare al mediului Python. Fişierele .py care conţin funcţii şi care sunt apoi importante in alte scripturi sunt adesea compilate în format binar creându-se fişiere tipul NumeFisierImportat.pyc

Dacă avem mai multe funcţii cu acelaşi nume, ultima este cea folosită def Funct(): print('Ana are ') return def Funct(): print('mere') return Funct()

Returnează „mere” Alte lucruri importante despre Module

� python –O Script.py #se generează un fişier obiect numit Script.pco

� python –OO Scrip.py #forţează compilatorul să facă optimizări care uneori generează cod nefuncţional

� programul nu rulează mai rapid dacă este tip .pyc sau pyo decât dacă este .py singura diferenţă este rapiditatea cu care sunt încărcate

� când un script este rulat din linie de comanda python Script.py codul binar pentru script nu este scris in fişiere .pyc sau .pyo

� compileall Directorcreează fişiere .pyc sau ,pyo când –O este utilizat pentru toate modulele dintr-un director

� import sys sys.path.append(`...cale...`) #adaugă o cale la calea PATH Funcţia dir() dir(NumeFisier) #returnează numele funcţiilor conţinute în acel fisier

PACHETE Exemplu de pachet:

sound/ Top-level package

__init__.py Initialize the

sound package

formats/ Subpackage for

file format conversions

__init__.py

wavread.py

wavwrite.py

aiffread.py

aiffwrite.py

auread.py

auwrite.py

...

effects/ Subpackage for

sound effects

__init__.py

echo.py

surround.py

reverse.py

...

filters/ Subpackage for

filters

__init__.py

equalizer.py

vocoder.py

karaoke.py

... La importarea unui pachet, Python caută prin directoarele stocate în sys.path căutând subdirectorul pachet. __init__.py sunt cerute ca Python să trateze directorul ca şi când ar conţine pachete. __init__.py poate fi un fişier gol dar poate executa cod de iniţializare pentru pachet sau setarea variabilei __all__ import sound.effects.echo #importă un modul individual din pachet echivalent cu: from sound.effects.echo import echofilter

FIŞIERE f = open(`cale/fişier`, `mod_deschidere`)

mod_deschidere `r` citire `r+’ citire şi scriere `w` scriere `a` adăugare `b` binară

f.read() #citeşte tot fişierul şi afişează tot conţinutul lui f.read(dimensiune) #citeşte şi retunează un şir de caractere(dacă fişierul a fost deschis in mod text) octeţi dacă a fost deschis în mod binar. Numărul de caractere sau octeţi cititi e dat de parametrul dimensiune, dacă dimensiune e negativ sau absent funcţia returnează tot conţinutul fişierului. Dacă s-a atuns finalul fişierului se returnează ``. f.readline() #returnează o linie de caractere, până inclusiv la citirea caracterului `\n` pe care îl plasează la finalul şirului returnat. f.readlines() #returnează o listă cu toate liniile din fişier f.readlines(nr) #citeşte linii de cod până când octeţii cititi depăşesc nr precizat ca parametru şi s-a atins un caracter newline. Doar linii complete sunt returnate. Functia returnează de asemenea o lista de şiruri de caractere. f.write(informatie) #scrie informatia dată ca parametru in fisier f.seek(offset, reper) #mută poziţia de citire sau scriere in fişier la distanţa precizată de offset faţă de reper care poate fi: 0 – începutul fisierului(default dacă acest parametru este ignorat),1 – poziţia curentă, 2 – capătul fişierului f.close() #închide fisierul Functia pickle() read() returnează numai stringuri care doar trimise unei funcţii gen int() poate face extragerea valorii numerice. Dacă avem un obiect ‚x’ si vrem să îl scriem într-un fisier f folosim pickle.dump(x, f) Dacă vrem să citim un obiect ‚x’ dintr-un fisier: x = pickle.loan(f)

CITIRE – SCRIERE în fişiere cu CSV CSV(Comma Separated Values) este cel mai important format de importare, exportare a înregistrărilor pentru baze de date. Se pot citi sau scrie date în format de exemplu Excel fără a cunoaşte formatul binar Exel. Funcţii definite în modulul csv: >>> import csv csv.reader(csvfile[,dialect=’exel’][,fmtparam]) Returnează un obiect care iterează printre liniile fisierului csvfile. csvfile poate fi orice obiect care suportă protocolul iterator şi returnează câte un string de fiecare dată când este apelată funcţia next(). Dacă csvfile este un fişier obiect, el trebuie uneori deschis cu opţiunea `b` (binar). Parametrul opţional dialect stabileşte un set de parametri specifici unui dialect CSV. list_dialects() returnează lista de dialecte recunoscute import csv

spamReader = csv.reader(open('eggs.csv', 'rb'),

delimiter=' ', quotechar='|')

for row in spamReader:

print (', '.join(row))

Spam, Spam, Spam, Spam, Spam, Baked Beans

Spam, Lovely Spam, Wonderful Spam

csv.writer(csvfile[,dialect=’excel’][,fmtparam]) Returnează un obiect scriere responsabil pentru conversia datelor trimise de utilizator în stringuri delimitate şi dându-le caracteristicile fişierelor în care sunt scrise. Dacă csvfile este un obiect fişier de cele mai multe ori trebuie deschis cu `b`. Parametrul opţional dialect specifică dialectul. Valorile date lui fmtparam specifică care câmpuri să fie suprascrise sau înscrise. import csv

spamWriter = csv.writer(open('eggs.csv', 'wb'),

delimiter=' ',

... quotechar='|',

quoting=csv.QUOTE_MINIMAL)

spamWriter.writerow(['Spam'] * 5 + ['Baked Beans'])

spamWriter.writerow(['Spam', 'Lovely Spam',

'Wonderful Spam'])

csv.register_dialect(name[,dialect][,fmtparam]) Asociază dialectul cu nume, nume trebuie sa fie un string Unicode. csv.unregister_dialect(name) şterge dialectul asociat cu numele csv.get_dialect(name) returnează dialectul asociat cu nume. csv.list_dialects() returnează dialectele înregistrate csv.field_size_limit([limită_nouă]) returnează dimensiunea maximă pentru parser

Clase conţinute in modulul csv class csv.DictReader(csvfile[,filenames=None[,restkey=None[,restval=None[,dialect=’exel’[,*args,**kwds]]]]]) Creează un obiect care operează ca un cititor regulat dar mapează informatia de citit într-un dict ale cărui chei sunt date de parametrul opţional filednames. Dacă fildnames este omis, valoarea din primul rând al csvfile va fi utilizată ca filednames. Dacă rândul citit are mai multe câmpuri decât secvenţa fieldnames, datele rămase sunt adăugate ca o secvenţă a cărei cheie este restkey. Dacă rândul citit are mai puţine câmpuri decât secvenţele fieldnames. Cheile rămase preiau valorile ale parametrului opţional restval. class csv.DictWriter(csvfile, fieldnames[,rest=”[,extrasaction=’raise’ [,dialect=’exel’[,*args, **kwds]]]]) Creează un obiect care operează ca un scriitor darmapează dicţionarul în rânduri de ieşire. Parametrul fieldnames identifică ordinea în care valorile din dicţionar sunt pasate functiei writerow(). Parametrul opţional restval specifică valoarea care trebuie scrisă în dicţionar dacă dicţionarului îi lipseşte o cheie în filednames. Dacă dicţionarul sapat lui writerow() conţine chei negăsite in fieldnames, parametrul opţional extrasaction indică acţiunea care trebuie să aibă loc. Dacă e setat pe ‚raise’ o valoare ValueError este ridicată. Dacă este setat la ‚ignore’, valori din dictionar sunt ignorate. class csv.Dialect Este o clasă container ce conţine parametrii specifici instanţelor reader şi writer class csv.excel Defineşte proprietăţi ale unui fisier Excel generat de obiectul CSV. class csv.excel_tab Defineşte proprietăţile uzuale ale unui fişier Execl cu delimitări cu taburi. Class csv.Sniffer Clasa Sniffer este utilizată pentru a deduce un format al fişierului CSV Mai multe pe siturile: 1) http://docs.python.org/library/csv.html 2) http://www.developer.com/tech/article.php/3727616/Creating-Excel-Files-with-Python-and-Django.htm 3) http://scienceoss.com/read-excel-files-from-python/ 4) http://snippets.dzone.com/posts/show/2036 5) http://michaelangela.wordpress.com/2008/07/06/python-excel-file-reader/

CLASE class NumeClasa: #date interne clasei raza = 1 pi = 3.14 def FunctieMembru(self): aria = self.raza**2 * self.pi return aria obiect = NumeClasa() #am definit un obiect de tipul clasei create mai sus Cea mai simplă clasă class Goala pass 0) Toate metodele trebuie să aibă parametrul self ca prim parametru, este o referire la clasa din care fac parte. În metodă, datele membru trebuie de accesate cu self.varMembru altfel interpretorul python va cauta variabila în afara clasei ca variabila globală. La apelarea metodei unei clase din afară NU trebuie specificat şi argumentul self, python ştie că e acolo.

1) Clasele au ceva asemănător unui constructor: __int__ class Clasa:

def __int__(self, filename=None) __int__ este apelat imediat după crearea obiectului şi trebuie să fie prima metodă scrisă în clasă. 2) Definirea unei clase moştenitoare class ClasaNoastra(ClasaStramos): .....metode şi date ale clasei noastre... Am definit o clasă care moşteneşte metodele si datele clasei ClasaStramos la care adaugă alte date şi metode. Moştenirea se face simplu, prim specificarea clasei de la care se moşteneşte intre paranteze rotunde. Dacă vom crea o clasă care moşteneşte la o altă clasă, __init__ al clasei moştenite nu se va executa decât dacă specificăm acest lucru: from UserDict import UserDict

class FileInfo(UserDict):

"store file metadata"

def __init__(self, filename=None):

UserDict.__init__(self)

self["name"] = filename

import math

class FormeGeometrice:

forma = "patrat"

L=10

l = 5

R = 20

def __init__(self, forma2):

self.forma = forma2

def SetVal(self, param, valoare):

if param == "L":

self.L = valoare

elif param == "l":

self.l = valoare

elif param == 'R':

self.R = valoare

else:

print("Functia nu are\

asemenea parametru")

def Aria(self):

if self.forma == "patrat":

return self.l**3

elif self.forma == 'dreptunghi':

return self.L*self.l

elif self.forma == "cerc":

return self.R**2*math.pi

else:

return -1 #ERRoare

A = FormeGeometrice("cerc")

B = FormeGeometrice("dreptunghi")

C = FormeGeometrice("patrat")

print("=====Obiect A======")

print("A.forma = ",A.forma)

print("A.R(aza) = ", A.R)

#desigur ca A are si parametrii 'L' si 'l' dar nu

#ii vom folosi

print('--Schimbam raza retinuta de A--' )

A.R = 50 #observam ca valorile sunt publice

print("A.R(aza)-noua = ", A.R)

print('=========--Afisem Ariile=================')

print("A.Aria a returnat= ", A.Aria())

print("B.Aria a returnat= ", B.Aria())

print("C.Aria a returnat= ", C.Aria())

GRAFICĂ ELEMENTARĂ Se va descrie modulul grafic dezvoltat de John Zelle pentru Python Se descarca biblioteca graphics.py şi se plasează în folderul unde lucrăm. Biblioteca poate fi găsită pe: http://mcsp.wartburg.edu/zelle/python/graphics.py from graphics import *

def main():

win = GraphWin('Face', 200, 150) # give title and

#dimensions

win.yUp() # make right side up coordinates!

#uneori s-ar putea ca linia de mai sus san u mearga

head = Circle(Point(40,100), 25) # set center and radius

head.setFill("yellow")

head.draw(win)

eye1 = Circle(Point(30, 105), 5)

eye1.setFill('blue')

eye1.draw(win)

eye2 = Line(Point(45, 105), Point(55, 105)) # set

#endpoints

eye2.setWidth(3)

eye2.draw(win)

mouth = Oval(Point(30, 90), Point(50, 85)) # set corners

#of bounding box

mouth.setFill("red")

mouth.draw(win)

label = Text(Point(100, 120), 'A face')

label.draw(win)

message = Text(Point(win.width/2, 20), 'Click anywhere to\

quit.')

message.draw(win)

win.getMouse()

win.close()

main()

Biblioteca se importează cu from graphics import * win = GraphWin(...) primeşte numele ferestrei şi dimensiunile ei apoi creează fereastra de windows

FIGURI GEOMETRICE pt = Point(x, y) – crează un obiect punct la coordonatele x, y dar nu se afişează nimic până nu se foloseşte funcţia pr.draw() pt.draw(win) –desenează obiect cir = Circle(pt, 25) cir.draw(win) – creează un cerc de rază 25 având în mijloc coordonatele lui pt. La fel, nimic nu se afişează până când nu e apelată funcţia .draw() cir = Circle(pt, 25) cir.setFill(``blue``) #colorează interiorul cercului în albastru cir.setOutline(``red``)#colorează exteriorul în roşu cir.draw(win) linie = Line(pt, Point(150, 100)) linie.setWidth(3) #stabileşte grosimea liniei linie.draw(win) #creează o linie între punctul pt şi punctul de coordonate x = 150, y = 100 dreptunghi = Rectangle(Point(20, 100), pt) dreptunghi.draw(win) #creează un dreptunghi cu vârful stânga sus în punctul pt şi punctul dreapta jos în punctul de coordonate x = 20,y =100 label = Text(Point(100, 120), 'A face') label.draw(win) #creează un spaţiu de text cu colţul dreapta sus în punctul de coodonate 100, 120 Textulmaipoate fi scris şi cu liniile de cod message = Text(Point(win.width/2, 20), 'Click anywhere to

quit.')

message.draw(win)

Obiectele pot fi mutate, lucru util în animaţii (,move) linie.move(10, 40) # win.close() #iese din modul grafic

Alte funcţii grafice: win.setBackground(`<culoare>`) #colorează fundalul în culoarea specificată mesaj=Text(Point(win.width/2, 20), `Mesaj`) mesaj.setTextColor(`<culoare>`) #stabileşte culoarea cu care va fi scris textul mesaj.setStyle(`italic`) #stabileşte stilul cu care va fi scris textul mesaj.setSize(20) #stabileşte cu ce grosime va fi scris textul mesaj.draw(win) Culori: Culorile se pot specifica ca nume (red, green, blue, white, black...) sau ca grupe de numere hexazecimale de tipul:

#rgb 4biţi/culoare #ff0 #rrggbb 8biţi/culoare #0011ff #rrrgggbbb 12biţi/culoare #2550127fa

SUNETE: Pentru platforme Windows: import winsound winsound.Beep(frecventa, durata) – generează un sunet de anumită frecvenţă o anumită durată de timp, frecv=37-:-32,767 winsound.PlaySound(fisSunet, mod) – apelează functia PlaySound, fisSunet trebuie să fie un fişier audio trimis ca şir de caractere mod = winsound.SND_FILENAME – fisierul audio este un .wav

winsound.SND_ALIAS – parametrul sunet este un sunet asociat cu un nume dintr-un registru. Dacă registrul nu conţine acest nume, rulează sunetul default dacă SND_NODEFAULT nu este specificat. winsound.SND_LOOP – rulează sunetul repetat. Se foloseşte SND_ASYNC pentru a se evita blocajul. Nu poate fi utilizat împreună cu SND_MEMORY winsound.SND_MEMORY – fisSunet este o imagine în memorie a fisierului audio .wav trimisă ca un şir de caractere winsound.SND_PURGE – opreşte rularea tuturor instanţelor sunetului specificat winsound.SND_ASYNC – rulează sunetul asincron winsound.SND_NODEFAULTS – dacă sunetul nu poate fi găsit, nu rulează sunetul default al sistemului

winsound.SND_NOSTOP – nu întrerupe sunetul ce rulează curent winsound.SND_NOWAIT – returnează imediat dacă driverul este ocupat winsound.MB_ICONASTERISK – rulează sunetul SystemDefault winsound.MB_ICONEXCLAMATION – rulează sunetul SystemExclamation winsound.MB_ICONQUESTION – rulează sunetul SystemQuestion winsound.MB_OK – rulează sunetul SystemDefault

winsound.MessageBeep([type=MB_OK]) – rulează un sunet specificat în unul din registre. Argumentul type specifică care sunet e rulat din lista mod de mai sus. Dacă type = -1 se produce un simplu beep

LUCRU CU ŞIRURI DE CARACTERE ---ADĂUGIRI import string Constante: string.ascii_leters – toate literele 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'. string.ascii_lowercase – toate literele minuscule 'abcdefghijklmnopqrstuvwxyz' string.ascii_upercase – toate literele majuscule 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' string.digits – toate cifrele, `0123456789` string.hexdigits – toate cifrele hexazecimale string.letters string.lowercase string.uppercase string.octdigits – cifrele octale string.punctuation – semne de punctuaţie string.whitespace – spaţiu Funcţii: string.capwords(s[,sep]) – desparte argumentul în cuvinte folosind str.split(), capitalizează fiecare cuvănt folosind str.capitalize şi uneşte cuvintele capitalizate utilizând str.join(). string.maketrans(sursa, destinatie) – returnează un tabeld e tranziţie pentru a-l da functiei translate(). Acesta va mapa fiecare caracter din sursă în caracterul de la aceeaşi poziţie în destinatie. Sursa şi destinatia trebuie să aibă aceeaşi lungime.

string.atof(s) – face conversia sir caractere ���� număr cu virgulă string.atoi(s[,baza]) – face conversia sir de car����nr întreg în baza specificata, baza = 0x, 0X(hexa), o(octal) string.atol(s[,baza]) – face conversia şir de caractere ���� nr întreg lung string.capitalize(word) – returnează o copie a cuvântului cu prima literă transformată în majusculă string.expandtabs(s[,tabsize]) – transformă taburile în spaţii string.find(s, sub[,start[,end]]) – returnează cel mai mic index unde este găsit subşirul sub astfel încât subşirul să fie conţinut în s[start:end] string.rfind(s, sub[,start[,end]]) – asemenea doar că returneaza indexul cel mai mare string.index(s, sub[,start[,end]]) – la fel ca fiind doar că incrementează valoarea lui ValueError dacă subşirul nu este găsit string.rindex(s, sub[,start[,end]])-----//--- string.count(s, sub[,start[,end]]) – returnează numărul de apariţii ale subşirului sub între poziţiile start:end din şir string.lower(s) – transformă caracterele şirului în minuscule string.upper(s) – transformă caracterele şirului în majuscule string.split(s,[,sep[,maxsplit]])- returnează o listă de cuvinte din şirul s. Dacă parametrul sep este absent sau None, cuvintele sunt separate prin şiruri de caractere de tabulare(spatii, taburi, linii noi). Sep ia valoarea caracterelor care vor fi interpuse între cuvintele returnate. Maxsplit este bydefault =0, dacă e diferit de 0 indică de câte ori se se face split. string.rsplit(s[,sep[,maxsplit]]) – returneaza o listă de cuvinte din sirul s căutând sfârşitul lui s. Singura diferentă fată de split() este că atunci când maxsplit !=0 ultima element din listă este primul string.splitfileds(s[,[,maxsplit]]) – ca si split() string.join(words[,sep]) – concatenează o lista de tupluri de cuvinte şi le desparte prin separatoarul sep string.lstrip(s[,chars]) – returnează o copie a sirului după ce a eliminat caracterele chars de la începutul şirului, dacă chars nu apare se elimină spaţiile string.rstrip(s[,chars]) – returnează o copie a sirului după ce a eliminat caracterele chars de la sfârşitul şirului, dacă chars nu apare se elimină spaţiile string.strip(s[,chars]) – returnează o copie a şirului după ce a eliminat caracterele chars de la inceputul şi sfârşitul şirului de caractere. Dacă chars nu apare se elimină spatiile

string.swapcase(s) – returnează o copie a şirului de caractere inversând minusculele în majuscule şi majusculele in minuscule string.translate(s, table[, deletechars]) – şterge toate caracterele din s care se află în deletechars şi apoi translatează caracterele folosind table care trebuie să fie un şir de 256 caractere cu translatările fiecărui caracter. Dacă tabelul este None atunci se face doar ştergerea de caractere. string.ljust(s, width[,fillchar]) string.rjust(s, with[,fillchar]) string.center(s, width[,fillchar]) – umple un spatiu width cu caracterele fillchar la centru pentru center(), la stânga pentru ljust(), la dreapta pentru rjust() string.zfill(s, width) – pune ‚0’ la stânga şirului pe o dimensiune de width. Şirurile care încep cu semn sunt manipulate corect string.replace(str, old, new[,maxreplace]) – returnează o copie a şirului str cu toate apariţiile subşirului old înlocuite de new. dacă argumentul maxreplace este dat, prima apariţie a lui maxreplace este înlocuită Intrări din linia de comandă: File | View | Search | Help import sys for i in range(1, len(sys.argv)): print(sys.argv[i])

Bibliografie: 1) python3.1 documentation – vine odată cu kitul de install 2) Python Programming – Wikibooks 3) GUI Programming with Python: QT Edition Boudewijn Rempt 4) http://docs.python.org/tutorial/ 5) http://docs.python.org/release/2.5.2/tut/tut.html 6) http://www.sthurlow.com/python/ 7) http://www.tutorialspoint.com/python/