Tutorial Python 3.2 ( Partea 3 )

[R0cc0]

String-uri in Python

Slicing and substrings ( Felierea si sub – stringuri )

Si mai interesanta este posibilitatea de taiere ( slicing ) , aceasta tehnia permite sa taiati o parte din lista care indica indicele de pornire si indicele de incheiere , este util sa stiti ca sub – stringul prelevat e acela care pleaca de la caracterul indicat al primului indice inclus , pana la indicele final exclus , omitand unu dintre indici indicam Python-ului sa mearga pana la sfarsit cu taierea , daca punem un numar negativ ca si indice final , Python va calcula caracterele in sens invers .

Niste exemple practice :

>>> y='Hello World'
>>> y[0] # Ia prima litere de la Y avand in vedere ca se porneste de la 0
'c'
>>> y[5]
'm'

>>> x='Programare Pythom'
>>> x[-2] # Printeaza al doilea caracter incepand de la dreapta
'o' 
>>> x[2:7] # Printeaza caracterele X inclusiv de la 2 la 7
'ogram' 
>>> x[4:] # Printeaza de la al patrulea caracter pana la sfarsit X
'ramuri python' 
>>> x[:4] # Printeaza caracterele X cuprinse de la inceput pana la al patrlea
'prog' 
>>> x[3:-2] # Printeaza de la al treilea caracter incepand de la 0 pana la penultimul X
'gramare python

Metode pentru string-uri

Observam acum anumite metode pentru stringuri care pot fii utile :

Metoda " find() " este utila a reincarca de caractere un string , iar daca nu este prezent de rezulta " -1 "

>>> s='rstforums.com'
>>> s.find('rst')
0

Metoda " replace() "

>>> s.replace('com','test')
'com.test'

Metodele " upper() si lower()" , servesc la convertirea

MAJUSCULELEOR si minusculelor intr-un string.

>>> up=s.upper()
>>> print(up)
rstforumc.com
>>> low=up.lower()
>>> print(low)

Construirea stringurilor :

Multumita operatorului " % " putem sa construim un string introducand parametr " semnalpost " care se pot substituii cu valori asumate de variabile , ca si in instructia " printf " din " C " , exemplu :

>>> nume = 'stefan'
>>> ani = 29
>>> rezultat = "%s are %d ani" % (nume, ani)
>>> print(rezultat)
stefan are 29 ani

In primele linii am definit variabilele + valorile string si numerice .

In linia " %s are %d ani " am introdus parametrii .

%s – Parametru de tip string

%d – Parametru de tip numeric

Parametrii pentru constrirea sting-urilor :

Python ne ofera alte functii pentru a gestii string-urile , toate sunt grupate imprena cu modulul numic " string " .

Liste

Listele in Python sunt coletii ordonate de obiecte simalre " array " al altor tipuri de limbaje , cum ar fii Java .

Diferit de string-urile despre care am vorbit , listele pot sa contina obiecte eterogene cum ar fii numere , string-uri si alte liste , acest ne permite de a manipula rapid si de a structura complexitati de alta natura , petru a declara o lista este suficient sa dati unui variabile o lista de valori , separate prin virgula si inchide cu paranteze patrate , exemplu :

>>> l1=[1, 'html.it'] # Lista cu un intreg si un string
>>> l2=[1, 1.2, 'ciao', [1,2] ] # Lista cu : intreg , real , string si o alta lista

O mare parte din ceea ce am scris pentru string-uri este valabil si pentr liste , ca si indice care incepe de la 0 , normal o serie de exemple vor demonstra cum lucreaza operatorii de indici si slicing ( taiere ) .

>>> s=['rst', 'com', 'rst.com']
*
>>> s[0]****** # indicare
'rst'
*
>>> s[-2]***** # Indicare incepand de la dreapta
'com'
*
>>> s[:2]***** # slicing
['rst', 'com']
*
>>> s[2:]
['rst.com']
*
>>> s[1:-1]
['com']

Sa vedem acum operatorii pentru concatare " + " si repetare " + " , pentru liste .

>>> [1, 2, 3] + [4, 5] # concatare
[1, 2, 3, 4, 5]
*
>>> ['rst.com']*3***** # repetare
['rst.com', 'rst.com', 'rst.com']

>>> y=[1,2,3]

*

>>> y[0]="unu"* # Modifica lista

>>> y

['unu', 2, 3]

*

>>> y[1:2]=[]** # Sterge un element din lista

>>> y

['unu', 3]

Pentru a cunoaste lngimea unei liste , utilizam functia " len()"

>>> lista=['c', 'a', 'b']***** 
>>> len(lista)
3

Metode pentru liste

Exemple :

>>> lista=['rst', 'rst', 'rst l']**** 
*
>>> lista.append('rst .com')************ #metoda append()
>>> lista
['rst', 'rst', 'rst', 'rst.com']
*
>>> lista.extend(['HYml','rst.COM'])*********#metoda extend()
>>> lista
['rst', 'rst', 'rst', 'rst.com', 'HYml', 'rst.COM']
*
>>> lista.insert(0, 'primuRST')************ #metoda insert()
>>> lista
['primuRST', 'rst', 'rst', 'rst', 'rst.com', 'HYml', 'rst.COM']

Acum sa vedem metode de stergere :

>>> lista=['rst', 'RST', 'Rst']**** 
>>> lista.pop() #Fara indice elimina ultimu element din lista
'Rst'
>>> lista
['rst', 'RST']

>>> lista=['rst', 'RST', 'Rst']**** 
>>> lista.remove('rst')****** 
['RST', 'Rst']
*
>>> lista=['rst', 'RST', 'Rst']
>>> lista.remove(lista[1])
>>> lista
['rst', 'Rst']

>>> lista=['c', 'a', 'b']***** 
>>> lista.sort()
>>> lista
['a', 'b', 'c']

Dictionare

Un dictionar este o coloectie neordonata de obiecte . Obiectele sunt identificate unice de o cheie ( in general un string ) in loc de mediante un indice numeric , cum se face la liste .

Fiecare element al dictionarului este reprezentat de o copie ( cheie / valoare ) , cheia este utila pentru a deschide elemente sau recuperare valori .

Este exact ca si cand ai cauta un cuvand in DEX , in practica ceea ce se cauta este o explicatie a cheii , pentru a face o comparatie cu alte limbaje , putem spune la dictionar ca este o specie de array asociativ .

Un dictionar este format din elemente separate , virgule si inchide in paranteze grafe , un dictionar gol este format din paranteze deschide si inchise .

>>> dictionar1={}*********** # dictioar gol
>>> dictionar1
{}

Putem creea noi insine un dictionat prin metoda " dict() "

>>> dictionar2=dict()******* # dictionar gol
>>> dictionar2
{}

Putem sa definim elemente din dictionar direct , listand copii ale cheilor-valorifice .

>>> dictionar={'rst':1, 'RST':2, 'ESt':3}
>>> dictionar
{'rst': 1, 'RST': 2, 'RSt': 3}

Pentru a recupera o valoare putem sa trecem la dictionarul nume de la cheia relativa.

>>> dictionar['RST']******* # Recupereaza valoarile incepand de la dictionarul 2

Putem verifica existenta unei chei prin keyward-ul " in "

>>>* 'rs' in dictionar******** # cauta cheia 
>>> True

Introduceri , modificari si stergeri

Sa vedem acum cum se introduce , modifica si sterge elemente dintr-un dictionar :

>>> dic={'rst':1, 'RST':2, 'RSt':3}
>>> dic['rst.com']=4****************** # introducere
>>> dic
{'rst': 1, 'RST': 2, 'rst.comt': 4, 'RSt': 3}
*
*
>>> dic['rst']=7********************* # modifica
>>> v
{'rst': 7, 'RST': 2, 'html.it': 4, 'RSt': 3}
*
*
>>> del dic['RST']******************* # stergere
>>> dic
{'rst': 7, 'rst.com': 4, 'RSt': 3}

Pentru a cunoaste numarul elementelor dintr-un dictionar , utilizam "len "

 >>> len(dic)
3

Metode pentru dictionare

>>> dic={'rst.com':1, 'RST':2, 'rst':3}
*
>>> dic.get('rst')*********************************** # metoda get()
3
*
>>> dic.values()************************************** # metoda values()
dict_values([1, 3, 2])
*
>>> dic.keys()****************************************metoda keys()
dict_keys(['rst.com', 'rst', 'RST'])* 
*
>>> dic.items()*************************************** # metoda items() 
dict_items([('rst.com', 1), ('rst', 3), ('RST', 2)])

Oridinea cheilor ( cuvintelor )

Cum era la inceput cu Python 3.x , nu putem sa ordonam un dictionar utilizand direct lista obtinuta prin metoda " keys " .

>>> dic1 = {'andrea':28, 'florin':25, 'marius':21, 'elena':28}
>>> k = dic1.keys()
>>> k.sort()
Traceback (most recent call last):
**File "<stdin>", line 1, in <module>
AttributeError: 'dict_keys' object has no attribute 'sort'

Ca o solutie ca saputem sa obtinem ceva ordonat convertind intr-o lista elancata de chei si aplcare metoda "sort"

>>> k=list(k) #conversie in lista
>>> k
['marius', 'florin', 'andrea', 'elena']
>>> k.sort()
>>> k
['andrea', 'elena', 'florin', 'marius']
>>> for elemento in k: print(element, dic1[element])
...
andrea 28
elena 28
florin 25
marius 21

Tupla ( Tuple )

O tupla in Python este mult similara unei liste , functia lor este in mare parte aceeasi .

Prima diferenta intre tupla si lista este sintaxa , tuplele sunt inchide intre paranteze rotunde ( nu patrate ) , exemple :

>>> t=()
>>> t
()

Iar pentru a reprezenta o tupla cu un element , se foloseste o sintaxa .

>>> t=(1,)
>>> t
(1,)

Urmatoare diferenta nu este prea vizibila , dar nu trebuie sa o trecem cu vederea .

Lista poate fii mutat , tupla NU .

Tipi mutabili

Sa incercam sa descifram , variabilele de tip mutabil pot sa sa isi schimbe " viata ", practic pentru o lista este posibil sa intrducel sau sa stergem elemente in orice moment , pentru tipurile non mutabile , adica nu este posibil sa schimbam blocul valorii in in intern .

Folosirea tuplelor

Tuplele sunt folosite cand noi nu vrem sa se modifice continutul unei elencari , deci nu se pot adauga / sterge elemente .

Operatorii sunt aceeasi ca cei ai listelor ( mai putin cei ce schimba valoarea care nu au motiv sa exista ) exemple :

>>> tupla=(1,2,3,4)
>>> tupla
(1, 2, 3, 4)
*
>>> tupla[3]****** #indicare
4
*
>>> tupla[1:-1]******* #slicing
(2, 3)

Ca si pentru string-uri si liste , avem operatori de concare si repetare :

>>> ('unu','doi')+('trei','patru') # concatare
('primo', 'secondo', 'terzo', 'quarto')
*
>>>* ('unu',)*2************************** # ripetare
('unu', 'unu')

Cum s-a mentionat mai sus , spre deosebire de liste, tuplele nu accepta modificari .

>>> tupla=(1,2,3)
>>> tupla.append(4)
Traceback (most recent call last):
**File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'append'
</pre>
*
<pre class="brush:plain">
>>> tupla.remove(1)
Traceback (most recent call last):
**File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'remove'
*
>>> tupla[0]=2
Traceback (most recent call last):
**File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

Conversatii liste -> tuple , tuple->liste

Este posibila conversatia dintre cele doua , cu functiile list si tuple , exeplu :

>>> tupla=(1,2,3,4)
>>> lista=list(tupla)***** # conversatie tupla-lista
>>> lista
[1, 2, 3, 4]
*
>>> tuplaconv=tuple(lista) # conversatie lista-tupla
>>> tuplaconv
(1, 2, 3, 4)

Fisiere in Python

Conceptul de fisier ( file ) este destul de bine cunoscut , faptul ca gestirea fisierelor in Pytho trebuie facuta in internul limbajuli ( built-in ) garanteaza o voteza si simplitate in gestirea lor , in particular este important sa putem gestiona fisiere cu instructii de limbaj programare , pentru salvarea informatiilor pe HDD si facute persistente .

Continuare ^

|

Variabilele " input si output " din tabel sunt obiecte de tip file , exemplu :

>>> myfile = open('R0cc0.txt','w')****** # apare fisierul in scriere
*
>>> myfile.write(' linia 1\n')************ #** scrie linia 1 
7
>>> myfile.write(' linia 2\n')************ #** scrie linia 2
7
>>> myfile.write(' linia 3\n')************ #** scrie linia 3
7
>>> myfile.close()********************* # inchide fisier
*
>>> myfile = open('R0cc0.txt','r')****** # Apare fisierul in timpul citirii
>>> myfile.readlines()***************** #** citeste din fisier si reda o lista in linii
['linia1\n', 'linia2\n', 'linia3\n']

Functia " open " ne da voie sa citim un fisier care il scriem si returneaza un obiect de tip file care se asociaza lui " myfile ", Utilizam creeatia pentru a scrie in file cu metoda " write " si il inchidem cu " close" . Apoi ne intoarcem la acelasi fisier in citire si printam continutul cu " readlines() .

Metode de deschidere ( open )

In afara de " w " si " r " ( write si read ) , care le-am studiat deja , funcia " open " ne arata alte modalitati de deschidere a fisierelor , care le putem utiliza ca si al doilea parametru :

Din fisierele deshide in mod binar , putem extrage date ca si byte , fara nici un cod .

>>> print(open.__doc__)

Miscandune in internul fisierului

Pentru a verifica statutul fisierului este suficient a printa datele instantei curente , exemplu :

>>> myfile
<_eo.TextEuWrapper name='RST.txt' mode='r' encoding='cp1252'>

NOTA : sa nu uitam , mereu trebuie sa inchidem fisierele dupa ce le folosim / modificam " (close()) " .

Functii

Functiile sunt grupuri de instructii care la inceput prind un intreg de valori parametrici si au ca rezultat aceeasi parametrii . Functiile sunt un instrument important .

Parmit reutilizarea codului , functiile folosite de mai multe ori intr-un program pot sa fie adunate intr-o singura functie .

Permit de structurare codul programului in bloccri omogene din punct de vedere logic pentru a imbunatatii munca programatorului .

Sintaxa definirii unei functii este :

def nume_functie(<listeaza parametri divizati de virgula >):
<bloc de instructiuni>
return <rezultat> # optional

Odata definita functia in acest mod este posibila retilizarea ei simplu , invocand numele ei , urmat de list de valori , se sub intelege , valorile le vom trece ca si parametri . Exemplu :

def patrat(valoare):
ris = valoare * valoare
return ris

a = 5
print patrat(a) 

Urmarind acest program , rezultat este 25 . Primele 3 linii definesc functia de patrat . De acum innainte numele " patrat " devine parte din " namespace " al modulului curent ( un intreg de nume semnificative in internul modulului ) .

Invoam funcia , valoarea trecuta ca si parametru vine transferat la functia numelui parametrului (" valoare ") , vine urmata functia si de restituie rezultatul modululuin invocat .

Toate asta ne permit sa sa le introducem in " patrat " , o operatie mai complexa .

Introducand functiile trebuie sa distrugem variabilele locale ale functiiloor , deci vor fii utilizate de la sine .

Variabilele globale , sau aparente in " namespace "modulului, deci se utilizeaza in afara functiei .

Cand se invoca o functie vin transferate valorile variabilelor parametrilor functiilor . Acesta permite functiilor de venire in urma fnctiior care provin din " bloc " .

Trecerea pe valori : Vine transferta functiei doar o copie a variabilei, deci funcia nu poate altera valoare variabilei .

Trecere pe referinte : In acest caz vine trandferata variabila adevarata , deci poate altera valoare variabilei .

In python parametrii trecuti la functii sunt mereu transferati pe valori . Asta e diferenta intre alte limbaje , ca si " C , Pascal" , unde se pot trece parametrii si pe referinte .

Practic cand se utilizeaza o variabila , Python incearca prima oara numele acelei variabile in " namespace "local . Daca , cautarea nu este pozitiva , se continua cu " namespace " global si doar succesiv se va cauta numele intre functii ( built – in ) . adica cele default in Python .

Acest mecanisc permite de utilizare valoarea variabile si provoaca creearea aceluiasi nume intr-un " namespace " nou . Exemplu :

def functie1():
x = 20 # variabila locala cu acelasi nume 
print x # adevarat' vazut 20 si nu 10
print y # devarat' vazut 19

x = 10 # variabile gloobale
y = 19
functie1() 

Treaba se schimba radicat pentru strcurarea datelor mutabile , care pot fii modificate in internul functiilor .

Practic nu sunt niste ariabile adevarate ,deci e posibil sa le modificam . Exemplu :

def functie2(a,b = 30):
print a, b

x = 10
y = 19
functie2(x)
functie2(x,y) 

Functia numita 2 "functie2" are 2 parametrii : a si b , ea vine invocata de 2 ori .

Rezultatul primului invoc este 10, 30 , practic parametrul b, nu este indicat , ia valoarea 30 .

Rezultatul la al doilea invoc este 10, 19 .

Module ( Moduli )

Cand se intra mai adanc in Python , programele / codurile cresc repede , si devin obositoare si greu de gestionat , intregul program intr-un singur file script .

Pentru asta e oportun subdidere programu in diverse fisiere de script . Aceasta medoda permite de creeare recolte de functii care pot sa fie utilizate in proiecte diverse .

Moduli sunt fisiere de script , "file.py " care pot sa fie reinvocate de alte programe Python pentru reutilizarea functiilor continute .

Moduli pot sa fie creati usor de noi cei ce programam , dar daca exista deja multi , dece sa nu ii modificam continutul .

Moduli pentru gestionarea string-urilor

Moduli pentru invocare functii , din sitemul operativ

Moduli pentru gestionarea internetului

Moduli pentru e-mail

Pentru a scrie un modul , este de ajuns sa creean un " file.py " si sa scriem toate functiile necesare , pentru al putea folosii il vom importa cu , comanda " import " . Exemplu :

NOTA : Nu va incerede tin moduli luati de pe internet .

import library

upa ce ati importat libraria ( modulul ) , ptem simplu invocare functiile continute , folosind " dot notation " .

Scriem numele modululi un punct si numele functiei , reusim sa intram in modul si invocare functia . Exemplu :

R0cc0.py , contine functiile " open() , close() " , si move(obiect ) , puteti sa invocati functii asa : 

import library
library.open()
ogg=5
library.move(ogg)
library.close() 

Daca nu doriti sa utilizati numele librariei , mereu cand invocati o functie , este posibil sa puneti si numele functiei direct .

import library
from library import move

libraty.open()
ogg=5
move(ogg)
library.close() 

In acest caz , fuctia mutat face parte din intregul de nume definite in program " namaspace " si nu necesita prefix de nume modul ( librarie ) .

library.py in internul programului , este de ajuns sa utilizati caracterul "*" .

from library import *

open()
ogg=5
move(ogg)
close() 

String : Modul care aduna functii pentru gestionarea string-urilor .

Functii pentru convertire din strind in numar

Functii petru convertire din minuscula in MAJUSCULA

Functii pentru inlocuirea de patilor dintr-un string

Sys : modul care adna functii pentru reperarea de informatii din sistem , ex : reperearea argumentelor trecute in linia de comanda ( CmD ) .

Os : Modul pentru a face operatii din sistemul operativ , ex : copierea , renumirea sau stergerea unui file .

Pentru a se inetelege mai bine conceputl de import al numelor functiilor , trebuie sa punem in paralele conceputul " namespace "

Fiecare modul are un intreg de nume ( cele de variabile si cele de functii ) care reprezinta nume utilizabile in internul sau . Acest intreg se mai numeste si " namespace " ( spatiul numelor ).

Pentr a transporta numele dintr-un " namespace " in altul se poate folosii comanda " import "

Mediant , functia " dir() " , cu , care este posibil sa vedem lista de nume .

>>> dir()
['__builtins__', '__doc__', '__name__'] 

Aceste nume de mai sus , sunt nume definite de interpret inainte de a incepe a comunia . Daca noi importam modulul " R0cc0.py " , se obtine asta :

>>> from libraty import *
>>> dir()
['__builtins__', '__doc__', '__name__', 'open', 'close', 'move']

Acum dupa cum vedeti toate functiile continute de " R0cc0.py " fac parte din " namespace " , de asta nu mai sunt deloc vizibile variabilele precedente , doar cele locale pentru functia in sine .

Uitasem , aici gasiti module ( toate ) .

Scuzati eventualele greseli gramaticale .

Edited March 2, 2013 by R0cc0

[pizzazzip]

Interesant