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


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

The Python interpreter is usually installed as
"/usr/local/bin/python3.10" on those machines where it is available;
putting "/usr/local/bin" in your Unix shell's search path makes it
possible to start it by typing the command:

   python3.10

î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ă.)

On Windows machines where you have installed Python from the Microsoft
Store, the "python3.10" command will be available. If you have the
py.exe launcher installed, you can use the "py" command. See Excursus:
Setting environment variables for other ways to launch Python.

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()".

Caracteristicile de editare a liniei de comandă ale interpretorului
includ editarea interactivă, substituția istoricului și completarea
codului pe sistemele care suportă biblioteca GNU Readline. Cea mai
rapidă cale de a vedea dacă este permisă editarea liniei de comandă
este să tastați "Control-P" la primul prompt de Python la care
ajungeți. Dacă se aude un bip, atunci dispuneți de editare a liniei de
comandă; vedeți Apendicele Editarea interactivă a datelor de intrare
și substituții în istoric pentru o prezentare a tastelor. În schimb,
dacă fie nu se întâmplă nimic fie ecoul va fi un "^P", nu aveți
editare în linie de comandă; tot ce puteți face este să folosiți
backspace-ul pentru eliminarea de caractere din linia curentă.

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.10
   Python 3.10 (default, June 4 2019, 09:25:04)
   [GCC 4.8.2] 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":

   >>> the_world_is_flat = True
   >>> if the_world_is_flat:
   ...     print("Be careful not to fall off!")
   ...
   Be careful not to fall off!

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: encoding -*-

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.
