Python un lombaj accesibil

4.2. pentru  declarații 

Instrucțiunea  pentru  Python diferă puțin de ceea ce puteți folosi în C sau Pascal. Mai mult decât oricare ar fi iterând asupra unei evoluții aritmetice a numerelor (ca în cazul lui Pascal) sau oferind utilizatorului posibilitatea de a defini atât etapa de repetare, cât și starea de oprire (ca C),  instrucțiunea  lui Python  pentru  iterație se  repetă asupra elementelor din orice secvență (o listă sau un șir), în ordinea în care apar în secvență. De exemplu (nu este destinat jocului):

>>>

>>> # Măsura unele caractere 
de caractere: ... cuvinte  =  [ 'pisică' ,  'fereastră' ,  'defenestrate' ] 
>>> pentru  w  în  cuvinte : 
...     printare ( w ,  Len ( w )) 
.. . 
pisică 3 
fereastra 6 
defenestrate 12

Dacă trebuie să modificați secvența pe care o repetați în interiorul bucla (de exemplu, pentru a duplica elementele selectate), este recomandat să creați o copie. Iterarea unei secvențe nu se face implicit o copie. Notatia de felie fata ca acest lucru deosebit de convenabil:

>>>

>>> pentru  w  version  cuvinte [:]:   # Bucla Faceți o copie cu peste un INTREGII Secțiune liste. 
...     dacă  lămâie ( w )  >  6 : 
...         cuvinte . inserați ( 0 ,  w ) 
... 
>>> cuvinte 
['defenestrate', 'cat', 'fereastră', 'defenestrate']

4.3. Intervalul ()  Funcția 

Dacă trebuie să repetați o secvență de numere, intervalul de funcții încorporat () este la îndemână. Aceasta generează progrese aritmetice:

>>>

>>> pentru  i  în  intervalul ( 5 ): 
...     print ( i ) 
... 
0 
1 
2 
3 
4

Punctul final dat nu este niciodată parte a secvenței generate; intervalul (10) generează 10 valori, indici legali pentru elementele cu o secvență de lungime 10. Este posibil să lăsăm intervalul să înceapă la un alt număr sau să specificăm o altă valoare (chiar negativă, uneori se numește "pas" ):

intervalul ( 5 ,  10 ) de la 
   5  la  9

intervalul ( 0 ,  10 ,  3 ) 
   0 ,  3 ,  6 ,  9

Gama ( - 10 ,  - 100 ,  - 30 ) 
  - 10 ,  - 40 ,  - 70

Pentru a itera peste indicii unei secvențe, puteți combina range () și len () după cum urmează:

>>>

>>> a  =  [ 'Maria' ,  ' a avut' ,  'o' ,  'mic' ,  'miel' ] 
>>> pentru  i  în  gama ( len ( a )): 
...     print ( i ,  o [ i ]) 
... 
0 Mary 
1 avea 
2 și 
3 puține 
4 mieluri

În majoritatea acestor cazuri, cu toate acestea, este convenabil să utilizați funcția enumerate () , consultați tehnicile de buclă .

Un lucru ciudat se întâmplă dacă imprimați doar o gamă:

>>>

>>> imprimare ( interval ( 10 )) 
interval (0, 10)

În multe privințe, obiectul returnat de domeniul () se comportă ca și cum ar fi o listă, dar de fapt nu este. Este un obiect care returnează elementele succesive ale secvenței dorite atunci când o iterați peste ea, dar nu face într-adevăr lista, economisind astfel spațiu.

Spunem că un astfel de obiect este iterabil , adică potrivit ca țintă pentru funcții și construcții care se așteaptă la ceva din care pot obține elemente succesive până la epuizarea aprovizionării. Am văzut că declarația pentru este un astfel de iterator . Lista de funcții () este alta; creează liste de la iterables:

>>>

>>> lista ( intervalul ( 5 )) 
[0, 1, 2, 3, 4]

Mai târziu vom vedea mai multe funcții care returnează iterabile și vor lua iterații ca argument.

4.4. întrerupeți și continuați declarațiile, și altfelClauzele pe buclă 

Pauză declarație, cum ar fi în C, izbucnește celui mai mic pentru sau în timp ce bucla.

Comportamentele buclă pot avea o altă clauză; se execută atunci când bucla se termină prin epuizarea listei (cu for ) sau atunci când condiția devine falsă (cu timp ), dar nu și atunci când bucla este terminată printr-o declarație de pauză . Acest lucru este exemplificat de următoarea buclă, care caută numere prime:

>>>

>>> pentru  n  în  intervalul ( 2 ,  10 ): 
...     pentru  x  în  intervalul ( 2 ,  n ): 
...         dacă  n  %  x  ==  0 : 
...             print ( n ,  'equals' ,  x ,  '*' ,  n // x ) 
...             pauză 
...     altceva : 
...         # buclă a căzut fără a găsi un factor 
...         print (n ,  „este un număr prim“ ) 
... 
2 este un număr prim 
3 este un număr prim 
4 este egal cu 2 * 2 
5 este un număr prim 
6 este egal cu 2 * 3 
7 este un număr prim 
8 este egal cu 2 * 4 
9 egal cu 3 * 3

(Da, acest lucru este codul corect Uită - te atent:. Altfel clauza aparține pentru bucla, nu dacă . Statement)

Atunci când este utilizat cu o buclă, altfel clauza are mai multe în comun cu altcineva clauza de o încercare declarație decât o face cea în cazul în declarații: o încercare declarație de altă clauză rulează atunci când are loc nici o excepție, și o buclă de altă clauză funcționează atunci când nu pauză apare . Pentru mai multe informații despre instrucțiunile de încercare și despre excepții, consultați Excepții de manipulare .

Declarația continuă , de asemenea împrumutată de la C, continuă cu următoarea iterație a buclei:

>>>

>>> pentru  num  în  interval ( 2 ,  10 ): 
...     if  num  %  2  ==  0 : 
...         print ( "A găsit un număr par" ,  num ) 
...         continue 
...     print ( " num " ,  num ) a 
găsit un număr par 2 a 
găsit un număr 3 a 
găsit un număr par 4 a 
găsit un număr 5 a 
găsit un număr par 6 a 
găsit un număr 7 a 
găsit un număr par 8 a 
găsit un număr 9

4.5. declarații trecute

Declarația de trecere nu face nimic. Acesta poate fi folosit atunci când o declarație este cerută sintactic, dar programul nu necesită nicio acțiune. De exemplu:

>>>

>>> în timp ce  True : 
...     pass   # Busy-așteptați întreruperea tastaturii (Ctrl + C) 
...

Acest lucru este folosit în mod obișnuit pentru crearea unor clase minime:

>>>

>>> clasa  MyEmptyClass : 
...     treci 
...

Un alt loc de trecere poate fi folosit ca un suport pentru o funcție sau un corp condiționat atunci când lucrați la un nou cod, permițându-vă să continuați să vă gândiți la un nivel mai abstract. Trecere este ignorat în tăcere:

>>>

>>> def  initlog ( * args ): 
...     pass    # Amintiți-vă să implementați acest lucru! 
...

4.6. Definirea funcțiilor 

Putem crea o funcție care scrie seria Fibonacci la o limită arbitrară:

>>>

>>> def  fib ( n ):     # scrie seria Fibonacci pana la n 
...     "" "Imprimați o serie Fibonacci pana la n" "" 
...     a ,  b  =  0 ,  1 
... în     timp ce  o  <  n : 
...         imprimare ( un ,  final = '' ) 
...         a ,  b  =  b ,  a + b 
...     imprimare () 
... 
>>> # acum apela funcția tocmai am definit: 
...fib ( 2000 ) 
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

Cuvântul cheie def introduce o funcție definiție . Acesta trebuie urmat de numele funcției și de lista paranteză a parametrilor formali. Instrucțiunile care formează corpul funcției încep la următoarea linie și trebuie să fie indentate.

Prima declarație a corpului funcției poate fi, opțional, un literal șir; acest șir literal este șirul de documentare al funcției sau docstring . (Mai multe despre docstrings pot fi găsite în secțiunea Documentation Strings .) Există instrumente care folosesc docstrings pentru a produce automat documente online sau imprimate sau pentru a permite utilizatorului să navigheze interactiv prin cod; este o practică bună să includeți docstrings în codul pe care îl scrieți, așa că faceți un obicei.

Executarea unei funcții introduce un nou tabel de simboluri folosite pentru variabilele locale ale funcției. Mai precis, toate alocările variabile ale unei funcții stochează valoarea în tabela simbolurilor locale; în timp ce referințele variabile se uită prima dată în tabela simbolurilor locale, apoi în tabelele cu simboluri locale ale funcțiilor de închidere, apoi în tabelul simbolurilor globale și, în final, în tabelul cu numele încorporate. Astfel, variabilele globale nu pot fi atribuite direct unei valori în cadrul unei funcții (cu excepția cazului în care sunt menționate într-o instrucțiune globală ), deși pot fi menționate.

Parametrii reali (argumente) la un apel funcțional sunt introduse în tabelul simbolului local al funcției numite atunci când este apelată; astfel, argumentele sunt transmise prin apel prin valoare (unde valoarea este întotdeauna o referință de obiect , nu valoarea obiectului). [1] Când o funcție apelează o altă funcție, este creată o nouă tabelă de simboluri locale pentru acel apel.

O definiție a funcției introduce numele funcției în tabela simbolică curentă. Valoarea numelui funcției are un tip care este recunoscut de către interpret ca o funcție definită de utilizator. Această valoare poate fi atribuită unui alt nume care poate fi folosit și ca o funcție. Acest lucru servește ca un mecanism general de redenumire:

>>>

>>> fib 
<function fib la 10042ed0> 
>>> f  =  fib 
>>> f ( 100 ) 
0 1 1 2 3 5 8 13 21 34 55 89

Venind din alte limbi, s-ar putea să vă obiectați că fibra nu este o funcție, ci o procedură, deoarece nu revine o valoare. De fapt, chiar și funcții fără întoarcere declarație returnează o valoare, chiar dacă una destul de plictisitoare. Această valoare se numește Niciuna (este un nume încorporat). Scrierea valorii Niciunul nu este în mod normal suprimat de interpret dacă ar fi singura valoare scrisă. Puteți vedea dacă doriți cu adevărat să utilizați print () :

>>>

>>> fib ( 0 ) 
>>> print ( fib ( 0 )) 
Nici unul

Este simplu să scrieți o funcție care returnează o listă cu numerele seriei Fibonacci, în loc să o tipăriți:

>>>

>>> def  fib2 ( n ):  # returnați seria Fibonacci până la n 
...     "" "Returnați o listă care conține seria Fibonacci până la n." " 
...     result  =  [] 
...     a ,  b  =  0 ,  1 
... în     timp ce  o  <  n : 
...         rezultat . append ( a )     # a se vedea mai jos 
...         a ,  b  =  b ,  a + b 
...     rezultatul returnat  ...

>>> f100  =  fib2 ( 100 )     # numesc 
>>> F100                 # scrie rezultatul 
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Acest exemplu, ca de obicei, demonstrează câteva noi caracteristici Python:

• Retur Declarația revine cu o valoare dintr - o funcție. întoarcere fără un argument expresie returnează Niciuna . Falling off de la sfârșitul unei funcții, de asemenea, returnează Nici unul.
• Instrucțiunea result.append (a) apelează o metodă a rezultatului obiectului listă . O metodă este o funcție care "aparține" unui obiect și este numită obj.methodname , unde objeste un obiect (aceasta poate fi o expresie), iar methodname este numele unei metode care este definită de tipul obiectului. Diferitele tipuri definesc diferite metode. Metodele de diferite tipuri pot avea același nume fără a cauza ambiguități. (Este posibil să definiți propriile tipuri de obiecte și metode, folosind clase , vedeți Clase ) Metoda append ()prezentată în exemplu este definită pentru obiectele din listă; adaugă un nou element la sfârșitul listei. În acest exemplu este echivalent cu rezultatul = rezultat + [a] , dar mai eficient.

4.7. Mai multe despre definirea funcțiilor 

De asemenea, este posibil să se definească funcții cu un număr variabil de argumente. Există trei forme care pot fi combinate.

4.7.1. Valori implicite ale argumentelor 

Forma cea mai utilă este să specificați o valoare implicită pentru unul sau mai multe argumente. Aceasta creează o funcție care poate fi apelată cu mai puține argumente decât este definită pentru a permite. De exemplu:

def  ask_ok ( promptă ,  reîncearcă = 4 ,  plângere = 'Da sau nu, te rog!' ): în 
    timp ce  Adevărat : 
        OK  =  intrare ( solicitare ) 
        dacă este  OK  în  ( 'y' ,  'voi' ,  'da' ): 
            întoarce  Adevărat 
        dacă  ok  în  ( 'n' ,  'nu' ,  'nop' ,  'nope' ): 
            întoarcere  False 
        retries  =  retries  - 1 
        dacă  retries  <  0 : 
            raise  IOError ( "utilizator necooperant" ) 
        print ( plângere )

Această funcție poate fi apelată în mai multe moduri:

• precizându -se numai argumentul obligatoriu: ask_ok ( „Nu ai într - adevăr doriți sărenunțați?“)
• oferind unul dintre argumentele opționale: ask_ok ( „OK pentru a suprascrie ? fișierul“,2)
• sau chiar da toate argumentele: ask_ok ( „OK pentru a suprascrie fișierul?“, 2, „Haipe, doar da sau nu!“)

Acest exemplu introduce , de asemenea , în cuvinte cheie. Aceasta testează dacă o secvență conține o anumită valoare sau nu.

Valorile implicite sunt evaluate în punctul de definire a funcției în domeniul definitoriu , astfel încât

i  =  5

def  f ( arg = i ): 
    print ( arg )

i  =  6 
f ()

va imprima 5 .

Avertisment important: Valoarea implicită este evaluată o singură dată. Aceasta face o diferență când implicit este un obiect mutabil, cum ar fi lista, dicționarul sau instanțele majorității clasei. De exemplu, următoarea funcție acumulează argumentele care i-au fost transmise în apelurile următoare:

def  f ( a ,  L = []): 
    L . adăugați ( a ) 
    returnați  L

print ( f ( 1 )) 
print ( f ( 2 )) 
print ( f ( 3 ))

Aceasta va fi imprimată

[ 1 ] 
[ 1 ,  2 ] 
[ 1 ,  2 ,  3 ]

Dacă nu doriți ca parola implicită să fie împărțită între apelurile ulterioare, puteți scrie funcția în felul acesta:

def  f ( a ,  L = None ): în 
    cazul în care  L  este  None : 
        L  =  [] 
    L . adăugați ( a ) 
    returnați  L

4.7.2. Argumentele pentru cuvinte cheie 

Funcțiile pot fi de asemenea apelate folosind argumentele de cuvinte cheie ale formulei kwarg = value . De exemplu, următoarea funcție:

def  papagal ( tensiune ,  starea = 'o rigid' ,  acțiune = 'Voom' ,  tip = 'norvegian albastru' ): 
    Print ( "- Acest papagal nu" ,  acțiune ,  sfârșitul = '' ) de 
    imprimare ( „dacă ați a pus“ ,  tensiune ,  "volți prin ea". ) 
    Print ( "- penaj Lovely, a" , de  tip ) 
    print ( "- e" , stat ,  "!")

acceptă un argument necesar ( tensiune ) și trei argumente opționale ( stare , acțiune și tip ). Această funcție poate fi apelată în oricare din următoarele moduri:

papagal ( 1000 )                                           # 1 pozițional argument 
papagal ( tensiune = 1000 )                                   # 1 cuvânt cheie argument 
papagal ( tensiune = 1000000 ,  acțiune = 'VOOOOOM' )              # 2 argumente cuvânt cheie 
papagal ( acțiune = 'VOOOOOM' ,  tensiune = 1000000 )              # 2 argumente cuvinte cheie 
papagal ( "un milion" ,  "lipsă de viață" ,  "salt" )          argumente 
pozitive # 3 papagal ('o mie' ,  stat = 'împingând margaretele' )   # 1 pozițional, 1 cuvânt cheie

dar toate apelurile următoare ar fi nevalide:

papagal ()                      # necesar lipsește argumentul 
papagal ( tensiune = 5,0 ,  'mort' )   # Argumentul de bază non-cuvânt cheie după un argument cuvânt cheie 
papagal ( 110 ,  tensiune = 220 )      # valoarea duplicat pentru același argument 
papagal ( actor = 'John Cleese' )   argument argument # necunoscut

Într-un apel pentru funcții, argumentele cuvintelor cheie trebuie să respecte argumentele poziționale. Toate argumentele de cuvinte cheie trecute trebuie să se potrivească cu unul dintre argumentele acceptate de funcție (de exemplu, actorul nu este un argument valid pentru funcția de papagal ) și ordinea lor nu este importantă. Acest lucru include și argumente non-opționale (de exemplu, papagalul (tensiunea = 1000) este valabil și). Nici un argument nu poate primi o valoare mai mult decât o dată. Iată un exemplu care nu reușește din cauza acestei restricții:

>>>

>>> Funcția def  ( a ): ... pass ... >>> funcția ( 0 , a = 0 ) Traceback (ultimul apel ultim): 
  Fișier "<stdin>" , line 1 , in ? TypeError : function () a primit mai multe valori pentru argumentul "a"
    

 

Atunci când este prezent un parametru formal final al formulei ** , acesta primește un dicționar (vezi tipurile de mapare - dict ) care conțin toate argumentele cuvintelor cheie, cu excepția celor care corespund unui parametru formal. Aceasta poate fi combinată cu un parametru formal al formularului * (descris în următoarea subsecțiune) care primește o tuplă care conține argumentele poziționale dincolo de lista de parametri formali. ( * numele trebuie să aibă loc înainte de ** nume .) De exemplu, dacă definim o funcție ca aceasta:

def  cheeseshop ( un fel ,  * argumente ,  ** cuvinte cheie ): 
    Print ( "- Ai" , un  fel ,  "?" ) de 
    imprimare ( "- Îmi pare rău, suntem cu toții în afara" , un  fel ) 
    pentru  arg  în  argumente : 
        imprimare ( arg ) 
    Print ( "-"  *  40 ) 
    chei  =  sortate ( cuvinte cheie . chei ()) 
    pentru  kw în  chei : 
        imprimare ( kw ,  ":" ,  cuvinte cheie [ kw ])

Ar putea fi numit astfel:

cheeseshop ( "Limburger" ,  "Este foarte alergat, domnule" , 
           "Este foarte foarte, foarte fugi, domnule" , 
           magazin = "Michael Palin" , 
           client = "John Cleese" , 
           sketch = "Cheese Shop Sketch" )

și, desigur, ar tipări:

- Ai vreun Limburger?
- Îmi pare rău, am ieșit din Limburger
E foarte risipit, domnule.
Este într-adevăr foarte, foarte curgător, domnule.
----------------------------------------
client: John Cleese
negustor: Michael Palin
schiță: Schița magazinelor de brânzeturi

Rețineți că lista de nume de cuvinte cheie ale cuvintelor cheie este creată prin sortarea rezultatelor metodei tastelor () ale dicționarului cuvintelor cheie înainte de a imprima conținutul; dacă acest lucru nu se face, ordinea în care sunt imprimate argumentele este nedefinită.

4.7.3. Liste de argumente libere 

În cele din urmă, opțiunea cea mai puțin frecvent utilizată este de a specifica că o funcție poate fi apelată cu un număr arbitrar de argumente. Aceste argumente vor fi înfășurate într-o tuplă (a se vedea Tupele și secvențele ). Înainte de numărul variabil de argumente, pot apărea zero sau mai multe argumente normale.

def  write_multiple_items ( fișier ,  separator ,  * args ): 
    fișier . scrie ( separator . join ( args ))

În mod normal, aceste argumente variadic vor fi ultime în lista parametrilor formali, pentru că vor scoate toate argumentele de intrare rămase care sunt transmise funcției. Orice parametri formali care apar după parametrul * args sunt argumentele "doar pentru cuvinte cheie", ceea ce înseamnă că ele pot fi folosite doar ca cuvinte cheie, nu ca argumente poziționale.

>>>

>>> def  concat ( * args ,  sep = "/" ): 
...    return  sep . se alăture ( args ) 
... 
>>> concat ( "pământ" ,  "Marte" ,  "Venus" ) 
'pământ / Marte / Venus' 
>>> concat ( "pământ" ,  "Mars" ,  "Venus" ,  sep = "." ) 
"earth.mars.venus"

4.7.4. Despachetarea listelor de argumente 

Situația inversă apare atunci când argumentele se află deja într-o listă sau în tuplu, dar trebuie să fie despachetate pentru un apel de funcție care necesită argumente poziționale separate. De exemplu, funcția range () încorporată așteaptă argumente separate de pornire și oprire . Dacă acestea nu sunt disponibile separat, scrieți apelul pentru funcții cu * -operatorul pentru a despacheta argumentele dintr-o listă sau dintr-o listă:

>>>

>>> lista ( interval ( 3 ,  6 ))             # apel normal cu argumente distincte 
[3, 4, 5] 
>>> ARGS  =  [ 3 ,  6 ] 
>>> lista ( interval ( * args ))             # apel cu argumente despachetat dintr-o listă 
[3, 4, 5]

În același mod, dicționarele pot furniza argumente de cuvinte cheie cu ** -operator:

>>>

>>> def  papagal ( tensiune ,  starea = 'o rigid' ,  acțiune = 'Voom' ): 
...     Print ( "- Acest papagal nu" ,  acțiune ,  sfârșitul = '' ) 
...     Print ( " dacă puneți " ,  tensiunea ,  " volte prin el " ,  end = '' ) 
...     tipăriți ( " E's " ,  state ,  "! " ) 
...
>>> d =  { "Tensiune" :  "patru milioane" ,  " de stat" :  "bleedin' defunctului" ,  "acțiune" :  "VOOM" } 
>>> papagal ( ** d ) 
- Acest papagal nu ar Voom dacă ai pus patru milioane de volți prin el. E bleedin a demisionat!

4.7.5. Expresii Lambda 

Funcțiile anonime mici pot fi create cu cuvântul cheie lambda . Această funcție returnează suma celor două argumente: lambda a, b: a + b . Funcțiile Lambda pot fi utilizate ori de câte ori sunt necesare obiecte funcționale. Acestea sunt limitate sintactic la o singură expresie. Semantic, ele sunt doar zahăr sintactic pentru o definiție normală a funcției. Asemenea definițiilor de funcții imbricate, funcțiile lambda pot să vadă variabile din domeniul de aplicare care conține:

>>>

>>> def  make_incrementor ( n ): 
...     întoarcere  lambda  x :  x  +  n 
... 
>>> f  =  make_incrementor ( 42 ) 
>>> f ( 0 ) 
42 
>>> f ( 1 ) 
43

Exemplul de mai sus utilizează o expresie lambda pentru a returna o funcție. O altă utilizare este aceea de a transmite o funcție mică ca argument:

>>>

>>> perechi  =  [( 1 ,  'unul' ),  ( 2 ,  'două' ),  ( 3 ,  'trei' ),  ( 4 ,  'patru' )] 
>>> perechi . sortare ( cheie = pereche lambda  : pereche [ 1 ]) >>> perechi [(4, 'patru'], (1, 'unul'), 

4.7.6. Structuri de documentare 

Iată câteva convenții despre conținutul și formatarea șirurilor de documentație.

Prima linie trebuie să fie întotdeauna un rezumat scurt și concis al scopului obiectului. Pentru brevitate, nu ar trebui să precizeze în mod explicit numele sau tipul obiectului, deoarece acestea sunt disponibile prin alte mijloace (cu excepția cazului în care numele se întâmplă să fie un verb care descrie funcționarea unei funcții). Această linie trebuie să înceapă cu o literă mare și să se încheie cu o perioadă.

Dacă există mai multe linii în șirul de documentație, al doilea rând trebuie să fie necompletat, separând vizual rezumatul de restul descrierii. Următoarele rânduri ar trebui să fie unul sau mai multe paragrafe care descriu convențiile de apel ale obiectului, efectele sale secundare etc.

Parserul Python nu dezinstalează indentarea de la literali de șir multi-line în Python, așa că instrumentele care procesează documentația trebuie să desprindă indentarea, dacă se dorește. Aceasta se face folosind următoarea convenție. Prima linie ne-goală după prima linie a șirului determină cantitatea de indentare pentru întregul șir de documentație. (Nu putem folosi prima linie deoarece este în general adiacentă citatelor de deschidere ale șirului, astfel încât indentarea sa nu este vizibilă în literalul șir.) Spațiul alb "echivalent" cu această indentare este apoi desprins de la începutul tuturor liniilor șirului . Linii care sunt mai puțin indentate nu trebuie să apară, dar dacă se întâmplă, toate spațiile lor de vârf trebuie să fie dezbrăcate. Echivalența spațiilor albe trebuie testată după expansiunea filelor (în mod normal, la 8 spații).

Iată un exemplu de docstring multi-linie:

>>>

>>> def  my_function (): 
...     "" "Nu faceți nimic, ci documentați-l 
...
...     Nu, într-adevăr, nu face nimic. 
...     "" 
... ...     treceți 
... 
>>> print ( my_function . __doc__ ) 
Nu faceți nimic, ci documentați-l.

    Nu, într-adevăr, nu face nimic.

4.7.7. Annotările funcției 

Funcțiile adnotărilor sunt complet opționale, informații despre metadatele arbitrare despre funcțiile definite de utilizator. Nici Python, nici biblioteca standard nu utilizează adnotări de funcții în nici un fel; această secțiune arată doar sintaxa. Proiectele terților pot folosi adnotări de funcții pentru documentare, verificări de tip și alte utilizări.

Adnotările sunt stocate în atributul __annotations__ al funcției ca dicționar și nu au efect asupra niciunei alte părți a funcției. Adnotările adnotărilor sunt definite după un nume de parametru printr-o colonă, urmată de o expresie evaluând valoarea adnotării. Returnarea adnotărilor este definită printr-un literal -> , urmat de o expresie, între lista de parametri și colon care denotă sfârșitul instrucțiunii def . Următorul exemplu are un argument pozițional, un argument cheie și valoarea returnată adnotată cu nonsens:

>>>

>>> def  f ( sunca :  42 ,  ouă :  int  =  'spam - ului' )  ->  "Nimic de văzut aici" : 
...     Print ( "Adnotările:" ,  f . __annotations__ ) 
...     Print ( "Argumente:" ,  șuncă ,  ouă ) 
... 
>>> f ( 'minunat' ) 
adnotărilor: { 'ouă': <clasa 'int'>, 'return': 'Nimic de văzut aici', 'șuncă': 42} 
Argumente:minunat spam

4.8. Intermezzo: Stilul de codificare 

Acum că sunteți pe punctul de a scrie mai multe piese mai complexe de Python, este un moment potrivit să vorbiți despre stilul de codare . Cele mai multe limbi pot fi scrise (sau mai concise, formatate) în diferite stiluri; unele sunt mai ușor de citit decât altele. A face ușor pentru alții să vă citească codul este întotdeauna o idee bună, și adoptarea unui stil de codare frumos ajută extraordinar pentru asta.

Pentru Python, PEP 8 a apărut ca ghid de stil pe care majoritatea proiectelor respectă; promovează un stil de codare foarte lizibil și plăcut pentru ochi. Fiecare dezvoltator Python ar trebui să o citească la un moment dat; aici sunt cele mai importante puncte extrase pentru tine:

• Utilizați indentare cu 4 spații și nu există file.
  4 spații sunt un compromis bun între indentarea mică (permite o adâncime de cuibare mai mare) și o indentare mare (mai ușor de citit). Filele introduc confuzie și sunt cel mai bine evitate.
• Înfășurați linii astfel încât să nu depășească 79 de caractere.
  Acest lucru ajută utilizatorii cu afișaje mici și face posibilă existența mai multor fișiere de coduri pe ecranele mai mari.
• Utilizați linii goale pentru a separa funcțiile și clasele și blocurile mai mari de coduri din interiorul funcțiilor.
• Când este posibil, puneți comentariile pe o linie proprie.
• Utilizați docstrings.
• Utilizați spațiile în jurul operatorilor și după virgule, dar nu direct în interiorul bracketing constructe: a = f (1, 2) + g (3, 4) .
• Denumiți cursurile și funcțiile în mod consecvent; convenția este de a folosi CamelCase pentru clase și lower_case_with_underscores pentru funcții și metode. Utilizați întotdeauna sine ca nume pentru primul argument al metodei (consultați A First Look at Classes pentru mai multe despre clase și metode).
• Nu utilizați codificări fanteziste dacă codul dvs. este destinat să fie utilizat în medii internaționale. Python implicit, UTF-8, sau chiar simplu ASCII funcționează cel mai bine în orice caz.
• De asemenea, nu utilizați caractere non-ASCII în identificatori dacă există doar cel mai mic șansă ca persoanele care vorbesc o limbă diferită să citească sau să mențină codul.

Notă de subsol

[1]	De fapt,  apelul după referința obiectului  ar fi o descriere mai bună, deoarece dacă un obiect mutabil este trecut, apelantul va vedea orice schimbare pe care apelantul o face (elementele introduse în listă). Sursa:  https://docs.python.org/3.3/tutorial/classes.html