Jump to content
R0cc0

Tutorial Python 3.2 ( Partea 3 )

Recommended Posts

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 .

Untitled.png

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 :

Untitled1.png

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

Untitled2.png

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 :

Untitled3.png

>>> 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']

Untitled4.png

>>> 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

Untitled5.png

>>> 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 .

Untitled6.png

Continuare ^

|

Untitled7.png

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 :

Untitled8.png

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

>>> print(open.__doc__)

Miscandune in internul fisierului

Untitled9.png

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 by R0cc0
  • Upvote 3
Link to comment
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Reply to this topic...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.



×
×
  • Create New...