# 7. Intrări și ieșiri

Există mai multe moduri de a prezenta rezultatul (sau ieșirea, de la englezescul output) execuției unui program; datele conținute în acest rezultat pot fi afișate într-o formă ușor de citit de către utilizatorii umani (în englezește, ca jargon, human-readable) sau pot fi scrise într-un fișier pentru o întrebuințare ulterioară. În capitolul de față vom discuta despre câteva din aceste feluri de prezentare.

## 7.1. Formatări elegante ale ieșirii

Până acum am întâlnit două modalități de scriere a valorilor: formulările de expresii și funcția `print()`. (O a treia modalitate este să folosim metoda `write()` a obiectelor fișier; fișierul standard de ieșire poate fi accesat ca `sys.stdout`. Vedeți Referința bibliotecii pentru mai multe informații în această privință.)

Adesea, veți dori să aveți mai mult control asupra formatului datelor de afișat decât simpla posibilitate de a le tipări cu câte un spațiu gol între ele. Dispunem de diferite procedee de a formata ieșirile.

- Pentru a folosi șiruri de caractere literale formatate, începeți șirul cu `f` sau cu `F`, poziționate înaintea ghilimelelor duble ori a celor triple de deschidere. În interiorul unui asemenea șir de caractere, puteți scrie o expresie Python încadrată de caracterele `{` și `}`, care să se refere la variabile ori la date literale.

      >>> anul = 2016
      >>> evenimentul = 'referendumul'
      >>> f'Rezultate la {evenimentul} din {anul}.'
      'Rezultate la referendumul din 2016.'

- Metoda `str.format()` a șirurilor de caractere necesită puțin mai multă muncă de redactare. Și aici veți utiliza `{` și `}` la încadrarea locului în care va fi substituită o anumită variabilă, respectiv veți avea posibilitatea de a da indicații detaliate în privința formatării, doar că va trebui să oferiți și informația de formatat. În blocul de cod care urmează se află două exemple despre cum se formatează variabilele:

      >>> voturi_pentru = 42_572_654
      >>> voturi_in_total = 85_705_149
      >>> procentaj = voturi_pentru / voturi_in_total
      >>> '{:-9} voturi PENTRU  {:2.2%}'.format(voturi_pentru, procentaj)
      ' 42572654 voturi PENTRU  49.67%'

  Să remarcăm că valoarea lui `voturi_pentru` este precedată de un spațiu gol la numerele pozitive și de un semn minus la cele negative. În același timp, codul din exemplu va afișa valoarea lui `procentaj` înmulțită cu 100 și urmată de două zecimale, respectiv de semnul procent (a se vedea Mini-limbajul specificației de format pentru detalii).

- În sfârșit, puteți să vă ocupați chiar dumneavoastră de întreaga manipulare a șirurilor de caractere folosind operațiile de tranșare și de concatenare a șirurilor pentru a crea orice machetă (de la englezescul layout) de afișare vă doriți. Tipul de date șir de caractere posedă diverse metode de spațiere a șirurilor la lățimi de caracter date.

Atunci când nu vă interesează nicio ieșire sofisticată ci, pur și simplu, vreți să afișați rapid valorile câtorva variabile în scopul depanării programului la care lucrați, ați putea converti orice valoare obținută într-un șir de caractere cu ajutorul funcțiilor `repr()` și `str()`.

Funcția `str()` a fost gândită să returneze reprezentări de valori care să fie ușor de citit de către utilizatorii umani, pe când funcția `repr()` a primit rolul de a genera reprezentări de date care să fie citite de către interpretorul de Python (sau să ridice o excepție `SyntaxError` atunci când reprezentările nu se potrivesc niciunui șablon sintactic). În cazul obiectelor care nu posedă nicio reprezentare distinctivă de oferit unui consumator uman, `str()` va întoarce aceeași valoare ca și `repr()`. Multe valori, cum ar fi numerele ori structurile de date de tipul listelor și al dicționarelor, primesc aceeași reprezentare de la amândouă funcțiile. Șirurile de caractere, pe de altă parte, posedă două reprezentări diferite.

Câteva exemple:

    >>> s = 'Salutare, lume.'
    >>> str(s)
    'Salutare, lume.'
    >>> repr(s)
    "'Salutare, lume.'"
    >>> str(1/7)
    '0.14285714285714285'
    >>> x = 10 * 3.25
    >>> y = 200 * 200
    >>> s = 'Valoarea lui x este ' + repr(x) + ', iar a lui y este ' + repr(y) + '...'
    >>> print(s)
    Valoarea lui x is 32.5, iar a lui y este 40000...
    >>> # Aplicarea lui repr() unui șir îi adaugă acestuia ghilimele simple
    >>> # și linii oblice inverse:
    >>> salut = 'salutare, lume\n'
    >>> salutări = repr(salut)
    >>> print(salutări)
    'salutare, lume\n'
    >>> # Argumentul lui repr() poate fi orice obiect Python:
    >>> repr((x, y, ('carne presată', 'ouă')))
    "(32.5, 40000, ('carne presată', 'ouă'))"

The `string` module contains support for a simple templating approach based upon regular expressions, via `string.Template`. This offers yet another way to substitute values into strings, using placeholders like `$x` and replacing them with values from a dictionary. This syntax is easy to use, although it offers much less control for formatting.

### 7.1.1. Șiruri de caractere literale formatate

Șirurile de caractere literale formatate (supranumite, pe scurt, f-șiruri) ne permit să introducem valoarea unei expresii Python în interiorul unui șir de caractere prefixând șirul cu `f` sau `F` și scriind expresia în cauză drept `{expresia}`.

Un specificator de format opțional îi poate urma expresiei. Prezența lui oferă un control sporit asupra modulului în care valoarea expresiei este formatată. Exemplul dat în continuare prezintă rotunjirea lui pi la trei cifre după virgulă (punct):

    >>> import math
    >>> print(f'Valoarea lui pi este de aproximativ {math.pi:.3f}.')
    Valoarea lui pi este de aproximativ 3.142.

Inserarea unui număr întreg imediat după semnul `':'` va avea ca efect printarea unui câmp lat de minim tot atâta caractere cât este valoarea inserată. O atare proprietate se dovedește utilă la alinierea coloanelor într-o afișare.

    >>> tabel = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
    >>> for nume, telefon in tabel.items():
    ...     print(f'{nume:10} ==> {telefon:10d}')
    ...
    Sjoerd     ==>       4127
    Jack       ==>       4098
    Dcab       ==>       7678

Alți modificatori pot fi întrebuințați la conversia unei valori înainte de formatare. Astfel, `'!a'` îi aplică valorii funcția `ascii()`, `'!s'` o aplică pe `str()` iar `'!r'` pe `repr()`:

    >>> animale = 'țipari'
    >>> print(f'Barca mea pe pernă de aer e plină de {animale}.')
    Barca mea pe pernă de aer e plină de țipari.
    >>> print(f'Barca mea pe pernă de aer e plină de {animale!r}.')
    Barca mea pe pernă de aer e plină de 'țipari'.

Specificatorul `=` poate fi utilizat la extinderea unei expresii sub formă de text al expresiei, urmat de semnul egal și de reprezentarea evaluării expresiei respective:

    >>> bugs = 'roaches'
    >>> count = 13
    >>> area = 'living room'
    >>> print(f'Debugging {bugs=} {count=} {area=}')
    Debugging bugs='roaches' count=13 area='living room'

A se vedea expresii auto-documentate pentru mai multe informații privind specificatorul `=`. Pentru o descriere cuprinzătoare a tuturor acestor specificații de format, consultați ghidul de referință despre Mini-limbajul specificației de format.

### 7.1.2. Metoda format() a tipului șir de caractere

Utilizarea de bază a metodei `str.format()` se face astfel – apelând, ca de obicei, la o scenetă Monty Python:

    >>> print('Noi suntem {} care strigă "{}!"'.format('bravii', 'Bau'))
    Noi suntem bravii care strigă "Bau!"

Acoladele și caracterele încadrate de ele (care se numesc câmpuri de format) vor fi înlocuite de obiectele transmise metodei `str.format()`. Un număr trecut între acolade poate fi utilizat ca referire la poziția obiectului ce trebuie transmis metodei `str.format()`.

    >>> print('{0} și {1}'.format('șuncă presată', 'ouă'))
    șuncă presată și ouă
    >>> print('{1} și {0}'.format('șuncă presată', 'ouă'))
    ouă și șuncă presată

Dacă vom întrebuința argumente cuvânt-cheie la apelul metodei `str.format()`, atunci ne vom referi la valorile acestora prin intermediul numelor argumentelor respective.

    >>> print('Această {aliment} este {nume_predicativ}.'.format(
    ...       aliment='șuncă presată', nume_predicativ='absolut îngrozitoare'))
    Această șuncă presată este absolut îngrozitoare.

Argumentele poziționale și cele cuvânt-cheie pot fi combinate în mod arbitrar:

    >>> print('Povestea lui {0}, {1} și {altul}.'.format('Bill', 'Manfred',
    ...                                                    altul='Georg'))
    Povestea lui Bill, Manfred și Georg.

În caz că aveți de manevrat un șir de format realmente lung și țineți neapărat să nu-l partiționați, ar fi util dacă v-ați putea referi la variabilele care trebuie formatate nu cu numărul – indicele poziției – ci cu numele. O atare rezolvare se obține transmițând, pur și simplu, un dicționar de date și folosind parantezele pătrate `'[]'` pentru a-i accesa cheile.

    >>> tabel = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
    >>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '
    ...       'Dcab: {0[Dcab]:d}'.format(tabel))
    Jack: 4098; Sjoerd: 4127; Dcab: 8637678

Același rezultat poate fi obținut transmițând dicționarul de date `tabel` ca pe un argument cuvânt-cheie dat în notația `**`.

    >>> tabel = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
    >>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'.format(**tabel))
    Jack: 4098; Sjoerd: 4127; Dcab: 8637678

Procedeul este extrem de folositor în combinație cu funcția predefinită `vars()`, care returnează un dicționar de date cu toate variabilele locale:

    >>> tabel = {k: str(v) for k, v in vars().items()}
    >>> mesaj = " ".join([f'{k}: ' + '{' + k +'};' for k in tabel.keys()])
    >>> print(mesaj.format(**tabel))
    __name__: __main__; __doc__: None; __package__: None; __loader__: ...

Ca exemplu, liniile de cod următoare produc un set de coloane aliniate compact care afișează numere întregi împreună cu pătratele și cuburile lor:

    >>> for x in range(1, 11):
    ...     print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
    ...
     1   1    1
     2   4    8
     3   9   27
     4  16   64
     5  25  125
     6  36  216
     7  49  343
     8  64  512
     9  81  729
    10 100 1000

Pentru o dare de seamă elaborată asupra formatării șirurilor de caractere folosind `str.format()`, a se vedea Sintaxa șirurilor de format.

### 7.1.3. Formatare manuală a șirurilor de caractere

Iată același tabel de pătrate și cuburi de numere întregi, însă formatat manual:

    >>> for x in range(1, 11):
    ...     print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
    ...     # Remarcați folosirea lui 'end' pe linia anterioară
    ...     print(repr(x*x*x).rjust(4))
    ...
     1   1    1
     2   4    8
     3   9   27
     4  16   64
     5  25  125
     6  36  216
     7  49  343
     8  64  512
     9  81  729
    10 100 1000

(Luați în considerare faptul că un spațiu gol, între două coloane consecutive, i se datorează modului de funcționare al funcției `print()`: aceasta adaugă întotdeauna spații goale între argumentele sale.)

Metoda `str.rjust()` a obiectelor șir de caractere aliniază la dreapta un șir într-un câmp de lățime dată inserând spații goale în stânga șirului. Python-ul dispune de încă două metode similare, și anume `str.ljust()`, respectiv `str.center()`. Ele nu inserează nimic (în vechiul șir), doar întorc un șir nou. Dacă șirul ce trebuie manipulat este prea lung, aceste metode nu-l vor trunchia, ci îl vor returna nemodificat; deși un asemenea comportament vă va afecta dpdv. estetic macheta coloanelor, alternativa ar fi mult mai rea, ea presupunând modificări de valori. (Dacă doriți, cu adevărat, o trunchiere a șirului manipulat, atunci puteți apela la operațiile de tranșare, cum ar fi `x.ljust(n)[:n]`.)

Mai există o metodă, `str.zfill()`, care completează la stânga, cu zerouri, șirurile de numere. Are capacitatea de a distinge cifrele de semnele plus și minus:

    >>> '12'.zfill(5)
    '00012'
    >>> '-3.14'.zfill(7)
    '-003.14'
    >>> '3.14159265359'.zfill(5)
    '3.14159265359'

### 7.1.4. Vechiul stil de formatare al șirurilor de caractere

Operatorul % (modulo) poate fi întrebuințat și la formatarea șirurilor de caractere. Fiind dată expresia `formatul % valorile` (unde formatul desemnează un șir de caractere), specificațiile conversiei `%` care sunt scrise în formatul vor fi înlocuite cu zero sau mai multe elemente din valorile. Această operație este cunoscută sub numele de interpolarea șirurilor (de caractere). De exemplu:

    >>> import math
    >>> print('Valoarea lui pi este aproximativ %5.3f.' % math.pi)
    Valoarea lui pi este aproximativ 3.142.

Mai multe informații se găsesc în secțiunea Formatarea șirurilor de caractere în vechiul stil printf.

## 7.2. Citirea și scrierea fișierelor

`open()` returnează un obiect fișier și este utilizată de obicei cu două argumente poziționale și un argument cuvânt-cheie: `open(nume_de_fișier, mod_de_deschidere, encoding=None)`

    >>> f = open('fișier_șantier', 'w', encoding="utf-8")

Primul argument este un șir de caractere desemnând numele fișierului pe care dorim să-l deschidem. Cel de-al doilea argument este tot un șir de caractere, foarte scurt, ce descrie felul în care vom folosi fișierul. mod_de_deschidere va fi `'r'` dacă dorim doar să citim fișierul, `'w'` dacă ne interesează numai să scriem în el (în caz că există fișierul omonim, acesta va fi șters), respectiv `'a'` pentru adăugare la sfârșitul fișierului. `'r+'` va deschide fișierul atât pentru citit cât și pentru scris. Argumentul mod_de_deschidere este opțional; dacă nu-l precizăm, atunci el va fi considerat `'r'`.

De obicei, fișierele se deschid în modul text, ceea ce înseamnă că puteți citi șiruri de caractere din ele, respectiv scrie șiruri de caractere în ele, șiruri care sunt codificate (de la englezescul encoding) conform unei codificări anumite. Atunci când codificarea nu este precizată, codificarea implicită va depinde de platforma de calcul (vedeți `open()`). Dat fiind că UTF-8 constituie, în zilele noastre, standardul de facto în domeniu, este recomandat să folosiți `encoding="utf-8"` dacă nu aveți, realmente, nevoie de vreo codificare specială. Adăugând sufixul `'b'` la modul de deschidere, fișierul în cauză va fi deschis în modul binar. Datele accesate în modul binar sunt citite și scrise sub formă de obiecte `octeți`. Nu vi se permite să specificați care este codificarea dacă deschideți fișierul în modul binar.

Atunci când manevrăm fișierul în modul text, la citire din el, caracterele care marchează sfârșitul de rând se vor transforma implicit din caractere sfârșit de rând specifice platformei de calcul (adică, din `\n` în Unix, respectiv din `\r\n` în Windows) în caracterul `\n`. Invers, la scrierea în fișier, toate aparițiile lui `\n` vor deveni implicit caracterele de sfârșit de rând specifice platformei pe care lucrăm. Deși o astfel de modificare sub capotă (de la englezescul behind-the-scenes) este convenabilă atunci când avem de a face cu fișiere text, ea va corupe datele binare precum cele dintr-un fișier `JPEG` ori `EXE`. Aveți mare grijă să folosiți modul binar atunci când fie citiți din asemenea fișiere fie scrieți în ele.

O bună practică ne este la îndemână prin intermediul cuvântului-cheie `with`, de întrebuințat dacă manevrăm obiecte fișier. Avantajul său constă în aceea că fișierul va fi întotdeauna închis corect la finalul execuției expresiei acestui construct, și aceasta chiar dacă a fost ridicată vreo excepție pe parcurs. În plus, folosirea lui `with` scurtează semnificativ codul care ar trebui scris dacă folosim constructul echivalent dat de blocurile `try`-`finally`:

    >>> with open('fișier_șantier', encoding="utf-8") as f:
    ...     citește_datele = f.read()

    >>> # Putem verifica dacă fișierul a fost închis automat.
    >>> f.closed
    True

În caz că nu utilizați cuvântul cheie `with`, atunci va trebui să apelați metoda `f.close()` pentru a închide fișierul și a elibera de îndată eventualele resurse ale sistemului pe care manevrarea fișierului le-a blocat.

Atenționare

Apelul lui `f.write()` fie fără să folosim cuvântul cheie `with` fie fără să-l însoțim de apelul lui `f.close()` poate avea drept consecință o scriere incompletă a argumentelor lui `f.write()` pe disc, și aceasta chiar dacă programul se va încheia corect.

După ce un obiect fișier a fost închis, fie printr-o instrucție `with` fie prin apelul metodei `f.close()`, orice încercare de a-l întrebuința va fi sortită eșecului.

    >>> f.close()
    >>> f.read()
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ValueError: I/O operation on closed file.

### 7.2.1. Metodele obiectelor fișier

Restul exemplelor din această secțiune presupune că un obiect fișier pe nume `f` a fost deja creat.

Ca să citiți conținutul unui fișier, apelați `f.read(cantitate)`, instrucțiune care citește o anumită cantitate de date și o returnează sub formă de șir de caractere (în modul text) sau sub forma unui obiect bytes (în modul binar). cantitate este un argument numeric opțional. Atunci când cantitate fie este omis fie este număr negativ, întregul conținut al fișierului va fi citit și apoi returnat; treaba dumneavoastră dacă fișierul în cauză se dovedește a fi de două ori mai mare ca memoria mașinii de calcul. Altfel, cel mult un număr de cantitate de caractere (în modul text) vor fi citite și returnate, respectiv un număr de cantitate de biți (în modul binar) vor fi citiți și returnați. Atunci când se va ajunge la finalul fișierului, `f.read()` va întoarce un șir gol (`''`).

    >>> f.read()
    'Acesta este întregul fișier.\n'
    >>> f.read()
    ''

`f.readline()` citește un singur rând din fișier; caracterul linie-nouă (`\n`) este păstrat la sfârșitul șirului de caractere citit, el fiind omis numai la ultimul rând al fișierului, atunci când fișierul nu se încheie cu o linie nouă (în englezește, ca jargon, newline). Procedeul în cauză face ca valoarea returnată să fie lipsită de ambiguitate; căci, dacă `f.readline()` returnează un șir gol înseamnă că am ajuns la finalul fișierului, în timp ce o linie goală (dintre paragrafe) va fi reprezentată de un `'\n'`, adică de un șir conținând numai un singur caracter, cel de linie nouă.

    >>> f.readline()
    'Acesta este primul rând al fișierului.\n'
    >>> f.readline()
    'Al doilea rând al fișierului\n'
    >>> f.readline()
    ''

Pentru a citi mai multe linii din fișier, puteți itera de-a lungul obiectului fișier. O atare procedură este eficientă dpdv. al consumului de memorie, este rapidă și se bazează pe un cod Python simplu:

    >>> for rând in f:
    ...     print(rând, end='')
    ...
    Acesta este primul rând al fișierului.
    Al doilea rând al fișierului

Dacă vă interesează să plasați toate rândurile unui fișier într-o listă, atunci ați putea folosi `list(f)` sau `f.readlines()`.

`f.write(șir_de_caractere)` scrie conținutul lui șir_de_caractere în fișier, returnând numărul de caractere scrise.

    >>> f.write('Acesta e un test\n')
    17

Obiectele de alt tip trebuie convertite mai întâi – fie la șiruri de caractere (în modul text) fie la obiecte bytes (în modul binar) – înainte de scrierea în fișier:

    >>> valoarea = ('răspunsul', 42)
    >>> s = str(valoarea)  # convertește tuplul în șir de caractere
    >>> f.write(s)
    17

`f.tell()` returnează un număr întreg care fie indică poziția curentă în obiectul fișier precizând la câți octeți ne găsim față de începutul fișierului, atunci când fișierul a fost deschis în modul binar, fie este o valoare opacă, atunci când fișierul a fost deschis în modul text.

Pentru a schimba poziția (cursorului) în obiectul fișier, întrebuințați metoda `f.seek(deplasament, sursă)`. Poziția se calculează adunând acest deplasament la punctul de referință; punctul de referință este precizat prin argumentul sursă. Valoarea 0 a lui sursă înseamnă că ne vom raporta la începutul fișierului, valoarea 1 se referă la poziția curentă în fișier, iar valoarea 2 implică folosirea finalului de fișier pe post de punct de referință.

    >>> f = open('fișier_șantier', 'rb+')
    >>> f.write(b'0123456789abcdef')
    16
    >>> f.seek(5)      # Mergi la cel de-al 6-lea octet din fișier
    5
    >>> f.read(1)
    b'5'
    >>>                # Mergi la octetul situat cu 3 poziții (octeți)
    >>>                # înaintea finalului
    >>> f.seek(-3, 2)
    13
    >>> f.read(1)
    b'd'

În fișierele text (adică, fișierele deschise fără să se utilizeze niciun `b` în șirul de caractere al modului de deschidere) sunt permise doar poziționările raportate la începutul fișierului (singura excepție fiind cea dată de poziționarea, folosind `seek(0, 2)`, chiar la finalul fișierului), iar valorile corecte pentru deplasament sunt numerele returnate de `f.tell()`, respectiv zero. Orice alt deplasament va cauza comportamente impredictibile.

Fișierele obiect posedă diverse alte metode, precum `isatty()` și `truncate()` care sunt mai rar întâlnite; consultați Referința bibliotecii pentru ghidul cuprinzător al obiectelor fișier.

### 7.2.2. Salvarea structurilor de date cu `json`

Șirurile de caractere se scriu ușor într-un fișier și se citesc (la fel de) ușor dintr-un fișier. Numerele presupun un efort suplimentar, dat fiind că metoda `read()` returnează doar șiruri de caractere, iar acestea din urmă trebuie transmise unei funcții precum `int()`, care funcție preia un șir ca `'123'` și întoarce valoarea sa numerică, adică pe 123. Atunci când vă interesează să salvați date de diverse tipuri mai sofisticate decât șirurile ori numerele, cum ar fi listele imbricate ori dicționarele de date, parsarea manuală și serializarea de mână devin niște sarcini complicate.

Ca să nu-i silească pe utilizatori să-și consume timpul scriind și corectând cod specializat în salvarea în fișiere a tipurilor complicate de date, Python-ul le permite acestora să întrebuințeze popularul format de (inter)schimb de date numit JSON (Notația obiectelor JavaScript). Modulul predefinit `json` preia date Python ierarhizate și le convertește în reprezentări sub formă de șiruri de caractere; un atare proces este numit serializare. Invers, reconstrucția datelor din reprezentările lor ca șiruri de caractere poartă numele de deserializare. Între o serializare și deserializarea subsecventă, șirul de caractere care reprezintă un obiect Python poate fi stocat într-un fișier sau într-un flux de date, ori transmis printr-o conexiune la rețeaua Internet către o mașină de calcul aflată la distanță.

Notă

Formatul JSON este utilizat frecvent de aplicațiile moderne care permit schimburi de date. Mulți programatori sunt deja familiarizați cu el, ceea ce îl face o alegere potrivită atunci când ne interesează interoperabilitatea.

Dacă aveți la îndemână un obiect Python `x`, atunci vă ajunge o singură linie de cod ca să-i vedeți reprezentarea JSON sub formă de șir de caractere:

    >>> import json
    >>> x = [1, 'banală', 'listă']
    >>> json.dumps(x)
    '[1, "banală", "listă"]'

O variantă a funcției `dumps()`, intitulată `dump()`, serializează de-a dreptul obiectul Python într-un fișier text. Așadar, dacă `f` este un obiect fișier text deschis pentru scriere, putem proceda astfel:

    json.dump(x, f)

Ca redecodificăm obiectul, presupunând că `f` este fie un obiect fișier binar fie un obiect fișier text care a fost deja deschis pentru citire, executăm:

    x = json.load(f)

Notă

Fișierele JSON trebuie să fie codificate UTF-8. Folosiți `encoding="utf-8"` atunci când deschideți un fișier JSON ca fișier text atât pentru citire cât și pentru scriere.

O asemenea tehnică simpl(ist)ă de serializare se descurcă la manevrarea listelor și a dicționarelor de date, însă serializarea în JSON a unor instanțe de clase oarecare necesită un anume efort. Referința la modulul `json` din documentație explică de ce.

Vezi și

`pickle` - modulul pickle

Spre deosebire de JSON, pickle (adică, muratul sau punerea la murat) desemnează un protocol capabil să serializeze obiecte Python oricât de complicate. Din care motiv, îi este tipic (doar) Python-ului și nu poate fi utilizat la comunicarea cu aplicații scrise în alte limbaje de programare. De asemeni, este nesigur în mod prestabilit: deserializarea unor date puse la murat pe care le-ați obținut de la o sursă dubioasă poate provoca execuții de cod despre care (să) nu știți nimic, în caz că datele au fost preparate de un atacator îndemânatic.