5. Structuri de date
********************

Capitolul de față se apleacă mai în detaliu asupra unor chestiuni cu
care v-ați întâlnit deja, iar acestora le adaugă, firește, și lucruri
noi.


5.1. Mai multe despre liste
===========================

The list data type has some more methods. Here are all of the methods
of list objects:

list.append(value, /)

   Adaugă un element la finalul listei. La fel ca "a[len(a):] = [x]".

list.extend(iterable, /)

   Extinde lista prin adăugarea tuturor elementelor unui (obiect)
   iterabil. La fel ca "a[len(a):] = iterabil".

list.insert(index, value, /)

   Inserează un element la poziția dată. Primul argument este indicele
   elementului înaintea căruia se va face inserția, de aceea
   "a.insert(0, x)" va realiza o inserție la începutul listei în timp
   ce "a.insert(len(a), x)" este echivalentă cu "a.append(x)".

list.remove(value, /)

   Remove the first item from the list whose value is equal to
   *value*.  It raises a "ValueError" if there is no such item.

list.pop(index=-1, /)

   Elimină din listă elementul de la poziția dată și îl returnează.
   Dacă nu se specifică indicele elementului, atunci "a.pop()" va
   elimina și va returna ultimul element al listei. Ridică o excepție
   "IndexError" atunci când fie lista este goală fie când indicele se
   găsește în afara plajei de valori a indicilor elementelor listei.

list.clear()

   Elimină toate elementele din listă. La fel ca "del a[:]".

list.index(value[, start[, stop]])

   Return zero-based index of the first occurrence of *value* in the
   list. Raises a "ValueError" if there is no such item.

   Argumentele opționale *start* și *end* sunt interpretate la fel ca
   în cazul unei tranșări și sunt folosite la limitarea căutărilor
   într-o anumită sub-secvență a listei. Indicele returnat se
   calculează relativ la începutul întregii secvențe și nu începând de
   la argumentul *start*.

list.count(value, /)

   Return the number of times *value* appears in the list.

list.sort(*, key=None, reverse=False)

   Sortează elementele listei păstrându-le în aceeași listă
   (argumentele pot fi folosite la construcția unei sortări
   personalizate, vezi "sorted()" pentru o justificare a lor).

list.reverse()

   Scrie în ordine inversă elementele listei păstrându-le în aceeași
   listă.

list.copy()

   Întoarce o copie superficială a listei. La fel ca "a[:]".

Un exemplu care întrebuințează majoritatea metodelor listei:

   >>> fructe = ['portocală', 'măr', 'pară', 'banană', 'kiwi', 'măr', 'banană']
   >>> fructe.count('măr')
   2
   >>> fructe.count('mandarină')
   0
   >>> fructe.index('banană')
   3
   >>> fructe.index('banană', 4)  # Găsește prima banană situată la dreapta poziției 4
   6
   >>> fructe.reverse()
   >>> fructe
   ['banană', 'măr', 'kiwi', 'banană', 'pară', 'măr', 'portocală']
   >>> fructe.append('struguri')
   >>> fructe
   ['banană', 'măr', 'kiwi', 'banană', 'pară', 'măr', 'portocală', 'struguri']
   >>> fructe.sort()
   >>> fructe
   ['banană', 'banană', 'kiwi', 'măr', 'măr', 'pară', 'portocală', 'struguri']
   >>> fructe.pop()
   'struguri'

Poate că ați remarcat deja că metode precum "insert", "remove" sau
"sort", adică metode care fac modificări în listă păstrând lista, nu
afișează nicio valoare returnată -- în fapt, ele returnează valoarea
prestabilită "None". [1]  Acesta este un principiu de design valabil
pentru toate structurile de date mutabile din Python.

Altă chestiune de remarcat este aceea că nu toate datele pot fi
sortate și nici comparate. De exemplu, "[None, 'salut', 10]" nu se va
sorta deoarece numerele întregi nu sunt comparabile cu șirurile de
caractere iar "None" nu poate fi comparat cu niciun alt tip de date.
De asemeni, există tipuri de date fără o relație de ordine totală.
Astfel, "3+4j < 5+7j" nu este o comparație validă.


5.1.1. Utilizarea listelor ca stive
-----------------------------------

Metodele tipului listă ne permit să utilizăm listele cu ușurință pe
post de stive, adică de instanțe ale acelui tip de date la care
ultimul element adăugat va fi extras primul ("ultimul intrat, primul
ieșit"). Pentru a pune un element în vârful stivei, folosiți
"append()". Pentru a scoate un element din vârful stivei, folosiți
"pop()" fără să precizați niciun index. De exemplu:

   >>> stiva = [3, 4, 5]
   >>> stiva.append(6)
   >>> stiva.append(7)
   >>> stiva
   [3, 4, 5, 6, 7]
   >>> stiva.pop()
   7
   >>> stiva
   [3, 4, 5, 6]
   >>> stiva.pop()
   6
   >>> stiva.pop()
   5
   >>> stiva
   [3, 4]


5.1.2. Făcând cozi din liste
----------------------------

Se poate să întrebuințăm o listă aidoma unei cozi, adică a unei
instanțe a acelui tip de date la care primul element adăugat va fi
extras primul ("primul intrat, primul ieșit"); însă listele nu au fost
proiectate ca să fie eficiente în acest scop. În timp ce adăugările la
final și extragerile de la finalul unei liste sunt rapide, realizarea
de inserări la început și de eliminări de la începutul unei liste sunt
operații lente (aceasta deoarece toate celelalte elemente trebuie
deplasate în lateral cu câte o poziție).

Pentru a implementa o coadă, folosiți "collections.deque" care a fost
proiectată special ca să realizeze adăugiri și eliminări rapide la
ambele capete. De exemplu:

   >>> from collections import deque
   >>> coadă = deque(["Eric", "John", "Michael"])
   >>> coadă.append("Terry")      # Terry intră în scenă
   >>> coadă.append("Graham")     # Graham intră în scenă
   >>> coadă.popleft()            # Primul sosit iese din scenă
   'Eric'
   >>> coadă.popleft()            # Al doilea sosit iese din scenă
   'John'
   >>> coadă                      # Coada rămasă, în ordinea intrărilor în scenă

   deque(['Michael', 'Terry', 'Graham'])


5.1.3. Comprehensiunea listelor
-------------------------------

Comprehensiunea listelor (*înțelegerea* dar și *explicarea* lor)
reprezintă o metodă succintă de a crea liste. Aplicațiile esențiale
ale acesteia sunt construcțiile de liste noi ale căror elemente să fie
rezultatul realizării anumitor operații cu fiecare din membrii unei
secvențe ori ai unui iterabil, respectiv crearea unei sub-secvențe din
acele elemente ale unei secvențe date care îndeplinesc o anumită
condiție.

De exemplu, să presupunem că dorim să creăm o listă de pătrate
perfecte, precum urmează:

   >>> pătrate_perfecte = []
   >>> for x in range(10):
   ...     pătrate_perfecte.append(x**2)
   ...
   >>> pătrate_perfecte
   [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Să remarcăm că procedeul anterior creează (ori suprascrie) o variabilă
numită "x" care va exista și după încheierea ciclului "for". Putem
calcula lista pătratelor perfecte și fără asemenea efecte secundare
dacă utilizăm fie expresia:

   pătrate_perfecte = list(map(lambda x: x**2, range(10)))

fie pe cea echivalentă acesteia:

   pătrate_perfecte = [x**2 for x in range(10)]

care este mai concisă și mai ușor de citit.

Comprehensiunea unei liste constă din paranteze drepte care încadrează
o expresie urmată de o clauză "for", apoi de zero sau mai multe clauze
"for" ori clauze "if". Rezultatul comprehensiunii va fi o listă nouă,
produsă ca urmare a evaluării expresiei în contextul clauzelor "for"
și "if" care îi urmează în cod. De exemplu, următoarea comprehensiune
de liste (în englezește, ca jargon, *listcomp*) combină elementele a
două liste atunci când aceste elemente nu sunt egale:

   >>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
   [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

și este echivalentă cu:

   >>> combinații = []
   >>> for x in [1,2,3]:
   ...     for y in [3,1,4]:
   ...         if x != y:
   ...             combinații.append((x, y))
   ...
   >>> combinații
   [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

Remarcați că ordinea instrucțiunilor "for" și "if" se păstrează în
ambele fragmente de cod.

Dacă expresia este un tuplu (precum "(x, y)"-ul din exemplul
precedent), atunci ea trebuie încadrată de paranteze.

   >>> vectorul = [-4, -2, 0, 2, 4]
   >>> # crearea unei liste noi cu valoarea elementelor dublată
   >>> [x*2 for x in vectorul]
   [-8, -4, 0, 4, 8]
   >>> # filtrarea listei pentru a exclude numerele negative
   >>> [x for x in vectorul if x >= 0]
   [0, 2, 4]
   >>> # aplicarea unei funcții fiecărui element din listă
   >>> [abs(x) for x in vectorul]
   [4, 2, 0, 2, 4]
   >>> # apelul unei metode a fiecărui element din listă
   >>> fructe_proaspete = ['  banană', '  hibrid de mure și zmeură ', 'fructul pasiunii  ']
   >>> [armă.strip() for armă in fructe_proaspete]
   ['banană', 'hibrid de mure și zmeură', 'fructul pasiunii']
   >>> # crearea unei liste de 2-tupluri de felul (numărul, pătratul său)
   >>> [(x, x**2) for x in range(6)]
   [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
   >>> # tuplul trebuie încadrat de paranteze, în caz contrar producându-se o eroare
   >>> [x, x**2 for x in range(6)]
     File "<stdin>", line 1
       [x, x**2 for x in range(6)]
        ^^^^^^^
   SyntaxError: did you forget parentheses around the comprehension target?
   >>> # serializarea unei liste folosind o listcomp cu două 'for'-uri
   >>> vectorul = [[1,2,3], [4,5,6], [7,8,9]]
   >>> [numărul for elementul in vectorul for numărul in elementul]
   [1, 2, 3, 4, 5, 6, 7, 8, 9]

Comprehensiunile de liste pot conține atât expresii complexe cât și
funcții imbricate:

   >>> from math import pi
   >>> [str(round(pi, i)) for i in range(1, 6)]
   ['3.1', '3.14', '3.142', '3.1416', '3.14159']


5.1.4. Comprehensiuni imbricate de liste
----------------------------------------

Expresia inițială dintr-o comprehensiune de liste poate fi orice fel
de expresie, deci poate include și o (altă) comprehensiune de liste.

Să luăm în considerare următorul exemplu de matrice 3x4 implementată
ca listă formată din 3 liste de lungime 4:

   >>> matrice = [
   ...     [1, 2, 3, 4],
   ...     [5, 6, 7, 8],
   ...     [9, 10, 11, 12],
   ... ]

Comprehensiunea de liste care urmează va transpune liniile și
coloanele matricei:

   >>> [[linia[i] for linia in matrice] for i in range(4)]
   [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

Așa cum am văzut în secțiunea anterioară, comprehensiunea listei
interioare este evaluată în contextul "for"-ul care îi urmează listei,
așa că exemplul de cod este echivalent cu:

   >>> transpusa = []
   >>> for i in range(4):
   ...     transpusa.append([linia[i] for linia in matrice])
   ...
   >>> transpusa
   [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

cod care, la rândul său, este identic cu:

   >>> transpusa = []
   >>> for i in range(4):
   ...     # următoarele 3 linii de cod implementează listcomp-a imbricată
   ...     linia_transpusei = []
   ...     for linia in matrice:
   ...         linia_transpusei.append(linia[i])
   ...     transpusa.append(linia_transpusei)
   ...
   >>> transpusa
   [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

În lumea reală, preferați funcțiile predefinite oricăror instrucțiuni
iterative complexe. Funcția "zip()" s-ar descurca de minune în cazul
de întrebuințare pe care îl studiem:

   >>> list(zip(*matrice))
   [(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]

A se vedea Despachetarea listelor de argumente pentru detalii despre
asteriscul de pe această linie de cod.


5.1.5. Unpacking in Lists and List Comprehensions
-------------------------------------------------

The section on Despachetarea listelor de argumente describes the use
of "*" to "unpack" the elements of an iterable object, providing each
one separately as an argument to a function.  Unpacking can also be
used in other contexts, for example, when creating lists.  When
specifying elements of a list, prefixing an expression by a "*" will
unpack the result of that expression, adding each of its elements to
the list we're creating:

   >>> x = [1, 2, 3]
   >>> [0, *x, 4, 5, 6]
   [0, 1, 2, 3, 4, 5, 6]

This only works if the expression following the "*" evaluates to an
iterable object; trying to unpack a non-iterable object will raise an
exception:

   >>> x = 1
   >>> [0, *x, 2, 3, 4]
   Traceback (most recent call last):
     File "<python-input-1>", line 1, in <module>
       [0, *x, 2, 3, 4]
   TypeError: Value after * must be an iterable, not int

Unpacking can also be used in list comprehensions, as a way to build a
new list representing the concatenation of an arbitrary number of
iterables:

   >>> x = [[1, 2, 3], [4, 5, 6], [], [7], [8, 9]]
   >>> [*element for element in x]
   [1, 2, 3, 4, 5, 6, 7, 8, 9]

Note that the effect is that each element from "x" is unpacked.  This
works for arbitrary iterable objects, not just lists:

   >>> x = [[1, 2, 3], 'cat', {'spam': 'eggs'}]
   >>> [*element for element in x]
   [1, 2, 3, 'c', 'a', 't', 'spam']

But if the objects in "x" are not iterable, this expression would
again raise an exception.


5.2. Instrucțiunea "del"
========================

Există o modalitate de a elimina un element dintr-o listă atunci când
îi știm indicele (poziția) dar nu și valoarea: instrucțiunea "del".
Aceasta diferă de metoda "pop()" care returnează valoarea elementului
eliminat. Instrucțiunea "del" poate fi utilizată și la eliminarea de
tranșe din listă ori la golirea întregii liste (ceea ce am făcut
anterior atribuindu-i tranșei o listă goală). De exemplu:

   >>> a = [-1, 1, 66.25, 333, 333, 1234.5]
   >>> del a[0]
   >>> a
   [1, 66.25, 333, 333, 1234.5]
   >>> del a[2:4]
   >>> a
   [1, 66.25, 1234.5]
   >>> del a[:]
   >>> a
   []

"del" poate fi folosită și la ștergerea completă a unei variabile:

   >>> del a

Referențierea numelui "a" de acum înainte este eronată (cel puțin până
când acestui nume îi vom atribui o valoare). Îi vom găsi ulterior și
alte întrebuințări lui "del".


5.3. Tupluri și secvențe
========================

Am văzut că șirurile de caractere și listele au multe proprietăți în
comun, cum ar fi operațiile de indexare și de tranșare. Tipurile
acestor obiecte sunt exemple de tipuri de date *secvență* (vezi Tipuri
secvență -- list, tuple, range). Deoarece Python-ul este un limbaj
aflat în plină evoluție, se poate ca și alte tipuri secvență de date
să îi fie adăugate. Mai există un tip secvență de date standard:
*tuplul*.

Un tuplu constă dintr-un număr de valori separate prin virgulă, cum ar
fi:

   >>> t = 12345, 54321, 'hello!'
   >>> t[0]
   12345
   >>> t
   (12345, 54321, 'hello!')
   >>> # Tuples may be nested:
   >>> u = t, (1, 2, 3, 4, 5)
   >>> u
   ((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
   >>> # Tuples are immutable:
   >>> t[0] = 88888
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: 'tuple' object does not support item assignment
   >>> # but they can contain mutable objects:
   >>> v = ([1, 2, 3], [3, 2, 1])
   >>> v
   ([1, 2, 3], [3, 2, 1])
   >>> # they support unpacking just like lists:
   >>> x = [1, 2, 3]
   >>> 0, *x, 4
   (0, 1, 2, 3, 4)

După cum puteți observa, atunci când sunt afișate, tuplurile apar
întotdeauna încadrate de paranteze, drept pentru care tuplurile
imbricate vor putea fi interpretate corect; pe de altă parte, ele pot
fi introduse cu sau fără paranteze, chiar dacă adesea parantezele sunt
necesare (atunci când tuplul face parte dintr-o expresie mai
cuprinzătoare). Deși nu îi putem atribui valori niciunui element
individual al unui tuplu, putem crea tupluri care conțin obiecte
mutabile, precum listele.

Chiar dacă tuplurile par să semene cu listele, ele se folosesc adesea
în situații diferite și pentru scopuri diferite de cele ale utilizării
listelor. Tuplurile sunt *imutabile* și conțin, de obicei, o secvență
eterogenă de elemente care pot fi accesate fie via despachetare (după
cum vom vedea ulterior în secțiunea de față) fie prin indexare (ba
chiar și prin intermediul atributelor în cazul "namedtuples"). În
schimb, listele sunt *mutabile* iar elementele unei liste sunt
omogene, de obicei, și se accesează prin iterări de-a lungul listei.

O problemă aparte o constituie construcția de tupluri cu 0 sau 1
elemente: sintaxa impune câteva adaosuri ciudate pentru a le acomoda.
Astfel, tuplurile goale se construiesc cu o pereche goală de paranteze
rotunde; un tuplu cu un singur element este construit dintr-o valoare
urmată de o virgulă (nu este suficient să încadrăm valoarea între
paranteze). Neplăcut, dar eficient. Ca, de exemplu:

   >>> gol = ()
   >>> singular = 'salut',    # <-- remarcați virgula de final
   >>> len(gol)
   0
   >>> len(singular)
   1
   >>> singular
   ('salut',)

Instrucțiunea "t = 12345, 54321, 'salut!'" este un exemplu de
*împachetare în tuplu*: valorile "12345", "54321" și "'salut!'" sunt
puse laolaltă într-un tuplu. Este posibilă și operația inversă:

   >>> x, y, z = t

Aceasta se numește, destul de potrivit, *despachetarea secvenței* și
funcționează pentru orice secvență admisă ca valoare de pe partea
dreaptă (ori r-valoare). Despachetarea secvențelor cere să fie tot
atâtea variabile pe partea stângă a semnului egal câte elemente are
secvența. Să observăm că atribuirea multiplă este, în realitate, doar
o combinație de împachetări de tupluri și de despachetări de secvențe.


5.4. Seturi
===========

Python also includes a data type for sets.  A set is an unordered
collection with no duplicate elements.  Basic uses include membership
testing and eliminating duplicate entries.  Set objects also support
mathematical operations like union, intersection, difference, and
symmetric difference.

Atât acoladele cât și funcția "set()" pot fi folosite la crearea de
mulțimi. Remarcă: pentru a crea o mulțime vidă trebuie să utilizați
"set()", nu "{}"; cea din urmă formulă va construi un dicționar de
date gol, iar despre o asemenea structură de date vom discuta în
secțiunea următoare.

Because sets are unordered, iterating over them or printing them can
produce the elements in a different order than you expect.

Iată o scurtă demonstrație:

   >>> coș = {'măr', 'portocală', 'măr', 'pară', 'portocală', 'banană'}
   >>> print(coș)               # arată că duplicatele au fost eliminate
   {'portocală', 'banană', 'pară', 'măr'}
   >>> 'portocală' in coș       # testarea rapidă a apartenenței
   True
   >>> 'pălămidă' in coș
   False

   >>> # Demonstrarea operațiilor cu mulțimi într-o problemă
   >>> # privind literele unicat din două cuvinte
   >>>
   >>> a = set('abracadabra')
   >>> b = set('alacazam')
   >>> a                        # litere unicat în a
   {'a', 'r', 'b', 'c', 'd'}
   >>> a - b                    # literele care sunt în a dar nu sunt în b
   {'r', 'd', 'b'}
   >>> a | b                    # literele care sunt sau în a sau în b sau în amândouă
   {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
   >>> a & b                    # literele care sunt și în a și în b
   {'a', 'c'}
   >>> a ^ b                    # literele care sunt sau în a sau în b dar nu în amândouă
   {'r', 'd', 'b', 'm', 'z', 'l'}

Similarly to list comprehensions, set comprehensions are also
supported, including comprehensions with unpacking:

   >>> a = {x for x in 'abracadabra' if x not in 'abc'}
   >>> a
   {'r', 'd'}

   >>> fruits = [{'apple', 'avocado', 'apricot'}, {'banana', 'blueberry'}]
   >>> {*fruit for fruit in fruits}
   {'blueberry', 'banana', 'avocado', 'apple', 'apricot'}


5.5. Dicționare de date
=======================

Alt tip de date util, predefinit în Python, este *dicționarul* (de
date, vezi Tipuri de asociere -- dict). Dicționare de date se găsesc
și în alte limbaje de programare, numite uneori "memorii asociative"
ori "tablouri asociative" (de la englezescul *array*). Spre deosebire
de secvențe, ale căror elemente sunt indexate cu indici dintr-un
domeniu de valori numerice, dicționarele de date au elementele
indexate cu *chei*, acestea putând fi obiecte ale oricărui tip de date
imutabile; șirurile de caractere și numerele pot fi oricând chei.
Tuplurile sunt întrebuințabile drept chei cu condiția să nu conțină
decât șiruri de caractere, numere, ori tupluri; dacă un tuplu conține
vreun obiect mutabil, fie în mod direct ori indirect, atunci el nu va
putea fi folosit pe post de cheie. Nu puteți utiliza listele drept
chei, deoarece listele pot fi modificate pe loc cu ajutorul
atriburilor la (un) index (dat), a atribuirilor la (o) tranșă (dată),
respectiv a unor metode precum "append()" și "extend()".

Cel mai bine este să ne gândim la dicționarul de date ca la o mulțime
de perechi *cheie: valoare* pentru care se cere să avem chei unice
(într-un singur dicționar). O pereche de acolade creează un dicționar
gol: "{}". Plasând o listă de perechi cheie:valoare cu elementele
separate prin virgule între aceste acolade, vom adăuga perechile
cheie:valoare din listă la dicționarul de date; acesta este, de fapt,
modul în care dicționarele sunt afișate.

The main operations on a dictionary are storing a value with some key
and extracting the value given the key.  It is also possible to delete
a key:value pair with "del". If you store using a key that is already
in use, the old value associated with that key is forgotten.

Extracting a value for a non-existent key by subscripting ("d[key]")
raises a "KeyError". To avoid getting this error when trying to access
a possibly non-existent key, use the "get()" method instead, which
returns "None" (or a specified default value) if the key is not in the
dictionary.

Executând instrucțiunea "list(d)" asupra unui dicționar de date "d",
se va returna lista tuturor cheilor utilizate de dicționar, în ordinea
în care ele au fost folosite la inserarea de valori (dacă le doriți
sortate, atunci folosiți "sorted(d)" în locul instrucțiunii
anterioare). Pentru a determina dacă o anumită cheie a fost deja
inclusă în dicționar, întrebuințați cuvântul-cheie "in".

Iată un exemplu succint de utilizare a dicționarului:

   >>> tel = {'jack': 4098, 'sape': 4139}
   >>> tel['guido'] = 4127
   >>> tel
   {'jack': 4098, 'sape': 4139, 'guido': 4127}
   >>> tel['jack']
   4098
   >>> tel['irv']
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   KeyError: 'irv'
   >>> print(tel.get('irv'))
   None
   >>> del tel['sape']
   >>> tel['irv'] = 4127
   >>> tel
   {'jack': 4098, 'guido': 4127, 'irv': 4127}
   >>> list(tel)
   ['jack', 'guido', 'irv']
   >>> sorted(tel)
   ['guido', 'irv', 'jack']
   >>> 'guido' in tel
   True
   >>> 'jack' not in tel
   False

Constructorul "dict()" produce dicționare de date direct din secvențe
de perechi cheie-valoare:

   >>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
   {'sape': 4139, 'guido': 4127, 'jack': 4098}

În plus, comprehensiunile de dicționare pot fi întrebuințate la a crea
dicționare de date din expresii arbitrare folosite de post de chei și
de valori:

   >>> {x: x**2 for x in (2, 4, 6)}
   {2: 4, 4: 16, 6: 36}

And dictionary unpacking (via "**") can be used to merge multiple
dictionaries:

   >>> odds = {i: i**2 for i in (1, 3, 5)}
   >>> evens = {i: i**2 for i in (2, 4, 6)}
   >>> {**odds, **evens}
   {1: 1, 3: 9, 5: 25, 2: 4, 4: 16, 6: 36}

   >>> all_values = [odds, evens, {0: 0}]
   >>> {**i for i in all_values}
   {1: 1, 3: 9, 5: 25, 2: 4, 4: 16, 6: 36, 0: 0}

Atunci când cheile sunt simple șiruri de caractere este mai
convenabil, uneori, să specificăm perechile dicționarului folosind
argumente cuvânt-cheie:

   >>> dict(sape=4139, guido=4127, jack=4098)
   {'sape': 4139, 'guido': 4127, 'jack': 4098}


5.6. Tehnici de iterare
=======================

Atunci când iterăm de-a lungul unui dicționar, cheia și valoarea
corespunzătoare ei pot fi capturate simultan cu ajutorul metodei
"items()".

   >>> cavaleri = {'Gallahad': 'cel fără de prihană', 'Robin': 'cel viteaz'}
   >>> for k, v in cavaleri.items():
   ...     print(k, v)
   ...
   Gallahad cel fără de prihană
   Robin cel viteaz

Atunci când iterăm de-a lungul unei secvențe, indicele de poziție și
valoarea corespunzătoare lui pot fi capturate simultan cu ajutorul
funcției "enumerate()".

   >>> for i, v in enumerate(['x', 'și', 'zero']):
   ...     print(i, v)
   ...
   0 x
   1 și
   2 zero

Pentru a itera de-a lungul a două sau mai multe secvențe în același
timp, elementele acestora pot fi împerecheate cu ajutorul funcției
"zip()".

   >>> întrebări = ['numele', 'țelul', 'stindardul tău']
   >>> răspunsuri = ['Lancelot', 'Sfântul Potir', 'cel albastru']
   >>> for q, a in zip(întrebări, răspunsuri):
   ...     print('Care este {0} tău?  Este {1}.'.format(q, a))
   ...
   Care este numele tău?  Este Lancelot.
   Care este țelul tău?  Este Sfântul Potir.
   Care este stindardul tău?  Este cel albastru.

Pentru a itera de-a lungul unei secvențe în sens invers, mai întâi
precizați secvența în ordinea ei obișnuită după care apelați funcția
"reversed()".

   >>> for i in reversed(range(1, 10, 2)):
   ...     print(i)
   ...
   9
   7
   5
   3
   1

Ca să iterați de-a lungul unei secvențe în ordinea sortării ei,
utilizați funcția "sorted()" care va returna o listă nouă, sortată,
lăsând nemodificată lista inițială.

   >>> coș = ['măr', 'portocală', 'măr', 'pară', 'portocală', 'banană']
   >>> for i in sorted(coș):
   ...     print(i)
   ...
   banană
   măr
   măr
   pară
   portocală
   portocală

Aplicând "set()" asupra unei secvențe îi eliminăm duplicatele.
Întrebuințarea lui "sorted()" în combinație cu "set()" asupra unei
secvențe constituie o modalitate idiomatică de a itera de-a lungul
elementelor unicat ale secvenței în ordinea sortării acesteia.

   >>> coș = ['măr', 'portocală', 'măr', 'pară', 'portocală', 'banană']
   >>> for f in sorted(set(coș)):
   ...     print(f)
   ...
   banană
   măr
   pară
   portocală

Este tentant, uneori, să modificăm o listă în timp ce iterăm de-a
lungul ei; cu toate acestea, este adesea mai simplu și mai sigur să
creăm o listă nouă în loc să o modificăm pe cea inițială.

   >>> import math
   >>> date_brute = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
   >>> date_filtrate = []
   >>> for valoarea in date_brute:
   ...     if not math.isnan(valoarea):
   ...         date_filtrate.append(valoarea)
   ...
   >>> date_filtrate
   [56.2, 51.7, 55.3, 52.5, 47.8]


5.7. Mai multe despre expresiile de control
===========================================

*Condițiile* de îndeplinit (sau *expresiile condiționale* ori
*expresiile de control*) conținute în instrucțiunile "while" și "if"
pot folosi orice fel de operatori nu doar pe cei de comparație
(relaționali).

Operatorii de comparație "in" și "not in" realizează teste de
apartenență care determină dacă o valoare se află (sau nu se află)
într-un container. Operatorii "is" și "is not" compară două obiecte
pentru a stabili dacă ele sunt, cu adevărat, același obiect. Toți
operatorii de comparație au aceeași prioritate, aceasta fiind mai mică
decât cea a indiferent cărui operator numeric.

Operațiile de comparație pot fi înlănțuite. De exemplu, "a < b == c"
va testa dacă "a" este (strict) mai mic decât "b" și dacă "b" este
egal cu "c".

Expresiile condiționale pot fi combinate folosind operatorii booleeni
"and" și "or", iar rezultatul unei comparații (ori valoarea de adevăr
a oricărei alte expresii booleene) poate fi negat cu "not". Acești
operatori booleeni au priorități mai mici decât cele ale operatorilor
de comparație; dintre ei, "not" are prioritatea cea mai mare iar "or"
pe cea mai mică, astfel că expresia "A and not B or C" este
echivalentă cu "(A and (not B)) or C". Ca de obicei, parantezele
rotunde pot fi întrebuințate la construcția compoziției dorite a
oricărei expresii.

Operatorii booleeni "and" și "or" fac parte din așa-numiții *operatori
de scurtcircuit*: argumentele (operanzii) lor se evaluează de la
stânga către dreapta iar evaluarea se oprește de îndată ce rezultatul
este determinat. De exemplu, dacă expresiile "A" și "C" sunt adevărate
iar "B" este falsă, atunci evaluarea expresiei "A and B and C" nu
necesită evaluarea lui "C". Dacă este folosită ca valoare generală și
nu ca dată booleană (valoare de adevăr), valoarea returnată de un
operator de scurtcircuit este ultimul argument evaluat.

Este posibil să atribuim rezultatul unei operații de comparare ori pe
cel al evaluării altei expresii booleene unei variabile. De exemplu,

   >>> șirul1, șirul2, șirul3 = '', 'Trondheim', 'Hammer Dance'
   >>> nenul = șirul1 or șirul2 or șirul3
   >>> nenul
   'Trondheim'

Atenție la faptul că în Python, spre deosebire de C, atribuirile din
interiorul expresiilor trebuie realizate folosind în mod explicit
operatorul morsă ":=". Această restricție ne permite să evităm un tip
de dificultăți întâlnite în mod obișnuit la programarea în C: situația
în care tastăm "=" într-o expresie în care intenționam să introducem
"==".


5.8. Comparând secvențe și alte tipuri de obiecte
=================================================

Obiectele secvență se compară, de obicei, cu alte obiecte de același
tip secvență. Operația de comparare folosește ordinea *lexicografică*:
mai întâi sunt comparate primul element al unuia din cele două obiecte
cu primul element al celuilalt obiect, iar dacă acestea diferă unul de
celălalt, atunci diferența dintre ele determină rezultatul
comparației; în schimb, dacă cele două elemente sunt egale, atunci se
va compara cel de-al doilea element al primului obiect cu cel de-al
doilea element al celuilalt obiect și așa mai departe, până când vom
ajunge la finalul  (măcar) unuia dintre obiecte. Dacă se întâmplă ca
elementele care sunt comparate să fie ele însele obiecte ale aceluiași
tip secvență, atunci comparația lexicografică va fi continuată în mod
recursiv. Dacă toate elementele celor două obiecte secvență sunt egale
două câte două, atunci obiectele secvență vor fi considerate egale.
Dacă unul dintre obiecte este, de la început, o sub-secvență a
celuilalt obiect, atunci obiectul mai scurt este cel mai mic (dintre
cele două). Ordinea lexicografică a șirurilor de caractere
întrebuințează numerele de punct de cod Unicode pentru ordonarea
caracterelor individuale. Iată câteva exemple de comparații între
secvențe de același tip:

   (1, 2, 3)              < (1, 2, 4)
   [1, 2, 3]              < [1, 2, 4]
   'ABC' < 'C' < 'Pascal' < 'Python'
   (1, 2, 3, 4)           < (1, 2, 4)
   (1, 2)                 < (1, 2, -1)
   (1, 2, 3)             == (1.0, 2.0, 3.0)
   (1, 2, ('aa', 'ab'))   < (1, 2, ('abc', 'a'), 4)

Remarcați că este permisă operația de comparare a obiectelor de tipuri
diferite folosind operatorii "<" sau ">" cu condiția ca obiectele
corespunzătoare să posede metode de comparație potrivite. De exemplu,
tipurile numerice diferite se compară folosind valoarea numerică a
obiectelor lor, astfel că 0 este egal cu 0.0 șamd. În caz contrar, în
loc să furnizeze o ordonare arbitrară, interpretorul va ridica o
excepție "TypeError".

-[ Note de subsol ]-

[1] În alte limbaje de programare, este posibil să se returneze
    obiectul mutat, ceea ce va permite înlănțuirea metodelor, cum ar
    fi "d->insert("a")->remove("b")->sort();".
