Ohjelmoinnin peruskurssien laaja oppimäärä

Ohjelmoinnin peruskurssien laaja oppimäärä Luento 10: Skriptausta, aliohjelmat, foreign function interface, Pythonin ominaisuuksia Riku Saikkonen (osa kalvoista on suoraan ei-laajan kurssin luennoista) 4. 4. 2012

Sisältö 1 Säännölliset lausekkeet 2 Aliohjelmien käyttäminen 3 Kielten sekoittaminen: foreign function interface 4 Pythonin propertyt ja dekoraattorit 5 Pythonin listaoperaatiot ja list comprehension -syntaksi

Säännölliset lausekkeet säännöllinen lauseke (regular expression) on tapa kuvata hahmo, joka sopii tietynlaisiin merkkijonoihin esim. ab*c sopii merkkijonoihin ac, abc, abbc, jne. näitä käytetään tekstimuotoisen datan käsittelyssä esim. tunnistamaan tietynlaisia rivejä tai jakamaan rivi osiin niille on tukea melkein kaikissa ohjelmointikielissä skriptikielissä (varsinkin Perl) niille on lyhyempi syntaksi ja niitä käytetään enemmän valitettavasti lausekkeiden syntaksi vaihtelee hieman eri kielissä samoin monissa (ohjelmointi-)editoreissa sekä ohjelmien konguraatiotiedostoissa ja mm. grep-komentorivityökalussa editoreissa haku- ja korvaustoimintojen lisäksi mm. syntaksin väritys tehdään useimmiten säännöllisillä lausekkeilla säännöllisillä lausekkeilla ei voi tunnistaa kaikkea yleensä ei rekursiivisia rakenteita esim. ohjelmointikielistä avainsanoja mutta ei sisäkkäisyyttä

Säännöllisten lausekkeiden syntaksi useimmiten säännöllisiä lausekkeita käytetään hakemiseen lauseke kuvaa osaa etsittävästä tekstistä (usein rivistä) kirjaimet jne. tavalliset merkit sopivat itseensä esim. ab sopii vain merkkijonoon ab Yleisimmät erikoismerkinnät. mikä tahansa yksi merkki [a-f] yksi kirjaimista a,b,c,d,e,f [^a-f] mikä tahansa paitsi a,b,c,d,e,f * edellinen lausekkeen osa 0 kertaa + edellinen lausekkeen osa 1 kertaa? edellinen lausekkeen osa 0 tai 1 kertaa \? merkki? (samoin \*, \. jne.) ^ tämä kohta on rivin alussa $ tämä kohta on rivin lopussa {2,4} edellinen lausekkeen osa 24 kertaa (foo bar) joko hahmo foo tai bar (tämän syntaksi vaihtelee hieman)

Esimerkkejä syntaksista Esimerkkilausekkeita [a-z]*=[0-9]* sopii esim. width=42 ^[a-za-z]+ *= *[0-9]+$ myös width = 42 ^def *[a-za-z]+$object$: def Box(object): (data/)?[a-z]+\.txt data/koe.txt ja koe.txt syntaksi vaihtelee hieman eri toteutuksissa huom. säännöllinen lauseke on eri asia kuin komentotulkin tiedostonimihahmot! (eli ns. glob-hahmot) siellä? = mikä tahansa merkki, * = 0 mitä tahansa merkkiä esim. foo/*.txt eikä foo/.*\.txt

Tekstin korvaaminen skripteissä säännöllisiä lausekkeita käytetään usein tekstin korvaamiseen tai osien irrottamiseen korvaavassa tekstissä voi viitata suluilla merkittyihin säännöllisen lausekkeen osiin (usein \1 on ensimmäinen osa jne.) esim. hahmossa ^([a-za-z]+) *= *([0-9]+)$ ja tekstissä width = 42 ensimmäinen osa on width ja toinen 42 esim. Perlissä width = 42:n voisi muuttaa muotoon set width to 42 Perl-lausekkeella s/^([a-za-z]+) *= *([0-9]+)$/set \1 to \2/ (syntaksi on s/ säännöllinen lauseke / korvaava teksti /) korvaamisen sijaan suluilla merkityt osat voi ottaa talteen muuttujiin

Säännölliset lausekkeet Pythonissa Pythonin re-paketissa on säännöllisten lausekkeiden käsittelyä: säännöllisiä lausekkeita voi hakea merkkijonoista funktioilla re.match (sopiiko alkuun), re.search (etsii mistä tahansa), re.findall ja re.finditer (löytävät kaikki esiintymät) re.split jakaa merkkijonon osiin, re.sub korvaa tekstiä toisella jos käyttää saamaa säännöllistä lauseketta paljon, re.compile:lla voi kääntää sen tehokkaampaan muotoon ohje: http://docs.python.org/howto/regex.html Esimerkkejä Python-tulkissa >>> import re >>> re.search("[a-z]*=[0-9]*", "abcde") # palauttaa None >>> re.search("[a-z]*=[0-9]*", " width=42asdf").group() 'width=42' >>> re.search("([a-z]*)=([0-9]*)", "width=42").group(2) '42' >>> re.split("[,.]? *", "Foo, bar ja baz.") ['Foo', 'bar', 'ja', 'baz', ''] >>> re.sub("^([a-za-z]+) *= *([0-9]+)$", "set \\1 to \\2", "width =42") 'set width to 42'

Aliohjelmat jotkut ohjelmat käynnistävät toisia ohjelmia aliohjelminaan syitä aliohjelmien käyttämiseen: valmiissa ohjelmassa on jo haluttu toiminto (joskus tosin olisi myös vastaava kirjasto) aliohjelmaa voi testata kokonaan erillään pääohjelmasta helppo tapa käyttää eri ohjelmointikieliä yhdessä helppo tapa tehdä rinnakkaisuutta aliohjelman voi hajauttaa eri koneelle (toisin kuin säikeen) useimmiten aliohjelma tekee jonkin selkeästi rajatun toiminnon tarkemmin rajatun kuin useimmmat kirjastot pää- ja aliohjelman välisen kommunikoinnin kannattaa olla yksinkertaista esimerkkejä: kuvatiedostoja voi skaalata ja konvertoida eri formaattiin ImageMagick-komentorivityökaluilla (tähän olisi kirjastojakin) jotkut selaimet tekevät nimipalvelukyselyt aliohjelmalla monet WWW-palvelimet ajavat sivuja tuottavaa koodia omissa aliohjelmissaan

Aliohjelman käynnistäminen Pythonissa aja komento ja odota että se loppuu: subprocess.call(['lp', 'foo.pdf']) aja komento taustalla: p = subprocess.popen(['sleep', '10'])... p.wait() aja komento ja lue sen syöte: out = subprocess.popen(['ls', '-l'], stdout=subprocess.pipe).communicate() aja komento ja kirjoita sille syötettä: p = subprocess.popen('gzip -c >x.txt.gz', stdin=subprocess.pipe, shell=true) p.communicate(inputstr) todellisuudessa pitää myös mm. tarkistaa paluuarvo ohje: http://docs.python.org/library/subprocess.html muissa kielissä nämä ovat usein nimellä system ja popen C:stä ja Unixin toiminnoista ks. http://www.gnu.org/ software/libc/manual/html_node/processes.html

(Ali)ohjelman kommunikointitavat 1/2 kaikilla käynnistetyillä ohjelmilla eli prosesseilla on: syötevirta (standard input, stdin = 0) tulostevirta (standard output, stdout = 1) virhetulostevirta (standard error, stderr = 2) paluuarvo lopettaessa (exit code, kokonaisluku 0127) prosessille voi lähettää signaalin (kokonaisluku noin 131) virtoja voi olla enemmänkin alla oleva toteutus: jätetään tiedostoja auki kun pääohjelma jakautuu pää- ja aliohjelmaksi useimmiten aliohjelman kanssa kommunikoidaan syöte- ja tulostevirroilla sekä paluuarvolla hyvin käyttäytyvä (ali)ohjelma kirjoittaa virheilmoituksensa stderr:iin eikä stdout:iin paluuarvo on yleensä 0 jos kaikki sujui hyvin virroilla voi tehdä kaksisuuntaista interaktiivisessa kommunikointia, mutta pitää muistaa puskurointi

(Ali)ohjelman kommunikointitavat 2/2 aliohjelman käynnistänyt ohjelma saa tiedon aliohjelman loppumisesta toteutettu signaalilla sekä wait-kutsulla joka saa paluuarvon Pythonissa subprocess.popen:n palauttaman olion wait-metodi odottaa aliohjelman loppumista poll-metodi kertoo, onko aliohjelma vielä hengissä send_signal-metodi lähettää aliohjelmalle signaalin Pythonin signal-moduulilla voi käsitellä saatuja signaaleja esimerkkejä aliohjelmien käytöstä: inkscape-0.47.0/share/extensions/perspective.py epydoc-3.0.1/epydoc/cli.py ja util.py

Erilliset ohjelmat joskus ohjelmat kommunikoivat keskenään ilman että pääohjelma on käynnistänyt aliohjelman erona edelliseen pitää löytää toinen ohjelma ja muodostaa yhteys kommunikointia varten usein käytetään joko verkkoyhteyksiä tai koneen sisäisiä yhteyksiä (esim. Unix domain socket) tai esim. käyttöliittymäkirjaston/työpöytäympäristön palveluita joskus myös käynnistää toinen ohjelma tarvittaessa käyttöjärjestelmissä on palveluita, jotka käynnistävät sellaisia pyydettäessä (Linuxissa esim. inetd ja D-Bus)

Foreign function interface melkein kaikissa ohjelmointikielissä on tapa liittää samaan ohjelmaan toisen kielen koodia melkein aina C/C++-kielien kautta esim. Python-ohjelma kutsuu C-funktiota tai C-funktio kutsuu Python-koodia myös esim. käyttöjärjestelmän C:llä tehtyjä kirjastoja kutsutaan samaan tapaan kuin omaa C-koodia useimmiten esim. Pythonilla tehty pääohjelma kutsuu yksittäisiä C-funktioita toisen kielen rajapinta C:n käyttöön on nimeltään foreign function interface (FFI) poikkeus: muutamat kielet sopivat yhteen suoremmin esim. C ja C++ sekä Java ja muut Javan virtuaalikonetta käyttävät kielet

Argumentit ja paluuarvot 1/2 suurin vaikeus kielten yhteiskäytössä on argumenttien välitys esim. toisen kielen merkkijono ei ole sama kuin C:n merkkijono samoin paluuarvot tapa 1: C:n tyypit toisessa kielessä natiivien arvojen lisäksi kielessä voi tehdä C-kielisiä arvoja yleensä niillä voi tehdä paljon vähemmän kuin natiiveilla arvoilla: tarkoitettu lähinnä C-funktioiden käyttöön esim. Pythonin ctypes-moduulin ctypes.c_int(42) tekee C-kokonaisluvun tapa 2: toisen kielen tyypit C:ssä C-kielinen koodi näkee toisen kielen arvoja (yleensä osoittimia, joita käsitellään tietyillä C-funktioilla) tässä mitä tahansa C-koodia ei voi kutsua suoraan: vain sellaista, joka ymmärtää näitä toisen kielen tyyppejä useimmiten kutsuttavat C-funktiot tekevät tyyppimuunnoksia ja lopulta kutsuvat tavallisia C-funktioita

Argumentit ja paluuarvot 2/2 tapa 3: automaattiset tyyppikonversiot kuten tapa 1, mutta C-kielen arvoja ei käsitellä erikseen, vaan kerrotaan vain C-funktioiden tyypit ja toisen kielen toteutus tekee konversiot taustalla tätä on usein helppo käyttää ongelmia: osaa yleensä konvertoida vain tiettyjä tyyppejä; joskus tekee turhaa konversiotyötä yleensä kielissä on ainakin tapa 1, usein kaikki kolmekin esimerkkejä FFI:n käytöstä Pythonissa: tapa 1: python2.6-2.6.6/lib/uuid.py tapa 2: pygame-1.8.1release/src/key.c

Kielten yhteiskäytön hankaluuksia useimmiten kielten tyyppien väliset muunnokset aiheuttavat kopiointia esim. taulukosta joudutaan usein tekemään kopio monimutkaisten tyyppien muuntaminen on hankalaa mm. oliot, funktiot ja kokoelmatyypit (esim. dict) yleensä joko muunnos pitää tehdä käsin tai automaattisessa muunnoksessa ei näy kaikkea (esim. metodeja) tai toimii vain tietynlaisille arvoille (esim. taulukko jonka kaikki alkiot ovat samantyyppisiä) muistinhallinta pitää yleensä tehdä käsin eli C-koodin pitää itse vapauttaa varaamansa muisti paitsi jos tekee toisen kielen arvoja (tapa 2 edellä) rinnakkaisuus on hankalaa tai huonosti määritelty ei kannata muuttaa samaa dataa eri säikeestä ja eri kielestä

Käytännön ohjeita koska argumentit yleensä kopioidaan, kannattaa tarkistaa että niissä on vain tarvittava data funktioargumentteja kannattanee välttää, vaikka ne useimmiten periaatteessa toimivat kannattaa pitää kielten välinen rajapinta mahdollisimman selkeänä ja yksinkertaisena jos tekee C-koodin itse, koodista tulee selkeämpää jos pyrkii tekemään yleiskäyttöisen C-kirjaston eikä tee C-koodia tarkasti toisen kielen koodin ehdoilla tyypillisimmin FFI:tä käytetään kutsumaan jo olemassaolevaa C:llä tehtyä kirjastoa kannattaa pyrkiä yhdistämään toinen kieli C:hen ei siis esim. yhdistää Pythonia ja Schemeä samaan ohjelmaan sillä se on hankalampaa (vaikka periaatteessa mahdollista) varsinkin tähän aliohjelmien käyttäminen on helpompi ratkaisu

Toinen tapa: sulautettu tulkki toinen tapa FFI:n sijaan: esim. C:llä tehty ohjelma voi sisältää Python-tulkin, jolla se ajaa Python-koodia eli toisen kielen tulkki on sulautettuna (embedded) ohjelmaan näin päin tehdään yleensä jos toista kieltä käytetään ohjelman laajentamiseen tai kongurointiin yleisimpiä sulautettavia kieliä: Scheme (osa toteutuksista toimii paremmin), Python ja Perl peleissä Lua (helppo sulauttaa) selaimissa JavaScript (tarvitaan muutenkin) joskus sovelluksen oma kieli (esim. Emacs Lisp) käytetään esim. tukemaan toisilla kielillä tehtyjä plugineja selaimia voi usein laajentaa JavaScriptilla Gimp-kuvankäsittelyohjelmaa voi laajentaa Schemellä, Pythonilla tai Perlillä Gnomen Hearts-pelin teköälyjä voi tehdä Pythonilla (ennen Lua)

(ei-laajan kurssin kalvo: luento 13 sivu 9) property Eli miten saada olion muuttujien käsittely saadaan näyttämään siltä, että niitä käytetään suoraan ilman metodeja. Käsiteltävä muuttuja class C(object): def init (self): self._x = None def getx(self): return self._x def setx(self, value): self._x = value def delx(self): Property:n docstring del self._x x = property(getx, setx, delx, "I'm the 'x' property.") new_object = C() new_object.x = 3 print new_object.x Varsinainen muuttuja kannattaa suojata _:lla Metodit arvon hakuun, asettamiseen ja poistoon. Järjestys on aina: haku, asetus, poisto. Muuttujan sijainti lauseessa määrää, mitä funktiota tulkki käyttää 14:45

(ei-laajan kurssin kalvo: luento 5 sivu 25) Propertyn avulla koodia voi yksinkertaistaa Metodeja kutsutaan kuin muuttujia Käsitellään muuttujaa x Kerrotaan property-funktiolle sen metodin nimi, jolla x:n arvo haetaan(get) ja sen, jolla asetetaan x:n arvo(set) Tulkki päättelee x sijainnin perusteella pitääkö käyttää asetus- vai hakumetodia =:n vasemmalla puolella tarvitaan tietenkin sijoitus Tulostuksessa haku Jne. class Example(object): def init (self): self._x = None def get_x(self): return self._x def set_x(self, value): self._x = value x = property(get_x, set_x) some = Example() some.x = 5 print some.x 14:58

(ei-laajan kurssin kalvo: luento 13 sivu 15) decorator Decorator Pythonissa tarkoittaa lyhyempää tapaa esittää tilanne, jossa muutetaan funktion toimintaa (eli periaatteessa sitä mitä decorator-malli tarkoittaa). def decorator_function(called): called.message = 'Change in the functionality' return called @decorator_function def adding(a,b): return a + b print adding(1, 2), print adding_copy.message def adding(a,b): return a + b target = decorator_function(adding) print target(1, 2), print target.message @-merkin jälkeen tulee funktion nimi. Tämä funktio saa parametrinaan @-merkin alapuolella olevalta riviltä alkavan funktion olion, jonka toimintaa se sitten muuttaa 14:45

(ei-laajan kurssin kalvo: luento 13 sivu 16) decorator Pythonissa on kaksi valmista funktiota, joita voi käyttää decorator-rakenteen yhteydessä. * staticmethod muuttaa metodin toimintaa niin, että sitä voi kutsun jo ennen kuin sen luokasta on luotu oliota. * classmethod taas tekee metodista luokkametodin, eli metodin, joka on yhteinen kaikille luokasta luoduille olioille. @staticmethod ## we can now call this method without an instance def column_char_to_integer(column): ''' Converts the letters a,b,c,d,e,f,g,h to positions 0-7. @param row the character representation of a column. @return the integer representation. ''' return ord(column) - ord('a') 14:45

(ei-laajan kurssin kalvo: luento 3 sivu 19) Regexp Aliohjelmat FFI Dekoraattorit Listaoperaatiot Abstrakti luokka (esimerkki) LibraryItem abstraktina luokkana Kaikissa siitä periytyvissä luokissa oltava metodit init ja is_available() Lehdet taas eivät kaikki ole lainattavissa, joten DailyPaper abstraktiksi import abc class LibraryItem(object): metaclass = abc.abcmeta @abc.abstractmethod def init (self, author_list,...):... class DailyPaper(LibraryItem): metaclass = abc.abcmeta @abc.abstractmethod def init (self, name, year,...): LibraryItem. init (self,...)... def get_number(self): return self.number def is_available(self): pass class Book(LibraryItem): def get_authors(self): return self.author_list... @abc.abstractmethod def is_available(self): '''Method docstring. ''' def init (self, author_list,...): LibraryItem. init (self,...)... def is_available(self): if self.due_date: return False else: return True 10:31

Property-dekoraattorit Toinen versio aiemmasta esimerkistä class Example(object): def init (self): self._x = None @property def x(self): return self._x @x.setter def x(self, value): self._x = value siis property toimii dekoraattorina, joka tekee getter-metodin x.setter on dekoraattori, joka vaihtaa x:n setter-metodin dekoraattoreita voi tehdä melko helposti itsekin muuhunkin käyttöön kuin getter- ja setter-metodeihin esimerkkejä: http://wiki.python.org/moin/pythondecoratorlibrary muissa kielissä samantapaisia rakenteita ovat Emacs Lispin defadvice ja Common Lispin oliojärjestelmän around-metodit

(ei-laajan kurssin kalvo: luento 13 sivu 10) map def increment(value): return value + 1 def decrement(value): return value - 1 test_list = [1,2,3,4,5] print map(increment, test_list) print map(decrement, test_list) Soveltaa annettua funktiota jokaiseen läpikäytävän olion alkioon ja palauttaa tuloksena listan [2, 3, 4, 5, 6] Parametrina voi antaa useammankin läpikäytävän, jolloin funktion pitää hyväksyä yhtä monta parametria ja jokaisesta läpikäytävästä otetaan vastaava alkio. zip liittää yhteen parametrina saamiensa sarja- tai iteroitavatyyppisten läpikäytävien alkiot monikoiksi listaan l1 = [1, 2, 3] l2 = [4, 5, 6] print zip(l1, l2) [(1, 4), (2, 5), (3, 6)] def fahrenheit(t): return ((float(9) / 5) * T + 32) def celsius(t): return (float(5) / 9) * (T - 32) temp = (36.5, 37, 37.5,39) F = map(fahrenheit, temp) C = map(celsius, F) for f, c in zip(f, C): print f, c 14:45

(ei-laajan kurssin kalvo: luento 13 sivu 11) filter Nimensä mukaisesti suodatin. Annettua funktiota sovelletaan jokaiseen annetun läpikäytävän alkioon alkio päätyy tuloslistaan, jos funktio palauttaa True. limit = 20 def is_prime(number): if number in [0, 1]: return False if number == 2: return True for divider in range(2, number): if number % divider == 0: return False return True primes = filter(is_prime, range(limit)) print primes [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,..., 19] [2, 3, 5, 7, 11, 13, 17, 19] False False True True 14:45

(ei-laajan kurssin kalvo: luento 13 sivu 12) reduce Supistaa läpikäytävän yhdeksi arvoksi soveltamalla annettua funktiota jokaiseen alkion. Funktion täytyy ottaa 2 parametria. Hakee suurimman: f = lambda a,b: a if (a > b) else b print reduce(f, [47,11,42,102,13]) 102 Ehdollinen lauseke 47-11 47-42 47-102 102-13 print reduce(lambda a,d: 10*a+d, [1,2,3,4,5,6,7,8]) 12345678 10*1 + 2 10*12 + 3 10*123 + 4 10*1234 + 5 14:45 10*1234567 + 8

(ei-laajan kurssin kalvo: luento 13 sivu 4) List comprehension Luo listan annettua sääntöä noudattaen result_list = [x**2 for x in range(10)] print result_list Tuottaa listan, jossa on lukujen neliöitä. Luvut saadaan forsilmukassa käymällä läpi range:n tuottama lista [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] result_list = [(x, y) for x in [1,2,3] for y in [3,1,4] if x!= y] print result_list [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)] Sama kuin: result_list = [] for x in [1,2,3]: for y in [3,1,4]: if x!= y: result_list.append((x, y)) 14:45

Muistutus: accumulate:n variaatiot (syksyn luennolta 3) accumulate:sta eli fold-right:sta on peilikuva fold-left: (fold-right + 0 (list 1 2 3 4)) (+ 1 (+ 2 (+ 3 (+ 4 0)))) 10 (fold-left + 0 (list 1 2 3 4)) (+ (+ (+ (+ 0 1) 2) 3) 4) 10 ks. SICP-kirjan tehtävä 2.38 molemmista on vielä versiot, joissa ei ole init -alkiota, vaan sellaisena käytetään listan ensimmäistä tai viimeistä alkiota (reduce-right + (list 1 2 3 4)) (+ 1 (+ 2 (+ 3 4))) 10 (reduce-left + (list 1 2 3 4)) (+ (+ (+ 1 2) 3) 4) 10 Pythonin reduce on reduce-left

List comprehension -esimerkki Esimerkki: parittomien lukujen neliöiden summa (accumulate + 0 (map (lambda (x) (* x x)) (filter odd? (enumerate-interval 1 100)))) 166650 ;; Sama Pythonilla: reduce(lambda x,y: x+y, map(lambda x: x*x, filter(lambda x: x%2==1, range(1, 100)))) 166650 sum([ x*x for x in range(1, 100) if x%2==1 ]) 166650 list comprehension on lyhennysmerkintä useimmille map- ja filter-ketjuille Pythonin lisäksi esim. Haskell- ja Scala-kielissä, ei Schemessä lyhennysmerkintä ei auta reduce:en; yllä käytetty sum on vain Pythonin valmis funktio joka tekee saman kuin juuri tämä reduce