adambard/learnxinyminutes-docs
1
1
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-12-25 16:23:37 +03:00
Code Issues Projects Releases Wiki Activity

Merge pull request #309 from ociule/master

Browse Source 
Romanian translation for Python.
This commit is contained in:
Adam Bard 2013-09-04 09:28:41 -07:00
commit 95e9194077
1 changed files with 489 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

489
ro-ro/python-ro.html.markdown Normal file
View File

@ -0,0 +1,489 @@
---
language: python
contributors:
- ["Louie Dinh", "http://ldinh.ca"]
translators:
- ["Ovidiu Ciule", "https://github.com/ociule"] lang: ro-ro filename: python-ro.html.markdown
filename: learnpython.py
---
Python a fost creat de Guido Van Rossum la începutul anilor '90. Python a devenit astăzi unul din
cele mai populare limbaje de programare. M-am indrăgostit de Python pentru claritatea sa sintactică.
Python este aproape pseudocod executabil.
Opinia dumneavoastră este binevenită! Puteţi sa imi scrieţi la [@ociule](http://twitter.com/ociule) sau ociule [at] [google's email service]
Notă: Acest articol descrie Python 2.7, dar este util şi pentru Python 2.x. O versiune Python 3 va apărea
în curând, în limba engleză mai întâi.
```python
# Comentariile pe o singură linie încep cu un caracter diez.
""" Şirurile de caractere pe mai multe linii pot fi încadrate folosind trei caractere ", şi sunt des
folosite ca şi comentarii pe mai multe linii.
"""
####################################################
## 1. Operatori şi tipuri de date primare
####################################################
# Avem numere
3 #=> 3
# Matematica se comportă cum ne-am aştepta
1 + 1 #=> 2
8 - 1 #=> 7
10 * 2 #=> 20
35 / 5 #=> 7
# Împărţirea este un pic surprinzătoare. Este de fapt împărţire pe numere întregi şi rotunjeşte
# automat spre valoarea mai mică
5 / 2 #=> 2
# Pentru a folosi împărţirea fără rest avem nevoie de numere reale
2.0 # Acesta e un număr real
11.0 / 4.0 #=> 2.75 ahhh ... cum ne aşteptam
# Ordinea operaţiilor se poate forţa cu paranteze
(1 + 3) * 2 #=> 8
# Valoriile boolene sunt şi ele valori primare
True
False
# Pot fi negate cu operatorul not
not True #=> False
not False #=> True
# Egalitatea este ==
1 == 1 #=> True
2 == 1 #=> False
# Inegalitate este !=
1 != 1 #=> False
2 != 1 #=> True
# Comparaţii
1 < 10 #=> True
1 > 10 #=> False
2 <= 2 #=> True
2 >= 2 #=> True
# Comparaţiile pot fi inlănţuite!
1 < 2 < 3 #=> True
2 < 3 < 2 #=> False
# Şirurile de caractere pot fi încadrate cu " sau '
"Acesta e un şir de caractere."
'Şi acesta este un şir de caractere.'
# Şirurile de caractere pot fi adăugate!
"Hello " + "world!" #=> "Hello world!"
# Un şir de caractere poate fi folosit ca o listă
"Acesta e un şir de caractere"[0] #=> 'A'
# Caracterul % (procent) poate fi folosit pentru a formata şiruri de caractere :
"%s pot fi %s" % ("şirurile", "interpolate")
# O metodă mai nouă de a formata şiruri este metoda "format"
# Este metoda recomandată
"{0} pot fi {1}".format("şirurile", "formatate")
# Puteţi folosi cuvinte cheie dacă nu doriţi sa număraţi
"{nume} vrea să mănânce {fel}".format(nume="Bob", fel="lasagna")
# "None", care reprezintă valoarea nedefinită, e un obiect
None #=> None
# Nu folosiţi operatorul == pentru a compara un obiect cu None
# Folosiţi operatorul "is"
"etc" is None #=> False
None is None #=> True
# Operatorul "is" testeaza dacă obiectele sunt identice.
# Acastă operaţie nu e foarte folositoare cu tipuri primare,
# dar e foarte folositoare cu obiecte.
# None, 0, şi şiruri de caractere goale sunt evaluate ca si fals, False.
# Toate celelalte valori sunt adevărate, True.
0 == False #=> True
"" == False #=> True
####################################################
## 2. Variabile şi colecţii
####################################################
# Printarea este uşoară
print "Eu sunt Python. Încântat de cunoştinţă!"
# Nu este nevoie sa declari variabilele înainte de a le folosi
o_variabila = 5 # Convenţia este de a folosi caractere_minuscule_cu_underscore
o_variabila #=> 5
# Dacă accesăm o variabilă nefolosită declanşăm o excepţie.
# Vezi secţiunea Control de Execuţie pentru mai multe detalii despre excepţii.
alta_variabila # Declanşează o eroare de nume
# "If" poate fi folosit într-o expresie.
"yahoo!" if 3 > 2 else 2 #=> "yahoo!"
# Listele sunt folosite pentru colecţii
li = []
# O listă poate avea valori de la început
alta_li = [4, 5, 6]
# Se adaugă valori la sfârşitul lister cu append
li.append(1) #li e acum [1]
li.append(2) #li e acum [1, 2]
li.append(4) #li e acum [1, 2, 4]
li.append(3) #li este acum [1, 2, 4, 3]
# Se şterg de la sfarşit cu pop
li.pop() #=> 3 şi li e acum [1, 2, 4]
# Să o adaugăm înapoi valoarea
li.append(3) # li e din nou [1, 2, 4, 3]
# Putem accesa valorile individuale dintr-o listă cu operatorul index
li[0] #=> 1
# Valoarea speciala -1 pentru index accesează ultima valoare
li[-1] #=> 3
# Dacă depaşim limitele listei declanşăm o eroare IndexError
li[4] # Declanşează IndexError
# Putem să ne uităm la intervale folosind sintaxa de "felii"
# În Python, intervalele sunt închise la început si deschise la sfârşit.
li[1:3] #=> [2, 4]
# Fără început
li[2:] #=> [4, 3]
# Fără sfarşit
li[:3] #=> [1, 2, 4]
# Putem şterge elemente arbitrare din lista cu operatorul "del" care primeşte indexul lor
del li[2] # li e acum [1, 2, 3]
# Listele pot fi adăugate
li + alta_li #=> [1, 2, 3, 4, 5, 6] - Notă: li si alta_li nu sunt modificate!
# Concatenăm liste cu "extend()"
li.extend(alta_li) # Acum li este [1, 2, 3, 4, 5, 6]
# Se verifică existenţa valorilor in lista cu "in"
1 in li #=> True
# Şi lungimea cu "len()"
len(li) #=> 6
# Tuplele sunt ca şi listele dar imutabile
tup = (1, 2, 3)
tup[0] #=> 1
tup[0] = 3 # Declanşează TypeError
# Pot fi folosite ca şi liste
len(tup) #=> 3
tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
tup[:2] #=> (1, 2)
2 in tup #=> True
# Tuplele pot fi despachetate
a, b, c = (1, 2, 3) # a este acum 1, b este acum 2 şi c este acum 3
# Tuplele pot fi folosite şi fără paranteze
d, e, f = 4, 5, 6
# Putem inversa valori foarte uşor!
e, d = d, e # d este acum 5 şi e este acum 4
# Dicţionarele stochează chei şi o valoare pentru fiecare cheie
dict_gol = {}
# Şi un dicţionar cu valori
dict_cu_valori = {"unu": 1, "doi": 2, "trei": 3}
# Căutaţi valori cu []
dict_cu_valori["unu"] #=> 1
# Obţinem lista cheilor cu "keys()"
dict_cu_valori.keys() #=> ["trei", "doi", "unu"]
# Notă - ordinea cheilor obţinute cu keys() nu este garantată.
# Puteţi obţine rezultate diferite de exemplul de aici.
# Obţinem valorile cu values()
dict_cu_valori.values() #=> [3, 2, 1]
# Notă - aceeaşi ca mai sus, aplicată asupra valorilor.
# Verificăm existenţa unei valori cu "in"
"unu" in dict_cu_valori #=> True
1 in dict_cu_valori #=> False
# Accesarea unei chei care nu exista declanşează o KeyError
dict_cu_valori["four"] # KeyError
# Putem folosi metoda "get()" pentru a evita KeyError
dict_cu_valori.get("one") #=> 1
dict_cu_valori.get("four") #=> None
# Metoda get poate primi ca al doilea argument o valoare care va fi returnată
# când cheia nu este prezentă.
dict_cu_valori.get("one", 4) #=> 1
dict_cu_valori.get("four", 4) #=> 4
# "setdefault()" este o metodă pentru a adăuga chei-valori fără a le modifica, dacă cheia există deja
dict_cu_valori.setdefault("five", 5) #dict_cu_valori["five"] este acum 5
dict_cu_valori.setdefault("five", 6) #dict_cu_valori["five"] exista deja, nu este modificată, tot 5
# Set este colecţia mulţime
set_gol = set()
# Putem crea un set cu valori
un_set = set([1,2,2,3,4]) # un_set este acum set([1, 2, 3, 4]), amintiţi-vă ca mulţimile garantează unicatul!
# În Python 2.7, {} poate fi folosit pentru un set
set_cu_valori = {1, 2, 2, 3, 4} # => {1 2 3 4}
# Putem adăuga valori cu add
set_cu_valori.add(5) # set_cu_valori este acum {1, 2, 3, 4, 5}
# Putem intersecta seturi
alt_set = {3, 4, 5, 6}
set_cu_valori & alt_set #=> {3, 4, 5}
# Putem calcula uniunea cu |
set_cu_valori | alt_set #=> {1, 2, 3, 4, 5, 6}
# Diferenţa între seturi se face cu -
{1,2,3,4} - {2,3,5} #=> {1, 4}
# Verificăm existenţa cu "in"
2 in set_cu_valori #=> True
10 in set_cu_valori #=> False
####################################################
## 3. Controlul Execuţiei
####################################################
# O variabilă
o_variabila = 5
# Acesta este un "if". Indentarea este importanta în python!
# Printează "o_variabila este mai mică ca 10"
if o_variabila > 10:
print "o_variabila e mai mare ca 10."
elif o_variabila < 10: # Clauza elif e opţională.
print "o_variabila este mai mică ca 10."
else: # Şi else e opţional.
print "o_variabila este exact 10."
"""
Buclele "for" pot fi folosite pentru a parcurge liste
Vom afişa:
câinele este un mamifer
pisica este un mamifer
şoarecele este un mamifer
"""
for animal in ["câinele", "pisica", "şoarecele"]:
# Folosim % pentru a compune mesajul
print "%s este un mamifer" % animal
"""
"range(număr)" crează o lista de numere
de la zero la numărul dat
afişează:
0
1
2
3
"""
for i in range(4):
print i
"""
While repetă pana când condiţia dată nu mai este adevărată.
afişează:
0
1
2
3
"""
x = 0
while x < 4:
print x
x += 1 # Prescurtare pentru x = x + 1
# Recepţionăm excepţii cu blocuri try/except
# Acest cod e valid in Python > 2.6:
try:
# Folosim "raise" pentru a declanşa o eroare
raise IndexError("Asta este o IndexError")
except IndexError as e:
pass # Pass nu face nimic. În mod normal aici ne-am ocupa de eroare.
####################################################
## 4. Funcţii
####################################################
# Folosim "def" pentru a defini funcţii
def add(x, y):
print "x este %s şi y este %s" % (x, y)
return x + y # Funcţia poate returna valori cu "return"
# Apelăm funcţia "add" cu parametrii
add(5, 6) #=> Va afişa "x este 5 şi y este 6" şi va returna 11
# Altă cale de a apela funcţii: cu parametrii numiţi
add(y=6, x=5) # Ordinea parametrilor numiţi nu contează
# Putem defini funcţii care primesc un număr variabil de parametrii nenumiţi
# Aceşti parametrii nenumiţi se cheamă si poziţinali
def varargs(*args):
return args
varargs(1, 2, 3) #=> (1,2,3)
# Şi putem defini funcţii care primesc un număr variabil de parametrii numiţi
def keyword_args(**kwargs):
return kwargs
# Hai să vedem cum merge
keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}
# Se pot combina
def all_the_args(*args, **kwargs):
print args
print kwargs
"""
all_the_args(1, 2, a=3, b=4) va afişa:
(1, 2)
{"a": 3, "b": 4}
"""
# Când apelăm funcţii, putem face inversul args/kwargs!
# Folosim * pentru a expanda tuple şi ** pentru a expanda kwargs.
args = (1, 2, 3, 4)
kwargs = {"a": 3, "b": 4}
all_the_args(*args) # echivalent cu foo(1, 2, 3, 4)
all_the_args(**kwargs) # echivalent cu foo(a=3, b=4)
all_the_args(*args, **kwargs) # echivalent cu foo(1, 2, 3, 4, a=3, b=4)
# În Python, funcţiile sunt obiecte primare
def create_adder(x):
def adder(y):
return x + y
return adder
add_10 = create_adder(10)
add_10(3) #=> 13
# Funcţiile pot fi anonime
(lambda x: x > 2)(3) #=> True
# Există funcţii de ordin superior (care operează pe alte funcţii) predefinite
map(add_10, [1,2,3]) #=> [11, 12, 13]
filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
# Putem folosi scurtături de liste pentru a simplifica munca cu map si filter
[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13]
[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
####################################################
## 5. Clase
####################################################
# Moştenim object pentru a crea o nouă clasă
class Om(object):
# Acesta este un atribut al clasei. Va fi moştenit de toate instanţele.
species = "H. sapiens"
# Constructor (mai degrabă, configurator de bază)
def __init__(self, nume):
# Valoarea parametrului este stocată in atributul instanţei
self.nume = nume
# Aceasta este o metoda a instanţei.
# Toate metodele primesc "self" ca si primul argument.
def spune(self, mesaj):
return "%s: %s" % (self.nume, mesaj)
# O metodă a clasei. Este partajată de toate instanţele.
# Va primi ca si primul argument clasa căreia îi aparţine.
@classmethod
def get_species(cls):
return cls.species
# O metoda statica nu primeste un argument automat.
@staticmethod
def exclama():
return "*Aaaaaah*"
# Instanţiem o clasă
i = Om(nume="Ion")
print i.spune("salut") # afişează: "Ion: salut"
j = Om("George")
print j.spune("ciau") # afişează George: ciau"
# Apelăm metoda clasei
i.get_species() #=> "H. sapiens"
# Modificăm atributul partajat
Om.species = "H. neanderthalensis"
i.get_species() #=> "H. neanderthalensis"
j.get_species() #=> "H. neanderthalensis"
# Apelăm metoda statică
Om.exclama() #=> "*Aaaaaah*"
####################################################
## 6. Module
####################################################
# Pentru a folosi un modul, trebuie importat
import math
print math.sqrt(16) #=> 4
# Putem importa doar anumite funcţii dintr-un modul
from math import ceil, floor
print ceil(3.7) #=> 4.0
print floor(3.7) #=> 3.0
# Putem importa toate funcţiile dintr-un modul, dar nu este o idee bună
# Nu faceţi asta!
from math import *
# Numele modulelor pot fi modificate la import, de exemplu pentru a le scurta
import math as m
math.sqrt(16) == m.sqrt(16) #=> True
# Modulele python sunt pur şi simplu fişiere cu cod python.
# Puteţi sa creaţi modulele voastre, şi sa le importaţi.
# Numele modulului este acelasi cu numele fişierului.
# Cu "dir" inspectăm ce funcţii conţine un modul
import math
dir(math)
```
## Doriţi mai mult?
### Gratis online, în limba engleză
* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
* [Dive Into Python](http://www.diveintopython.net/)
* [The Official Docs](http://docs.python.org/2.6/)
* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
* [Python Module of the Week](http://pymotw.com/2/)
### Cărţi, în limba engleză
* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)