Pythonin loogiset operaatiot. Vaihteleva määrä argumentteja. Argumenttien oletusarvot arvioidaan vain kerran

Jokaisella operaatiolla on omat operaattorinsa. Unääri- ja binäärioperaatioissa niitä käytetään perusoperaattoreita(lisäys, vähennyslasku, negatiivinen, unaarinen plus, unaarinen miinus, osoitus). Kolmiosaisella on kolme argumenttia: jos-ehto, lauseke, jos ehto == tosi, ja lauseke, jos ehto == false.

Seuraava esimerkki auttaa sinua ymmärtämään, mikä operaattori on.

A = b + c

c lisätään muuttujaan b ja tulos liitetään muuttujaan a. Koko esimerkki kokonaisuudessaan a = b + c on lauseke. Siinä näkyvät muuttujat ovat operandeja. Suoritettu toiminto on summaus, ja tähän käytetty operaattori on "+".

Python-aritmeettiset operaattorit

Python tarjoaa suuri määrä kirjastot laskennallisten ongelmien ratkaisemiseen. Suuri joukko menetelmiä asettaa Pythonin Matlabin ja Octaven tasolle. Aritmeettiset operaatiot sovelletaan suhteessa kokonaislukuihin kirjoita int, oikeantyyppinen kelluva, monimutkainen kompleksi.

Jos toiminnon argumentteina käytetään vain kokonaislukuja, tulos on myös kokonaisluku. Liukulukujen väliset operaatiot johtavat kokonaisluvun ja murtoluvun. Ainoa operaatio, jossa kokonaislukujen vuorovaikutus tuottaa murtoluvun, on jako.

Kaikki mahdolliset aritmeettiset operaatiot on esitetty taulukossa.

Numeron lisääminen toiseen suorittaa lisäoperaattori. Vähennys tehdään vähennyslaskulla. Yhden luvun kertominen toisella tapahtuu kertolaskulla. Eksponenttioinnissa käytetään eksponenttia. Jakoa käytetään jakoon.

Moduuli (%) -operaattori palauttaa jäännöksen, kun vasen operandi jaetaan oikealla operandilla. Jos muuttuja a = 10, muuttuja b = 20, niin b%a == 0. Mikä on jakooperaattori jäännöksellä, voidaan helposti ymmärtää seuraavan esimerkin avulla. Jos 9/2 == 4,5, niin 9//2 palauttaa tuloksen 4. Jakaminen kerrosjaolla (//) palauttaa kokonaisluvun vasemman operandin jakamisesta oikealla operandilla.

Kaikki toiminnot suoritetaan suoraan itse numeroilla tai muuttujilla, joille on määritetty numeeriset arvot. Tuloksena voi olla toinen muuttuja tai jokin olemassa olevista muuttujista.

Yhdessä koko ja todellisia lukuja Pythonissa on kompleksilukuja. Ne koostuvat todellisesta ja kuvitteellisesta osasta. Kirjoitettu muodossa c = a+bj, missä a on reaaliosa,

C.real() #a

b - kuvitteellinen.

C.imag() #b

Aritmeettisilla operaatioilla kompleksiluvuilla on samat ominaisuudet kuin reaaliluvuilla. Kompleksilukujen käyttö voidaan esittää tasossa suorakaiteen muotoisella koordinaattijärjestelmällä. X-akselin ja Y-akselin leikkauspiste a vastaa kompleksilukua x + yi. Siten X-akseli sisältää reaalilukuja ja pystysuora Y-akseli imaginaarilukuja.

Vertailu

Pythonin operaattoreita käytetään muuttujien vertailuun. alkaen tunnettujen standardien lisäksi matemaattisia ongelmia, on arvon ja tyypin tarkistus sekä epätasa-arvon tarkistus.

Vertailuoperaatiot suoritetaan muodossa a x b, jossa x on vertailuoperaattori.

Ohjelmoinnissa "="-operaattori toimii eri tavalla kuin matematiikassa. Jokaisen argumentin vastaavan arvon määrittää "=="-operaattori, mutta "=" antaa vain arvon. Käyttämällä != tarkistaa muuttujien epäyhtälö. Tämä operaattori voidaan korvata nimellä "<>”, joka ei ole tavallinen operaattori muilla kielillä, kuten C, Java tai Javascript.

Tehtävä

Python-lauseet antavat arvon muuttujalle.

Tehtävä on yksi ohjelmoinnin keskeisistä rakenteista. Sen avulla muuttujat saavat tietyt arvot, jotka voivat muuttua ohjelman aikana.

Työalgoritmi:

• vasemmanpuoleinen arvon laskenta;
• oikeanpuoleinen arvon laskeminen;
• yhden arvon määrittäminen toiselle - jos tyyppien välillä on ristiriita, ne on annettava;
• palauttaa toiminnon tuloksen - tosi tai epätosi.

JA matemaattinen operaatio toimii tämän periaatteen mukaan:

a x b, jossa x on operaattori, tarkoittaa, että a = a x b. Siten a += b sanoo, että muuttujan a arvo lisätään muuttujan b arvoon ja niiden tulos annetaan muuttujalle a. Sama tapahtuu muidenkin esimerkkien kanssa. Esimerkiksi a **= b puretaan muodossa a = a ** b, eli a korotetaan b:n potenssiin, tulos määrätään lopulta a:lle.

ehdot

Kuntotestaus tehdään Pythonin kolmiosaisella operaattorilla.

Se koostuu kahdesta tai kolmesta osasta:

• if - tarkistettava lauseke;
• elif - valinnainen opetus (samanlainen kuin if else tai elseif);
• muu on pääohje.

a = int(tulo()), jos X: A = Y muuten: A = Z

Lauseke voidaan määrittää yhdellä rivillä.

A = Y, jos X muuten Z

Muu- ja elseif-osat voidaan hylätä, lauseke näyttää tältä:

Jos 1: tulosta ("hei 1")

Pythonilla on tauko ja jatka -lauseet. Break keskeyttää koodin suorittamisen kaikilla tasoilla. Jatka pysäyttää nykyisen iteraation ja jatkaa suoritusta seuraavasta pisteestä.

Bitittain

Tällaiset Python-operaattorit tulkitsevat operandinsa nollien ja ykkösten sarjaksi.

Ne käyttävät numeroita binäärimuodossa ja palauttavat tuloksen 32-bittisenä numerona.

a = 0 #a = 1 #a = 2 #a = 3 #a = 255 #

Negatiivinen luku binäärimuodossa saadaan kääntämällä bitti ja lisäämällä 1.

314 #-314 #+ 1 =

Ero a >> b:n ja a >>> b:n välillä on se, että kun siirretään ja hylätään oikeita arvoja, ensimmäisten bittien kopiot lisätään vasemmalle.

9 #9 >> 2 #-9 #-9 >> 2 #

Mutta a >>> b:llä vasemmat arvot täytetään nolilla.

9 #-9 >>> 2 #

aivojumppa

Loogisia operaattoreita on yhteensä kolme.

• ja - palauttaa tosi, jos a == b == x;
• tai - palauttaa tosi on a == x tai b == x;
• not - palauttaa epätosi, jos a == b == x.

Liittyminen

Jäsenyysoperaattori testaa, onko muuttuja osa sekvenssiä.

• a in b palauttaa tosi, jos se löytää muuttujan a sekvenssistä b;
• a not in b palauttaa tosi, jos se ei löydä muuttujaa a sekvenssistä b.

Identiteetti

• a is b palauttaa tosi, jos muuttujat oikealla ja vasemmalla osoittavat samaan objektiin;
• a ei ole b palauttaa tosi, jos muuttujat eivät osoita samaan objektiin.

Prioriteetit

Luettelo sisältää operaattoreita ja lausekkeita, jotka on lajiteltu suoritusprioriteetin mukaan alimmasta korkeimpaan.

Pythonin operaattorit ja niiden suoritusprioriteetti:

• Lambda ilmaisuja.
• Python.
• Boolen TAI.
• Boolen I.
• Boolen EI.
• Identiteettioperaattorit, jäsenyys, toimeksiantooperaattorit.
• Bittinen TAI.
• Bitittain EI.
• Bitovy I.
• Bittisiirtooperaattori.
• Yhteen-ja vähennyslasku.
• Kerto- ja jakolasku, mukaan lukien jakolaskun ja kokonaislukujen loppuosan saaminen.
• Bitittain EI.
• Eksponentointi.
• Matriisielementin käyttäminen indeksillä, viipalointi, luokkaobjektin käyttö, funktion kutsuminen argumenteilla.

Luettelon ensimmäinen kohde on lambda-lauseke. Lambda-lauseketta käytetään anonyymien funktioiden luomiseen. Lambda käyttäytyy tavallisen funktion tavoin ja on ilmoitettu nimellä

Def (argumentit): palauttaa lauseke

Lambda-lausekkeen jälkeen ovat Python-kolmiooperaattorin suorittamat toiminnot.

Luettelon lopussa on menetelmiä taulukoiden ja funktioiden käsittelyyn. Taulukon elementin käyttäminen indeksin perusteella näyttää tältä:

Tässä tapauksessa a on taulukko, i on elementtiindeksi.

Viipalointi tarkoittaa taulukon täydellisen kopion tai luettelon jäsenten valikoivan sekvenssin välittämistä. Haluttujen arvojen alue on merkitty . Argumentteina x on alkuperä, y on loppu ja z on vaihe, jossa taulukon elementit kulkevat kussakin iteraatiossa. X tarkoittaa oletusarvoisesti luettelon alkua, y loppua ja z on yhtä. Jos määrität z:n negatiivinen luku, listan arvot välitetään käänteisessä järjestyksessä lopusta alkuun.

Boolen tietotyyppi (tai Boolen arvo) on primitiivinen tyyppi, joka ottaa yhden kahdesta mahdollisesta arvosta: True tai False. Tätä tyyppiä käytetään monissa ohjelmointikielissä algoritmien rakentamiseen ja ohjelman toiminnan ohjaamiseen.

Huomautus: Tämän tietotyypin nimi (Boolean) kirjoitetaan aina iso kirjain, kuten se on nimetty matemaatikko George Boolen mukaan, joka tutki matemaattista logiikkaa. Arvot True ja False kirjoitetaan myös isot kirjaimet– Pythonissa ne ovat erikoisarvoja.

Tämä opetusohjelma tutustuttaa sinut Boolen logiikan perusteisiin Pythonissa: vertailuoperaattorit, loogiset operaattorit, totuustaulukot jne.

Vertailuoperaattorit

Ohjelmoinnissa vertailuoperaattoreita käytetään arvioimaan ja vertailemaan arvoja ja sitten vähentämään ne yhdeksi Boolen arvoksi (tosi tai epätosi).

Operaattorit Python vertailut 3 on esitetty tässä taulukossa:

Operaattori	Merkitys
==	Tarkistaa komponenttien välisen tasa-arvon; ehto on tosi, jos komponentit ovat yhtä suuret.
!=	Tarkistaa komponenttien välisen tasa-arvon; ehto on tosi, jos komponentit EIVÄT ole samat.
<	Arvioi vasemman komponentin arvon; ehto on tosi, jos se on pienempi kuin oikea.
>	Arvioi vasemman komponentin arvon; ehto on tosi, jos se on suurempi kuin oikea.
<=	Arvioi vasemman komponentin arvon; ehto on tosi, jos se on pienempi tai yhtä suuri kuin oikea komponentti.
>=	Arvioi vasemman komponentin arvon; ehto on tosi, jos se on suurempi tai yhtä suuri kuin oikea komponentti.

Yritä työskennellä näiden operaattoreiden kanssa ymmärtääksesi, kuinka he toimivat. Luo ensin pari muuttujaa:

Vertaa nyt muuttujien arvoja käyttämällä yllä olevia operaattoreita.

x = 5
y = 8
print("x == y:", x == y)
print("x != y:", x != y)
print("x< y:", x < y)
print("x > y:", x > y)
print("x<= y:", x <= y)
print("x >= y:", x >= y)
x == y: Väärin
x != y: Totta
x< y: True
x > y: Väärin
x<= y: True
x >= y: Väärin

Matemaattista logiikkaa noudattaen Python arvioi muuttujien arvojen väliset suhteet seuraavasti:

• 5 on 8? Valehdella
• 5 ei ole yhtä kuin 8? Totta
• 5 on pienempi kuin 8? Totta
• Onko 5 enemmän kuin 8? Valehdella
• Onko 5 pienempi tai yhtä suuri kuin 8? Totta
• Onko 5 suurempi tai yhtä suuri kuin 8? Valehdella

Vertailuoperaattoreita voidaan soveltaa myös liukulukuihin ja merkkijonoihin.

Huomautus: Merkkijonot ovat isoja ja pieniä; Tämän toiminnan poistamiseksi käytöstä sinun on käytettävä erityistä menetelmää.

Kokeile kahden merkkijonon vertailua:

Hei = "Hei"
hei = "hei"

Hei == hei: Väärin

Merkkijonot Hello ja hello sisältävät saman merkkijoukon, mutta ne eivät ole samanarvoisia, koska yksi niistä sisältää merkit isot kirjaimet. Kokeile lisätä toinen muuttuja, joka sisältää myös isoja merkkejä, ja vertaa niitä sitten.

Hei = "Hei"
hei = "hei"
Hello_there = "Hei"
print("Hei == hei: ", Hei == hei)
print("Hei == Hei_there", Hei == Hei_there)
Hei == hei: Väärin
Hei == Hello_there: Totta

Voit myös käyttää >- ja -operaattoreita merkkijonojen vertailuun.<. Python выполнит лексикографическое сравнение строк на основе значений символов ASCII.

Vertailuoperaattoreita voidaan soveltaa Boolen arvoihin True ja False:

t = tosi
f = Väärin
print("t != f: ", t != f)
t != f: Totta

Huomaa ero =- ja ==-operaattoreiden välillä.

x = y # Tehtäväoperaattori. Asettaa tasa-arvon x:n ja y:n välille (eli antaa x:lle y:n arvon).
x == y # Vertailuoperaattori. Testaa x:n ja y:n välistä yhtäläisyyttä ja arvioi lausekkeen tosi tai epätosi. Lauseke on tosi, jos x ja y ovat yhtä suuret.

Loogiset operaattorit

Arvojen vertailuun käytetään kolmea loogista operaattoria, jotka pienentävät tuloksen loogiseksi arvoksi True tai False.

Loogiset operaattorit käytetään yleensä kahden tai useamman lausekkeen arvioimiseen. Niitä voidaan käyttää esimerkiksi ohjelmassa, joka tarkistaa:

• läpäisikö opiskelija kokeen?
• Ja Onko hän rekisteröity?

Jos molemmat arvot ovat tosia, opiskelija ylennetään seuraavalle kurssille.

Toinen esimerkki: loogisilla operaattoreilla varustettu ohjelma voi tarkistaa käyttäjien toiminnan verkkokaupassa:

• käyttikö hän kauppaluottoa
• tai onko hän tilannut tavaroita viimeisen 6 kuukauden aikana.

Kokeile esimerkiksi kolmen lausekkeen vertailua:

tulosta((9 > 7) ja (2< 4)) # Molemmat lausekkeet ovat tosi (tosi)
tulosta((8 == 8) tai (6 != 6)) # Yksi ilmauksista on tosi (tosi)
print(not(3<= 1)) # Ilmaus on väärä
Totta
Totta
Totta

Ensimmäisessä tapauksessa molemmat lausekkeet ovat tosi, joten ja-operaattori palauttaa True.

Toisessa tapauksessa vain arvo 8 == 8 on tosi. Koska ainakin yksi annetuista ehdoista on tosi, operaattori tai palauttaa True. ja-operaattori palauttaisi sitten False.

Kolmannessa tapauksessa lauseke 3<= 1 ложно. Оператор not изменяет полученное логическое значение на противоположное: not False = True.

Yritä nyt vertailla liukulukuja.

print((-0,2 > 1,4) ja (0,8< 3.1)) # Yksi lausekkeista on epätosi (False)
tulosta((7.5 == 8.9) tai (9.2 != 9.2)) # Molemmat lausekkeet ovat vääriä (False)
print(not(-5.7<= 0.3)) # Ilmaus on totta

• Koska ensimmäisessä esimerkissä yksi lausekkeista on epätosi ja palauttaa False. Operaattori ja arvioi lausekkeen todeksi vain, jos molemmat komponentit ovat tosi.
• Koska molemmat lausekkeet ovat epätosi, tai-operaattorin arvo on False.
• Koska ilmaus on totta, ei operaattori palauttaa False (ei True = False).

Huomautus: Jos et ymmärrä, miten tämä toimii, totuustaulukot auttavat sinua selvittämään sen. Käsittelemme tätä aihetta myöhemmin tässä oppaassa.

Loogiset operaattorit voidaan yhdistää yhdistelmälausekkeiksi:

not((-0.2 > 1.4) ja ((0.8< 3.1) or (0.1 == 0.1)))

Lauseke (0.8< 3.1) or (0.1 == 0.1) истинно, поскольку оба математических выражения, из которых оно состоит, истинны. Оператор or вернёт True.

Otettu vastaan Todellinen arvo tulee seuraavan lausekkeen komponentiksi: (-0.2 > 1.4) ja (tosi). Operaattori ja palauttaa arvon False, koska lauseke -0.2 > 1.4 on epätosi. (False) ja (True) = Väärin.

Totuustaulukot

Matemaattinen logiikka on erittäin hyödyllinen tietoalue ohjelmoinnissa. SISÄÄN tämä käsikirja Tutustumme sen pääpiirteisiin.

Alla on vertailuoperaattorin == ja kaikkien loogisten operaattoreiden totuustaulukot. Niitä voidaan käyttää loogisia lausekkeita kirjoitettaessa. Taulukot luettelo yleisiä tapauksia operaattorin käyttöä, joten on suositeltavaa opetella ne ulkoa.

Operaattorin totuustaulukko ==

JA operaattorin totuustaulukko

Operaattorin totuustaulukko TAI

NOT-operaattorin totuustaulukko

Totuustaulukot ovat yleisiä matemaattisia taulukoita, joita käytetään logiikassa. On hyödyllistä opetella ne ulkoa, jotta voit käyttää niitä algoritmien rakentamisessa ja ohjelmien kirjoittamisessa.

Loogisten operaattoreiden käyttö virran ohjaamiseen

Voit hallita ohjelman tuloksia ja tietovirtoja ehdolliset lausunnot(ehto) lausekkeineen (lauseke).

Ehdolliset lausunnot arvioivat todeksi tai epätosi.

Lauseke on koodilohko, joka tulee ehdollisen lauseen jälkeen ja määrittää ohjelman tuloksen.

Alla on koodilohko, joka näyttää, kuinka ehdollisia lauseita yhdistetään Python-ohjelman kulun ohjaamiseksi.

jos arvosana >= 65: # ehto
print("Hyväksytty arvosana") # lauseke
muu:
tulosta ("hylätty arvosana")

Tämä ohjelma arvioi jokaisen opiskelijan suorituksen ja määrittää, läpäisikö hän kokeen vai ei. Jos opiskelija esimerkiksi kirjoittaa luvun 83, ensimmäinen ehto tulee arvoksi Tosi ja ohjelma näyttää rivin:

Jos opiskelija sai 59 pistettä, ensimmäinen ehto on epätosi, joten ohjelma tulostaa.

• Käännös

Tämä artikkelin osa kattaa temppuja, joilla valitaan yksi kahdesta arvosta loogisen ehdon perusteella, mielivaltaisen määrän funktioargumenttien välittäminen ja vastaanottaminen sekä yleinen virhelähde - se, että funktion argumenttien oletusarvot ovat arvioida vain kerran.

4. Arvojen valinta

4.1. Oikea tapa

Python tukee versiosta 2.5 lähtien "value_if_true" -syntaksia jos testata muu arvo_jos_epätosi". Tällä tavalla voit valita kahdesta arvosta turvautumatta outoon syntaksiin ja yksityiskohtaisiin selityksiin:
testi = tosi # testi = Väärä tulos = "Testi on tosi" jos testi muuten "Testi on epätosi" # tulos = "Testi on tosi"
Valitettavasti se on silti vähän ruma. Voit myös käyttää useita näistä rakenteista yhdellä rivillä:
testi1 = Epätosi testi2 = Tosi tulos = "Testi1 on tosi" jos testi1 muuten "Testi1 on epätosi, testi2 on tosi" jos testi2 muuten "Testi1 ja testi2 ovat molemmat vääriä"
Ensimmäinen if/else suoritetaan ensin, ja jos testi1 = false, toinen if/else suoritetaan. Voit tehdä monimutkaisempia asioita, varsinkin jos käytät sulkeita.

Tämä menetelmä on melko uusi ja minulla on ristiriitaisia ​​tunteita siitä. Se on hyvä, puhdas muotoilu, pidän siitä... mutta se on silti ruma, varsinkin kun käytetään useita sisäkkäisiä rakenteita. Tietenkin kaikkien arvojen valitsemiseen liittyvien temppujen syntaksi on ruma. Minulla on pehmeä kohta alla olevalle ja/tai menetelmälle, mielestäni se on nyt intuitiivinen, ymmärrän nyt, kuinka se toimii. Lisäksi se ei ole vähemmän tehokas kuin "oikea" menetelmä.

Vaikka inline if/else on uusi, enemmän Oikea tapa, sinun tulee silti lukea seuraavat kohdat. Vaikka aiot käyttää Python 2.5:tä, näet nämä tekniikat vanhemmassa koodissa. Tietysti jos tarvitset taaksepäin yhteensopivuus, on itse asiassa parempi tarkistaa ne.

4.2. Temppu ja/tai

"ja" ja "tai" Pythonissa - monimutkaisia ​​olentoja. Ja soveltaminen useisiin lausekkeisiin ei vain palauta tosi tai epätosi. Se palauttaa ensimmäisen väärän lausekkeen tai viimeisen lausekkeen, jos ne ovat kaikki tosi. Tulos on odotetusti: jos kaikki lausekkeet ovat tosi, palautetaan viimeinen, joka on tosi; Jos yksi niistä on epätosi, se sekä palautetaan että muunnetaan epätosi-arvoksi loogisen arvon testauksen yhteydessä.

Vastaavasti tai-toiminto palauttaa ensimmäisen tosiarvon tai viimeisen, jos kumpikaan ei ole tosi.

Tämä ei auta, jos testaat vain lausekkeen loogista arvoa. Mutta voit käyttää ja ja tai muihin tarkoituksiin. Suosikkitapani on valita arvo tyylillä, joka muistuttaa C-teräistä operaattoria "test? value_if_true: value_if_false":
testi = tosi # testi = Väärä tulos = testi ja "Testi on tosi" tai "Testi on epätosi" # nyt tulos = "Testi on tosi"
Kuinka se toimii? Jos testi=true, ja-operaattori ohittaa sen ja palauttaa sille annetun toisen (viimeisen) arvon: "Testi on tosi" tai"Testi on väärä". Seuraava tai palauttaa ensimmäisen tosi lausekkeen, eli "Test is True".

Jos test=false ja palauttaa testin, se jättää testin tai"Testi on väärä". Koska test=false, tai ohittaa sen ja palauttaa toisen lausekkeen "Testi on epätosi".

Varoitus, ole varovainen keskiarvon ("if_true") kanssa. Jos se on epätosi, lauseke tai ohittaa sen aina ja palauttaa viimeisen arvon ("if_false") testin arvosta riippumatta.

Tämän menetelmän käytön jälkeen oikea tapa (osio 4.1) vaikuttaa minusta vähemmän intuitiiviselta. Jos et tarvitse taaksepäin yhteensopivuutta, kokeile molempia tapoja ja katso, mikä pidät eniten. Jos et osaa päättää, käytä oikeaa.

Tietenkin, jos tarvitset yhteensopivuutta aiemmat versiot Python, "oikea" tapa ei toimi. Tässä tapauksessa ja/tai - paras valinta useimmissa tilanteissa.

4.3. True/False indeksinä

Toinen tapa valita kahdesta arvosta on käyttää True ja False luettelon indekseinä ottaen huomioon, että False == 0 ja True == 1:
testi = tosi # testi = Väärä tulos = ["Testi on epätosi","testi on tosi"] # now result = "Testi on tosi"
Tämä menetelmä on rehellisempi, ja arvo_jos_tosi ei tarvitse olla totta. Hänellä kuitenkin on merkittävä haitta: Molemmat luetteloelementit arvioidaan ennen niiden tarkistamista. Jousille ja muille yksinkertaisia ​​elementtejä Se ei ole ongelma. Mutta jos jokainen niistä vaatii suuria laskelmia tai I/O-operaatioita, molempien lausekkeiden arviointia ei voida hyväksyä. Joten pidän parempana tavallista rakentamista tai ja/tai.

Huomaa myös, että tämä menetelmä toimii vain, jos olet varma, että testi on boolen arvo eikä jonkinlainen objekti. Muussa tapauksessa sinun on kirjoitettava bool(test) testin sijaan, jotta se toimisi oikein.

5. Toiminnot

5.1. Argumenttien oletusarvot arvioidaan vain kerran

Aloitetaan tämä osio varoituksella. Tämä ongelma on hämmentänyt monia ohjelmoijia monta kertaa, myös minua, vaikka tajusin ongelman. Oletusarvoja käyttämällä on helppo tehdä virhe:
def function(tuote, tavara = ): tavarat.append(tuote) tulosta tavarafunktio(1) # tulostaa ""-funktion(2) # tulostaa "" !!!
Argumenttien oletusarvot arvioidaan vain kerran, funktion määrittelyn aikana. Python yksinkertaisesti määrittää tämän arvon halutulle muuttujalle joka kerta, kun funktiota kutsutaan. Se ei kuitenkaan tarkista, onko tämä arvo muuttunut. Joten jos muutat sitä, muutos tulee voimaan tulevissa toiminnon kutsuissa. Edellisessä esimerkissä, kun lisäsimme arvon tavaraluetteloon, muutimme sen oletusarvoa pysyvästi. Kun kutsumme funktiota uudelleen odottaen oletusarvoa, saamme muuttuneen arvon.

Ratkaisu: Älä käytä muuttuvia objekteja oletusarvoina. Voit jättää kaiken ennalleen, jos et muuta niitä, mutta se on huono idea. Näin edellinen esimerkki olisi pitänyt kirjoittaa:
def function(tuote, tavara = Ei mitään): jos tavara on Ei mitään: tavaraa = tavaraa.append(item) print stuff function(1) # tulostaa "" function(2) # tulostaa "" odotetusti
Mikään ei ole muuttumaton (emme kuitenkaan yritä muuttaa sitä), joten olemme suojassa oletusarvon äkilliseltä muuttamiselta.

Toisaalta älykäs ohjelmoija saattaa muuttaa tämän temppuksi käyttää staattisia muuttujia, kuten C:ssä.

5.1.1. Pakotamme oletusarvot laskemaan joka kerta

Jos et halua lisätä tarpeetonta sotkua toimintokoodiisi, voit antaa tulkin laskea argumentin arvot uudelleen ennen jokaista kutsua. Seuraava sisustaja tekee tämän:
kopiosta import deepcopy def resetDefaults(f): oletukset = f.func_defaults def resetter(*args, **kwds): f.func_defaults = deepcopy(defaults) return f(*args, **kwds) resetter.__name__ = f. __name__ palauttaa resetterin
Käytä tätä koristelua toimintoon saadaksesi odotetut tulokset:
@resetDefaults # näin käytämme koristelun def-funktiota(tuote, tavara = ): stuff.append(item) print stuff function(1) # tulostaa ""-funktion(2) # tulostaa "" odotetusti

5.2. Muuttuva numero argumentteja

Python antaa sinun käyttää mielivaltaisen määrän argumentteja funktioissa. Ensin määritetään tarvittavat argumentit (jos sellaisia ​​on), sitten on määritettävä tähdellä varustettu muuttuja. Python antaa sille jäljellä olevien (nimeämättömien) argumenttien luettelon arvon:
def do_something(a, b, c, *argumentit): tulosta a, b, c, args do_something(1,2,3,4,5,6,7,8,9) # tulostaa "1, 2, 3, (4, 5, 6, 7, 8, 9)"
Miksi tämä on välttämätöntä? Esimerkiksi funktion tulee ottaa useita elementtejä ja tehdä niillä sama asia (esimerkiksi lisää). Voit pakottaa käyttäjän välittämään luettelon funktiolle: sum_all(). Tai voit sallia mielivaltaisen määrän argumentteja, jolloin saat enemmän puhdas koodi: summa_all(1,2,3).

Funktiolla voi myös olla muuttuva määrä nimettyjä argumentteja. Kun olet määrittänyt kaikki muut argumentit, määritä muuttuja "**":lla alussa. Python määrittää tälle muuttujalle sanakirjan vastaanotetuista nimetyistä argumenteista, pois lukien pakolliset:
def do_something_else(a, b, c, *args, **kwargs): tulosta a, b, c, args, kwargs do_something_else(1,2,3,4,5,6,7,8,9, aikakatkaisu=1.5 ) # tulostaa "1, 2, 3, (4, 5, 6, 7, 8, 9), ("aikakatkaisu": 1.5)"
Miksi tehdä tämä? Luulen, että yleisin syy on se, että funktio on toisen funktion (tai funktioiden) kääre, ja käyttämättömät nimetyt argumentit voidaan välittää toiselle funktiolle (katso osa 5.3).

5.2.1. Selvennys

Nimettyjen argumenttien ja mielivaltaisen määrän säännöllisiä argumentteja niiden jälkeen käyttäminen ei ilmeisesti ole mahdollista, koska nimetyt argumentit on määritettävä ennen "*"-parametria. Kuvittele esimerkiksi funktio:
def do_something(a, b, c, fact_print = True, *args): if fact_print: tulosta a, b, c, args
Meillä on ongelma: emme voi välittää fact_printiä nimettynä argumenttina, jos meidän on välitettävä useita nimeämättömiä argumentteja. Molemmat seuraavista vaihtoehdoista aiheuttavat virheen:
do_something(1, 2, 3, 4, 5, fact_print = True) # fact_print asetetaan ensin arvoon 4 (katso miksi?) ja sitten # ohitetaan, mikä aiheuttaa TypeErrorin ("sain useita arvoja avainsanaargumentille") do_something( 1, 2, 3, fact_print = True, 4, 5, 6) # Nimetyt argumentit eivät voi edeltää tavallisia argumentteja. SyntaxError tapahtuu. Ainoa tapa asettaa fact_print tässä tilanteessa on välittää se tavallisena argumenttina: do_something(1, 2, 3, True, 4, 5, 6) # tulos: "1, 2, 3, (4, 5, 6 )"
Ainoa tapa asettaa fact_print tässä tilanteessa on välittää se tavallisena argumenttina:
do_something(1, 2, 3, True, 4, 5, 6) # tulos: "1, 2, 3, (4, 5, 6)"

5.3. Listan tai sanakirjan välittäminen useana argumenttina

Koska voit vastaanottaa hyväksytyt argumentit luettelona tai sanakirjana, ei ole yllättävää, että voit välittää funktioargumentteja myös luettelosta tai sanakirjasta. Syntaksi on täsmälleen sama kuin edellisessä kappaleessa, sinun on laitettava tähti luettelon eteen:
args = pow(*args) # palauttaa pow(5,2), eli 25
Ja sanakirjaan (jota käytetään useammin) sinun on laitettava kaksi tähteä:
def do_something(actually_do_something=Tosi, print_a_bunch_of_numbers=False): if really_do_something: tulosta "Jotain on ollut done" # if print_a_bunch_of_numbers: print range(10) kwargs = ("todella_do_something": Totta, "print_a_bunch_of_numbers": True) do_something(**kwargs) # tulostaa "Jotain on tehty", sitten ""
Historiallinen huomautus: Pythonissa ennen versiota 2.3, sisäänrakennettu soveltaa toimintoa(funktio, arg_list, keyword_arg_dict)".

Operaattorit ovat rakenteita, jotka voivat manipuloida operandien arvoa. Tarkastellaan lauseketta 4 + 5 = 9. Tässä 4 ja 5 kutsutaan operandiksi ja + kutsutaan operaattoriksi.

Operaattorityypit

Python kieli tukee seuraavat tyypit operaattorit:

• Aritmeettiset operaattorit
• Vertailu (relaatio)operaattorit
• Tehtäväoperaattorit
• Loogiset operaattorit
• Bittioperaattorit
• Jäsenoperaattorit
• Tunnistusoperaattorit

Tarkastellaan kaikkia operaattoreita yksitellen.

Aritmeettiset operaattorit Pythonissa

A arvo on 10 ja muuttuja b sisältää arvon 21, niin:

operaattori	Kuvaus	esimerkki
+ Lisäys	Arvojen lisääminen operaattorin kummallekin puolelle.	a + b = 31
– Vähennys	Vähentää oikean operandin vasemmasta operaandista.	a - b = -11
* Kertominen	Arvon kertominen operaattorin kummallakin puolella	a * b = 210
/ Division	Jakaa vasemman operandin oikealla	b/a = 2,1
% moduuli	Jakaa vasemman operandin oikealla ja palauttaa jäännöksen	b % a = 1
** Näytteilleasettaja	Suorittaa eksponentiaalisen laskennan operaattoreille	a**b = 10 luvun 20 potenssiin
// jako pyöristyksellä	Floor Division - Operandien jako, jossa tulos on kerroin, jossa desimaalipilkun jälkeinen numero poistetaan. Mutta jos yksi operandeista on negatiivinen, niin tulos pyöristetään, ts. pyöristetty nollasta poispäin (suhteessa negatiiviseen äärettömyyteen):	9 // 2 = 4 ja 9,0 // 2,0 = 4,0, -11 // 3 = -4, -11,0 // 3 = -4,0

Vertailuoperaattorit Pythonissa

Operaattorit vertailevat molemmin puolin olevia arvoja ja päättävät niiden välisen suhteen. Niitä kutsutaan myös relaatiooperaattoreiksi.

Oletetaan muuttuja A sisältää arvon 10 ja muuttujan b jonka arvo on 20, niin:

operaattori	Kuvaus	esimerkki
==	Jos molempien operandien arvot ovat yhtä suuret, ehdosta tulee tosi.	(a == b) ei ole oikein.
!=	Jos kahden operandin arvot eivät ole samat, ehdosta tulee tosi.	(a! = b) totta.
>	Jos vasemman operandin arvo suurempi arvo oikea operandi, ehdosta tulee totta.	(a > b) ei ole oikein.
<	Jos vasemman operaandin arvo on pienempi kuin oikean operandin arvo, ehdosta tulee tosi.	(A< б) истинно.
> =	Jos vasemman operandin arvo on suurempi tai yhtä suuri kuin oikean operandin arvo, ehdosta tulee tosi.	(a >= b) ei ole oikein.
<=	Jos vasemman operandin arvo on pienempi tai yhtä suuri kuin oikean operaandin arvo, ehdosta tulee tosi.	(A<= б) истинно.

Tehtäväoperaattorit Pythonissa

Oletetaan, että muuttuja sisältää A arvo on 10 ja muuttuja b jonka arvo on 20, niin:

operaattori	Kuvaus	esimerkki
=	Määrittää arvot operandien oikealla puolella operandin vasemmalle puolelle	c = a + b määrittää a + b:n arvon c:lle
+ = Lisää ja	Lisää oikean operandin vasempaan operandiin ja määrittää tuloksen vasemmalle operandille	c + = a vastaa c = c + a
– = vähennä ja	Vähentää oikean operandin vasemmasta operaandista ja määrittää tuloksen vasemmalle operandille	c – = a vastaa c = c – a
* = kerro ja	Kertoo oikean operandin vasemmalla operandilla ja määrittää tuloksen vasemmalle operandille	c * = a vastaa c = c * a
/ = jaa ja	Jakaa vasemman operandin oikealla operandilla ja määrittää vasemman operandin tuloksen	c / = a vastaa c = c / ac /= a vastaa c = c / a
% = Moduuli ja	Ottaa moduulin kahdella operandilla ja määrittää vasemman operandin tuloksen	c% = a vastaa c = c % a
** = Eksponentti ja	Laskee operaattoreiden eksponentin ja antaa arvon vasemmalle operandille	c** = a vastaa c = c**a
// = Floor Division	Suorittaa operaattorijaon pyöristyksellä ja määrittää arvon vasemmalle operandille	c // = a vastaa c = c // a

Bittioperaattorit Pythonissa

Bittioperaattorit käsittelevät bittejä ja suorittavat operaatioita bitti kerrallaan. Oletetaan, jos a = 60; ja b = 13; Tällä hetkellä binäärimuodossa ne näyttäisivät tältä:

—————–

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

Pythonin sisäänrakennettua bin()-funktiota voidaan käyttää kokonaisluvun binääriesityksen saamiseksi.

Python tukee seuraavia Bitwise-operaattoreita:

Operaattori	Kuvaus	Esimerkki
& binääri JA	bittioperaattorin kopiot, jolloin tuloksena on, jos niitä on molemmissa operandeissa	(a & b) (0000 tarkoittaa 1100)
| binääri TAI	kopioi hieman, jos se on jossakin operandissa.	(a | b) = 61 (tarkoittaa 0011 1101)
^ binary Exclusive or	kopioi hieman, jos se on asetettu yhteen operandiin, mutta ei molempiin.	(a^b) = 49 (tarkoittaa 0011 0001)
~ Binäärikomplementti	Tämä on epäyhtenäistä ja sillä on "kääntävän" bitin vaikutus.	(~a) = -61 (muodossa tarkoittaa 1100 0011:n kaksoiskomplementtia etumerkillisen binääriluvun vuoksi.
<< Двоичный сдвиг влево	Vasemman operandin arvoa siirretään vasemmalle oikean operaandin määrittämän bittimäärän verran.	A<< = 240 (1111 означает 0000)
>> Binäärisiirto oikealle	Vasemman operandin arvoa siirretään oikealle oikean operandin määrittämän bittimäärän verran.	a >> = 15 (0000 tarkoittaa 1111)

Loogiset operaattorit Pythonissa

Python tukee seuraavia Boolen operaattoreita. Oletetaan, että muuttuja on kelvollinen ja muuttuja b on väärä, niin:

Jäsenoperaattorit Pythonissa

Jäsenyystestauslausekkeiden tila sarjoissa, kuten merkkijonoissa, listoissa tai monikoissa. Jäsenoperaattoreita on kaksi, kuten alla selitetään:

Identiteettioperaattorit Pythonissa

Tunnistusoperaattorit vertaavat kahden objektin muistipaikkoja. On olemassa kaksi tunnistusoperaattoria, kuten alla selitetään:

Ensisijaiset operaattorit Pythonissa

Seuraavassa taulukossa luetellaan kaikki operaattorit korkeimmasta alimpaan prioriteettiin.

Sarjanumero	Operaattori ja kuvaus
1	** Eksponentiointi (voiman lisääminen)
2	~ + – Täydennys, yksipuolinen plus ja miinus (kahdelle viimeiselle menetelmän nimet ovat +@ ja -@)
3	* / % // Kerto-, modulo-jako ja jakojäännös
4	+ – Yhteen-ja vähennyslasku
5	>> << Oikea ja vasen bittisiirto
6	& Bittikohtainen "AND"
7	^ | Bittikohtaisesti poissulkeva OR ja tavallinen OR
8	<= <>> = vertailuoperaattoreita
9	<> ==! = tasa-arvotoimijat
10	= %= /= //= -= += *= **= toimeksiantojen operaattorit
11	ei ole tunnistusoperaattorit
12	sisään ei sisään jäsentoimijat
13	ei tai ja Loogiset operaattorit

Usein tosielämässä hyväksymme väitteen tai kiellämme sen. Jos he esimerkiksi kertovat sinulle, että lukujen 3 ja 5 summa on suurempi kuin 7, olet samaa mieltä ja sano: "Kyllä, se on totta." Jos joku väittää, että kolmen ja viiden summa on pienempi kuin seitsemän, pidät tällaista väitettä vääränä.

Tällaiset lauseet ehdottavat vain kahta vastausvaihtoehtoa - joko "kyllä", kun väite arvioidaan todeksi, tai "ei", kun väite arvioidaan virheelliseksi, vääräksi. Ohjelmoinnissa ja matematiikassa, jos lausekkeen arvioinnin tulos voi olla vain tosi tai epätosi, niin tällaista lauseketta kutsutaan loogiseksi.

Esimerkiksi lauseke 4 > 5 on looginen lauseke, koska sen tulos on joko tosi tai epätosi. Lauseke 4 + 5 ei ole looginen lauseke, koska sen tulos on luku.

Edellisellä oppitunnilla tutustuimme kolmeen tietotyyppiin - kokonais- ja reaalilukuihin sekä merkkijonoihin. Tänään esittelemme neljännen - boolen tyyppi tiedot (bool tyyppi). Sitä kutsutaan myös Boolen. Tällä miehellä on vain kaksi mahdollisia arvoja: Totta(tosi) ja Väärä(valehdella).

>>> a = Totta >>> kirjoita (a) >>> b = Väärin >>> tyyppi (b)

Tässä muuttujalle a määritettiin arvo True, jonka jälkeen sisäänrakennettua Python-funktiot type() tarkistaa tyyppinsä. Tulkki kertoi, että näin on luokan muuttuja bool. Käsitteet "luokka" ja "tietotyyppi" sisällä tässä tapauksessa sama. Muuttuja b liittyy myös loogiseen arvoon.

Ohjelmoinnissa False rinnastetaan yleensä nollaan ja True ykköseksi. Varmistaaksesi tämän, voit muuntaa loogisen arvon muotoon kokonaislukutyyppi:

>>> int (tosi) 1 >>> int (väärä) 0

Myös päinvastainen on mahdollista. Voit muuntaa minkä tahansa arvon boolen tyypiksi:

>>> bool (3.4) Totta >>> bool (-150 ) Totta >>>bool(0) Väärä >>> bool(" ") Totta >>> bool ("" ) Väärä

Ja sääntö toimii tässä: kaikki mikä ei ole 0 tai tyhjyys on totta.

Loogiset operaattorit

Luonnollisella kielellä (esimerkiksi venäjäksi) puhuttaessa vertaamme sanoja "yhtä", "enemmän", "vähemmän". Ohjelmointikielet käyttävät erikoismerkkejä vastaavista aiheista, joita käytetään matematiikassa: > (lisää),< (меньше), >= (suurempi tai yhtä suuri kuin),<= (меньше или равно), == (равно), != (не равно).

Älä sekoita arvon määrittämistä muuttujalle, joka on merkitty Python kieli yksi yhtäsuuruusmerkki ja vertailuoperaatio (kaksi yhtäläisyysmerkkiä). Tehtävä ja vertailu ovat eri toimintoja.

>>> a = 10 >>> b = 5 >>> a + b > 14 Totta >>>a< 14 - b Väärä >>>a<= b + 5 Totta >>> a != b Totta >>> a == b Väärä >>> c = a == b >>> a, b, c(10, 5, väärä)

SISÄÄN tässä esimerkissä ilmaisu c = a == b koostuu kahdesta osalausekkeesta. Ensin suoritetaan muuttujien a ja b vertailu (==). Loogisen operaation tulos annetaan sitten muuttujalle c. Ilmaisu a ,b,c yksinkertaisesti näyttää muuttujien arvot näytöllä.

Monimutkaiset loogiset lausekkeet

Boolen lausekkeet, kuten kByte >= 1023, ovat yksinkertaisia, koska ne suorittavat vain yhden loogisen toiminnon. Käytännössä kuitenkin usein tarvitaan monimutkaisempia ilmaisuja. Saatat haluta saada "kyllä" tai "ei" vastauksen riippuen kahden yksinkertaisen lausekkeen tuloksesta. Esimerkiksi "ulkona sataa lunta tai sataa", "uutismuuttuja on suurempi kuin 12 ja alle 20".

Tällaisissa tapauksissa käytä erikoisoperaattoreita, joka yhdistää kaksi tai useampia yksinkertaisia ​​loogisia lausekkeita. Kaksi operaattoria on laajalti käytössä - niin sanottu looginen AND ( ja) ja tai ( tai).

ja, on välttämätöntä, että molempien yksinkertaisten lausekkeiden tulokset yhdistävät tämä operaattori, olivat totta. Jos vähintään yhdessä tapauksessa tulos on epätosi, koko kompleksilauseke on epätosi.

Saadaksesi True operaattoria käytettäessä tai, on välttämätöntä, että ainakin yhden kompleksiseen lausekkeeseen sisältyvän yksinkertaisen lausekkeen tulos on tosi. Operaattorin tapauksessa tai monimutkaisesta lausekkeesta tulee epätosi vain, kun molemmat sen muodostavat yksinkertaiset lausekkeet ovat vääriä.

Oletetaan, että muuttujalle x annettiin arvo 8 (x = 8), muuttujalle y annettiin arvo 13 (y = 13). Boolen lauseke y< 15 and x >8 suoritetaan seuraavasti. Lauseke y suoritetaan ensin< 15 . Его результатом будет True. Затем выполнится выражение x >8. Sen tulos on false. Lauseke pienennetään sitten arvoon True and False , mikä palauttaa False.

>>> x = 8 >>> y = 13 >>>y< 15 and x > 8 Väärä

Jos kirjoitamme lausekkeen näin: x > 8 ja y< 15 , то оно также вернуло бы False. Однако сравнение y < 15 не выполнялось бы интерпретатором, так как его незачем выполнять. Ведь первое простое логическое выражение (x >8) on jo palauttanut arvon false, mikä ja-operaattorin tapauksessa muuttaa koko lausekkeen epätosi.

Operaattorin tai tapauksessa toinen yksinkertainen lauseke testataan, jos ensimmäinen palauttaa epätosi, eikä sitä testata, jos ensimmäinen palauttaa jo tosi. Koska koko lausekkeen totuuteen riittää yksi True, riippumatta siitä, kummalla puolella se on.

>>>y< 15 or x > 8 Totta

Pythonissa on myös yksipuolinen looginen operaattori ei, eli kieltäminen. Hän muuttaa totuuden valheiksi ja valheet totuudeksi. Se on unaarinen, koska se koskee yhtä lauseketta sen jälkeen, ei sen oikealla ja vasemmalla puolella, kuten binäärin ja ja tai tapauksessa.