Mitä def tarkoittaa pythonissa. Rekursion käsite, toteutus Pythonissa. Funktiot antavat ohjelmarakenteen

Toiminnot voivat siirtää mitä tahansa tietoa kehostaan ohjelman päähaaraan. Funktion sanotaan palauttavan arvon. Useimmilla ohjelmointikielillä, mukaan lukien numero Python, funktiosta poistuminen ja tietojen välittäminen paikkaan, josta se kutsuttiin, suoritetaan return-käskyllä.

Jos Python-tulkki funktion runkoa suorittaessaan kohtaa returnin, se "ottaa" tämän komennon jälkeen määritetyn arvon ja "poistuu" funktiosta.

def sylinteri() : r = float(tulo()) h = float(syöte()) # sylinterin sivupinta-ala: sivu = 2 * 3,14 * r * h # sylinterin yhden pohjan alue: ympyrä = 3,14 * r**2 # sylinterin kokonaispinta-ala: täysi = sivu + 2 * ympyrä paluu täysi neliö = sylinteri() tulosta (neliö)

Toteutusesimerkki:

3 7 188.4

Tässä ohjelmassa paikallismuuttujan full arvo palautetaan funktiosta päähaaraan. Ei itse muuttuja, vaan sen arvo tässä tapauksessa– mikä tahansa luku, joka saadaan laskemalla sylinterin pinta-ala.

Ohjelman päähaarassa tämä arvo on määritetty globaalille muuttujalle neliö. Eli lauseke square = cylinder() suoritetaan seuraavasti:

Cylinder()-funktiota kutsutaan.

Arvo palautetaan siitä.

Tämä arvo on määritetty neliömuuttujalle.

Tulosta ei tarvitse määrittää muuttujalle, se voidaan näyttää välittömästi näytöllä:

Tulosta (sylinteri())

Tässä välitetään suoraan cylinder():stä saatu numero tulostustoiminnot(). Jos kirjoitamme yksinkertaisesti cylinder() ohjelmaan ilman, että kohdistamme vastaanotettua dataa muuttujaan tai siirrämme sitä jonnekin pidemmälle, tämä data menetetään. Mutta syntaksivirhe ei ole.

Funktiolla voi olla useita return-lauseita. Kuitenkin vain yksi niistä suoritetaan aina. Se, jonka suoritussäie saavuttaa ensimmäisenä. Oletetaan, että päätämme käsitellä poikkeusta, joka tapahtuu väärä syöttö. Poistutaan sitten poikkeuskäsittelijän funktiosta ilman laskutoimituksia ja arvon välittämistä:

def cylinder() : kokeile : r = kellua (syöttö () ) h = kellua (syöttö () ) paitsi ValueError : paluupuoli = 2 * 3,14 * r * h ympyrä = 3,14 * r**2 täysi = sivu + 2 * ympyrä palauttaa koko tulostus (sylinteri() )

Jos yrität syöttää kirjaimia numeroiden sijasta, kenttään paitsi sisäkkäinen palautus toimii. Se lopettaa toiminnon, joten kaikki myöhemmät laskelmat, mukaan lukien paluu täynnä, jätetään pois. Toteutusesimerkki:

Mutta odota! Mikä on tämä sana Ei mitään, jonka "tyhjä" palautus palautti meille? Tämä ei ole mitään, tällainen esine on "ei mitään". Se kuuluu NoneType-luokkaan. Ennen tätä tunsimme neljä tietotyyppiä, jotka tunnetaan myös neljänä luokkana: int, float, str, bool. On viidennen aika.

Kun mitään ei ole määritetty palautuksen jälkeen, oletusarvo on, että siellä on None-objekti. Mutta kukaan ei estä sinua kirjoittamasta nimenomaisesti paluuta Ei mitään.

Lisäksi. Aiemmin tarkastelimme funktioita, jotka eivät näyttäneet palauttavan arvoa, koska niillä ei ollut return-lausetta. Itse asiassa se palautettiin, emme vain kiinnittäneet siihen huomiota, emme määrittäneet sitä millekään muuttujalle emmekä näyttäneet sitä näytöllä. Pythonissa jokainen funktio palauttaa jotain. Jos sillä ei ole return-lausetta, se palauttaa None. Sama kuin jos se sisältäisi "tyhjän" palautuksen.

Useiden arvojen palauttaminen

Pythonissa voit palauttaa useita objekteja funktiosta luettelemalla ne pilkuilla erotettuna return-komennon jälkeen:

def sylinteri() : r = float (syöttö () ) h = float (syöttö () ) puoli = 2 * 3,14 * r * h ympyrä = 3,14 * r**2 täysi = sivu + 2 * ympyrä paluupuoli, täysi sCyl , fCyl = sylinteri() tulosta ( "Sivupinta-ala %.2f"% sCyl) tulostus ( "Kokonaispinta-ala %.2f"% fCyl)

Cylinder()-funktio palauttaa kaksi arvoa. Ensimmäinen niistä on määritetty muuttujalle sCyl, toinen - fCyl. Mahdollisuus tällaiseen ryhmätehtävään on Python-ominaisuus, ei yleensä ole tyypillistä muille kielille:

>>> a, b, c = 10 , 15 , 19 >>>a 10 >>> b 15 >>>c 19

Temppu tässä on se, että arvojen listaus pilkuilla erotettuina (esimerkiksi 10, 15, 19) luo monikkotyyppisen objektin. Käännetty venäjäksi "tupleksi". Tämä on eräänlainen tietorakenne, jota tarkastellaan myöhemmin.

Kun monikko määritetään usealle muuttujalle kerralla, sen elementtejä verrataan vastaaviin jonon muuttujiin. Tätä kutsutaan purkamiseksi.

Siten, kun funktio palauttaa useita arvoja, se palauttaa itse asiassa yhden monikkoobjektin. Nämä useat arvot pakataan monikkoon ennen palauttamista. Jos return-käskyn jälkeen on vain yksi muuttuja tai objekti, sen tyyppi säilytetään sellaisenaan.

Pakkauksen purkaminen on valinnaista. Se toimii näin:

...tulostus(sylinteri())

Toteutusesimerkki:

4 3 (75.36 , 175.84 )

Näytöllä näkyy monikko suluissa ilmoitettuna. Se voidaan myös määrittää yhdelle muuttujalle ja näyttää sen arvon näytöllä.

Tässä artikkelissa aion puhua funktioista, nimetyistä ja anonyymeistä, def-, return- ja lambda-käskyistä, pakollisista ja valinnaisista funktion argumenteista, funktioista, joissa on mielivaltainen määrä argumentteja.

Nimetyt funktiot, def-käsky

Pythonin funktio on objekti, joka ottaa argumentteja ja palauttaa arvon. Tyypillisesti funktio määritellään käskyllä def.

Määritellään yksinkertaisin toiminto:

def add (x, y): palauttaa x + y

Ohjeet palata sanoo, että sen on palautettava arvo. Meidän tapauksessamme funktio palauttaa x:n ja y:n summan.

Nyt voimme kutsua sitä:

>>> add (1 , 10 ) 11 >>> add ("abc" , "def" ) "abcdef"

Funktio voi olla minkä tahansa monimutkainen ja palauttaa kaikki objektit (luettelot, monikot ja jopa funktiot!):

>>> def newfunc (n): ... def myfunc (x): ... return x + n ... return myfunc ... >>> new = newfunc (100) # new on funktio >>> uusi (200) 300

Funktio ei saa päättyä return-lauseeseen, mutta funktio palauttaa arvon:

>>> def func (): ... pass ... >>> print (func ()) Ei mitään

Toiminnan argumentit

Toiminto voi kestää mielivaltainen määrä argumentteja tai olla hyväksymättä niitä ollenkaan. Yleisiä ovat myös funktiot, joissa on mielivaltainen määrä argumentteja, funktiot, joissa on paikka- ja nimettyjä argumentteja, pakollisia ja valinnaisia.

>>> def func (a , b , c = 2 ): # c - valinnainen argumentti... palauttaa a + b + c ... >>> funktio (1 , 2 ) # a = 1, b = 2, c = 2 (oletus) 5 >>> funktio (1, 2, 3) # a = 1, b = 2, c = 3 6 >>> funktio (a = 1, b = 3) # a = 1, b = 3, c = 2 6 >>> funktio (a = 3, c = 6) # a = 3, c = 6, b määrittelemätön Traceback (viimeisin puhelu viimeisin):Tiedosto "", rivi 1, func(a=3, c=6) TypeError: func() ottaa vähintään 2 argumenttia (2 annettu)

Toiminto voi myös hyväksyä vaihteleva määrä sijaintiargumentit, niin nimen eteen sijoitetaan *:

>>> def func (* args): ... palautusarvot ... >>> func (1, 2, 3, "abc") (1, 2, 3, "abc") >>> func () () >>> toimi (1 ) (1,)

Kuten esimerkistä näkyy, args on kaikki funktiolle välitetyt argumentit, ja voit työskennellä muuttujan kanssa samalla tavalla kuin monikon kanssa.

Funktio voi ottaa mielivaltaisen määrän nimettyjä argumentteja, jolloin nimen eteen sijoitetaan **:

>>> def func (** kwargs): ... palauta kwargs ... >>> funktio (a = 1, b = 2, c = 3) ("a": 1, "c": 3, " b": 2) >>> func () () >>> func (a = "python" ) ("a": "python")

Tallennamme kwargs-muuttujan, jolla voimme jälleen tehdä mitä haluamme.

Anonyymit toiminnot, lambda-ohje

Anonyymit funktiot voivat sisältää vain yhden lausekkeen, mutta ne myös suoritetaan nopeammin. Anonyymit funktiot luodaan käskyn avulla lambda. Lisäksi niitä ei tarvitse määrittää muuttujaan, kuten teimme def func() -käskyn kanssa:

>>> funktio = lambda x , y : x + y >>> funktio (1 , 2 ) 3 >>> funktio ("a" , "b" ) "ab" >>> (lambda x , y : x + y )(1 , 2 ) 3 >>> (lambda x , y : x + y )("a" , "b" ) "ab"

Lambda-funktio, toisin kuin tavallinen, ei vaadi paluukäskyä, vaan toimii muuten täsmälleen samalla tavalla:

>>> func = lambda * args : args >>> func (1 , 2 , 3 , 4 ) (1, 2, 3, 4)

Toiminto on jotain, joka on tarkoitus suorittaa. tietty tehtävä eristetty koodilohko, jota voidaan käyttää uudelleen. Toiminnot tekevät ohjelmakoodista modulaarisen ja kompaktimman.

Python tarjoaa monia sisäänrakennettuja toimintoja. Nämä ovat luultavasti sinulle tuttuja:

print() tulostaa objektin terminaaliin.
int() muuntaa merkkijonot tai numerot kokonaisluvuiksi.
len() palauttaa objektin pituuden.

Funktion nimi sisältää sulkeita ja voi sisältää parametreja.

Tämä opetusohjelma opettaa sinulle, kuinka voit määrittää mukautettuja toimintoja.

Toiminnon määritelmä

Kokeile ensin muuntamista yksinkertainen ohjelma"Hei maailma!" funktioksi.

Luo uusi tekstitiedosto hello.py ja määritä sitten funktio.

Määritä funktio käyttämällä def-avainsanaa ja määritä sitten funktion nimi ja sulut, jotka voivat sisältää parametreja (jos parametreja ei ole, sulut jäävät tyhjiksi) ja sen jälkeen kaksoispiste.

Voit määrittää hello()-funktion lisäämällä hello.py-tiedostoosi:

Tämä alkuperäinen määritelmä toimintoja.

def hei ():
print ("Hei, maailma!")

Toiminto on nyt määritetty. Mutta jos päällä tässä vaiheessa suorita ohjelma, mitään ei tapahdu: jotta funktio toimisi, se ei ole vain määritettävä, vaan myös kutsuttava.

Kun olet määrittänyt funktion, kutsu sitä:

def hei ():
print ("Hei, maailma!")
Hei()

Suorita nyt ohjelma:

Sen pitäisi palata:

Hello()-funktio on melko yksinkertainen esimerkki. Toiminnot voivat olla paljon monimutkaisempia: sisältää silmukoita, ehdollisia lausekkeita ja muut komponentit.

Kun funktio saavuttaa return-lauseen, se lopettaa suorittamisen.

# Tiedosto return_loop.py
def loop_five():
x:lle alueella (0, 25):
tulosta (x)
jos x == 5:
# Pysäytystoiminto kohdassa x == 5
palata
print("Tätä riviä ei suoriteta.")
loop_five()

Palautusilmoitus sisään silmukalle lopettaa funktion suorittamisen, joten funktion jälkeisiä rivejä ei suoriteta. Jos sitä käytettäisiin sen sijaan taukooperaattori, ohjelma lopettaa silmukan suorittamisen funktion sijaan ja viimeinen print()-käsky käsitellään.

päätoiminto

SISÄÄN Python kieli funktiota voidaan kutsua ohjelman lopussa ja se toimii (kuten edellisissä esimerkeissä näkyy), mutta jotkut ohjelmointikielet (kuten C++ tai Java) vaativat pääfunktion. Main()-funktio Pythonissa on valinnainen, mutta sen avulla voit loogisesti jäsentää Python-ohjelmasi ja yhdistää sen tärkeimmät komponentit yhdeksi funktioksi. Se tekee Python-ohjelmista myös helpompia lukea muilla kielillä työskenteleville ohjelmoijille.

Palaa hello.py-tiedostoon ja lisää päätoiminto(), säilyttäen hello()-funktion.

def hei ():
print ("Hei, maailma!")
def main():

Lisää print()-käsky main()-funktioon. Kutsu sitten hello()-funktio main()-funktion sisällä.

def hei ():
print ("Hei, maailma!")
def main():
print("Tämä on päätoiminto")
Hei()

Kutsu tiedoston lopussa main()-funktiota.

def hei ():
print ("Hei, maailma!")
def main():
print("Tämä on päätoiminto.")
Hei()
pää()

Nyt voit ajaa ohjelman:

python hello.py
Tämä on päätoiminto.
Hei maailma!

Yritä nyt käyttää useita toimintoja.

Funktio ohjelmoinnissa on erillinen koodinpätkä, jota voidaan kutsua viittaamalla siihen sillä nimellä, jolla se nimettiin. Kutsuttaessa funktion rungon komennot suoritetaan.

Toimintoja voidaan verrata pieniin ohjelmiin, joita ei suoriteta itsenäisesti, eli itsenäisesti, vaan ne ovat sisäänrakennettuja säännöllinen ohjelma. Niitä kutsutaan usein aliohjelmiksi. muut tärkeimmät erot Ohjelmista ei ole toimintoja. Toiminnot voivat myös vastaanottaa ja palauttaa tietoja tarpeen mukaan. Vain yleensä he eivät saa niitä syötteestä (näppäimistö, tiedosto jne.), vaan kutsuvasta ohjelmasta. Täällä he palauttavat työnsä tulokset.

Ohjelmointikielessä on monia toimintoja. Olemme jo kohdanneet joitakin näistä Pythonissa. Näitä ovat print(), input(), int(), float(), str(), type(). Heidän kehonsa koodi ei ole meille näkyvissä, se on "piilotettu kielen sisällä". Meillä on vain käyttöliittymä - toiminnon nimi.

Toisaalta ohjelmoija voi aina määritellä omat toimintonsa. Niitä kutsutaan custom. Tässä tapauksessa "käyttäjä" tarkoittaa ohjelmoijaa, ei sitä, joka käyttää ohjelmaa. Selvitetään, miksi tarvitsemme näitä toimintoja ja miten ne luodaan.

Oletetaan, että sinun täytyy pyytää numeropari kolme kertaa peräkkäin ja lisätä ne. Tätä tarkoitusta varten voit käyttää silmukkaa:

i = 0, kun taas i< 3 : a = int (input () ) b = int (input () ) print (a+b) i += 1

Entä jos ennen jokaista numeropyyntöä sinun on näytettävä merkintä, miksi niitä tarvitaan, ja joka kerta tämä merkintä on erilainen. Emme voi katkaista kiertoa ja palata sitten samaan kiertokulkuun uudelleen. Meidän on hylättävä se, ja sitten päädymme pitkälle koodille eri paikkoja ah, identtiset osat:

tulosta () a = int (syöttö () ) b = int (syöttö () ) tulosta ("Yhteensä", a+b, "kpl." ) tulosta () a = int (syöttö () ) b = int (syöttö () ) tulosta ("Yhteensä", a+b, "kpl." )

Esimerkki ohjelman suorittamisesta:

Kuinka monta banaania ja ananasta apinoille? 15 5 Yhteensä 20 kpl. Kuinka monta kovakuoriaista ja matoa siileille? 50 12 Yhteensä 62 kpl. Kuinka monta kalaa ja äyriäisiä saukkolle? 16 8 Yhteensä 24 kpl.

Toimintojen käyttöönoton avulla voit ratkaista koodin monistamisen ongelman ohjelman eri paikoissa. Niiden ansiosta voit suorittaa saman koodiosan ei heti, vaan vain tarvittaessa.

Toiminnon määritelmä. def-operaattori

Kielessä Python ohjelmointi funktiot määritellään käyttämällä def-lausetta. Katsotaanpa koodia:

def countFood() : a = int (syöttö () ) b = int (syöttö () ) print ("Yhteensä", a+b, "kpl." )

Tämä on esimerkki funktion määrittelystä. Kuten muutkin monimutkaiset ohjeet Kuten ehdollinen operaattori ja silmukat, funktio koostuu otsikosta ja rungosta. Otsikko päättyy kaksoispisteeseen ja siirtymään kohtaan uusi rivi. Runko on painettu.

Avainsana def kertoo tulkille, että tämä on funktion määritelmä. def:n jälkeen on funktion nimi. Se voi olla mikä tahansa, aivan kuten mikä tahansa tunniste, esimerkiksi muuttuja. Ohjelmoinnissa on erittäin toivottavaa antaa kaikelle merkitykselliset nimet. Joten tässä tapauksessa funktiota kutsutaan nimellä "countFood" käännettynä venäjäksi.

Toiminnon nimen perässä on sulkeet. Annetussa esimerkissä ne ovat tyhjiä. Tämä tarkoittaa, että toiminto ei hyväksy tietoja sitä kutsuvalta ohjelmalta. Se voisi kuitenkin hyväksyä ne, ja sitten ns. parametrit olisi merkitty suluissa.

Kaksoispistettä seuraa runko, joka sisältää käskyt, jotka suoritetaan, kun funktiota kutsutaan. On tehtävä ero funktion määrittelyn ja kutsumisen välillä. SISÄÄN ohjelmakoodi he eivät ole lähellä eivätkä yhdessä. Voit määrittää funktion, mutta älä koskaan kutsu sitä. Et voi kutsua funktiota, jota ei ole määritetty. Jos määrittelet funktion, mutta et koskaan kutsu sitä, et koskaan suorita sen runkoa.

Toiminnon kutsuminen

Harkitsemme täysversio ohjelmat, joissa on toiminto:

def countFood() : a = int (syöttö () ) b = int (syöttö () ) tulosta ("Yhteensä", a+b, "kpl." ) tulosta ( "Kuinka monta banaania ja ananasta apinoille?") countFood() tulosta ( "Kuinka monta kovakuoriaista ja matoa siileille?") countFood() tulosta ( "Kuinka monta kalaa ja äyriäisiä saukkolle?") countRuoka()

Jokaisen näyttämisen jälkeen infoviesti suoritetaan funktiokutsu, joka näyttää vain siltä, että sen nimi mainittaisiin suluissa. Koska emme välitä mitään funktioon, sulut ovat jälleen tyhjiä. Yllä olevassa koodissa funktiota kutsutaan kolme kertaa.

Kun funktiota kutsutaan, ohjelman säie hyppää määrittelyyn ja alkaa suorittaa sen runkoa. Kun funktion runko on suoritettu, suoritussäie palaa pääkoodiin paikassa, jossa funktiota kutsuttiin. Seuraavaksi suoritetaan kutsua seuraava lauseke.

Pythonissa funktiomäärityksen on edeltävä sen kutsuja. Tämä johtuu siitä, että tulkki lukee koodia rivi riviltä eikä vielä tiedä, mikä on alavirtaan. Siksi, jos funktiokutsu edeltää sen määrittelyä, tapahtuu virhe (NameError-poikkeus heitetään):

Tulosta( "Kuinka monta banaania ja ananasta apinoille?") countFood() tulosta ( "Kuinka monta kovakuoriaista ja matoa siileille?") countFood() tulosta ( "Kuinka monta kalaa ja äyriäisiä saukkolle?") countFood() def countRuoka() : a = int (syöttö () ) b = int (syöttö () ) tulosta ("Yhteensä", a+b, "kpl." )

Tulos:

Kuinka monta banaania ja ananasta apinoille? Traceback (viimeisin puhelu viimeinen ): Tiedosto "test.py" , rivi 2 , sisään< module>countFood() NameError: nimeä "countFood" ei ole määritetty

Monilla käännetyillä kielillä tämä ei ole vaadittu kunto. Siellä voit määritellä ja kutsua funktion mielivaltaisissa paikoissa ohjelmassa. Kuitenkin koodin luettavuuden vuoksi ohjelmoijat haluavat myös tässä tapauksessa noudattaa tiettyjä sääntöjä.

Funktiot antavat ohjelmarakenteen

Toimintojen etu ei ole vain mahdollisuus kutsua samaa koodia useita kertoja ohjelman eri paikoista. Yhtä tärkeää on, että ne antavat ohjelmalle todellisen rakenteen. Toiminnot näyttävät jakavan sen erillisiin osiin, joista jokainen suorittaa oman tehtävänsä.

Oletetaan, että sinun on kirjoitettava ohjelma, joka laskee eri kuvioiden pinta-alat. Käyttäjä ilmoittaa alueen, jonka kuviosta hän haluaa laskea. Tämän jälkeen syöttää alkutiedot. Esimerkiksi pituus ja leveys suorakulmion tapauksessa. Jos haluat jakaa suoritussäikeen useisiin haaroihin, sinun tulee käyttää if-elif-else -lausetta:

kuva = syöte () if figuuri == "1" : a = float (syöttö ("Leveys: " ) ) b = float (syöttö ("Korkeus: " ) ) tulosta ("Ala: %.2f" % (a*) b) ) elif figuuri == "2" : a = float (syöttö ("Pohja: " ) ) h = float (syöttö ("Korkeus: " ) ) tulosta ("Ala: %.2f" % (0.5 * a * h) ) elif figure == "3" : r = float (syöttö ("Säde: " ) ) tulosta ("Ala: %.2f" % (3.14 * r**2 ) ) else : print ("Syötevirhe" )

Täällä ei ole toimintoja ja kaikki on kunnossa. Mutta kirjoitetaan versio funktioilla:

def rectangle() : a = float (syöttö ("Leveys: " ) ) b = float (syöttö ("Korkeus: " ) ) print ("Ala: %.2f" % (a*b) ) def triangle() : a = float (syöttö ("Pohja: " ) ) h = float (syöttö ("Korkeus: " ) ) print ( "Ala: %.2f" % (0.5 * a * h) ) def circle() : r = float (syöttö ("Säde: " ) ) tulosta ( "Ala: %.2f" % (3.14 * r**2 ) ) figure = input ( "1-suorakulmio, 2-kolmio, 3-ympyrä: ") if figure == "1" : suorakulmio() elif-figuuri == "2" : kolmio() elif-kuvio == "3" : ympyrä() else : print ("Syötevirhe")

Se näyttää monimutkaisemmalta, ja kutakin kolmesta funktiosta kutsutaan vain kerran. Ohjelman yleisestä logiikasta on kuitenkin poistettu ja eristetty ohjeet alueiden etsimiseen. Ohjelma koostuu nyt yksittäisistä "Lego-palikoista". Päähaarassa voimme yhdistää niitä haluamallamme tavalla. Sillä on ohjausmekanismin rooli.

Jos haluamme koskaan laskea kolmion pinta-alan käyttämällä Heronin kaavaa korkeuden sijaan, meidän ei tarvitse etsiä koodia koko ohjelmasta (kuvittele, että se on tuhansia koodirivejä, kuten oikeita ohjelmia). Siirrymme sinne, missä funktiot on määritelty, ja muutamme yhden niistä runkoa.

Jos joudumme käyttämään näitä toimintoja jossain toisessa ohjelmassa, voimme tuoda ne sinne viitaten Tämä tiedosto koodilla (miten tämä tehdään Pythonissa, käsitellään myöhemmin).

Käytännön työ

Ohjelmoinnissa voit kutsua toisen toiminnon yhdestä funktiosta. Havainnollistaaksesi tätä mahdollisuutta, kirjoita ohjelma, jossa on seuraava kuvaus.

Ohjelman päähaara, funktiootsikoita lukuun ottamatta, koostuu yhdestä koodirivistä. Tämä on kutsu test()-funktiolle. Se pyytää kokonaislukua. Jos se on positiivinen, kutsutaan positiivinen()-funktio, jonka runko sisältää komennon näyttää sana "Positive" näytöllä. Jos luku on negatiivinen, kutsutaan negatiivinen()-funktio, jonka runko sisältää lausekkeen, joka näyttää sanan "Negatiivinen".

5. elokuuta 2008 klo 16.14

Pythonin perusteet - lyhyesti. Osa 5. Toimintojen määrittely, perusteet.

Python

Kun aloin kirjoittaa lukua OOP:sta, tajusin, että olin täysin unohtanut pyhittää niin suuren ja vaadittu jakso Python funktioina. Tämä aihe on laaja ja laaja, joten en venytä oppituntien välistä taukoa liikaa, päätin jakaa sen kahteen osaan. Ensin kerron sinulle perusasiat ja sitten Pythonin funktiosuunnittelun perusteelliset ominaisuudet.

Pythonissa funktioita ei ilmoiteta yksinkertaisesti, vaan hyvin yksinkertaisesti. Tässä on esimerkki yksinkertaisimmasta:

def empty_func(): pass
Mainos alkaa avainsana def, joka, kuten saatat arvata, on lyhenne sanoista define. Hänen jälkeensä menee nimi toimintoja. Nimen jälkeen suluissa on lista parametreista, jotka puuttuvat tässä tapauksessa.
Toimintokappale on sisennetty seuraava rivi. Huomaa, että funktiot, joissa on tyhjä runko, ovat kiellettyjä Pythonissa, joten "tyhjä operaattori" -passia käytetään yllä olevan funktion rungona.
Katsotaanpa nyt vakavampaa esimerkkiä.

Oletusarvo kusipää!"
Tässä esimerkissä on useita innovaatioita. Ensimmäinen asia, joka kiinnittää huomiosi, on dokumentaatiorivi (docstring), joka tulee välittömästi funktion rungon jälkeen.
Yleensä tämä rivi vie useamman kuin yhden rivin lähdeteksti(anteeksi sanaleikki) ja on siksi määritelty kolminkertaisissa lainausmerkeissä. Se on tarkoitettu kuvaamaan toimintoa, sen tarkoitusta, parametreja jne. Kaikki hyvät IDE:t voivat toimia tämän linjan kanssa. Voit käyttää sitä myös itse ohjelmasta __doc__-ominaisuuden avulla:

Tulosta safe_div.__doc__
Tätä ominaisuutta (kyllä, kyllä, täsmälleen ominaisuus, Pythonissa jopa funktiot ovat itse asiassa luokkia) on kätevä käyttää interaktiivisen konsolin istuntojen aikana.
>>> ftplibista tuo FTP >>> tulosta FTP.__doc__ An FTP asiakas luokkaa. Luo yhteys kutsumalla luokkaa käyttämällä näitä argumentteja: host, user, passwd, acct Nämä ovat kaikki merkkijonoja ja niillä on oletusarvo "". Käytä sitten self.connect() valinnaisen isäntä- ja porttiargumentin kanssa. # loput olen tehnyt minä :-)
Palataan alkuperäiseen toimintoomme. Sen olemus on hyvin yksinkertainen, se vaatii 2 parametria: x ja y. Jos y ei ole 0, se jakaa x:n y:llä, tulostaa tuloksen näytölle ja palauttaa osamääränsä tuloksena. Funktion tulos palautetaan return-komennolla. Viime oppitunnilla kuvatun monikkomekanismin ansiosta Pythonin funktiot voivat palauttaa useita objekteja samanaikaisesti.
Jos jakaja on edelleen yhtä suuri kuin nolla, toiminto näyttää virheilmoituksen. Olisi väärin olettaa, että tässä tapauksessa funktio ei palauta mitään. Olisi oikeampaa sanoa, että funktio palauttaa "ei mitään" :) Toisin sanoen, jos funktiolla ei ole return-lausetta tai sitä kutsutaan ilman parametreja, niin funktio palauttaa erikoisarvon None. Voit tarkistaa tämän helposti kutsumalla jotain, kuten print safe_div(10, 0).

Tässä on hieman monimutkaisempi esimerkki, joka on otettu Guido van Rossumin esittelyraportista.

Def gcd(a, b): "Etsitään GCD:tä", kun taas a != 0: a,b = b%a,a # rinnakkaismäärittely return b
Tämä funktio löytää kahden luvun suurimman yhteisen jakajan.

Muista, että Python-funktioiden parametrit välitetään viitteellä. Toinen, ehkä ei-triviaali tosiasia, johon sinun on totuttava, on se, että funktiot itsessään ovat arvo, joka voidaan määrittää. Jos käytämme safe_div-funktiota lisäkokeiluihin, voimme kirjoittaa seuraavan koodin.

Mystic_function = safe_div tulosta mystic_function(10, 4)
Siinä se tällä kertaa, Pythonin funktioiden määrittelyssä on vielä monia näkökohtia, jotka on jätetty "yli laidan", jotka käsitellään ensi kerralla.

Harjoituksia testaukseen.
1. Perustuu olemassa oleva toiminto löytääksesi GCD, kirjoita funktio, joka löytää kahden luvun LCM:n.
2. Kirjoita taulukointirutiini argumenttina välitetylle funktiolle. Argumentit määrittävät myös alku-, loppuarvon ja taulukointivaiheen.

PS muuten, mikä on "oppitunnin" optimaalinen pituus? Mikä on parempi - suuret luvut julkaistaan harvemmin vai "vähemmän on parempi, useammin?"