Care sunt funcțiile în python. Returnează valori dintr-o funcție. declarație de returnare
O funcție este ceva destinat să fie îndeplinit. sarcina specifica un bloc izolat de cod care poate fi reutilizat. Funcțiile fac codul programului modular și mai compact.
Python oferă multe funcții încorporate. Probabil că ești familiarizat cu acestea:
- print() imprimă obiectul pe terminal.
- int() convertește șiruri de caractere sau numere în numere întregi.
- len() returnează lungimea obiectului.
Numele funcției conține paranteze și poate conține parametri.
Acest tutorial vă va învăța cum să definiți funcții personalizate.
Definiția funcției
În primul rând, încercați să convertiți un program simplu"Salut Lume!" într-o funcție.
Creați unul nou fisier text hello.py și apoi definiți funcția.
Pentru a defini o funcție, utilizați cuvântul cheie def, apoi specificați numele funcției și parantezele care pot conține parametri (dacă nu există parametri, parantezele rămân goale), urmate de două puncte.
Pentru a defini funcția hello(), adăugați următoarele în fișierul hello.py:
Aceasta este definiția originală a funcției.
def salut():
print("Bună, lume!")
Funcția este acum definită. Dar dacă pe în această etapă rulați programul, nu se va întâmpla nimic: pentru ca funcția să funcționeze, trebuie nu numai definită, ci și apelată.
După definirea unei funcții, numiți-o:
def salut():
print("Bună, lume!")
Buna ziua()
Acum rulați programul:
Ar trebui să se întoarcă:
Funcția hello() este un exemplu destul de simplu. Funcțiile pot fi mult mai complexe, conținând bucle for, expresii condiționate și alte componente.
Când funcția ajunge la instrucțiunea return, se oprește execuția.
# Fișier return_loop.py
def loop_five():
pentru x în interval (0, 25):
print(x)
dacă x == 5:
# Funcția de oprire la x == 5
întoarcere
print("Această linie nu se va executa.")
loop_five()
Declarația de returnare în pentru buclă oprește executarea funcției, astfel încât liniile de după funcție nu vor fi executate. Dacă ar fi folosit în schimb declarație de pauză, programul ar opri executarea buclei mai degrabă decât a funcției, iar ultima instrucțiune print() ar fi procesată.
functie principala
ÎN Limbajul Python o funcție poate fi apelată la sfârșitul unui program și va rula (așa cum se arată în exemplele anterioare), totuși unele limbaje de programare (cum ar fi C++ sau Java) necesită o funcție principală. Funcția main() din Python este opțională, dar vă permite să vă structurați logic programul Python și să combinați cele mai importante componente într-o singură funcție. De asemenea, face programele Python mai ușor de citit pentru programatorii care lucrează în alte limbi.
Reveniți la fișierul hello.py și adăugați funcția main(), păstrând în același timp funcția hello().
def salut():
print("Bună, lume!")
def main():
Adăugați o instrucțiune print() la funcția main(). Apoi apelați funcția hello() din cadrul funcției main().
def salut():
print("Bună, lume!")
def main():
print("Aceasta este functia principala")
Buna ziua()
La sfârșitul fișierului, apelați funcția main().
def salut():
print("Bună, lume!")
def main():
print("Aceasta este funcția principală.")
Buna ziua()
principal()
Acum puteți rula programul:
python salut.py
Aceasta este funcția principală.
Salut Lume!
Acum încercați să utilizați mai multe funcții.
O funcție din programare este o bucată separată de cod care poate fi apelată făcând referire la ea prin numele cu care a fost numită. Când sunt apelate, sunt executate comenzile corpului funcției.
Funcțiile pot fi comparate cu programe mici care nu sunt executate singure, adică autonom, dar sunt încorporate în program regulat. Ele sunt adesea numite subrutine. Alții diferențe cheie Nu există funcții din programe. De asemenea, funcțiile pot primi și returna date după cum este necesar. Numai că de obicei le primesc nu de la intrare (tastatură, fișier etc.), ci de la program de apelare. Aici ei returnează rezultatele muncii lor.
Există multe funcții încorporate în limbajul de programare. Am întâlnit deja unele dintre acestea în Python. Acestea sunt print(), input(), int(), float(), str(), type(). Codul corpului lor nu este vizibil pentru noi; este undeva „ascuns în limbaj”. Ni se oferă doar o interfață - numele funcției.
Pe de altă parte, programatorul își poate defini întotdeauna propriile funcții. Se numesc obiceiuri. ÎN în acest caz, Prin „utilizator” înțelegem programatorul, nu cel care folosește programul. Să ne dăm seama de ce avem nevoie de aceste funcții și cum să le creăm.
Să presupunem că trebuie să cereți o pereche de numere de trei ori la rând și să le adăugați. În acest scop, puteți utiliza o buclă:
i = 0 în timp ce i< 3 : a = int (input () ) b = int (input () ) print (a+b) i += 1
Cu toate acestea, ce se întâmplă dacă înainte de fiecare solicitare de numere, trebuie să afișați o inscripție de ce sunt necesare și de fiecare dată această inscripție este diferită. Nu putem întrerupe un ciclu și apoi să revenim din nou la același ciclu. Va trebui să renunți la el și apoi se va rezolva cod lung, conţinând în locuri diferite ah, secțiuni identice:
print () a = int (input () ) b = int (input () ) print ("Total", a+b, "buc." ) print () a = int (input () ) b = int (input) () ) print ("Total", a+b, "buc." )
Exemplu de executare a programului:
Câte banane și ananas pentru maimuțe? 15 5 Total 20 buc. Câți gândaci și viermi pentru arici? 50 12 Total 62 buc. Câți pești și crustacee pentru vidre? 16 8 Total 24 buc.
Introducerea funcțiilor vă permite să rezolvați problema dublării codului în diferite locuri ale programului. Datorită lor, puteți executa aceeași secțiune de cod nu imediat, ci numai atunci când este necesar.
Definiția unei funcții. operator def
În limbaj Programare Python funcțiile sunt definite folosind instrucțiunea def. Să ne uităm la cod:
def countFood() : a = int (input () ) b = int (input () ) print ("Total", a+b, "buc." )
Acesta este un exemplu de definiție a funcției. Ca și alte instrucțiuni complexe, cum ar fi operator condiționalși bucle, o funcție constă dintr-un antet și un corp. Titlul se termină cu două puncte și o tranziție la linie nouă. Corpul este indentat.
Cuvântul cheie def îi spune interpretului că aceasta este o definiție a funcției. def este urmat de numele funcției. Poate fi orice, la fel ca orice identificator, de exemplu, o variabilă. În programare, este foarte de dorit să dai tuturor nume semnificative. Deci, în acest caz, funcția se numește „countFood” tradus în rusă.
Numele funcției este urmat de paranteze. În exemplul dat, acestea sunt goale. Aceasta înseamnă că funcția nu acceptă date din programul care o apelează. Cu toate acestea, le-ar putea accepta, iar apoi așa-numiții parametri ar fi indicați între paranteze.
Coloana este urmată de un corp care conține instrucțiunile care sunt executate atunci când funcția este apelată. Trebuie făcută o distincție între definirea unei funcții și apelarea acesteia. ÎN codul programului nu sunt apropiați și nici împreună. Puteți defini o funcție, dar nu o apelați niciodată. Nu puteți apela o funcție care nu a fost definită. Dacă definiți o funcție, dar nu o apelați niciodată, nu veți executa niciodată corpul acesteia.
Apelarea unei funcții
Sa luam in considerare versiunea completa programe cu functie:
def countFood() : a = int (input () ) b = int (input () ) print ("Total", a+b, "buc." ) print ( — Câte banane și ananas pentru maimuțe?) countFood() print ( — Câți gândaci și viermi pentru arici?) countFood() print ( — Câți pești și scoici pentru vidre?) countFood()
După ce fiecare mesaj informativ este afișat, se efectuează un apel de funcție, care arată pur și simplu ca menționarea numelui acestuia între paranteze. Deoarece nu trecem nimic în funcție, parantezele sunt din nou goale. În codul de mai sus, funcția este apelată de trei ori.
Când o funcție este apelată, firul de execuție al programului sare la definiția sa și începe să-și execute corpul. După ce corpul funcției este executat, firul de execuție revine la codul principal în locul în care a fost apelată funcția. În continuare, se execută expresia care urmează apelului.
În Python, o definiție de funcție trebuie să precedă apelurile sale. Acest lucru se datorează faptului că interpretul citește codul linie cu linie și nu știe încă ce este în aval. Prin urmare, dacă un apel de funcție precede definiția sa, apare o eroare (este aruncată o excepție NameError):
imprimare( — Câte banane și ananas pentru maimuțe?) countFood() print ( — Câți gândaci și viermi pentru arici?) countFood() print ( — Câți pești și scoici pentru vidre?) countFood() def countFood() : a = int (input () ) b = int (input () ) print ("Total", a+b, "buc." )
Rezultat:
Câte banane și ananas pentru maimuțe? Traceback (cel mai recent apel ultimul): fișierul „test.py” , linia 2 , în< module>countFood() NameError: numele „countFood” nu este definit
Pentru multe limbi compilate, acest lucru nu este condiție cerută. Acolo puteți defini și apela o funcție în locuri arbitrare din program. Cu toate acestea, pentru citirea codului, programatorii chiar și în acest caz preferă să urmeze anumite reguli.
Funcțiile dau o structură a programului
Beneficiul funcțiilor nu este doar capacitatea de a apela același cod de mai multe ori din locuri diferite din program. La fel de important, ele oferă programului o structură adevărată. Funcțiile par să-l împartă în părți separate, fiecare dintre ele îndeplinește propria sarcină specifică.
Să presupunem că trebuie să scrieți un program care calculează ariile diferitelor figuri. Utilizatorul indică zona a cărei cifră dorește să o calculeze. După aceasta, introduce datele inițiale. De exemplu, lungimea și lățimea în cazul unui dreptunghi. Pentru a împărți un fir de execuție în mai multe ramuri, ar trebui să utilizați instrucțiunea if-elif-else:
figure = input () if figure == "1" : a = float (input ("Latime: " ) ) ) b = float (input ("Inaltime: " ) ) print ("Zona: %.2f" % (a*) b) ) figura elif == "2" : a = float (intrare ("Baza: " ) ) h = float (intrare ("Inaltime: " ) ) print ("Zona: %.2f" % (0,5 * a * h) ) elif figure == "3" : r = float (intrare ("Radiu: " ) ) print ("Zona: %.2f" % (3.14 * r**2 ) ) ) else : imprimare ("Eroare de intrare" )
Nu există funcții aici și totul este în regulă. Dar să scriem o versiune cu funcții:
def rectangle() : a = float (input ("Latime: " ) ) b = float (input ("Inaltime: " ) ) print ("Area: %.2f" % (a*b) ) def triangle() : a = float (intrare ("Baza: " ) ) h = float (intrare ("Înălțime: " ) ) print ( "Zona: %.2f" % (0,5 * a * h) ) def circle() : r = float (input ("Radiu: " ) ) print ( "Zona: %.2f" % (3.14 * r**2 ) ) figura = intrare ( "1-dreptunghi, 2-triunghi, 3-cerc:") if figure == "1": dreptunghi() elif figure == "2": triunghi() elif figure == "3": circle() else: print ("Eroare de intrare")
Pare mai complex și fiecare dintre cele trei funcții este numită o singură dată. Cu toate acestea, din logica generală a programului, instrucțiunile pentru găsirea zonelor au fost eliminate și izolate. Programul constă acum din „cărămizi Lego” individuale. În ramura principală le putem combina după bunul plac. Joacă rolul unui mecanism de control.
Dacă vrem vreodată să calculăm aria unui triunghi folosind formula lui Heron mai degrabă decât înălțimea, nu va trebui să căutăm cod în întregul program (imaginați-vă că este vorba de mii de linii de cod, cum ar fi programe reale). Vom merge acolo unde sunt definite funcțiile și vom schimba corpul uneia dintre ele.
Dacă trebuie să folosim aceste funcții într-un alt program, le putem importa acolo făcând referire la acest fișier cu cod (cum se face acest lucru în Python va fi discutat mai târziu).
Munca practica
În programare, puteți apela o altă funcție dintr-o funcție. Pentru a ilustra această posibilitate, scrieți un program cu următoarea descriere.
Ramura principală a programului, fără a număra anteturile funcției, constă dintr-o linie de cod. Acesta este un apel la funcția test(). Solicită o intrare întreg. Dacă este pozitiv, atunci este apelată funcția positive(), al cărei corp conține o comandă pentru a afișa cuvântul „Pozitiv” pe ecran. Dacă numărul este negativ, atunci se apelează funcția negative(), corpul său conținând o expresie pentru a afișa cuvântul „Negativ”.
5 august 2008 la 16:14Bazele Python- pe scurt. Partea 5. Definirea funcțiilor, elemente de bază.
- Piton
Când am început să scriu capitolul despre OOP, mi-am dat seama că am uitat complet să acopăr o secțiune atât de mare și necesară din Python ca funcții. Acest subiect este amplu și extins, așa că pentru a nu întinde prea mult pauza dintre lecții, am decis să-l împart în 2 părți. În primul rând, vă voi spune elementele de bază, apoi caracteristicile aprofundate ale ingineriei funcțiilor Python.
Funcțiile în Python sunt declarate nu simplu, ci foarte simplu. Iată un exemplu din cel mai simplu:
def empty_func(): trece
Anunțul începe cu cuvânt cheie def, care, după cum ați putea ghici, este o abreviere pentru define. Este urmată de numele funcției. După numele în parantezele este specificată o listă de parametri care lipsesc în acest caz.
Corpul funcției este indentat cu rândul următor. Vă rugăm să rețineți că funcțiile cu un corp gol sunt interzise în Python, astfel încât trecerea „operatorului gol” este folosită ca corp al funcției de mai sus.
Acum să ne uităm la un exemplu mai serios.
Def safe_div(x, y): """Fă o împărțire sigură:-) pentru distracție și profit""" if y != 0: z = x / y print z return z else: print "Yippie-kay-yay, mama-mamă!”
Există mai multe inovații în acest exemplu. Primul lucru care vă atrage atenția este linia de documentație (docstring) care vine imediat după corpul funcției.
De obicei, această linie ocupă mai mult de o linie text sursă(scuzați jocul de cuvinte) și, prin urmare, este specificat între ghilimele triple. Este destinat să descrie funcția, scopul acesteia, parametrii etc. Toate IDE-uri buneștii cum să lucrezi cu această linie. De asemenea, îl puteți accesa din programul însuși, folosind proprietatea __doc__:
Imprimați safe_div.__doc__
Această proprietate (da, da, exact o proprietate, în Python chiar și funcțiile sunt de fapt clase) este convenabil de utilizat în timpul sesiunilor consolei interactive.
>>> din ftplib import FTP >>> print FTP.__doc__ O clasă de client FTP. Pentru a crea o conexiune, apelați clasa folosind următoarele argumente: host, user, passwd, acct Acestea sunt toate șiruri de caractere și au valoarea implicită „”. Apoi utilizați self.connect() cu argument opțional gazdă și port. # restul il fac eu :-)
Să revenim la funcția noastră inițială. Esența sa este foarte simplă, are nevoie de 2 parametri: x și y. Dacă y nu este 0, acesta împarte x la y, tipărește rezultatul pe ecran și returnează coeficientul său ca rezultat. Rezultatul funcției este returnat folosind comanda return. Datorită mecanismului tuplu descris în ultima lecție, funcțiile din Python pot returna multe obiecte în același timp.
Dacă divizorul este nemișcat egal cu zero, funcția afișează un mesaj de eroare. Ar fi greșit să presupunem că în acest caz funcția nu va returna nimic. Ar fi mai corect să spunem că funcția va returna „nimic” :) Cu alte cuvinte, dacă funcția nu are o instrucțiune return, sau este apelată fără parametri, atunci funcția returnează sens special Nici unul. Puteți verifica cu ușurință acest lucru apelând ceva de genul print safe_div(10, 0).
Iată un exemplu ceva mai complicat, luat dintr-un raport de prezentare al lui Guido van Rossum.
Def gcd(a, b): „Găsirea GCD” în timp ce a != 0: a,b = b%a,a # definiție paralelă returnează b
Această funcție găsește cel mai mare divizor comun al două numere.
În general, rețineți că parametrii din funcțiile Python sunt transmise prin referință. Un alt fapt, poate non-trivial, cu care va trebui să vă obișnuiți este faptul că funcțiile în sine sunt o valoare care poate fi atribuită. Dacă folosim funcția noastră safe_div pentru experimente ulterioare, putem scrie următorul cod.
Mystic_function = safe_div print mystic_function(10, 4)
Asta e tot pentru această dată, există încă multe aspecte ale definirii funcțiilor în Python rămase „la bord” care vor fi acoperite data viitoare.
Exerciții pentru testare.
1. Pe baza functia existenta pentru a găsi MCD, scrieți o funcție pentru a găsi LCM a două numere.
2. Scrieți o rutină de tabelare pentru funcția transmisă ca argument. Argumentele specifică și inițiala, valoarea finalăși tabulator.
PS apropo, care este durata optimă a unei „lecții”? Ce este mai bine - capitole mari publicate mai rar sau „mai puțin este mai bine, mai des?”
Funcții denumite, instrucțiune def
O funcție în python este un obiect care preia argumente și returnează o valoare. De obicei, o funcție este definită folosind o instrucțiune def.
Să definim cea mai simplă funcție:
Declarația return spune să returnăm o valoare. În cazul nostru, funcția returnează suma lui x și y.
Acum o putem numi:
>>> adaugă (1, 10)
>>> add("abc", "def")
Funcția poate fi de orice complexitate și poate returna orice obiecte (liste, tupluri și chiar funcții!):
>>> def newfunc(n):
Def myfunc(x):
Returnează x + n
Returnează funcția mea
>>> new = newfunc(100) # new este o funcție
>>> nou(200)
Este posibil ca funcția să nu se termine cu o instrucțiune return, dar funcția va returna valoarea None:
>>> def func():
>>> print(func())
Argumente ale funcției
O funcție poate lua un număr arbitrar de argumente sau deloc. De asemenea, sunt comune funcțiile cu un număr arbitrar de argumente, funcțiile cu argumente poziționale și numite, obligatorii și opționale.
>>> def func(a, b, c=2): # c - argument optional
Returnează a + b + c
>>> func(1, 2) # a = 1, b = 2, c = 2 (implicit)
>>> func(1, 2, 3) # a = 1, b = 2, c = 3
>>> func(a=1, b=3) # a = 1, b = 3, c = 2
>>> func(a=3, c=6) # a = 3, c = 6, b nedefinit
Traceback (cel mai recent apel ultimul):
Fișierul „”, rândul 1, în
TypeError: func() ia cel puțin 2 argumente (2 date)
Funcția poate lua, de asemenea, un număr variabil de argumente poziționale, apoi un * este plasat în fața numelui:
>>> def func(*args):
>>> func(1, 2, 3, "abc")
(1, 2, 3, „abc”)
>>> functia(1)
După cum puteți vedea din exemplu, args este un tuplu al tuturor argumentelor transmise funcției, iar o variabilă poate fi lucrată în același mod ca un tuplu.
Funcția poate lua un număr arbitrar de argumente numite, apoi un ** este plasat în fața numelui:
>>> def func(**kwargs):
Înapoi kwargs
>>> func(a=1, b=2, c=3)
("a": 1, "c": 3, "b": 2)
>>> func(a="python")
În variabila kwargs stocăm un dicționar, cu care, din nou, putem face orice vrem.
Funcții anonime, instrucțiuni lambda
Funcțiile anonime pot conține o singură expresie, dar se execută și mai rapid. Funcțiile anonime sunt create folosind instrucțiunea lambda. În plus, nu trebuie să fie atribuite unei variabile, așa cum am făcut cu instrucțiunea def func():
>>> func = lambda x, y: x + y
>>> func(1, 2)
>>> func ("a", "b")
>>> (lambda x, y: x + y)(1, 2)
>>> (lambda x, y: x + y)("a", "b")
Funcția lambda, spre deosebire de una obișnuită, nu necesită o instrucțiune de returnare, dar în rest se comportă exact la fel:
>>> func = lambda *args: args
>>> func(1, 2, 3, 4)
19. Conceptul de recursivitate, implementare în Python
În programare, recursiunea este apelarea unei funcții (procedură) de la ea însăși, direct (recursie simplă) sau prin alte funcții (recursie complexă sau indirectă), de exemplu, o funcție apelează o funcție, iar o funcție apelează o funcție. Numărul de apeluri imbricate la o funcție sau o procedură se numește adâncimea recursiunii.
Mai simplu de spus nu poate fi. Există o zicală faimoasă despre recursivitate:
Pentru a înțelege recursiunea, trebuie mai întâi să înțelegeți recursiunea
Deci, Python face lucrul cu recursivitate ușor și relaxat. Primul exemplu de recursivitate pe care îl întâlnesc majoritatea programatorilor este găsirea unui factorial. Codul ar putea fi astfel:
factorial def (n):
dacă n<= 1: return 1
altfel: returnează n * factorial(n - 1)
După cum puteți vedea, am scris declarația if else într-un mod ușor neobișnuit pentru Python, dar acest lucru este permis în acest caz, datorită faptului că lizibilitatea nu este afectată aici, dar acest stil nu trebuie abuzat. Și, în general, PEP8 va judeca pe toată lumea. :)
Acum haideți să clarificăm câteva caracteristici importante pe care ar trebui să le aveți întotdeauna în vedere atunci când lucrați cu recursiuni.
Există o limită a profunzimii recursiunii. Implicit este 1000.
Pentru a modifica această limită, trebuie să apelați funcția sys.setrecursionlimit() și pentru a vedea limita curentă, sys.getrecursionlimit().
În ciuda acestui fapt, există o limitare a dimensiunii stivei, care este instalată de sistemul de operare.
Recursiunea în Python nu poate fi utilizată în funcții generatoare și corutine. Cu toate acestea, puteți corecta acest comportament, dar este mai bine să nu o faceți.
Un ultim lucru - aplicarea decoratorilor la funcțiile recursive poate duce la rezultate neașteptate, așa că fiți foarte atenți când decorați funcțiile recursive.
De asemenea, ar trebui să definiți întotdeauna puncte de ieșire din funcțiile recursive. Este ca și în cazul buclelor - o buclă nesfârșită vă poate irosi cu adevărat sistemul de operare. Și, în sfârșit, unde este mai bine să folosiți recursiunea și unde este mai bine să vă abțineți și să vă descurcați, de exemplu, cu bucle? Desigur, multe aici depind de sarcină, dar ar trebui să vă amintiți întotdeauna că recursiunea este de câteva ori mai lentă decât o buclă. Python este proiectat în așa fel încât apelarea unei funcții te costă mult :) În general, nu ar trebui să apelezi funcții în bucle, cu atât mai puțin funcții recursive.
Recursiunea este potrivită acolo unde performanța nu este prea importantă, dar lizibilitatea și mentenabilitatea codului sunt mai importante. De exemplu, scrieți două funcții pentru a parcurge un arbore de directoare, una recursivă și una cu bucle.
Navigare rapidă:
1.31 Liste - matrice. Prima intalnire. 1.30 Funcții care returnează un rezultat - return 1.29 Subrutine: funcții și proceduri în Python 1.28 Conversia tipurilor de date - int() 1.27 Introducerea datelor de la tastatură - input() 1.26 Tipuri și dimensiuni de date 1.25 Buclă cu o precondiție - while. Numerele Fibonacci 1.24 Măsurarea lungimii unei linii, liste 1.23 Secțiuni de linie - scoaterea unui anumit număr de caractere din textul existent 1.22 Șiruri și caractere de control 1.21 Erori de sistem în timpul depanării programului 1.20 Operator de ramificare - dacă, comentarii 1.19 Imprimare - print(), introducere rapidă a datelor, rotunjire, comentarii 1.18 Tipuri de programare. Partea 2. Programare orientată pe obiecte 1.17 Tipuri de programare. Partea 1. Programare structurată. Bucle 1.16 Reprezentarea informației simbolice - ASCII 1.15 Împărțirea numerelor binare 1.14 Operații matematice cu numere binare 1.13 Cum sunt stocate și înregistrate informațiile. Biți și octeți 1.12 Conversia numerelor întregi din sistemul numeric zecimal în alt sistem 1.11 Conversia numerelor întregi din hexazecimal în zecimal 1.10 Conversia numerelor întregi binare în hexazecimal 1.9 Conversia numerelor întregi binare într-un alt sistem numeric 1.8 Sisteme numerice 1.7 Algebra booleană. Expresii logice 1.6 Concepte de bază. Partea 3 - Numere, expresii, operanzi, semne de operație 1.5 Concepte de bază. Partea 2 - Program, date 1.4 Concepte de bază. Partea 1 - Problemă și algoritm 1.3 Mediul de dezvoltare SI 1.2 Istoria limbajelor de programare 1.1 Introducere
Când scrieți programe în orice limbaj de programare, trebuie să vă străduiți să scrieți coduri compacte, astfel încât să puteți naviga cu ușurință în codul în sine.
Se întâmplă că nu este posibil să vă implementați codul în acest fel și, de multe ori, codul programului arată ca un scroll nesfârșit de lung al unui document antic care ocupă 10 - 15 ecrane de monitor pe verticală...
Desigur, înțelegerea unui astfel de program poate fi extrem de dificilă pentru autorul unei astfel de creații.
În acest caz, programatorul poate veni în ajutorul împărțirii codului programului în subrutine.
Subrutină- acesta este un fel de program complet, dar nu independent.
Este apelat dintr-un program de nivel superior doar pentru a efectua una sau alta acțiune.
Cum arată asta în practică?
De exemplu, într-un program foarte mare trebuie să produceți (ne-am uitat deja la algoritmul pentru funcționarea acestuia).
Și în loc să scriem cod pentru calcularea numerelor Fibonacci în acest cod de program mare de fiecare dată, pur și simplu îl punem într-un fișier separat. Aceasta va fi subrutina.
Apoi, în locul în care ar trebui să se facă calculul necesar al acestor numere, introducem doar câteva indicații că subrutina noastră ar trebui apelată în acest loc.
În acest caz, codul programului este semnificativ redus în volum și va fi mult mai ușor de înțeles funcționarea programului.
În diferite limbaje de programare, astfel de subrutine se numesc:
Proceduri sau
- functii
În limbajul SI, astfel de subrutine se numesc funcții.
Apropo, deja am folosit funcțiile în practică!
De exemplu, am folosit funcții BUILT-IN în interpret:
Print() - pentru a tipări datele anumitor parametri care au fost încadrați în paranteze
- str() - pentru a converti datele în tip șir. Aceasta este ceea ce funcția print() rulează înainte.
- int() - pentru a converti datele într-un număr întreg
- float() - pentru a converti numerele întregi în tip fracțional
- round() - pentru rotunjirea unei anumite valori
și așa mai departe.
Asa de.
Pentru a apela o funcție, trebuie doar să tastați numele acesteia și să enumerați între paranteze parametrii necesari (argumentele) pe care vrem să îi transmitem acestei funcție.
Dar ar fi complet neinteresant dacă nu am avea ocazia să ne creăm propriile funcții pentru a îndeplini anumite sarcini.
În ceea ce privește Python, are un operator special de definire a funcției cu următoarea sintaxă:
def FUNCTION_NAME(PARAMETER_LIST):
SECVENȚA EXPRESIUNILOR
Numele de funcții trebuie selectate în același mod ca și numele de variabile - conform acelorași reguli: numele trebuie să înceapă cu o literă latină.
- Lista de parametri conține anumite valori care sunt transmise funcției. Acești parametri sunt listați separați prin virgule.
În Python, pentru a defini o funcție, primul parametru este un cuvânt funcție def(titlul funcției) (din defini- define) - cu aceasta indicăm că vom apela funcția.
Antetul funcției de după paranteza de închidere se termină cu două puncte (în Python) și este urmat de expresiile necesare începând cu un offset față de începutul liniei (de obicei se folosește tasta TAB).
Revenind la calculul numerelor Fibonacci, să folosim exemplul său pentru a analiza cum funcționează un apel de funcție.
Vom lua o altă opțiune pentru calcularea numerelor Fibonacci, pe care nu am luat-o în considerare înainte.
Se bazează pe atribuirea paralelă a valorilor variabilelor.
Def fib(n): a, b = 0, 1 în timp ce a< n: print(a, end = " ") a, b = b, a + b print()
Pe scurt, linia:
a, b = 0, 1
înseamnă (dar nu este complet echivalent cu):
a = 0 b = 1
Și linia
a, b = b, a + b
înseamnă intrarea:
a = b b = a + b
Să ne uităm la codul linie cu linie:
1
def fib(n):
- defini ( def) funcţionează după nume fib cu parametrii (argumentele) specificati in paranteze pe care vrem sa ii transmitem chiar acestei functii dupa nume fib.
Acestea. ca parametru n vom trece valoarea pentru care se va efectua calculul. Acest număr va fi transmis funcției noastre ca argument.
După două puncte, intrarea este indentată în interpretul Python. Acest lucru sugerează că aceste date sunt direct legate de această funcție.
2
a, b = 0, 1
Inițializam variabilele cu valorile corespunzătoare:
a = 0 b = 1
3
In timp ce< n:
Operator de buclă in timp ce- va fi executat atâta timp cât condiția de buclă este îndeplinită A
Și aici, după colon, se deschide un nou bloc care este DIRECT legat doar de ciclu.
Acest bloc va fi tipărit după avansul de linie cu indentare suplimentară.
4
print(a, final = " ")
Tipărim datele variabilei a și un spațiu după fiecare iterație a buclei
5
a, b = b, a + b
Atribuim valorile adecvate variabilelor:
a = b b = a + b
Pentru a schimba datele inițiale și a continua munca de calcul a numerelor Fibonacci
6
imprimare()
Vă rugăm să rețineți că aceasta imprimare() trebuie să imprimați sub in timp ce... adica nu mai aparține corpului buclei in timp ce, și la corpul funcției fib
Totuși, de ce avem nevoie de al doilea? imprimare() si chiar si cu paranteze goale?
În acest caz, aceasta este rezultatul unei linii goale - faceți o „break” - o întrerupere de linie. Sau, mai degrabă, această funcție imprimă caracterul de avans de linie.
În cazul nostru, nu trebuie să-l folosim.
Deci am definit funcția fib pentru calcularea numerelor Fibonacci și, după cum ați observat, nu funcționează.
Pentru ca acesta să funcționeze, trebuie să îl apelați și să îi transmiteți un anumit parametru pentru calcule.
Apelăm funcția noastră și transmitem valoarea ca argument 40
.
Ca rezultat, ar trebui să obținem un calcul al numerelor Fibonacci pentru toate numerele până la 40
:
Printăm în interpretul Python:
fib(40)
Primim:
0 1 1 2 3 5 8 13 21 34
Puteți apela din nou funcția fib() cu un parametru diferit și obțineți aceeași ieșire a datelor necesare.
De exemplu, hai să intrăm
fib(400)
Și obținem:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Astfel, funcția noastră poate fi rulată de numărul necesar de ori.
În multe limbaje de programare, procedura și funcția nu sunt sinonime și au diferențe între ele.
Cum diferă între ele în astfel de limbaje de programare?
Funcție - returnează valoarea
- Procedura - nu returnează o valoare
Să explicăm cu un exemplu:
Dacă am putea folosi o notație ca aceasta (doar ca exemplu):
x = fib(n)- atunci aceasta este o funcție, atribuie valoarea rezultată unei variabile X(în acest caz, nu se va scrie nimic în variabila x)
Dacă doar înregistrarea este posibilă fib(n)- atunci aceasta este o procedură.
Deci putem spune că exemplul nostru este o PROCEDURĂ.
Vom analiza cum să folosim codul nostru în Python pentru a calcula numerele Fibonacci ca funcție puțin mai târziu...
