From 63a6eb1182205389388e13b680962199ac9b3ffb Mon Sep 17 00:00:00 2001 From: Andy Date: Sat, 1 Apr 2017 22:19:58 +0200 Subject: [haskell] Updating second headline (#2695) * Haskell: Updating second headline * Haskell: Updating second headline (es) * Haskell: Updating second headline (fr) * Haskell: Updating second headline (pl) * Haskell: Updating second headline (pt) * Haskell: Updating second headline (ro) * Haskell: Updating second headline (ru) * Haskell: Updating second headline (cn) --- ro-ro/haskell-ro.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'ro-ro') diff --git a/ro-ro/haskell-ro.html.markdown b/ro-ro/haskell-ro.html.markdown index 082f138b..b0cc4099 100644 --- a/ro-ro/haskell-ro.html.markdown +++ b/ro-ro/haskell-ro.html.markdown @@ -66,7 +66,7 @@ not False -- True ---------------------------------------------------- --- Liste si tupli +-- 2. Liste si tupli ---------------------------------------------------- -- Fiecare element dintr-o lista trebuie sa aiba acelasi tip. -- cgit v1.2.3 From f6300aad29005e9b5f95bf63fdfbfbb8cc3dca7d Mon Sep 17 00:00:00 2001 From: Vitalie Lazu Date: Fri, 20 Jul 2018 16:22:47 +0300 Subject: Added Romanian translation for Elixir --- ro-ro/elixir-ro.html.markdown | 459 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 459 insertions(+) create mode 100644 ro-ro/elixir-ro.html.markdown (limited to 'ro-ro') diff --git a/ro-ro/elixir-ro.html.markdown b/ro-ro/elixir-ro.html.markdown new file mode 100644 index 00000000..d8b261af --- /dev/null +++ b/ro-ro/elixir-ro.html.markdown @@ -0,0 +1,459 @@ +--- +language: elixir +contributors: + - ["Joao Marques", "http://github.com/mrshankly"] + - ["Dzianis Dashkevich", "https://github.com/dskecse"] + - ["Ryan Plant", "https://github.com/ryanplant-au"] + - ["Ev Bogdanov", "https://github.com/evbogdanov"] +translators: + - ["Vitalie Lazu", "https://github.com/vitaliel"] + +filename: learnelixir-ro.ex +--- + +Elixir este un limbaj funcțional modern construit pe baza mașinii virtuale Erlang. +E total compatibil cu Erlang, dar are o sintaxă mai prietenoasă și propune mai multe +posibilități. + +```elixir + +# Comentariile de o linie încep cu simbolul diez. + +# Pentru comentarii pe mai multe linii nu există sintaxă separată, +# de aceea folosiți mai multe linii cu comentarii. + +# Pentru a folosi shell-ul elixir utilizați comanda `iex`. +# Compilați modulele cu comanda `elixirc`. + +# Ambele comenzi vor lucra în terminal, dacă ați instalat Elixir corect. + +## --------------------------- +## -- Tipuri de bază +## --------------------------- + +# Numere +3 # număr întreg +0x1F # număr întreg +3.0 # număr cu virgulă mobilă + +# Atomii, sunt constante nenumerice. Ei încep cu `:`. +:salut # atom + +# Tuplele sunt păstrate în memorie consecutiv. +{1,2,3} # tuple + +# Putem accesa elementul tuplelui folosind funcția `elem`: +elem({1, 2, 3}, 0) #=> 1 + +# Listele sunt implementate ca liste înlănțuite. +[1,2,3] # listă + +# Fiecare listă ne vidă are cap (primul element al listei) +# și coadă (restul elementelor). +# Putem accesa capul și coada listei cum urmează: +[cap | coadă] = [1,2,3] +cap #=> 1 +coadă #=> [2, 3] + +# În Elixir, ca și în Erlang, simbolul `=` denotă potrivirea șabloanelor și +# nu atribuire. +# +# Aceasta înseamnă că expresia din stînga (șablonul) se potrivește cu +# expresia din dreaptă. +# +# În modul acesta exemplul de mai sus lucrează accesînd capul și coada unei liste. + +# Potrivirea șablonului va da eroare cînd expresiile din stînga și dreapta nu se +# potrivesc, în exemplu acesta tuplele au lungime diferită. +{a, b, c} = {1, 2} #=> ** (MatchError) + +# Există și date binare +<<1,2,3>> + +# Sunt două tipuri de șiruri de caractere +"salut" # șir de caractere Elixir +'salut' # listă de caractere Erlang + +# Șir de caractere pe mai multe linii +""" +Sunt un șir de caractere +pe mai multe linii. +""" +#=> "Sunt un șir de caractere\npe mai multe linii..\n" + +# Șirurile de caractere sunt codificate în UTF-8: +"Bună dimineața" #=> "Bună dimineața" + +# Șirurile de caractere sunt date binare, listele de caractere doar liste. +<> #=> "abc" +[?a, ?b, ?c] #=> 'abc' + +# `?a` în Elixir întoarce codul ASCII pentru litera `a` +?a #=> 97 + +# Pentru a concatena listele folosiți `++`, pentru date binare - `<>` +[1,2,3] ++ [4,5] #=> [1,2,3,4,5] +'Salut ' ++ 'lume' #=> 'Salut lume' + +<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>> +"Salut " <> "lume" #=> "Salut lume" + +# Diapazoanele sunt reprezentate ca `început..sfîrșit` (inclusiv) +1..10 #=> 1..10 +început..sfîrșit = 1..10 # Putem folosi potrivirea șabloanelor cu diapazoane de asemenea +[început, sfîrșit] #=> [1, 10] + +# Dicţionarele stochează chei şi o valoare pentru fiecare cheie +genuri = %{"Ion" => "bărbat", "Maria" => "femeie"} +genuri["Ion"] #=> "bărbat" + +# Dicționare cu chei de tip atom au sintaxă specială +genuri = %{ion: "bărbat", maria: "femeie"} +genuri.ion #=> "bărbat" + +## --------------------------- +## -- Operatori +## --------------------------- + +# Operații matematice +1 + 1 #=> 2 +10 - 5 #=> 5 +5 * 2 #=> 10 +10 / 2 #=> 5.0 + +# În Elixir operatorul `/` întotdeauna întoarce un număr cu virgulă mobilă. + +# Folosiți `div` pentru împărțirea numerelor întregi +div(10, 2) #=> 5 + +# Pentru a obține restul de la împărțire utilizați `rem` +rem(10, 3) #=> 1 + +# Există și operatori booleni: `or`, `and` and `not`. +# Acești operatori așteaptă ca primul argument o expresie booleană. +true and true #=> true +false or true #=> true +1 and true #=> ** (BadBooleanError) + +# Elixir de asemenea oferă `||`, `&&` și `!` care acceptă argumente de orice tip. +# Toate valorile în afară de `false` și `nil` se vor evalua ca `true`. +1 || true #=> 1 +false && 1 #=> false +nil && 20 #=> nil +!true #=> false + +# Operatori de comparație: `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` și `>` +1 == 1 #=> true +1 != 1 #=> false +1 < 2 #=> true + +# `===` și `!==` au strictețe mai mare cînd comparăm numere întregi și reale: +1 == 1.0 #=> true +1 === 1.0 #=> false + +# Putem compara de asemenea și date de diferite tipuri: +1 < :salut #=> true + +# La compararea diferitor tipuri folosiți următoare prioritate: +# număr < atom < referință < funcție < port < proces < tuple < listă < șir de caractere + +# Cităm pe Joe Armstrong în acest caz: "Ordinea actuală nu e importantă, +dar că ordinea totală este bine definită este important." + +## --------------------------- +## -- Ordinea execuției +## --------------------------- + +# expresia `if` +if false do + "Aceasta nu veți vedea niciodată" +else + "Aceasta veți vedea" +end + +# expresia opusă `unless` +unless true do + "Aceasta nu veți vedea niciodată" +else + "Aceasta veți vedea" +end + +# Țineți minte potrivirea șabloanelor? Multe structuri în Elixir se bazează pe ea. + +# `case` ne permite să comparăm o valoare cu multe șabloane: +case {:unu, :doi} do + {:patru, :cinci} -> + "Aceasta nu se potrivește" + {:unu, x} -> + "Aceasta se potrivește și atribuie lui `x` `:doi` în acest bloc" + _ -> + "Aceasta se va potrivi cu orice valoare" +end + +# Simbolul `_` se numește variabila anonimă. +# Folosiți-l pentru valori ce nu vă interesează. +# De exemplu, dacă doar capul listei ne intereseaza: +[cap | _] = [1,2,3] +cap #=> 1 + +# Pentru o citire mai bună putem scri: +[cap | _coadă] = [:a, :b, :c] +cap #=> :a + +# `cond` ne permite să verificăm multe condiții de odată. +# Folosiți `cond` în schimbul la multe expresii `if`. +cond do + 1 + 1 == 3 -> + "Aceasta nu veți vedea niciodată" + 2 * 5 == 12 -> + "Pe mine la fel" + 1 + 2 == 3 -> + "Aceasta veți vedea" +end + +# Este obușnuit de setat ultima condiție cu `true`, care se va potrivi întotdeauna. +cond do + 1 + 1 == 3 -> + "Aceasta nu veți vedea niciodată" + 2 * 5 == 12 -> + "Pe mine la fel" + true -> + "Aceasta veți vedea (este else în esență)" +end + +# Blocul `try/catch` se foloște pentru prelucrarea excepțiilor. +# Elixir suportă blocul `after` care se execută în orice caz. +try do + throw(:salut) +catch + mesaj -> "Am primit #{mesaj}." +after + IO.puts("Sunt în blocul after.") +end +#=> Sunt în blocul after. +# "Am primit salut" + +## --------------------------- +## -- Module și Funcții +## --------------------------- + +# Funcții anonime (atenție la punct la apelarea funcției) +square = fn(x) -> x * x end +square.(5) #=> 25 + +# Ele de asemenea aceptă multe clauze și expresii de gardă. +# Expresiile de gardă vă permit să acordați potrivirea șabloanelor, +# ele sunt indicate după cuvîntul cheie `when`: +f = fn + x, y when x > 0 -> x + y + x, y -> x * y +end + +f.(1, 3) #=> 4 +f.(-1, 3) #=> -3 + +# Elixir de asemenea oferă multe funcții incorporate. +# Ele sunt accesibile în scopul curent. +is_number(10) #=> true +is_list("salut") #=> false +elem({1,2,3}, 0) #=> 1 + +# Puteți grupa cîteva funcții într-un modul. În interiorul modulului folosiți `def` +# pentru a defini funcțiile necesare. +defmodule Math do + def sum(a, b) do + a + b + end + + def square(x) do + x * x + end +end + +Math.sum(1, 2) #=> 3 +Math.square(3) #=> 9 + +# Pentru a compila modulul nostru simplu Math îl salvăm ca `math.ex` și utilizăm `elixirc`. +# în terminal: elixirc math.ex + +# În interiorul modulului putem defini funcții cu `def` și funcții private cu `defp`. +defmodule PrivateMath do + # O funcție definită cu `def` este accesibilă pentru apelare din alte module, + def sum(a, b) do + do_sum(a, b) + end + + # O funcție privată poate fi apelată doar local. + defp do_sum(a, b) do + a + b + end +end + +PrivateMath.sum(1, 2) #=> 3 +PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError) + +# Declarația funcției de asemenea suportă expresii de gardă și multe clauze: +defmodule Geometry do + def area({:rectangle, w, h}) do + w * h + end + + def area({:circle, r}) when is_number(r) do + 3.14 * r * r + end +end + +Geometry.area({:rectangle, 2, 3}) #=> 6 +Geometry.area({:circle, 3}) #=> 28.25999999999999801048 +Geometry.area({:circle, "not_a_number"}) #=> ** (FunctionClauseError) + +# Din cauza variabilelor imutabile, un rol important îl ocupă funcțiile recursive +defmodule Recursion do + def sum_list([head | tail], acc) do + sum_list(tail, acc + head) + end + + def sum_list([], acc) do + acc + end +end + +Recursion.sum_list([1,2,3], 0) #=> 6 + +# Modulele în Elixir suportă atribute, există atribute incorporate și +# puteți adăuga altele. +defmodule MyMod do + @moduledoc """ + Este un atribut incorporat + """ + + @my_data 100 # Acesta e atributul nostru + IO.inspect(@my_data) #=> 100 +end + +# Operatorul |> permite transferarea rezultatului unei expresii din stînga +# ca primul argument al unei funcții din dreapta. +Range.new(1,10) +|> Enum.map(fn x -> x * x end) +|> Enum.filter(fn x -> rem(x, 2) == 0 end) +#=> [4, 16, 36, 64, 100] + +## --------------------------- +## -- Structuri și Excepții +## --------------------------- + +# Structurile sunt extensii a dicționarelor ce au valori implicite, +# verificări în timpul compilării și polimorfism +defmodule Person do + defstruct name: nil, age: 0, height: 0 +end + +joe_info = %Person{ name: "Joe", age: 30, height: 180 } +#=> %Person{age: 30, height: 180, name: "Joe"} + +# Acesarea cîmpului din structură +joe_info.name #=> "Joe" + +# Actualizarea valorii cîmpului +older_joe_info = %{ joe_info | age: 31 } +#=> %Person{age: 31, height: 180, name: "Joe"} + +# Blocul `try` cu cuvîntul cheie `rescue` e folosit pentru a prinde excepții +try do + raise "o eroare" +rescue + RuntimeError -> "a fost prinsă o eroare runtime" + _error -> "aici vor fi prinse toate erorile" +end +#=> "a fost prinsă o eroare runtime" + +# Toate excepțiile au un mesaj +try do + raise "o eroare" +rescue + x in [RuntimeError] -> + x.message +end +#=> "o eroare" + +## --------------------------- +## -- Concurența +## --------------------------- + +# Concurența în Elixir se bazează pe modelul actor. Pentru a scrie programe +# concurente avem nevoie de trei lucruri: +# 1. Crearea proceselor +# 2. Trimiterea mesajelor +# 3. Primirea mesajelor + +# Un nou proces se crează folosind funcția `spawn`, care primește o funcție +# ca argument. +f = fn -> 2 * 2 end #=> #Function +spawn(f) #=> #PID<0.40.0> + +# `spawn` întoarce identificatorul procesului pid, îl puteți folosi pentru +# a trimite mesaje procesului. Mesajele se transmit folosind operatorul `send`. +# Pentru primirea mesajelor se folosește mecanismul `receive`: + +# Blocul `receive do` este folosit pentru așteptarea mesajelor și prelucrarea lor +# cînd au fost primite. Blocul `receive do` va procesa doar un singur mesaj primit. +# Pentru a procesa mai multe mesaje, funcția cu blocul `receive do` trebuie +# recursiv să se auto apeleze. + +defmodule Geometry do + def area_loop do + receive do + {:rectangle, w, h} -> + IO.puts("Aria = #{w * h}") + area_loop() + {:circle, r} -> + IO.puts("Aria = #{3.14 * r * r}") + area_loop() + end + end +end + +# Compilați modulul și creați un proces +pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0> +# Un alt mod +pid = spawn(Geometry, :area_loop, []) + +# Trimiteți un mesaj către `pid` care se va potrivi cu un șablon din blocul `receive` +send pid, {:rectangle, 2, 3} +#=> Aria = 6 +# {:rectangle,2,3} + +send pid, {:circle, 2} +#=> Aria = 12.56000000000000049738 +# {:circle,2} + +# Interpretatorul este de asemenea un proces, puteți folosi `self` +# pentru a primi identificatorul de proces: +self() #=> #PID<0.27.0> + +## --------------------------- +## -- Agenții +## --------------------------- + +# Un agent este un proces care urmărește careva valori ce se schimbă. + +# Creați un agent cu `Agent.start_link`, transmițînd o funcție. +# Stare inițială a agentului va fi rezultatul funcției. +{ok, my_agent} = Agent.start_link(fn -> ["roșu", "verde"] end) + +# `Agent.get` primește numele agentului și o `fn` care primește starea curentă +# Orice va întoarce `fn` este ceea ce veți primi înapoi: +Agent.get(my_agent, fn colors -> colors end) #=> ["roșu", "verde"] + +# Actualizați starea agentului în acelaș mod: +Agent.update(my_agent, fn colors -> ["albastru" | colors] end) +``` + +## Link-uri utile + +* [Primii pași](http://elixir-lang.org/getting-started/introduction.html) de pe [situl Elixir](http://elixir-lang.org) +* [Documentația oficială Elixir](http://elixir-lang.org/docs/master/) +* [Un mic conspect pe Elixir](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf) +* [Cartea "Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) de Dave Thomas +* [Cartea "Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) de Fred Hebert +* [Cartea "Programming Erlang: Software for a Concurrent World"](https://pragprog.com/book/jaerlang2/programming-erlang) de Joe Armstrong -- cgit v1.2.3 From 5da3efebe49e5ef7cdfbbaf8e24d6ee679b09e37 Mon Sep 17 00:00:00 2001 From: Rholais Lii Date: Wed, 5 Sep 2018 11:53:59 -0500 Subject: Add language label --- ro-ro/elixir-ro.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'ro-ro') diff --git a/ro-ro/elixir-ro.html.markdown b/ro-ro/elixir-ro.html.markdown index d8b261af..10fec3c5 100644 --- a/ro-ro/elixir-ro.html.markdown +++ b/ro-ro/elixir-ro.html.markdown @@ -7,7 +7,7 @@ contributors: - ["Ev Bogdanov", "https://github.com/evbogdanov"] translators: - ["Vitalie Lazu", "https://github.com/vitaliel"] - +lang: ro-ro filename: learnelixir-ro.ex --- -- cgit v1.2.3 From 9b5b5f6d31b64be55e64c5f45084e45115f2f350 Mon Sep 17 00:00:00 2001 From: Anindya Srivastava Date: Wed, 6 Feb 2019 07:26:25 +0530 Subject: Type correction for the output of math.sqrt() propagated across versions and languages --- ro-ro/python-ro.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'ro-ro') diff --git a/ro-ro/python-ro.html.markdown b/ro-ro/python-ro.html.markdown index c96e30dc..ada0c034 100644 --- a/ro-ro/python-ro.html.markdown +++ b/ro-ro/python-ro.html.markdown @@ -449,7 +449,7 @@ Om.exclama() #=> "*Aaaaaah*" # Pentru a folosi un modul, trebuie importat import math -print math.sqrt(16) #=> 4 +print math.sqrt(16) #=> 4.0 # Putem importa doar anumite funcţii dintr-un modul from math import ceil, floor -- cgit v1.2.3 From 1adab9bc3f80d82123987ff34083568030735db7 Mon Sep 17 00:00:00 2001 From: Simon Shine Date: Wed, 12 Feb 2020 04:49:56 +0100 Subject: Rename Python 2 markdown files into 'pythonlegacy' ``` for f in $(find . -iname "*python*" | grep -vE 'python3|git|statcomp'); do flegacy=$(echo "$f" | sed 's/python/pythonlegacy/') git mv "$f" "$flegacy" done ``` --- ro-ro/python-ro.html.markdown | 493 ------------------------------------ ro-ro/pythonlegacy-ro.html.markdown | 493 ++++++++++++++++++++++++++++++++++++ 2 files changed, 493 insertions(+), 493 deletions(-) delete mode 100644 ro-ro/python-ro.html.markdown create mode 100644 ro-ro/pythonlegacy-ro.html.markdown (limited to 'ro-ro') diff --git a/ro-ro/python-ro.html.markdown b/ro-ro/python-ro.html.markdown deleted file mode 100644 index ada0c034..00000000 --- a/ro-ro/python-ro.html.markdown +++ /dev/null @@ -1,493 +0,0 @@ ---- -language: python -contributors: - - ["Louie Dinh", "http://ldinh.ca"] -translators: - - ["Ovidiu Ciule", "https://github.com/ociule"] -filename: learnpython-ro.py -lang: ro-ro ---- - -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.0 - -# 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) - diff --git a/ro-ro/pythonlegacy-ro.html.markdown b/ro-ro/pythonlegacy-ro.html.markdown new file mode 100644 index 00000000..ada0c034 --- /dev/null +++ b/ro-ro/pythonlegacy-ro.html.markdown @@ -0,0 +1,493 @@ +--- +language: python +contributors: + - ["Louie Dinh", "http://ldinh.ca"] +translators: + - ["Ovidiu Ciule", "https://github.com/ociule"] +filename: learnpython-ro.py +lang: ro-ro +--- + +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.0 + +# 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) + -- cgit v1.2.3 From 95c8b24ebf8b8e0ed02923787a9f793bdf295200 Mon Sep 17 00:00:00 2001 From: Simon Shine Date: Wed, 12 Feb 2020 05:09:13 +0100 Subject: Python 2 'language': Python 2 (legacy) Instead of listing 'language: python' for Python 2, use language: Python 2 (legacy) ``` find . -iname "*pythonlegacy*" -exec \ sed -i 's/^language: .*/language: Python 2 (legacy)/' {} \; ``` --- ro-ro/pythonlegacy-ro.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'ro-ro') diff --git a/ro-ro/pythonlegacy-ro.html.markdown b/ro-ro/pythonlegacy-ro.html.markdown index ada0c034..2badef08 100644 --- a/ro-ro/pythonlegacy-ro.html.markdown +++ b/ro-ro/pythonlegacy-ro.html.markdown @@ -1,5 +1,5 @@ --- -language: python +language: Python 2 (legacy) contributors: - ["Louie Dinh", "http://ldinh.ca"] translators: -- cgit v1.2.3 From 887cbee8af080034177734b528819491e73a7a16 Mon Sep 17 00:00:00 2001 From: Simon Shine Date: Wed, 12 Feb 2020 05:50:44 +0100 Subject: Change 'filename:' for Python 2 (legacy) Before renaming, all Python 2 filenames were 'learnpython-*.py'. This commit renames them to 'learnpythonlegacy-*.py'. To verify that the filenames were named consistently across translations prior to this commit, and to change this: ``` find . -name "pythonlegacy*.markdown" -exec ack filename: {} \; find . -name "pythonlegacy*.markdown" -exec \ sed -i 's/^filename: learnpython/filename: learnpythonlegacy/' {} \; ``` --- ro-ro/pythonlegacy-ro.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'ro-ro') diff --git a/ro-ro/pythonlegacy-ro.html.markdown b/ro-ro/pythonlegacy-ro.html.markdown index 2badef08..a368ff99 100644 --- a/ro-ro/pythonlegacy-ro.html.markdown +++ b/ro-ro/pythonlegacy-ro.html.markdown @@ -4,7 +4,7 @@ contributors: - ["Louie Dinh", "http://ldinh.ca"] translators: - ["Ovidiu Ciule", "https://github.com/ociule"] -filename: learnpython-ro.py +filename: learnpythonlegacy-ro.py lang: ro-ro --- -- cgit v1.2.3