2. Utilizarea interpretorului de Python
***************************************


2.1. Invocarea interpretorului
==============================

Interpretorul de Python este instalat, de obicei, ca
"/usr/local/bin/python3.15" în mașinile de calcul pe care este
disponibil; dacă adăugați "/usr/local/bin" la calea de căutare a
interpretorului dumneavoastră de comenzi Unix, atunci veți putea să-l
porniți tastând comanda:

   python3.15

în terminal. [1] Deoarece alegerea directorului în care se găsește
interpretorul este o opțiune de instalare, există și alte locuri
posibile; întrebați-l de ele fie pe gurul de Python din partea locului
fie pe administratorul de sistem. (De exemplu, "/usr/local/python"
este o locație alternativă populară.)

Pe mașinile Windows pe care ați instalat Python-ul luat din Microsoft
Store este disponibilă comanda "python3.15". Dacă ați instalat
lansatorul py.exe, atunci puteți folosi comanda "py". Vedeți Excurs:
setarea variabilelor de mediu pentru alte modalități de a lansa în
execuție Python-ul.

Tastarea caracterului sfârșit-de-fișier ("Control"-"D" în Unix,
"Control"-"Z" în Windows) la promptul principal va face ca
interpretorul să încheie execuția cu codul de ieșire zero. Dacă
această acțiune nu are niciun efect, atunci veți putea ieși din
interpretor tastând comanda: "quit()".

The interpreter's line-editing features include interactive editing,
history substitution and code completion on most systems. Perhaps the
quickest check to see whether command line editing is supported is
typing a word in on the Python prompt, then pressing Left arrow (or
"Control"-"b"). If the cursor moves, you have command line editing;
see Appendix Editarea interactivă a datelor de intrare și substituții
în istoric for an introduction to the keys. If nothing appears to
happen, or if a sequence like "^[[D" or "^B" appears, command line
editing isn't available; you'll only be able to use backspace to
remove characters from the current line.

Interpretorul operează cumva asemănător modului în care o face
interpretorul de comenzi Unix: atunci când îl apelați dintr-un input
standard conectat la un dispozitiv tty, el citește și execută
comenzile în mod interactiv; dacă îl apelați având ca argument un nume
de fișier sau cu un fișier pe post de input standard, el citește și
execută un *script* din respectivul fișier.

Al doilea mod de pornire a interpretorului este "python -c comanda
[arg] ...", ceea ce va produce execuția instrucțiunilor din *comanda*,
la fel ca atunci când folosim opțiunea "-c" a interpretorului de
comenzi. Dat fiind că instrucțiunile Python conțin, în mod obișnuit,
spații goale ori diverse caractere socotite drept speciale de către
interpretorul de comenzi, vă recomandăm să încadrați *comanda* cu
ghilimele.

Unele module Python sunt utile și ca scripturi. Ele pot fi invocate cu
"python -m modulul [arg] ...", ceea ce va produce execuția fișierului-
sursă al modulului *modulul* la fel ca atunci când ați fi scris numele
complet al acestuia în linia de comandă.

Când folosim fișierul unui script, este util, uneori, să putem mai
întâi rula scriptul iar apoi reveni la modul interactiv de lucru.
Aceasta se poate face inserând "-i" înaintea scriptului.

Toate opțiunile din linia de comandă sunt descrise în Linia de comandă
și mediul de execuție.


2.1.1. Transmiterea argumentelor
--------------------------------

Atunci când îi sunt făcute cunoscute interpretorului, numele unui
script și argumentele adiționale de după el sunt transformate într-o
listă de șiruri de caractere care îi este atribuită variabilei "argv"
din modulul "sys". Puteți accesa această listă executând "import sys".
Lungimea listei trebuie să fie cel puțin 1; dacă nu sunt inserate nici
scriptul nici argumentele, "sys.argv[0]" va fi șirul nul. Dacă numele
scriptului este introdus ca "'-'" (ceea ce desemnează inputul
standard), atunci "sys.argv[0]" va fi setat ca "'-'". Când se
folosește "-c" *comandă*, "sys.argv[0]" va fi setat la "'-c'". Când se
folosește "-m" *modul*, "sys.argv[0]" va fi setat la numele complet al
locației modulului. Opțiunile ce vor fi găsite după "-c" *comandă* ori
"-m" *modul* nu vor fi consumate la procesarea de opțiuni a
interpretorului de Python ci vor fi lăsate în "sys.argv" pentru a fi
manevrate fie de către comandă fie de către modul.


2.1.2. Modul interactiv
-----------------------

Atunci când comenzile se citesc dintr-un dispozitiv tty (terminal), se
spune că interpretorul se găsește în *modul interactiv*. Când este în
acest mod, el cere o comandă nouă afișând *promptul principal*, de
obicei sub forma unui set de trei caractere mai-mare-ca (">>>");
pentru a trece pe linia de continuare a unei comenzi, el afișează
*promptul secundar*, format de obicei din trei puncte ("...").
Interpretorul printează un mesaj de bun-venit care cuprinde numărul
versiunii sale și o informare despre drepturile de autor înainte să
afișeze primul prompt:

   $ python3.15
   Python 3.15 (default, May 7 2025, 15:46:04)
   [GCC 10.2.0] on linux
   Type "help", "copyright", "credits" or "license" for more information.
   >>>

Liniile de continuare sunt necesare atunci când inserăm un construct
de mai multe linii. De exemplu, să aruncăm o privire asupra următoarei
instrucțiuni "if":

   >>> pământul_e_plat = True
   >>> if pământul_e_plat:
   ...     print("Atenție să nu cădeți de pe el!")
   ...
   Atenție să nu cădeți de pe el!

Pentru mai multe despre modul interactiv, vedeți Modul interactiv.


2.2. Interpretorul și mediul său
================================


2.2.1. Codificarea codului-sursă
--------------------------------

În mod obișnuit, fișierele-sursă Python sunt considerate a fi
codificate în UTF-8. Sub această codificare, caracterele majorității
limbilor lumii pot fi folosite fără nicio restricție atât în constante
de tip șir de caractere cât și în identificatori ori în comentarii ---
chiar dacă biblioteca standard utilizează numai caractere ASCII pentru
identificatori, convenție ce ar trebui îndeplinită de către orice fel
de cod portabil. Pentru a afișa corect aceste caractere, editorul
dumneavoastră trebuie să recunoască fișierul ca fiind UTF-8 și trebuie
să utilizeze un font care suportă toate caracterele din fișier.

Pentru declararea unei codificări diferite de cea implicită, o linie
specială de comentarii trebuie inserată ca *prima* linie a fișierului.
Sintaxa ei este după cum urmează:

   # -*- coding: codificare -*-

unde *codificare* este unul dintre "codec-urile" (adică, un
*codificator-decodificator*) valide permise de Python.

De exemplu, pentru a declara că urmează să fie folosită codificarea
Windows-1252, prima linie din codul-sursă al dumneavoastră trebuie să
fie:

   # -*- coding: cp1252 -*-

O excepție de la regula *primei linii* este atunci când codul-sursă
începe cu o linie "shebang" UNIX. În această situație, declarația
codificării trebuie inserată pe cea de-a doua linie a fișierului. De
exemplu:

   #!/usr/bin/env python3
   # -*- coding: cp1252 -*-

-[ Note de subsol ]-

[1] În Unix, interpretorul de Python 3.x nu este instalat implicit cu
    numele de executabil "python", astfel că nu se va intra în
    conflict (de nume) cu niciun executabil de Python 2.x deja
    instalat.
