Programozás tankönyv évfolyam

Átírás

1 Programozás tankönyv évfolyam 1

2 Programozás története 1822 ben Charles Babbage, az angliai Cambridge egyetem hallgatójaként felismerte, hogy az akkori számító eszközök nagy része, (például a csillagászati táblázatok, vízállásdiagramok, hajózási térképek kritikus hibákat és hiányosságokat tartalmaznak. (A hibák gyakran a emberi életébe is kerültek.) Mivel a pontatlanságok forrá sának az emberi tényezőt tartotta, az volt az elképzelése, hogy gőzgépek segítségével a táblázatok és a diagra mok készítéséből és karban tartásából kiiktatja a találgatásokat. Az egyik ilyen gép, a Difference Engine néven emlegetett szerkezet Babbage életének hátralevő részében ren geteg idejét lekötötte. Még a brit kormányt is felkereste, hogy pénzügyi segítséget kérjen: az első kéréssel a szá mítógép tudományi kutatás finanszírozásához kért kormányzati támogatást. A Difference Engine 10 évnyi fejlesztése után Babbage felismerte, hogy az egy funkciós gép kizárólag egyetlen művelet végrehajtására képes. Rájött, hogy ez igen komoly korlátozás, és egy időre felfüggesztette a munkát a sokoldalú Analytical Engine fejlesztésének kedvéért. Ez a gép a modern számítógép alapelemeit tartalmazta, és megalapozta Babbage számára a számítógép atyja nevet. Az Analytical Engine nem nyert széles körben elismerést, mivel Babbage ugyanazzal a problémával küzdött, ami évszázadokra megkeserítette a programozók és az informatikusok életét: képtelen volt világosan dokumen tálni és ezáltal közkinccsé tenni ötleteit! 1854 a következő állomásunk, amikoris Charles Boole elkészítette a nevét viselő szimbolikus logikai rendszert (Boole algebra), amelynek igen jelentős szerepe van a programozásban. A rendszer bevezette a nagyobb, mint, kisebb, mint, egyenlő és nem egyenlő fogalmát, és egy szimbolikus rendszer segítségével megje lenítette ezeket a fogalmakat ben az Egyesült Államok népszámlálási hivatala versenyt írt ki. Az 1880 as népszámláláskor az adatok összesítése 7 évet vett igénybe, valamint a lakosság is növekedett, így a becslések szerint az 1890 es népszám lálási adatok feldolgozása nem fejeződött volna be az 1900 as népszámlálás előtt. Ezért a verseny célja az volta, hogy fellendítse a számítástudomány iránti érdeklődést, és ennek eredményeként előálljon egy adatfeldolgozó berendezés, amely a kormány munkáját segíti. A versenyt Herman Hollerith német származású amerikai statisztikus nyerte. Az ötletét a Jaquard féle szövő gépek lyukkártyás módszeréből merítette. Jacquard módszerének kulcsa egy kártyasorozat alkalmazása, ame lyen lyukak vannak elhelyezve, mégpedig úgy, hogy azok a kívánt mintát rajzolják ki. Ennek láttán találta ki, hogy a Jacquard deszkalapjaihoz hasonló perforált kártyákat adatfeldolgozásra is lehet használni. Egy kártyára egy ember adatait lyukasztotta. Maga a lyukasztás kézi munkával történt. Az adatok feldolgozásá ra olyan rendszert használt, ahol a lyukkártyák elektromos érintkezők között mentek át. Ahol a kártyán lyuk volt, az áramkör bezárult. Így a lyukakat meg lehetett számolni. Ezzel dolgozta fel az USA 1890 es népszámlálási adatait, mindössze négy hét alatt. A lyukkártyás módszer egyébként később, több programozási nyelv kialakulására is hatással volt. Miután bebizonyította a technológia eredményességét, Hollerith más országokban is vállalta népszámlálási in formációk feldolgozását. Ennek sikere láttán alapította 1896 ban a Tabulating Machine Company nevű céget, amelyből aztán 1924 ben megalakult az IBM ben Konrad Zuse programozás történetének újabb meghatározó alakja kifejlesztette Z 1 névre hallgató számítógépét. Ez volt az első számítógép, amely reléket használt, és a kettes számrendszer segítségével szá molt. Ez a gép a számítógépek modern korának előfutára. Zuse volt az, aki a világ első programozási nyelve, a Plankalkül kifejlesztésével 1946 ban megalapozta a mo dern programozást. A nyelv megjelenése azért volt nagy áttörés, mert modern nyelvek összetevőinek nagy ré szét, többek között a táblákat és az adatstruktúrákat is tartalmazta a számítástechnika történetében újabb fontos állomást jelentett, felbukkant az a szó, amelytől mindenki hi degrázást kap: a hiba! 1945 ben Grace Murray Hopper (később Hopper admirális) a Harvard egyetemen a Mark II Aiken féle átkapcsoló kalkulátoron dolgozott. A gépekkel akkortájt folyamatosan probléma volt, és az egyik ilyen kellemetlen eset során, szeptember 9 én az egyik technikus felfedezte, hogy egy moly került a gépbe. Az esettel kapcsolatban a következő naplóbejegyzés született: Az első eset, amely során tényleges hibát (bug) találtam. Ebből a bejegyzésből született a gép hibakeresése (debugged), valamint a számítógép hiba keresése (debugging a computer) és a számítógépprogram hiba keresése (debugging a computer program) 2

3 kifejezés is. A 20. század közepétől felgyorsult a fejlődés. Egyre több fejlesztés történt: rengeteg különböző programnyelv jött létre, amelyek mindegyike rendelkezik egyaránt előnyös és hátrányos tulajdonságokkal. Megjelent az Internet, amely szintén nyelvek seregét hozta magával. Az Internet másik nagy előnye, hogy meg könnyíti az információk és a programok megosztását másokkal, így a programozás és a programozási nyelvek iránti érdeklődés egyre nő, és ezt az érdeklődést az információk, ötletek és alkalmazások akadálytalan cseréje még inkább fellendíti, vagyis a fejlődés nem áll meg ben Neumann János tervei elkészül az EDVAC, az első Neumann elvek alapján épített gép volt. Első sorban matematikai problémák megoldására lett specializálva, a programok gép függőek voltak, a programo zás tulajdonképpen nem volt más, mint adott utasítások sorozatának leírása. A programok megírása sok időt vett igénybe. A 60 as években egyre több számítógép került a nagyvállalatokhoz, ahol már nemcsak a számítások elvégzése volt az igény, szerettek volna számítógépen ennél összetettebb feladatokat is megoldani. A nehézkes programozási módszerek és a gazdasági élet amely a vállalatok döntéseit alapvetően befolyásolja dinamikus változásai nem igazán voltak összhangban egymással. A hosszú, nehéz munkával készített programok igen gyorsan elavultak, és máris lehetett hozzákezdeni a következő írásához. Tehát új, gyorsabb, egyszerűbb programfejlesztési módszerekre volt szükség. Ebben az időben jelentek meg az első magas szintű programozási nyelvek, amelyek már nem a számítógép, hanem az emberi gondolkodás logikája alapján próbálták a problémákat megközelíteni. A fejlesztések, kutatások eredményeképpen új programozási módszerek, technikák, filozófiák jelentek meg. Most már nemcsak a problémamegoldás egyszerűsítése volt a cél, a programok szerkezeti felépítése, az emberi logika minél hatékonyabb kihasználása lett az újabb fejlesztések irányvonala. Megjelentek az általános célú és a specializált programozási nyelvek, a 70 es évek elején új módszerként jelentkezett a strukturált programozás. A 90 es évekre komoly teret nyertek a számítógépek az élet valamennyi területén. Komoly igény volt arra, hogy a szoftverpiac követni tudja az egyre szélesebb körű igényeket, tehát új eszközökre volt szükség, amelyek segítségével a programozók gyorsan tudnak hatékony és megbízható alkalmazásokat írni. A gyors programfejlesztés céljait egy az emberi gondolkodáshoz közel álló módszer teszi lehetővé, ugyanakkor a programnak nem szabad hatékonyságát elveszítenie, tehát minél elemibb egységekből kell felépíteni. Mindkét igényt kielégítette az objektum orientált programozási technika, amely a valódi tárgyakhoz hasonlóan képes kezelni a rendszer absztrakt elemeit. Azaz a programozónak rendelkezésére állnak az előre definiált programelemek, amelyekből összeállíthatja a működőképes programot. Annak érdekében, hogy a problémának leginkább megfelelő alkalmazást lehessen előállítani, az egyes elemek tulajdonságait a programozó tetszése szerint módosíthatja. A 90 es évek második felére jellemző a legújabb programozási technikák kialakulása, amelyek esetében már nemcsak egy probléma megoldására nyílik lehetőség, komplex információs rendszereket kezelhetünk általuk. Ezen a szinten a programozónak már nem arra kell koncentrálnia, hogy hogyan oldja meg a problémát, sokkal fontosabbá válik a mivel kérdése. A legfejlettebb programozási rendszerek már automatikusan generálják a kódot, ezzel a programozónak már nem kell foglalkoznia. Ezek a rendszerek sok esetben nemcsak a program helyességét ellenőrzik, hanem a problémamegoldás hatékonyságát is. Ezáltal a programozónak kizárólag a megoldandó probléma lényegére kell figyelnie, megkeresheti a kritikus pontokat a programban, és minden korábbi lehetőségnél hatékonyabban optimalizálhatja annak működését. Az évek során igen sok programozási nyelv alakult ki, amelyeket szemléletük, fontosabb jellemzőik alapján négy generációba soroltak. Programozási nyelvek generációi Első generációs programozási nyelvek Az első programozási nyelv a gépi kód volt. Ennek a nyelvnek az utasításait a számítógép képes volt közvetlenül, minden átalakítás nélkül végrehajtani, értelmezni. A problémákat nagyon precízen kellett megfogalmazni, lépésekre bontani. Emellett a nyelv erősen gépfüggő volt, hiszen minden gépen más és más utasításokat használt, az adott problémát minden géptípus esetén másképpen kellett leírni, megfogalmazni, 3

4 alkalmazkodva a számolóegység sajátosságaihoz. (A gépi kód mai napig sem egységes a különböző processzorok esetében.) A gépi nyelv olyan utasításokból állt, amelyek a gép számára közvetlenül értelmezhetőek voltak, az emberi nyelvektől azonban igen messze állt a gépi logika. Hátrányai mellett néhány előnyt is meg kell említenünk: A leggyorsabb programot eredményezi, mivel nem tartalmaz felesleges utasításokat. Az egyes utasítások egységes formában vannak leírva. Az első generációs nyelvek nagy érdeme, hogy bevezették a kifejezés fogalmát. Itt jelenik meg az egész és valós típus, illetve néhány egyszerű vezérlési szerkezet. Példa egy gép kódú utasításra: 0B0A 0C0E 0D00 Az első négy számjegy az utasítás, a második négy számjegy az első memóriacím, a második négy számjegy a második memóriacím. A gépi kódú lehetőségekhez képest komoly előrelépést jelentett az Assembly nyelvek megjelenése, amelyek tulajdonképpen segédeszközt jelentettek a gépi kódú utasítások egyszerűbb megfogalmazásában. Az egyes gépi kódú utasításokhoz egy egy mneomnikus kódot rendeltek hozzá, a tárcímeket pedig a memória kezdetéhez viszonyított relatív címekkel számították. Szintén újdonságnak számított, hogy az egyes memóriacímeket egy egy szimbolikus névvel lehetett helyettesíteni. Egy összeadás Assembly nyelven: ADD X, Y Az ADD szócska az összeadásra (addition) utal, az X és Y pedig memóriacímeket szimbolizálnak. Tehát az Assembly egy olyan alacsony szintű programozási nyelv, amelynél a művelet és a tárcím szimbolikusan megadható, de a programozás logikája továbbra is követni a gépi logikát. Természetesen, ha egy Assembly programot szeretnénk futtatni, azt mindig meg kell előznie egy átalakítási, fordítási műveletnek, amikor az Assembly utasításokat gépi utasításokká alakítjuk át. Az Assembly virágkorában az operációs rendszerek tartalmazták az Assembly fordítót. A fordítóprogramok compiler típusúak voltak. Az Assembly legtöbb utasítása egyetlen gépi utasítást reprezentált, azaz az Assembly 1:1 tipusú nyelv. Volt néhány utasítás, amely több gépi kódú utasítást jelentett, ezeket makróknak nevezték. Az Assembly nyelv a gépi kódú programozás után igen nagy előrelépést jelentett, általa sokkal kényelmesebbé vált a programfejlesztési munka. Napjainkra az alacsony szintű programozási nyelvek háttérbe szorultak. Az Assembly t ma már csak olyan feladatok esetén használják, ahol hardver szintű vezérlést kell megvalósítani. A visszaszorulásuknak sok oka mellett két fontosabbat szeretnék mindössze kiemelni: A processzorok utasításkészlete ma is különböző, ezért a gépi kódban írt program nem hordozható. Az alacsony szintű programozási nyelvek aprólékos, átgondolt munkát feltételeznek egyszerű problé mák esetén is. A mai kor követelménye pedig a gyors, látványos, rövid idő alatt elkészülő programok felé mutat. Második generációs programozási nyelvek A számítógépek alkalmazási területének bővülése szükségessé tette a programok fejlesztési idejének csökken tését, azaz felmerült az igény, hogy a programokat minél gyorsabban írják meg a programozók. A gépi kód és az assembly nehézkessége, géphez igazodása miatt nem volt erre alkalmas. A 60 as évek elején jelentek meg az első magas szintű programozási nyelvek. Az új nyelvek struktúrája már nem a számítógép sajátosságaihoz, hanem a problémához igazodott, a programozóknak itt már nem kellett a gé pi végrehajtással foglalkoznia. Minél függetlenebb egy programozási nyelv a gépi logikától, annál magasabb szintű, annál magasabb minőségi követelményeknek tud eleget tenni. A magas szintű programozási nyelvek 1:N típusú nyelvek, azaz egyetlen magas szintű programnyelvi utasítás több gépi kódú utasítást reprezentál. Természetesen a magas szintű nyelven írt programokat is le kell fordítani az assembly hez hasonlóan de komoly előny, hogy ezeknél a nyelveknél már sokkal kisebb a hibalehetőség, a forrásprogram sokkal áttekinthetőbb lett. A magas szintű programozási nyelvek már sokkal közelebb állnak az emberi logikához, mint elődük, jóval egyszerűbben, világosabban le lehet írni segítségükkel a problémát. Egy összeadási művelet assembly ben, il letve magas szintű programozási nyelvben: 4

5 mov x,10 mov y,12 add x,y mov sum,x X=10 Y=12 SUM=X+Y FORTRAN Az első magas szintű programozási nyelv az IBM cég által kidolgozott FORTRAN volt ben jelent meg, elsősorban a műszaki tudományos számítások legősibb nyelve. Nevét a Formula Translation szavak összevoná sából kapta. Elsősorban matematikai formulákat tartalmazó elágazások kezelésére volt alkalmas, a numerikus algoritmusok széles körét támogatta, viszont az I/O műveletek, és a karakteres adathalmazok kezelése szempontjából nem bi zonyult hatékony nyelvnek. Az I/O műveleteket mindössze alapvető függvények által valósította meg, a nyelv elsődleges célja a matematikai problémák megoldása volt, ehhez a speciális területhez azonban nagyon haté kony eszköznek bizonyult. A nyelv szerkezetét vizsgálva azt tapasztaljuk, hogy a programok két részből állnak: főprogramból, amely a PROGRAM és END utasítások között helyezkedik el. egymásba nem ágyazható alprogramokból, szubrutinokból, amelyek a FUNCTION...END, illetve a SUBROUTIN...END utasítások között helyezkednek el. A fordítóprogram az egyes szerkezeti elemeket külön fordítja, a különböző tárgyprogramokat kell összeszer keszteni, hogy futtatható programot kapjunk. A FORTRAN képességeinek növelésén a fejlesztők igen sokat fáradoztak. A nyelvnek igen sok szabványosított változata jelent meg ban a FORTRAN 66, 1977 ben a FORTRAN 77 ANSI, és ezek mellett készültek el a FORTRAN II., IV. és V. változatok. Az utolsó szabványosított változat a FORTRAN 90 volt, melyek ma is használnak a tudományos számítások programozására. Bár napjaink igényei az univerzális nyelvek felé mutatnak, a FORTRAN mégis megmaradt a műszaki és tudo mányos számítások nyelvének. Jelenleg folyamatban van vagy már elkészült a legújabb verzió, a FORTRAN ALGOL A FORTRAN hoz hasonlóan, úttörő nyelv volt a magas szintű nyelvek sorában ben fejlesztették ki, a matematikai, műszaki számítások célnyelveként. Az első véglegesnek tekintett változatot 1960 ban fogadták el egy párizsi konferencián, neve ALGOL 60 volt. Később, több lépcsőben történő fejlesztés után megjelent a nyelv egy újabb változata, az ALGOL 68. Mindkét változat támogatta a moduláris programozást és a dinamikus tárolóelhelyezést (hasonló a mai muta tókhoz). Új lehetősége volt a rekurzív alprogramok írása. Az ALGOL viszonylag kis utasításkészlettel rendelkezett, azonban szintaktikája nagyon hasonlított az emberi beszédre (Bacus Naur Forma). A nyelv szimbólumrendszere azonos volt a matematikában alkalmazott szimbó lumrendszerrel, ami az ilyen jellegű problémák programozását nagyon megkönnyítette. A programban lévő blokkok önálló egységeket képviseltek, az alprogramokat egymásba lehetett ágyazni. Az ALGOL szabad formátumú nyelv, az utasítások tetszőleges helyre írhatók. Minden utasítást ; vel kell lezár ni. A főprogram kezdetét a PROCEDURE szó jelzi, a program végét az END. Mindkettő után meg kell adni a program nevét. A programban használt változókat deklarálni kell, a deklarációk a blokkok elején helyezkednek el. Az ALGOL nyelv elsősorban a kutatómunkában és az oktatás területén terjedt el. Első számú alkalmazási terü lete az informatikai kutatás volt. Jelentősége azonban vitathatatlan, mivel számos később kialakult programozá si nyelv alapjaként szolgált. Pl.: PASCAL. COBOL Az eddigiekben tárgyalt programozási nyelvek elsősorban a matematikai, műszaki számítások területét támo gatták sikeresen. Szükség lett volna egy olyan nyelvre is, amely az adatfeldolgozást, az információs rendszerek kezelését segíti, támogatja. Az Amerikai Védelmi Minisztérium finanszírozásával 1959 ben létrejött a CO DASYL (Conference on Data Systems Language) bizottság, és lefektette az alapokat egy új, a gazdasági, keres 5

6 kedelmi életben jól használható adatfeldolgozás orientált programozási nyelv kifejlesztéséhez ban szüle tett meg a COBOL (Common Business Oriented Language), amely alkalmasnak látszott a gazdasági életben va ló alkalmazásra is. Az Amerikai Szabványügyi Hivatal (ANSI) 1968 ban elfogadta, majd újabb fejlesztések után 1974 ben szabványossá nyilvánította a nyelvet. A COBOL megjelenése után hamar népszerűvé vált, mert minden számítógéptípuson alkalmazható nyelv volt. Kiterjedt lehetőségeket biztosított az adatállományok létrehozására, karbantartására és lekérdezésére. A COBOL kötött szerkezetű programozási nyelv volt, 4 szerkezeti blokkból épült fel: Identification Division: Azonosító rész. Olyan információkat tartalmaz, mint a program és a programozó neve, készítési idő pontja stb. Environment Division: Környezethívó rész. A futási környezet meghatározását, az alkalmazandó perifériák hivatkozásait tartal mazza. Data Division: Adatleíró rész. Az alkalmazandó állományok és adatstruktúrák leírását tartalmazza. Procedure Division: Az eljáráshívó rész. A feldolgozandó adatokkal végzett műveletek, utasítások leírása. A COBOL nyelvet ma is használják az adatfeldolgozás területén. Az első változathoz képest a nyelv igen nagy változásokon ment keresztül, nagyon sokat fejlesztették az évek során ben jelent meg a strukturált, né hány évvel később az objektumorientált változata. A COBOL nyelv előnyeként meg kell említeni a kiváló do kumentálási lehetőségeket, a komplex adathalmazok kezelésének jelentős könnyítését. Hátránya viszont, hogy a programok mérete igen nagy lesz, és az alapvető matematikai műveleteken túl nem támogatja a bonyolultabb számítási feladatokat. BASIC A BASIC nyelv kialakulása a programozási nyelvek fejlődésének bölcsőjéhez vezet vissza, amikor a magyar származású Kemény János és munkatársa, Thomas Kurtz elhatározták, hogy kidolgoznak egy olyan programo zási nyelvet, amelynek segítségével a programozás könnyen oktatható és tanulható. A köztudatban a BASIC nyelv a kezdő programozók nyelveként vált ismertté. Az ötlet a 60 as évek elején született, amikor megjelentek az első Time sharing (időbeosztásos) rendszerek, és a központi számítógépen tárolt adatokhoz egyre több felhasználó férhetett hozzá. A felhasználóknak szükségük volt egy olyan programozási nyelvre, amelynek segítségével megvalósíthatták a központi adatokhoz való inter aktív hozzáférést. A FORTRAN és COBOL nyelvek batch üzemmódban készültek, ezért nem voltak alkalma sak az adatok dialogikus feldolgozására, igény volt egy általános célú, interaktív, eljárás orientált programozási nyelv létrehozására. Az első ilyen interpreter típusú nyelv a BASIC volt, amely nagymértékben egyszerűsítette a programok írását és tesztelését. A BASIC (Beginners All Purpose Symbolic Instruction Code) nyelv első működő változata 1963 ban jelent meg. A nyelv valójában a FORTRAN egyszerűsített változata volt, korlátozott utasításkészlettel és egyszerű szimbólumrendszerrel. A FORTRAN nél lényegesen hatékonyabb támogatást nyújtott a karakteres adatok és az I/O műveletek keze léséhez, szintaktikája közel állt az emberi gondolkodáshoz. Az első változatok utasításkészlete még nem tette lehetővé a struktúrált programozást, gyakran kellett alkalmaz ni az ugró utasításokat (GOTO). A BASIC ben a programok végrehajtása utasításonként történt (INTERPRE TER módban), ami gyakorlatilag nagyon megkönnyítette a programok tesztelését. Az első változattól kezdve a nyelv nagyon sok változtatáson ment keresztül, nagyon sok változata jelent meg, újabb és újabb lehetőségekkel bővítve a nyelvet. A fontosabb változatok a QUICK BASIC, GFA BASIC, MS BASIC, és a Pascal elemet is tartalmazó VISUAL BASIC. A változatok közül egyedül a VISUAL BASIC et tekintjük strukturált programozási nyelvnek, a programblok kok és eljárások, függvények kezelése miatt. 6

7 RPG A 60 as évek végén jelent meg egy új, az IBM cég által kidolgozott programozási nyelv, amely a COBOL hoz hasonlóan az adatfeldolgozás támogatását tűzte ki célként, de a megvalósítás során teljesen eltérő filozófiát al kalmazott. Ez a nyelv volt az RPG (Report Program Generator). Ellentétben az eddig tárgyalt procedurális nyelvekkel, az RPG a nyelvbe épített, előre definiált standard elemekkel dolgozott. A technikát arra alapozták, hogy minden üzleti típusú jelentés, kimutatás gyakorlatilag azonos felépítésű. Az RPG volt az első listageneráló programozási nyelv. Lehetővé tette a bonyolult adatok gyors és egyszerű feldolgozását, és emellett viszonylag kis memóriát igényelt. Hátránya volt, hogy nem támogatta a bonyolultabb számításokat, ezek elvégzéséhez As sembly rutinokat kellett beszúrni. A nyelvnek sokféle változata született, sokáig próbálták fejleszteni, piacon tartani. Ennek ellenére korlátozott felhasználási területe miatt háttérbe szorult. Harmadik generációs programozási nyelvek A második generáció programozási nyelvei már lényegesen függetlenebbek voltak a gépi logikától, mint az első generációs nyelvek, az elkészített programokat többféle gépen is használni lehetett. Azonban a 2 GL nyelvek többsége egy egy problémacsoport megoldására specializálódott, ami a programok fejlesztése, javítása során igen komoly akadályokat jelentett. A 60 as évek derekán kíséreltek meg először olyan programozási nyelvet fejleszteni, amely rendelkezik a 2 GL nyelvek jó tulajdonságaival is, emellett többféle problémacsoport megoldására alkalmas, univerzális. Az új kor szakot a procedurális programozási szemlélet és az adatok struktúrájának hangsúlyozása jellemezte. Megszülettek az első 3 GL nyelvek, amelyeket még ma is használnak. Ezek a programnyelvek már igen sokféle probléma megoldására alkalmasak, de minden problémára optimális programozási lehetőséget biztosító progra mozási nyelv nem létezik. A 3 GL nyelveket három csoportra oszthatjuk: általános célú, magas szintű nyelvek objektum orientált nyelvek specializált nyelvek Az általános célú programozási nyelvek családjába tartozó nyelvek széleskörűen alkalmazhatók a gazdasági számításoktól a rendszerprogramozási fejlesztésekig, széles a lehetőségek skálája. Néhány ismertebb, szélesebb körben elterjedt 3 GL programozási nyelv: PL/1, APL, PASCAL, Modula 2, ADA, C. PL/1 (Programming Language I.) A PL/1 programozási nyelvet az IBM cég fejlesztette ki, az első változata 1964 ben jelent meg. Ez a nyelv még nem igazán sorolható a harmadik generációs programozási nyelvek közé, de mivel igen sokféle feladat megol dására alkalmas, megérdemli a 3 GL elnevezést. A PL/1 szabad formátumú nyelv, amely a FORTRAN, az ALGOL és a COBOL nyelvek előnyeit egyesíti ma gában. Egyaránt alkalmas az adat feldolgozási és a számítási problémák megoldására, emellett a program szerkezete egyszerű és követhető, formai előírásai nem túl szigorúak. A programok blokk szerkezetű felépítése már a strukturáltság koncepcióját vetíti előre. A program tartalmaz egy főprogram részt, amely külön blokkokban több alprogramot foglalhat magába, az alprogramok egymásba ágyazhatók. A fordító a deklarációkat utólag helyezi el a program elején. A PL/1 előnyei: mindenféle alkalmazáshoz jól használható könnyen tanulható, egyszerű nyelv bonyolult feladatok megoldására is alkalmas szabad formátumú programozást tesz lehetővé blokkszerkezete jól illeszkedik a struktúrált programozási szemlélethez, az eljárások, függvények jól el választhatók egymástól Az első verziót újabb és újabb változatok követték, 1976 ban jelent meg az oktatáshoz is jól alkalmazható vál tozata a PL/C. Bár a PL/1 univerzális programozási nyelv, mégis csak az IBM gépek alkalmazói körében terjedt el, aminek 7

8 oka a megjelenés időpontjában keresendő. Ekkorra már a programozók többsége megismerte a FORTRAN és a COBOL használatát, és nem kívántak egy újabb nyelvre áttérni, főleg mivel ez a nyelv az előző kettő integráci ójának tekinthető, igaz tartalmaz néhány újdonságot. APL (A Programming Language) Az APL egy a matematikai problémák megoldására orientálódott, többcélú (de nem általános) programozási nyelv volt. A nyelvet Kenneth Iverson, amerikai matematikus dolgozta ki, elsősorban műszaki, tudományos al kalmazások fejlesztése céljából. Az APL programok egyik sajátossága, hogy kezelik a görög betűket, beépített (implicit) lehetőségei közé tar toznak az egy és többdimenziós tömbökkel végzett műveletek. A nyelv szimbólumrendszere és szerkezete szabad formátumú. Az APL programok írásához speciális billentyű zetre van szükség (a görög betűk és a speciális operátorok miatt). Az APL nyelv nem támogatja a struktúrált programozást, így nagyobb feladatok megoldását nehézkessé teszi, de a nagy számban rendelkezésre álló beépí tett operandussal kiválóan alkalmas prototípusok gyors készítésére. A 70 es, 80 as években műszaki, tudományos és gazdasági problémák megoldásra egyaránt hatékonyan hasz nálták. Az újabb változatok (APLG) támogatják a grafikus feldolgozást is, manapság a numerikus számítógépek műkö désének leírásához használják. PASCAL A PASCAL nyelv volt az első igazi és legteljesebb körű megvalósítása a strukturált szemléletű programozás el veinek. Niklaus Wirth professzor, a zürichi Műszaki Főiskola oktatója dolgozta ki a nyelvet a 70 es években, és Blaise Pascal francia matematikus filozófusról nevezte el. Wirth professzor az ALGOL programozási nyelv alapján definiálta a PASCAL szabályait, a cél egy az AL GOL hoz hasonló, de általános célú programozási nyelv elkészítése volt. A PASCAL általános célú programozási nyelv, amelyet elsősorban az oktatásban, a műszaki tudományos szá mítások területén és a komplex programrendszerek fejlesztése során alkalmaznak elterjedten. Szabad formátumú nyelv, mely viszonylag kevés utasítást tartalmaz. A programok szerkezete kötött, szigorú előírások vonatkoznak rá. A PASCAL programok blokkokból épülnek fel, a blokkok a BEGIN foglalt szóval kezdődnek és az END fog lalt szóval érnek véget. Minden utasítás végére ; t kell tenni. A PASCAL nyelv támogatja a moduláris progra mozást, függvények és eljárások definiálhatók a FUNCTION és a PROCEDURE foglalt szavak segítségével. A függvények, eljárások egymásba ágyazhatók, sőt a nyelv támogatja a rekurziót is. A PASCAL erősen típusos nyelv. A programban használni kívánt változókat a főprogram előtt elhelyezkedő deklarációs részben fel kell tüntetni. A PASCAL fordítók compiler típusú fordítók. A programok szabályos, szigorú, egyértelmű felépítése miatt a nyelv az oktatás kedvelt programozási nyelve. A PASCAL nagyon jó alapot biztosít más programozási nyelvek tanulásához, a strukturált programozás alapelvei nek megértéséhez. MODULA 2 Amint a nevéből is lehet következtetni, olyan programozási nyelvről van szó, amely igen magas szinten támo gatja a moduláris programozás módszerét, azaz a feladatok részfeladatokra bonthatók és az egyes részeket kü lön lehet programozni, fejleszteni. Az egyes modulok az utasítások mellett tartalmazzák a modul során felhasz nált adatokat, változókat, konstansokat is. A modulok hierarchikus felépítésűek, tehát egymásba ágyazhatók. Célszerű élni ezzel a lehetőséggel, annak érdekében, hogy az egyes alprogramok egymással megfelelően tudjanak kommunikálni. A nyelv támogatja a rekurzív alprogramok mellett, a párhuzamos vezérlőszerkezetek készítését is. Ez utóbbi lehetőség a verseny helyzetben álló folyamatok programozásánál lehet hasznos (multitasking). A nyelv egyik nagy előnye, hogy a moduláris felépítésű programok könnyen áttekinthetők, értelmezhetők egy esetleges módosításkor. Manapság is népszerű nyelv, majdnem minden operációs rendszerhez beszerezhető a fordítóprogramja. 8

9 ADA A 70 es évek közepén fejlesztették ki ezt a Pascal hoz hasonló nyelvet, amely nagyon hatékonyan alkalmazha tó mind a rendszerszintű programok írása során, mind a komplex gazdasági számítások megoldásakor. A nyelv Augusta Ada Byron ról kapta a nevét, akit Charles Babbage munkatársaként az első női programozóként említ az informatika története. Az ADA nyelv fejlesztésének célja egy hatékony, teljes gépfüggetlenséget biztosító programozási nyelv létre hozása volt. Éppen ezen törekvések miatt az ADA nyelv nagyon sok lehetőséget biztosít, a fontosabbak: mult itasking, kommunikáció, megszakítás kezelés. Az ADA programok moduláris felépítésűek, az egyes modulokat Package nek nevezzük. Ezek az egységek gyakorlatilag egymástól függetlenül elkészíthetők és lefordíthatók. A modulok hivatkozhatnak egymásra a USE kulcsszó segítségével. A nyelv sajátossága, hogy az egymástól csak néhány ponton eltérő modulokat a GENERIC és NEW kulcssza vak segítségével egymásból származtathatjuk. Ez a tulajdonság már az objektum orientált nyelvek irányába mutat előre. A nyelv előnye, hogy támogatja a multitaskos működést, amely ma már alapvető követelménynek számít. A megírt program áttekinthető, könnyen módosítható, a moduláris felépítés miatt. A nyelv szerteágazó lehetőségei szinte minden területen használhatóvá teszik, ugyanakkor ebben a komplexitásban kereshető a nyelv hibája is. Az ADA egyik gyenge pontja, hogy bonyolult és sajátságos szemantikával rendelkezik, amely más nyelvek ese tén nem jellemző, ezért tanulása elég nehéz feladat. C nyelv A rendszerprogramozás fejlődése során mérföldkőnek tekinthetjük az 1972 ben megjelent C nyelvet. Megalko tója Dennis Ritchie, aki eredetileg a UNIX rendszerek fejlesztőeszközének szánta. Később különleges haté konyságát és sokoldalú felhasználási lehetőségét látva más operációs rendszerekhez kidolgozták a C nyelvű for dítóprogramokat. A nyelv különlegessége, hogy egyesíti magában a hardverközeli programozás és a magasszintű nyelvek elő nyeit, ilyen módon jól kihasználhatjuk a hardver adta lehetőségeket javul a futási idő mégis gyorsan tudunk új programokat írni, mivel logikájában a magas szintű nyelvek formáját követi a C is. A Pascal hoz hasonlóan viszonylag kevés utasítást tartalmaz, a legtöbb műveletet előre definiált függvények se gítségével oldja meg. A C nyelv támogatja az alprogramok készítését, de csak a függvény típusú modulokat is meri. Az eljárásokat visszatérési érték nélküli függvényként definiálhatjuk. Lehetőség van rekurzív alprogra mok készítésére is. A C nyelv nagyon erősen támaszkodik a mutatókra. Előnyös a C programok írása során kihasználni a mutatók adta lehetőségeket, mert programunk ezáltal gyorsabb, hatékonyabb lehet. Típuselőírásai sokkal engedékenyebbek, mint azt a Pascal nyelv esetén tapasztaltuk, bár az automatikus típus deklarációt nem támogatja, a konverziók terén igen nagy szabadságot biztosít a programozónak. A C nyelv utasításai mindössze a strukturált programok készítéséhez szükséges utasításokra korlátozódnak: Összetartozó utasítások (utasításblokk {}) Kétirányú elágazási szerkezet (if else) Esetszétválasztás (switch case ) Ciklusszervező utasítások A C nyelvet 1989 ben fogadta el az Amerikai Szabványügyi Hivatal. Ekkor jelent meg az ANSI C, az első szabványos C fordító. A későbbi változatok ennek lehetőségeire építkeztek. A C nyelvet ma is széles körben használják, első számú alkalmazási területe a rendszerprogramozás. A mai követelményeknek megfelelő C vál tozatok a C++, az objektum orientált lehetőségekkel bővített C nyelv, és a Concurent C, a párhuzamos folyama tok programozását segítő eszköz. Objektum orientált programozási nyelvek Az utóbbi években kezdett széleskörűen elterjedni egy új szemléletű programozási technika, az objektum orien tált programozás, amely az elődeinél egyszerűbbé, hatékonyabbá, biztonságosabbá teszi a programkészítési munkát. Az objektum orientált programozási nyelvek absztrakt adattípusokkal és a hozzájuk tartozó előre definiált algo ritmusokkal segítik a programozó munkáját. Az objektum orientált nyelvek az adatokat és az őket kezelő eljá 9

10 rásokat, függvényeket egységbe foglaltan ún. objektumként kezelik. Az objektum orientált programozás lényege, hogy a programozás során felhasznált elemeket a nyelv előre de finiálja, és különböző tulajdonságokkal ruházza fel. Amikor a programozó használni szeretné az egyik elemet, csak a tulajdonságait kell egyéni ízlése illetve a feladatnak megfelelő elvárások szerint megváltoztatnia. Egy egyszerű példán szemléltetve: A nyelvben előre definiált objektum a Kor, amely egy kör rajzolását teszi lehetővé. A Kor objektum: Type Kor=object Szin: Integer; Sugar: Integer; X: Integer; Y: Integer; Procedure Rajzol; End; A Kor objektum felhasználása: Kor.Szin:= Green; Kor.Sugar:= 120; Kor.X:= 200; Kor.Y:= 300; Kor.Rajzol; Ez a programozási technika sokkal közelebb áll az emberi gondolkodáshoz, mint a procedurális programozás. Az objektum orientált programozás elterjedésével sok új nyelv jött létre, amelyek tiszta objektum orientált nyelvek, más technikát egyáltalán nem támogatnak. Sok nyelvet kibővítettek az objektum orientált technika al kalmazásának lehetőségével, ezek az ún. vegyes nyelvek. Tiszta objektum orientált nyelvek SmallTalk A 70 es évek elején fejlesztette ki Adele Coldberg és munkatársa Alan Kay azzal a céllal, hogy egy rugalmas, felhasználóbarát programozási környezetet biztosítson a fejlesztők számára. Manapság is széles körben használt programozási nyelv. Eiffel 1988 ban dolgozta ki a nyelvet Bertold Meyer. Objektum orientált, erősen típusos nyelv. A hordozhatóság ér dekében a megírt programot C nyelvre is le lehet fordítani. A szakemberek szerint az egyik legjobb objektum orientált programozási nyelv. Vegyes nyelvek Turbo Pascal A Turbo Pascal 5.5 verziójától kezdve támogatja az objektumok létrehozásának és kezelésének lehetőségét. A 6.0 verzióba már került egy előre definiált objektumrendszer TVISION is, amely a szöveges felületű prog ramok készítése során használható fel hatékony segédeszközként. Borland C++ A C++ elnevezés a hagyományos C nyelv objektum orientált lehetőségekkel bővített változatát jelenti. A Bor land C verzió már támogatja az objektum orientált technika alkalmazását. Hasonló környezetet és objek tumrendszert biztosít, mint a Turbo Pascal 6.0. Specializált programozási nyelvek Ma már a számítógépet a tudományos és kutatómunka igen sok területén is felhasználják. Ezek a területek olyan speciális igényeket támasztanak a számítógépekkel szemben, amelyek megoldásához hasonlóan speciális eszközökre van szükség. Ezen problémák támogatása érdekében fejlesztették ki a specializált programozási 10

11 nyelveket, amelyek sokszor csak igen szűk problémacsoportok megoldására alkalmasak. Ez mégsem említhető hátrányként, hiszen éppen ezért alkották őket: egy egy probléma megoldásához hatékony segítséget biztosíta nak. Rendszer és fordítóprogramok fejlesztése A programfordítók fejlesztéséhez olyan magasszintű programozási nyelvre van szükség, amely hatékonyan tá mogatja az alacsony szintű programozás és az operatív tár közvetlen kezelését egyaránt, lehetővé teszi a biten kénti műveletek végzését, mégis rendelkezik a magasszintű nyelvek előnyeivel. Ilyen nyelvek: B, C, BCPL, Pascal. Formulakezelő nyelvek Nagy pontosságot igénylő, bonyolult matematikai, műszaki számítások számítógép által történő elvégzéséhez biztosítanak hatékony segítséget ezek a nyelvek. Például: FORMAC, REDUCE, MACSYMA. Szimbólum feldolgozó nyelvek Nagy mennyiségű szöveges információk, hosszú listaadatok értékelésére, elemzésére kidolgozott célnyelvek. Felhasználási területük az információkutatás, a matematikai kutatások. Például: PROLOG, CONVERT, LISP, SNOBOL, COGENT. Szimulációs nyelvek Nagyon sok területen használatos nyelvek, kísérletek, folyamatok eredményeinek előrejelzését segítő eszközök. Például: SIMSCRIPT, SIMULA, GPSS. Adatbázis kezelő nyelvek Adatbázisokban tárolt adatok kezelését segítő programozási nyelvek. Segítségükkel lekérdezhetjük, módosít hatjuk, karbantarthatjuk az adatbázisban tárolt adatokat. Kiterjeszthető programnyelvek A harmadik generációs programozási nyelvek legfejlettebb változatai. A programozási feladat megoldásához a nyelv csak egy minimális bázist definiál előre. A hiányzó eszközöket azonban a programozó maga állíthatja elő a már létező elemek segítségével. Például: LOGO, FORTH. Negyedik generációs programozási nyelvek A XX. század második felében a számítástechnika forradalmi változáson ment keresztül. A Neumann elvek megjelenése és az első memóriában tárolt gépi nyelvű program lefuttatása után alig ötven évvel már informáci ós rendszerek, központilag vezérelt számítógép hálózatok programozása, döntéshozást támogató rendszerek fej lesztése a célunk. Nyilvánvaló, hogy ilyen jellegű munkák elvégzésére a hagyományos programozási nyelvek által biztosított eszközök nem megfelelőek. A hardver eszközök rohamos fejlődésére támaszkodva kezdett ki alakulni a programozás során egy új szemlélet, mely az eddigi alapelvekkel szöges ellentétben állt. A 4 GL nyelvek előnyösen egyesítik a procedurális és a non procedurális nyelvek elemeit, lehetőségeit, kihasz nálva mindkét nyelv előnyeit, és kiküszöbölve a hátrányok jelentős részét. A programok (programrendszerek) tervezése során a programozónak már nem a hogyan kérdésre kell válaszolnia, csak azzal kell törődnie, hogy mit szeretne megvalósítani. A legújabb programozási nyelvek esetében már nem az algoritmust, hanem az el érendő célt kell megfogalmazni, a kód generálását legtöbb esetben a fejlesztő rendszer automatikusan végzi el. Fontos jellemzője a nyelveknek, hogy nemcsak a program szintaktikai helyességét ellenőrzik, hanem megvizs gálják a program hatékonyságát, rendszerbe illeszthetőségét is. Meg kell említenünk a 4 GL nyelvek nyilvánvaló előnyei mellett néhány rossz tulajdonságot is. A program ha tékonyságának növekedésével egyenes arányban nő a program hardverigénye elsősorban memória igénye is, a lefordított program méretéről nem is beszélve. A gyakorlati alkalmazások kb. 25% a fejleszthető optimáli san a 4 GL programozási nyelvek valamelyikével, a maradék 75% esetében továbbra is hatékonyabb eszköznek bizonyulnak a 3 GL nyelvek. A 4 GL nyelvek osztályozása Lekérdező nyelvek Biztosítják az adatbázisok adataihoz történő hozzáférést, akár egyszerű lekérdezésről, akár az adatok módosí 11

12 tásáról, rendezéséről, vagy az adatbázis bővítéséről van szó. Programgenerátorok Lehetővé teszik, hogy a felhasználó egy előre definiált minta alapján egyszerűen és hibátlanul hozzon létre egy harmadik generációs programnyelvi alkalmazást. Egyéb 4 GL nyelvek Ebbe a csoportba sorolhatjuk a döntéstámogató rendszerek fejlesztésére használatos nyelveket, a prototípus nyelveket (modellezést, tervezést segítő nyelvek), és a formális specifikáció nyelveit. Ötödik generációs programozási nyelvek A XX. század második felében a számítástechnika forradalmi változáson ment keresztül. A Neumann elvek megjelenése és az első memóriában tárolt gépi nyelvű program lefuttatása után alig ötven évvel már informáci ós rendszerek, központilag vezérelt számítógép hálózatok programozása, döntéshozást támogató rendszerek fej lesztése a célunk. Nyilvánvaló, hogy ilyen jellegű munkák elvégzésére a hagyományos programozási nyelvek által biztosított eszközök nem megfelelőek. A hardver eszközök rohamos fejlődésére támaszkodva kezdett ki alakulni a programozás során egy új szemlélet, mely az eddigi alapelvekkel szöges ellentétben állt. Párhuzamos programozás Hálózatok programozása Programozási nyelvek osztályzása Felhasználói kör szerint Amatőr nyelvek (Pascal, Logo, Elan, Prolog 1. része, Basic) mérnök, tanár, közgazdász, stb. használja, egyszerű programszerkezet, sok nyelvi elem (a felhasználót így nem kell terhelni az alapeljárások megírásával), sok gépfüggő elem (saját gépen saját célra való felhasználás miatt), interaktivitás (könnyen, gyorsan lehessen kipróbálni, módosítani a programokat, mivel a nemhivatásos programozó több hibát ejt), gyors fejlődés. Professzionális nyelvek (Pascal, Prolog 2. része, Modula 2, Ada) programozó használja, kevés nyelvi elem, szűkebb utasításkészlete (mindent a programozónak kelljen megírni), modularatás (modulokra bonthatóság), hordozhatóság (gépfüggetlenség), viszonylagos stabilitás (nem jó, ha nagy programokat gyakran újra kell írni, viszont jó, ha az újabb vál tozatok felülről kompatibilisek a régivel). Számítási modell szerint Neumann elvű nyelvek A Neumann elvű nyelvek mögé egy Neumann elvű számítógépet képzelünk: címezhető, írható olvasható memória: az adatok és a program a memóriában van, program végrehajtása utasítások szekvenciális végrehajtása, változó fogalmának megjelenése, értékadás, adatok beolvasása, kiírása, memóriacímre való ugrás, el ágazás, ciklusok szervezése, a mai nyelvek többsége ilyen; pl. Fortran, Pascal, Basic stb. Automata elvű nyelvek végrehajtója (elvben) egy automata (ipari robot, festőautomata, lángvágó), 12

13 az automata rendelkezik állapotokkal, s az állapotok közötti átmenetet leíró függvényekkel, egy egy állapot az összes globális "változó" ill. jellemző pillanatnyi értékét tartalmazza; ezek az álla potkomponensek, utasítások: állapotmódosító illetve állapotlekérdező, minden állapotváltozás relatív, hiszen a változás az előző állapothoz képest történt, nincs változó, nincs értékadás (helyette állapotkomponens változtatás van), nincs beolvasás (helyette eljárások paraméterezése, ill. állapotlekérdezés szerepel), nincs kiírás (helyette az eredmény az állapotváltozások nyoma (pl. teknőc rajza)), elágazások, ciklusok paraméter illetve állapotfüggők egyszerűbbek, mint a Neumann elvű nyelvek ben. A ciklus vagy adott lépésszámú ciklus vagy rekurzív eljárás lehet, pl. Logo teknőcgrafika. Funkcionális nyelvek a program egy függvény, a program végrehajtása a függvény kifejtéséből áll, programstrukturálás: függvénykompozíció f ( x ) = g o h ( x ) alternatív függvény f ( x ) = [ g ( x ) ha p ( x ) [h (x) ha nem p (x) rekurzív függvény f ( x ) = [ g ( x ) ha nem p ( x) [ h o f o i (x) ha p (x) nincs memóriacímzés, nincs változó (helyette függvényparaméter van, ez lehet újabb függvény is), nincs értékadás, nincs ciklus, nincs beolvasás (helyette függvényparaméterezés van), nincs kiírás (helyette a kiszámított függvényérték automatikus kijelzése történik), pl. Logo. Logikai nyelvek a program egy logikai formula, a program végrehajtása a logikai függvény kiértékelése, a program eredménye: FALSE vagy TRUE ill. azon paraméterek megadása, melyekre a TRUE teljesül, nincs memória, nincs változó, nincs értékadás, nincs beolvasás (helyette paraméterezés van), nincs kiírás, nincs szekvencia, elágazás, ciklus, őket logikai formulákban szereplő "és", "vagy", "nem" műveletek he lyettesítik. A program struktúrája: f ( x ) ha h ( x ) é s g ( x ) egymás utáni végrehajtás f ( x ) ha h ( x ) vagy g ( x ) alternatív végrehajtás f ( x ) ha g ( x ) vagy i ( x ) é s f ( x ) rekurzív formula pl. Prolog. Felhasználói közelség szerint Gépi kód ez a legalacsonyabb szintű nyelv. Ez az a nyelv, amit a számítógép processzora közvetlenül megért, a gép lehetőségeinek maradéktalan kihasználása (memóriacímek, regiszterek, verem, megszakítások, op.r. változói közvetlenül elérhetők), gépi kódú utasítás (bináris szám). 13

14 Alacsonyszintű nyelv Minden gépi kódú utasításnak megfelel egy alacsonyszintű nyelvi utasítás, amelyet azonban már egy szimbolikus elnevezés takar (ezek állhatnak több gépi utasításból is). Adatokat, adatok helyfoglalását, a programkód memóriába helyezését definiáló utasítások megjelenése. Memóriacímek azonosítóval való ellátása, adatok kezdőcímének elnevezése (a rájuk való hivatkozás a változófogalom első megjelenése). elágazás, ciklus szervezhető, de a nyelvnek nem eleme, kiegészítés: minden lehetőség kihasználható, amit a hardware nyújt, változó = kezdőcím (megjelenik a változó fogalma, de még az adatoknak nincs szerkezetük), azonosító = memória cím neve, utasítás = azonosító, feltételes vezérlésátadás. Visszatérés, általában gyorsabb mint egy magas szintű nyelv, primitívebb, minden gépi utasításhoz nyelvi utasítást rendel. Magasszintű nyelvek magas szintű nyelvek feladatorientált nyelvek, kifejezés. változó. típusfogalom. elágazás. ciklus. eljárás megjelenése, kiegészítés: faladatorientált, változó memóriatartpményt jelöl, típusfogalom, kifejezések, az algoritmusban felhasznált utasítások a nyelv elemi utasításaival kódolhatók, elágazás, ciklus, értékadás, I/O, eljárások = programegységek, paraméterek. Egyéb osztályozások "Compiler" illetve "Interpreter" nyelvek Arra utal, hogy egyes nyelvekhez gyakrabban készítenek interpretert (értelmezőprogramot), míg másokat szinte kizárólag compilerrel (fordítóprogrammal) használnak. Procedurális illetve nem procedurális nyelvek procedurális: a program írásban a megoldó algoritmus leírására törekszik (pl. Neumann elvű illetve automata elvű nyelvek) nem procedurális: a program írásban nem a megoldó algoritmus leírására törekszik; a megoldó algoritmust a nyelv kiértékelési szabálya tartalmazza. (pl. funkcionális és logikai nyelvek) Deklaratív nyelv Olyan nyelv, amelyben csak a specifikációt adjuk meg, s a rendszer ennek alapján automatikusanállít elő meg oldást. (pl. logikai nyelvek) Utasításorientált nyelv Olyan programnyelv, melynek alapelemei utasítások,s a program végrehajtása ezek egymás utáni elvégzéséből áll. (pl. Pascal, Elan) Kifejezésorientált nyelv Olyan programnyelv, melynek alapelemei kifejezések,s a program kifejezések kiértékeléséből áll. Objektum orientált nyelv Olyan programnyelv, mely az objektum orientált programozás eszközeivel rendelkezik. (pl. Delphi) Párhuzamos programnyelv Olyan programnyelv, mely a párhuzamosság kezelésére szolgáló eszközökkel rendelkezik. 14

15 Programozási alapfogalmak Algoritmus Lépések sorozata, amellyel egy feladat kiindulásától a megoldásáig jutunk. Program Az algoritmus megfogalmazása a számítógépek, vagy a fordító programok számára érthető nyelven. Programozó A programozó a matematikushoz hasonlóan formális nyelveket használ az okfejtések (vagy az algoritmusok) leírására. A mérnökhöz hasonlóan terveket gondol ki, az alkotó részekből szerkezeteket állít össze, és értékeli azok teljesítményét. Mint a tudós megfigyeli az összetett rendszerek viselkedését, magyarázatokat vá zol föl, ellenőrzi a jóslatokat. A programozó fő tevékenysége a problémamegoldás. Ez különböző képességeket és ismereteket igényel: egy problémát különböző módokon kell tudnunk meg/újrafogalmazni, innovatív és hatékony megoldásokat kell tudnunk elképzelni, ezeket a megoldásokat világosan és komplett módon kell tudnunk kifejezni. Programozás A számítógép programozása lényegében abból áll, hogy részletesen megmagyarázzuk egy gépnek, (ami nem ért meg, az emberi nyelvet, csupán karaktersorozatok automatikus kezelésére képes) hogy mit kell tennie. A program előre rögzített konvenciók ezek együttesét programozási nyelvnek nevezzünk szigorú betartásá val kódolt utasítások sorozata. A gép rendelkezik egy eljárással ami úgy dekódolja ezeket az utasításokat, hogy a nyelv minden szavához egy pontosan meghatározott akciót rendel. Programozás alatt szűkebb értelemben a kódolást értjük, tágabb értelemben a feladat kigondolásától kezdődően a kész program leírásáig minden lépés ide tartozik. Forrásprogram A programot, ahogyan azt egy szerkesztő programmal (egyfajta specializált szövegszerkesztővel) megírjuk mostantól fogva forrásprogramnak (vagy forráskódnak) nevezzük. Programozási nyelv A programozási nyelv nagyon pontos szabályokhoz rendelt (önkényesen választott) kulcsszavaknak a készlete. Azt írja le, hogyan rakhatjuk össze ezeket a szavakat olyan mondatokká, amiket az interpreter vagy a compi ler a gép nyelvére (bináris számokra) le tud fordítani. A programozás szintjei Gépi kódú A számítógép számára közvetlenül érthető nyelv a gépi kód. A nyelv elemei közvetlenül a processzor számára ismert gépi kódú utasítások. Mind az utasítások, mind az adatok bináris kódúak. A memóriában tárolt adatok el helyezkedésének és helyes felhasználásának összes gondja a programozót terheli. Assembly nyelv A nyelv utasításkészlete szinte teljesen egyezik a gépi kódú programozáséval, de az utasításokat könnyebben megjegyezhető angol nevekkel látták el, valamint az adatokat és memóriacímeket sem kell binárisan megadni, hanem használható a sokkal kényelmesebb hexadecimális számrendszer is. Természetesen az assembly nyelvű programok közvetlenül nem értelmezhetőek a processzor számára, hanem egy fordító program segítségével gé pi kódúvá kell lefordítani ahhoz, hogy futtatható legyen. Magas szintű programozási nyelvek Magasabb szintű utasításkészlet, amely már nem a processzor utasításkészletéhez áll közel, hanem inkább az emberi gondolkodáshoz. Az adatok kezelésével kapcsolatos gondok nagy részét átveszi a fordítóprogram. Ezek kel a nyelvekkel fogunk részletesebben foglalkozni. 15

16 Újabb generációs nyelvek Az emberi gondolkodáshoz még közelebb álló programozási nyelvek. Szintaxis és szemantika leírás Szintaxisnak nevezzük egy programozási nyelven írt program formai helyességére vonatkozó szabályok gyűjte ménye. A szemantika pedig ugyanennek a jelentését, tartalmi helyességét leíró szabályokat tartalmazza. Szintaxisleíró eszközök A szintaxis leírására sokféle eszköz szolgál, ezek közül gyakran használt a BNF (Backus Naur forma), szinta xisgráf, és axiómákkal és következtetési szabályokkal való leírás. BNF metanyelv Nagyon kevés szimbólumot használ. A definiálandó fogalmakat <, > jelek közé kell tennünk, a definiálás jele a ::=, az alternatív definíciókat a jellel választjuk el egymástól, a megismétlendő elemeket pedig a {,} jelek közé tesszük. Példák: <Program> ::= Program: {<Utasítás>} Program vége. <Értékadás> ::= <Változó> := <Kifejezés> <Adat> ::= <Változó> <Konstans> Szintaxisgráf vasútdiagram A szintaxisgráf csomópontjait nyelvi elemek alkotják, s ezek lehetséges sorrendjét az irányított gráf élei jelölik ki. Példák: Program Értékadás Fordítás és értelmezés Ahhoz, hogy egy számítógéppel beszéljünk, olyan fordító rendszereket kell alkalmaznunk, melyek képesek a számunkra érthetőbb kulcsszavakat (rendszerint angol szavakat) alkotó karaktersorozatokat bináris számokká alakítani. Fordításnak nevezzük azt a folyamatot, amikor egy adott nyelven (forrásnyelven) megírt programot egy prog ram (fordítóprogram compiler) lefordít egy másik nyelvre (célnyelvre). A célnyelvi program futtatásához ez után sem a forrásnyelvi programra, sem a fordítóprogramra nincs szükség. Az értelmező (interpreter) a programszöveget nem alakítja át, hanem utasításonként olvassa, elemzi, a a felis mert utasítást azonnal végre is hajtja, majd megkeresi a végrehajtásban következő utasítást. Programkészítés és futtatás menete Interpreteres nyelvek esetén (pl. Basic, script) 1. Program megírása egy programozási nyelven, ez az úgynevezett forrás program. 2. Forrás program futtatása egy futtató program (interpreter) segítségével. vagy 16

17 (pl. JAVA) 1. Program megírása egy programozási nyelven, ez az úgynevezett forrás program. 2. Forrás program lefordítása egy köztes kódra (ezt a fordítót is szokás compiler nek nevezni). 3. Köztes kód futtatása egy futtató program segítségével. Compileres nyelvek esetén (pl. C, C++, Pascal, Delphi) 1. Program megírása egy programozási nyelven, ez az úgynevezett forrás program. 2. Forrás program lefordítása a fordító program segítségével gépi kódú programmá. 3. A gépi kódú program futtatása. A compiler es nyelvek előnye: gyorsabb, hátránya: a lefordított kód csak ugyanolyan architektúrájú gépen futtatható, mint amelyiken fordították. Az interpreter es nyelvek előnye: a program hordozható minden olyan helyre, ahol van interpreter, hátránya: lassabb. Byte kód fordítás Egyes modern nyelvek megpróbálják a két módszert kombinálni, hogy mindegyikből a legjobbat hozzák ki. Ez a helyzet a Python és a Java esetében is. Amikor egy forráskódot adunk át, az először egy gépi kódhoz hasonló közbenső kódot ú.n. bytecode ot hoz létre, amit aztán egy interpreternek ad át végrehajtásra. A számítógép szempontjából a bytecode ot nagyon egyszerű gépi nyelven interpretálni. Ez az interpretáció tehát sokkal gyorsabb lesz, mint egy forráskód interpretációja. 17

18 Ennek a módszernek az előnyei érzékelhetőek: Az, hogy állandóan rendelkezünk egy interpreterrel, lehetővé teszi bármilyen kis programrészlet köz vetlen tesztelését. Egy alkalmazás bármelyik alkotójának helyes működését igazolhatjuk an nak létrehozását követően. A lefordított bytecode interpretációja nem olyan gyors, mint egy igazi bináris kódé, de számos program számára, beleértve a grafikus programokat is, nagyon megfelel. A bytecode portábilis. Ahhoz, hogy egy Python vagy egy Java program különböző gépeken végrehaj tódjon elég ha mindegyik gépen rendelkezésre áll egy adaptált interpreter. Case sensitive, case insensitive nyelvek A case sensitive nyelvek megkülönböztetik a kisbetűket és a nagybetűket, a case insensitive nyelvek nem, azaz mindegy, hogy valamit kisbetűvel vagy nagybetűvel írunk. Megjegyzések A megjegyzéseket a fordító nem veszi figyelembe. Azt a célt szolgálja, hogy a programot olvasó könnyebben eligazodjon a programban, ezzel segítve a kód újrafelhasználását. Megjegyzésekkel szokás magyarázni a fontosabb változók szerepét, a függvények szerepét, hívásának módját, paramétereit, eredményét modul tartalmát, egyes trükkösebb megoldásokat. Kulcsszavak A nyelv rögzített jelentéssel bíró szavai, amelyet más célra nem lehet használni. Programstruktúrák Program A program utasítások olyan sorozata, amely a számítógépen önállóan képes megoldani egy feladatot. A prog ram háttértáron futtatható formában egy fájlban található. Programcsomag Rokon programok halmaza, amelyek egy feladatkör megoldására szolgálnak. Párhuzamos folyamat (taszk) Egyes programok a feladat megoldására olyan programrészeket használnak, amelyek egymással párhuzamosan végrehajthatók, a megoldás során egymással kommunikálnak, működésüket szinkronizálni kell, s meg kell oldani a közös erőforrások megosztását. Ezeket a párhuzamosan működő programrészleteket nevezzük folyamatoknak. Fordítási egység (Modul, unit, szegmens) A program önállóan, a többi résztől függetlenül lefordítható legkisebb nyelvtani egységét nevezzük fordítási egységnek. Ez a fordítóprogram egyszeri végrehajtásával lefordítható. Nem tévesztendő össze azzal, amikor egy fájlban több fordítási egységet helyezünk el, s azokat egyszerre fordítjuk. Export, importlisták Ezek a fordítási egységek olyan részei, amelyek leírják egyrészt, hogy az adott egység mely azonosítóit használhatja más modul, másrészt, hogy ő mely modulokat, azokat, azoknak mely objektumait használja. Nem csak a modulnevet kell megadni, hanem azt is, hogy abból a modulból mire van szükségünk. Programegység Egy részfeladatot megoldó utasítások összefüggő csoportja. A programegység egyben, egységként hajtható végre, a külvilágtól valamilyen mértékben elzárt, azzal változókon, paramétereken keresztül kapcsolatot tartó, lokális típusokkal, változókkal konstansokkal, a blokkstruktúrájú nyelvekben lokális programegységekkel rendelkező utasításcsoport. 18

19 Eljárás, függvény, operátor Gyakorlatilag háromfajta programegységet használunk : az eljárást, a függvényt, valamint a függvény egy speciális fajtáját: az operátort. Az eljárás olyan programegység, amely egy utasítást helyettesíthet a programban. A függvény értékével egy kifejezésben szereplő értéket reprezentálhat. Az unáris vagy bináris operátort szintén kifejezésekben használhatjuk. Ezek a programegységek, az ún. alprogramok paraméterezhetők. Definíciójukban formális paramétereket használunk, a ezeket híváskor feleltetjük meg az aktuális paramétereknek. Deklarációs rész, törzs Egyes programozási nyelvekben önálló programegységként szerepel a típusdefiníció, vagy blokk. A programegység egy (ELAN) vagy két (Pascal) részből áll. A deklarációs rész adatok, típusok, blokkstruktúrá jú nyelvekben ezeken kívül más programegységek definícióit tartalmazza, a törzs pedig végrehajtható utasítá sok sorozatát. Ha e két rész nincs elkülönítve, akkor azt a szabályt kell betartanunk, hogy egy dolog használatát meg kell hogy előzze a definiálása. Néhány nyelvben a programegységek egy harmadik részt is tartalmaznak, a kivételkezelés. Blokkstruktúra Programok programegységeit kétféleképpen helyezhetjük el. Az egyik, egyszerűbb elv szerint a program programegységek sorozata, melyek sorrendje lényegtelen. A Neumann-elvű nyelveknél gyakoribb esetben a programegységek deklarációs részeiben tartalmazhatnak újabb programegységeket. A programegységek egymásba ágyazásával előállt struktúrát hívjuk blokkstruktúrának. Programkészítés elvei Stratégiai elveinek Taktikai elvek Technológiai elvek Technikai elvek Esztétikai ergonómiai elvek Stratégiai elvek Egyik legfontosabb, sokféleképpen alkalmazható elvünk oszd meg és uralkodj elve alapján fogalmazható meg: oszd részekre, majd a részek független megoldásával az egész feladatot könnyebben oldhatjuk meg. Így programunk könnyen kézben tarthatjuk. Lépésenkénti finomítás A feladat megoldását először átfogóan végezzük el, nem törődve a részletekkel, részfeladatra bontjuk. Úgy is mondhatnánk: a feladatot megoldjuk a legfelső szinten. Ezt az eljárást fogjuk követni az egyes részfeladatok megoldásakor is mindaddig, amíg olyan utasítások szintjéig nem érünk, amelyeket gépünk (kódolás után) már végre tud hajtani. (Piramis elv) Pontosan ki kell jelölni, hogy az adott részműveletek milyen adatokat kezel, milyeneket állít elő, és ezeket mi ként kell egymáshoz rendelni. Két azonos szinten definiált részfeladat között biztosítani kell a harmóniát úgy, hogy a végrehajtásban előbb kö vetkező az utána következő adatait szolgáltassa. Program felülről lefelé való kifejtése (top down programozás) A bemeneti adatokból indul ki és a kimeneti adatokat próbálja előállítani. Ez a leggyakrabban használt mód szer, ezt segítik az eljárások, függvények és elemi programozási tételek is. Program alulról felfelé való felépítése (bottom up programozás) A kimeneti adatokból indul ki és próbálja meghatározni az előállításukhoz szükséges bemeneti adatokat és a megfelelő utasítássort. 19

20 Taktikai elvek Milyen elv alapján hajtsuk végre a lépésenkénti finomítást. Párhuzamos finomítás elve A szint összes részfeladatára kell elvégezni a finomítást. Nem szabad előre sietni valamelyik könnyebbnek vélt ágon, mert előfordulhat, hogy munkánk kárba vész. Vissza az ősökhöz elv Erre akkor van szükségünk, amikor körültekintő megfontolásaink ellenére zsákutcába kerülünk. Ekkor vissza kell lépni az előző szinthez (őshöz), és újra végig kell gondolni a részfeladatokra bontást, és tapasztalatainkat. Technológiai elvek Ezek az elvek az algoritmus (és a kód) írására, annak szabályaira vonatkoznak. Algoritmusleírási szabályok Kevés, de egyértelmű szabályt kell kialakítani az algoritmusok leírására. Az adatokat beolvasó és kiíró utasítások az ablak szerepét játsszák a külvilág felől, illetve a program felhasz nálója felé. A program változóinak értékkel való ellátását az értékadó utasítások végzik. A feltételektől függő végrehajtást teszik lehetővé az ún. feltételes utasítások, elágazások. A számítógépre szánt feladatok mindegyike feltételezi bizonyos részfeladatok ismételt elvégzését. A számító gép erősségét, a gyorsaságot éppen a mechanikus ismétlések használják ki a legjobban! Ezek ciklusutasítások segítségével valósulnak meg. A program adott szintjén elemi utasításként felhasznált, meghatározott, de nem finomított részprogramok (eljá rások, függvények, operátorok) beépítését (az ún. eljáráshívást) is meg kell oldanunk nyelvünkben. Természetesen a felhasznált és még hiányzó eljárások finomítása (másként szólva: az eljárás kifejtése) sem hiá nyozhat. Az algoritmusleírás mellett e nyelvek rendelkeznie kell az adatok (konstansok, változók) és típusok leírására szolgáló eszközökkel is. Értelmes sorokra tördelés világos tagolás Kérdés, hogy mit írjunk egy sorba, mit több sorba. Alapelképzelésünk lehetne például az, hogy minden utasítást külön sorba kell tenni. Ezt a következőképpen módosítjuk: kerüljenek egy sorba azok az utasítások, amelyek szervesen összekapcsolhatók, és egy sorba írásukkal a program még áttekinthető marad. Bekezdéses leírás Az algoritmikus gondolatainkat, az algoritmus főbb eseményeit, epizódjait jól láthatóan el kell különíteni a programban. A program teljes levezetése (finomítása) után a program szerkezetének vissza kell tükröznie a szintekre tagozódást: egy szint elemi utasításai a bekezdések azonos szintjeit alkossák! Egyes nyelvi szövegszerkesztők automatikusan a bekezdéses leírásnak megfelelően tördelik programunkat. Összetett struktúrák zárójelezése Az algoritmusokban szereplő elágazások, ciklusok, eljárások, valamint az összetett adatstruktúrák úgy ismerhe tők fel könnyen, ha nemcsak az elejüket jelzi valamilyen nyelvi elem, hanem a végüket is egyértelműen rögzít jük. A beszédes azonosítók elve A konstansoknak, változóknak, típusoknak, eljárásoknak, függvényeknek, operátoroknak olyan nevet érdemes adni, ami utal arra, hogy mire használjuk. Ez kizárja az azonosítók keveredését: hiszen a név sugallja funkciót, az algoritmusban betöltött szerepet. Nagy segítséget nyújt a kódoláskor is, például lehetővé teszi, hogy minimá lis számú változót rendeljünk az adatokhoz, hiszen a munkaváltozókhoz azonos neveket is rendelhetünk. Nem minden esetben a hosszú azonosítók a beszédesek, például ha egy fizikai képlettel (E=m*g*h) dolgozunk, akkor éppen ezek az egybetűs jelölések a beszédesek, ha pedig mátrixösszeadásra definiálunk egy operátort, ak kor azt célszerű a + jellel jelölni. Technikai elvek A program kódjával kapcsolatosak. Inkább úgy mondhatjuk, hogy az előzőek a program megírásához szükségesek, ez utóbbiak pedig a program használhatóságához elengedhetetlenek. Ilyen értelemben 20

21 beszélhetünk a csak helyes programról, amely a feladat logikája szempontjából tökéletes, és a jó programról, amely ezen túl elő is segíti saját felhasználását. Barátságosság, udvariasság Az udvarias program bemutatkozással kezdi (tájékoztató), és ezzel tudatja a felhasználójával képességeit, szol gáltatásait, használatának mikéntjét. Az udvariasság másik fontos megnyilvánulása, hogy a program futása so rán megjelenő kérdések bárki számára azaz a nem informatikus szakemberek számára is érthetők, és a vála szok a lehető legegyszerűbben megadhatók legyenek. Biztonságosság A bolondbiztos program az, amit a kísérletezni vágyó vagy éppen balszerencsés felhasználó sem képes ellen őrizetlen vágányokra terelni azáltal, hogy nem a megfelelő módon, vagy nem a megfelelő pillanatban válaszol a feltett kérdésére. Ennek érdekében a program kritikus pontjait, azaz ahol a felhasználó közvetlenül avatkozik be a program további menetébe, nagy odafigyeléssel kell megírni. Az esetleges hibalehetőségekre fel kell készíteni a programot úgy, hogy a felhasználónak lehetősége legyen a helyesbítésre is. (Itt használjuk ki a specifikáció előfeltétel részében leírtakat.) Nem támaszkodhatunk a számítógép, illetve az értelmező vagy fordítóprogram eleve meglévő hibajelzéseire. Ezek ugyanis arra valók, hogy segítségükkel felderíthessük és kijavíthassuk az esetleges programhibákat, tehát a program írója, nem pedig a használója számára készültek. Jól olvasható program A program módosításakor, továbbfejlesztésekor óriási előnyt jelent, ha nem kell a programunk minden mellé kes vonását újra feltérképezni a megértéshez, hanem a lényeges tulajdonságai a program megfelelő helyén könnyen kiolvasható formában megtalálhatók, és így biztos kézzel nyúlhatunk bele a program legérzékenyebb részeibe is. Már két idevágó elvet is említettünk: a bekezdéses leírás és az összetett utasítások zárójelezése elveket Ezt kiegészíthetjük a kódoláskor különösen nagy jelentőségűvé váló jó magyarázatok (kommentek) elvével. A programozási nyelvre való áttéréskor ugyanis a programozási nyelv kötöttségei miatt sok, az algoritmust nagyban jellemző tulajdonság elveszne, ha ezeket az információkat nem őriznénk meg egy egy jól megfogal mazott megjegyzés formájában. A (jól) dokumentált program Sokszor nincs lehetőség a program méretére rótt korlátozások miatt arra, hogy az előző elvet maradéktala nul megvalósíthassuk; ekkor le kell írni a program fontos vonásait: az algoritmusát (felépítését), a változóit és ezek szerepét, értelmezését, értéktartományát, hatáskörét stb., a kódolásnál követett szabályokat (a leíró és a programozási nyelv utasításainak, illetve változóinak megfeleltetését). Ezeket a dokumentációban is rögzíteni kell, amelyben ezen kívül még foglalkozni kell a használat mikéntjével és az esetleges, előre látható fejlesztési lehetőségekkel is. Esztétikai ergonómiai elvek A program emberközelségéről van szó. Nagy gondot kell fordítani a program által megjelenített információk külalakjára. Ide nemcsak az eredmény jellegű kiírandók tartoznak, hanem például a tájékoztató, a felhasználó val való párbeszéd módja is. Lapkezelési technika A kiírandó szövegek, adatok logikai egységekre bontva jól különüljenek el, egyszerre csak annyi és olyan ütemezésben, amennyit és ahogy a felhasználó be tud fogadni. Ennek megvalósítására alkalmazzák a lapkezelés technikáját. Egyszerre egy képernyőlapnyi információt jelenítünk meg, és a felhasználónak lehetősége van lapozásra, példá ul egy adott billentyű lenyomásával jelzi a gépnek: Elolvastam! Lapozhatsz! (Többek között ennek megvaló sítására használható a Várj, amíg szükséges utasítás.) Nem szerencsés ez esetben az adott ideig történő vára kozás gondoljunk a különböző olvasási sebességű felhasználókra! Nyomtató esetén e várakozásra nincs szükség, viszont újdonságként felmerülhet a lapszámozás, illetve a fejléc vagy lábléc írása. Képernyőkezelés esetén is lehetőséget kell teremtenünk arra, hogy az aktuális képernyőtartalmat kinyomtathas suk. 21

22 Ügyelni kell a képernyőlap arányos kitöltésére, és jó, ha az egy lapon belül szereplő, logikailag szorosan össze nem tartozó információk egymástól elkülönülnek. Az elkülönítés megoldható üres sorok beiktatásával, az egyes részek szakaszokkal való elkülönítésével, illetve bekeretezésével. A mondanivalónk legfontosabb elemeit a gép adta lehetőségek figyelembevételével kiemeljük (inverz be tűkkel, vagy bekeretezve, vagy más színű háttérrel, illetve betűkkel stb.). Menütechnika A lapkezeléssel szorosan összefüggő módszer, amely a felhasználóval való párbeszéd elegáns megszervezésére alkalmas. Általában bonyolult szolgáltatásokkal rendelkező programoknál használatos, amelyből a felhasználó akár egy menüből kiválaszthatja a számára szükséges lehetőséget. Minden egyes válaszával (válaszcsoporttal) a kérdések egy nagy hányadát kizárja, ezeket a számítógépnek fel sem kell tennie, megkímélve a felhasználót a fölösleges válaszadásoktól (hierarchikus menürendszer). A menü egy lap (vagy ablak), amelyen megjelennek a választási lehetőségek; közülük sorszámmal (vagy kezdőbetűvel), illetve rámutatással (kurzormozgató billentyűk vagy egér segítségével) választhatunk. A program főmenüjében célszerűen szerepel egy Munka befejezése menüpont, a többi menüpont végrehajtása után pedig újra e főmenü jelenik meg. Az egyes almenük hasonló elven épülhetnek fel, de ezekben a befejezés helyett a Vissza az előző menühöz pont választható. Ikontechnika A szöveges menüknél esetenként gyorsabban felismerhetők az egyes választási lehetőségek, ha azokat kicsi jel lemző ábrával, ún. ikonnal jelenítjük meg; közülük rámutatással (kurzormozgató billentyűk vagy egér segítsé gével) választhatunk. Ez a technika azonban könnyen veszélyessé válhat: a túl sok és túl kicsi ikon a képet áttekinthetetlenné teheti. Értelmezési tartomány kijelzése A kérdéseknél nagyon sokszor épp az okoz bizonytalanságot, hogy a felhasználónak fogalma sincs arról, hogy az adatot milyen mértékegységben kell megadni. Ezért a kérdés szövege mellett célszerű közölni az adat mér tékegységét, sőt ha nem magától értetődő, akkor még az értéktartományt is. Így elkerülhető, hogy például a program egy szöget radiánban vár, a gyanútlan felhasználó pedig a legnagyobb természetességgel fokban adja meg az értéket. Az ilyesmiből származó hibát nyilván nem kell ecsetelnünk. Fontos adatok kiemelése Nemcsak az információk könnyebb megértése szempontjából van jelentősége, hanem hasznos a program álla potának, meghatározó paramétereinek azonnali visszajelzésekor is. Például amikor a számítógép egy hosszadalmas számítást végez, vagy bármilyen időigényes tevékenységbe fog, akkor ne maradjon el időnként egy egy kiírás, ami értesíti a felhasználót, hogy mely tevékenységgel foglalkozik éppen a program, és hogy még kis türelmet kér. Látványos lehet ilyen esetekben közölni azt esetleg grafikus formában is, hogy a feldolgozás hány százalékánál tart éppen a program. Tördelés A legelemibb elvárás a képernyőn megjelenő szövegekkel szemben, hogy a sorok/szavak tördelése a helyesírás szabályainak megfeleljen. Ne sajnálja a programozó a fáradságot mondanivalójának gördülékeny megfogalmazására, szép elhelyezésére, hiszen csak ily módon kaphat mindenki számára kellemes programot! Következetesség A következetes beolvasási és kiírási szokások is fontosak. Tartsunk mértékletességet a beolvasási módszerek változatosságában. Nem díjazzák a felhasználók kiterjedt programozási ismereteinket, ha a választ hol ENTERrel lezárva, hol anélkül várja a program. Hasonló probléma az IGEN-NEM választ igénylő kérdések sokféle feldolgozási lehetősége, válasszunk egyfajtát, és ahhoz ragaszkodjunk. Ha lehetőségünk van rá, akkor a lapkezelési technikához kapcsolódva az azonos jellegű kérdések, illetve eredményadatok a lapok azonos helyein jelenjenek meg. Hibajelzés követelményei A hibák kézben tartásának szükségességéről már volt szó, de a hibák jelzésének mikéntje is jellemzi a programot. Igyekezni kell a hibajelzés legmegfelelőbb módjának kiválasztására. Ehhez a következő szempontokat érdemes megfontolni: A hibajelzés ideje. Hibát akkor kell jelezni, amikor bekövetkezett, nem pedig valamely következményekor! Tipikusan bosszantó lehet több száz adat beolvasása után olyan üzenetet látni, hogy 22

23 kezdjük elölről a begépelést, mert a legelső rossz volt. A hibajelzés látványkörnyezete. Ha a kezelői hiba javítása után folytatható a végrehajtás, akkor a képernyőlátványt vissza kell-e, illetve vissza lehet-e állítani? A hibajelzés időtartama. Mindig a felhasználó dönthessen a továbbhaladásról! Kerüljük az adott időtartamig megjelenő hibajelzéseket! A felhasználó ugyanis lehet lassúbb vagy gyorsabb, esetleg éppen nem a képernyőre figyel, és így elmulaszthatja a hibajelzést. A hibajelzés mozgósító ereje. Biztosan észlelhető legyen, érthető legyen, azaz ne legyen túl rövid csak a program írója ismeri a megfejtést, esetleg külön búvárkodást igényel, túl hosszú az ember az ilyenkor természetes türelmetlensége miatt csak hevenyészve képes végigszaladni a leírt regényen, a várható felhasználói számára érthető szakkifejezéseket tartalmazzon. Felesleges azonban abban az esetben külön hibajelzés szöveget kiírni, amikor a kérdés szövegéből egyértelmű, hogy a felhasználó mit rontott el. Ekkor elég például egy hangjelzés, majd a kérdés újra feltevése. Naplózás A program futása során több olyan esemény következhet be, amelyeket jó feljegyezni a későbbi esetleges feldolgozás érdekében. A felhasználó nem biztos, hogy megteszi ezeket. Ennek megoldására szolgál az ilyen események automatikus fájlba írása, a naplózás. Ez többnyire egy egyszerű szerkezetű szöveges fájl, amit a használó könnyen (egy igénytelen szövegszerkesztővel is) képes megjeleníteni, nyomtatni. Funkcióbillentyűk Érdemes lehet egyes funkciókhoz, funkciócsoportokhoz egy-egy billentyűt hozzárendelni, és annak bármikori lenyomása a megfelelő funkciók végrehajtását jelenti. Például szimulációs programokban gyakran találkozunk olyan funkcióbillentyűkkel, amelyek a szimuláció leállítására, újra paraméterezésére, megjelenítési módjának változtatására, részleges összesítések elkészítésére stb. vonatkoznak. Segítség Egy tipikus funkcióbillentyű a segítség (HELP=SÚGÓ) billentyű. Ennek lenyomása a futás bármely pillanatában a program aktuális állapotáról szükséges tudnivalók kiírását eredményezi. Ennek egy hasznos formája a menüben mozgás alatti segítség, amely az aktuális menüpont részletes leírását adja a felhasználó kívánságára Ablaktechnika A homogén képernyő helyett célszerű olyan lapokat, ún. ablakokat használni, amelyek a képernyő elkülönített részein jelennek meg. Egy ablak mindig egy keret, és egy a belsejében levő tartalom. Az ablak kiírásakor a képernyőn alatta lévő részt eltakarja, és levételekor újra megjelenik az eltakart rész. Ablakokat használhatunk a segítségszöveg megjelenítésére, hibajelzésre, menük kezelésére, a program állapotának kijelzésére stb. Programkészítés lépései Feladat meghatározása (specifikáció) Algoritmus készítése Kódolás Tesztelés, hibakeresés, javítás Hatékonyságvizsgálat Dokumentálás Feladat meghatározása (specifikáció) A feladat lehető legpontosabb, rövid, egyértelmű írásos megfogalmazása. A program helyes működéséhez szükséges körülmények megfogalmazása. Specifikáció tartalmazza a következőket A specifikációnak tartalmaznia kell a bemenő és a kimenő adatok leírását, azok értékhalmazát is meg kell ad nunk, tartalmaznia kell a feladatban használt fogalmak definícióját, valamint az eredmény kiszámítási szabá lyát. Itt lehetne megadni a bemenő adatokra vonatkozó összefüggéseket is. A bemenő, illetve a kimenő adatokra 23

24 kirótt feltételeket nevezzük előfeltételnek, illetve utófeltételnek. Az előfeltétel nagyon sokszor egy azonosan igaz állítás, azaz a bemenő adatok értékhalmazát semmilyen külön feltétellel nem szorítjuk meg. Feladat: Valaki nyissa ki az ablakot! Bemenet: ablak, valaki (pl. Géza), ablaknyitó tevékenység Előfeltétel: csukva legyen az ablak Kimenet: ablak Utófeltétel: nyitva legyen az ablak Feladat: Add meg az osztályból a 10. legnagyobb emberkét! Bemenet: osztály, magasságok, kiválasztási módszer Előfeltétel: legalább 10 fő legyen az osztály, legyenek csökkenő sorba rendezve Kimenet: egy emberke Utófeltétel: előtte 9 ember legyen 1. Feladat: Valaki adja meg az osztályból magasság szempontjából a középső embert! Bemenet: osztály, magasságok, kiválasztási módszer Előfeltétel: legyenek növekvő sorba rendezve Kimenet: egy vagy kettő emberke Utófeltétel: előtte és utána is ugyanannyi emberke legyen 2. Feladat: Kerüljön fel a táblára egy angol szó! Bemenet: tábla, valaki (pl. Géza), táblára írás módszere Előfeltétel: valaki (pl. Géza) tudjon egy angol szót Kimenet: tábla Utófeltétel: táblán legyen egy angol szó A feladatspecifikáció történhet szövegesen, illetve matematikai és logikai szimbólumok alkalmazásával. Mindkét esetben maximális pontosságra és egyértelműségre kell törekednünk. A specifikáció során használható szimbólumok A feladatok specifikálásakor gyakran alkalmazunk logikai műveleteket, valamint a matematikai logika egyéb szimbólumait. A legtöbbször használt jelek a következők: ÉS logikai művelet VAGY logikai művelet KKOR logikai művelet (implikáció) AKKOR és CSAK AKKOR logikai művelet (ekvivalencia) minden logikai kvantor létezik logikai kvantor Példaként tekintsünk egy rövid részletet egy feladatspecifikációból, amely az előbbi szimbólumokat használja: Jelekkel: i (1<= i <=N) : (A[i]>0 B[i]<0) C[i]<0 Szöveggel: minden 1 és N közé eső i értékre, amennyiben az A tömb i. eleme pozitív, a B tömb i. eleme pedig negatív, akkor a C tömb i. eleme negatív. Megfigyelhető, hogy a jelekkel felírt specifikáció sokkal tömörebb. 24

25 Algoritmuskészítés Algoritmus Az algoritmus olyan pontos elírás, amely megmondja, hogy milyen műveleteket kell meghatározott sorrendben elvégezni, hogy megoldjuk a problémát. Az algoritmus olyan pontos elírás, amely megmondja, hogy milyen műveleteket kell meghatározott sorrendben elvégezni, hogy megoldjuk a problémát. Algoritmussal szemben támasztott követelmények Legyen időben és lépésszámban véges. Legyen egyértelmű: ugyanazon bemenet adatokra minden esetben ugyanazt az eredményt szolgáltassa. Legyen általános: ne csak egy konkrét feladatot oldjon meg, hanem lehetőleg minél szélesebb problémaosztályt! (Pl. ne csak egy konkrét másodfokú egyenletet oldjon meg, hanem bármelyiket) Algoritmikus elemek program, értékadó utasítás, beolvasó utasítás, kiíró utasítás, megjegyzések, utasításblokk (szekvencia), elágazások (szelekció), ciklusok (iteráció). Program A program minden esetben utasítások sorozata. Program: utasítás Program vége. Értékadó utasítás Változók legtöbbször értékadó utasítással kapnak értéket. Az értékadás jel: :=, a bal oldalán a célként megje lölt változó, jobb oldalon pedig a kiszámítandó kifejezés szerepel. azonosító := kifejezés pl. a:=12 Az azonosító tetszőleges objektum neve lehet, a kifejezés pedig a matematikában és más tudományokban hasz nált operátorokat, függvényeket, konstansokat tartalmazhat. Beolvasó utasítás Tetszőleges adat beolvasására szolgál a felhasználó által kezelt perifériáról (billentyűzet). Mivel a felhasználó nem része a programnak, ezért az általa beírt adatok és a program által várt paraméterek típusát, értékhalmazát ellenőrizni kell. Az adatokat karakteresen kell megadni, és beolvasáskor a megfelelő változó típusa szerinti automatikus konverzió történik. Be: azonosítók [feltételek] A feltételek elmaradhatnak, ha a beolvasandó értékekre semmilyen előfeltevésünk nincs. Kiíró utasítás A felhasználó által figyelt perifériára helyezi el az adatokat karakteresen. Ki: kifejezések [formátum megkötés] 25

26 Ha a kiírás formátumára van valamilyen speciális megkötésünk, akkor az itt szerepelhet, illetve a legtöbb ilyet majd a kódolásnál kell megfontolni. Megjegyzések Az algoritmusban elhelyezhetünk magyarázó szövegeket, a program állapotára vonatkozó állításokat, bármit, ami az olvashatóságot növeli, a későbbi munkánkat megkönnyítheti. [magyarázó szöveg] Utasításblokk szekvencia A szekvenciát alkotó utasítások a megadás (leírás) sorrendjében végrehajtandók. Utasítás1 Utasítás2... Pl.: Kelj fel! Moss arcot! Fésülködj meg Elágazás szelekció Két (vagy több) műveletcsoport közül csak az egyiket kell végrehajtani. A döntés mindig valamilyen logikai feltételtől függenek, és annak ismeretében egyértelmű a döntés. Egyszerű elágazás Egy utasításblokkból áll. Az utasításblokk a feltételtől függően vagy végrehajtásra kerül, vagy nem. Ha logikai kifejezés akkor utasítássor Összetett elágazás Két utasításblokkból álló A két utasításblokk közül a feltételtől függően pontosan az egyik utasításblokk hajtódik végre. Ha logikai kifejezés akkor utasítássor különben utasítássor Összetett elágazás Több utasításblokkból álló A több utasításblokk közül legfeljebb az egyik kerül végrehajtásra elképzelhető, hogy egyik feltétel sem telje sül. Ekkor ha van KÜLÖNBEN ág, akkor az hajtódik végre ha nincs KÜLÖNBEN ág, akkor egyik blokk sem hajtódik végre ha több feltétel is teljesül, akkor sorrendben csak az első hajtódik végre Ha logikai kifejezés akkor utasítássor különben ha logikai kifejezés akkor utasítássor különben utasítássor Elágazás feltétel_1 akkor utasítássor_1 feltétel_2 akkor utasítássor_2 feltétel_n akkor utasítássor_n egyéb esetben utasítássor_n+1 Elágazás vége. 26

27 Ciklus iteráció Egy feltételtől függően egy adott utasításblokk többszöri ismételt végrehajtását jelenti. Az utasításblokkot cik lusmagnak, a feltételt ciklus vezérlő feltételnek nevezzük. Elöltesztelős ciklus Feltétel előbb értékelődik ki, majd megfelelő esetben végrehajtásra kerül a ciklusmag előbb tesztel, aztán ciklusmag. Ciklus amíg logikai kifejezés utasítássor Ciklus vége Hátultesztelős ciklus A ciklusmag végrehajtódik, majd kiértékelődik a ciklus vezérlő feltétel, és megfelelő esetben újra végrehajtásra kerül a ciklusmag. Egyszer mindenképpen lefut a ciklus. ciklus mag, majd tesztelés Ciklus utasítássor amíg feltétel Ciklus vége Számlálós/Növekményes ciklus A ciklusmag utasításai a fejrészben megadott számszor hajtódnak végre, megadott lépésenként. Ciklus cv=k tól L ig utasítássor Ciklus vége. Eljárás, függvények, operátor Programjainkat célszerű részfeladatokra bontani. Az olyan részfeladatokat megoldó részprogramokat, amelyek valamit csinálnak, nevezzük eljárásoknak. Az eljárások egyik fontos szerepe az absztrakció támogatása. Az eljárás formailag ugyanúgy néz ki mint a (fő)program. Használata egyszerűen a nevének a leírásával történik, önálló utasításnak számít. Eljárás Eljárásnév: utasítássor Eljárás vége. Az eljárások paraméterezhetőek, az eljáráson belül használt paramétereket formális paramétereknek, az eljárás hívásánál is fel kell sorolni, itt aktuális paramétereknek nevezzük. A paramétereket megkülönböztetjük még bemenő (amiből az eljárás számol valamit) és kimenő (amit ered ményül ad az eljárás). Egy másik csoportosításban a paraméter értéke az eljárásban vagy megváltozik (változó paraméter), vagy pedig nem (konstans). Eljárás Eljárásnév(formális paraméterek): utasítássor Eljárás vége. Eljárás hívás: Eljárásnév(aktuális paraméterek) Az eljárás mellet a másik absztrakciós eszköz a függvény. Definiálása hasonló az eljáráshoz, használata formai lag ugyanaz, csak nem önálló utasításként, hanem kifejezésben szerepel. 27

28 Függvény Függvénynév(formális paraméterek): függvényérték típusa utasítássor Függvénynév:=kifejezés Függvény vége. Függvény hívás: Változónév = Függvénynév(aktuális paraméterek) Vannak speciális függvények, amelyeket a többiektől eltérő módon használunk, jelüket nem az argumentumuk elé, hanem argumentumaik közé írjuk, ezeket operátoroknak vagy műveleteknek nevezzük. Művelet Operátornév(formális paraméterek): értékének típusa utasítássor Operátornév:=érték Művelet vége....aktuális paraméter_1 Operátornév aktuális paraméter_2 Műveletek csoportosítása Elemi műveletek Azok a tevékenységek, amelyek nem igényelnek magyarázatot, azonnal végrehajthatók. Ezen műveleteket a végrehajtó (a számítógép) ismeri, és azokat végre tudja hajtani. Elemi utasítások: értékadás, függvényhívás, beolvasás, kiíratás. Összetett műveletek Azok a tevékenységek, amelyek elemi tevékenységekből épülnek föl, tartalmukat mindig meg kell magyarázni, maguk is egyszerűbb algoritmusokból épülnek föl. Ezen tevékenységeket a végrehajtó (a számítógép) nem is meri, azok további magyarázatra várnak, ki kell bontani őket. Összetett utasítások: utasítás blokk (több utasítás egyben), elágazások: döntési szerkezetek, ciklusok: ismétlési szerkezetek. Algoritmus leíróeszközök Néhány ismertebb algoritmus leíróeszköz: folyamatábra (blokkdiagram), struktogram, Jackson módszer, mondatszerű leírás (pszeudokód). Folyamatábra (blokkdiagram) Az egyik legkorábban kialakult megadási mód. Alapjeleit maga Neumann János dolgozta ki. A nyilakkal jelöl jük a végrehajtási sorrendet. Téglalap: értékadó utasítás, eljárások, Rombusz vagy hatszög: az egy vagy többágú kiválasztás, Paralelogramma: az adatáramlás, Kör: a vezérlő utasítások Az ismétlési szerkezeteket elrejtve tartalmazza az ábra. 28

29 5. Ciklusok: 29

30 30

31 Struktogram Gépfüggetlen, nyelv független algoritmus leíró nyelv. Az egyes szerkezeti elemeket különböző téglalapba fog lalható ábrákkal jelöljük. A szerkezetek egymásba ágyazhatók, de vonalaik nem keresztezhetik egymást. A fo lyamatábra hibáit próbálja meg kiküszöbölni ezzel. Előny: a program gráfot élek nélkül ábrázolja, egyetlen alapelem marad a téglalap. Hátrány: rajzossága miatt terjedelmes nehezen javítható nehezen olvasható 31

32 Jackson diagram Szekvencia esetén az utasításokat balról jobbra haladva kell végrehajtani, a kétféle elágazásnál az igaz feltételű, jobb felső sarkában kis karikával (o) jelölt téglalap tartalmát, ciklusnál pedig mindaddig, amíg a feltétel teljesül, a jobb felső sarkában csillaggal (*) jelöltét. Az új eszköz egyértelmű előnye az algoritmus és adatleírás egységessége, áttekinthetősége azonban az eddigi eknél is rosszabb. A szekvenciát itt azonnal, mint sok utasítás szekvenciáját definiáltuk, a többi alapelem a szo kásossal megegyező. 32

33 Mondatszerű leírás Az anyanyelvi megfogalmazáshoz hasonló, de annál tömörebb leírási mód. Az élőnyelv pontatlanságait próbál juk vele kizárni, de még egyszerűen értelmezhető marad. 1. Értékadó utasítás változó := kifejezés Az utasítás hatására a változó felveszi a kifejezés aktuális értékét. 2. Beolvasó utasítás BE: változók [az adatokkal szemben állított követelmények] Kiírató utasítás KI: kifejezések [a kiírás formájára vonatkozó követelmények] 3. Utasítás sorozat: Egymás alá írással adjuk meg az egymás után végrehajtandó utasításokat 4. Elágazás Egyszerű: HA logikai kifejezés AKKOR utasítások Összetett: HA logikai kifejezés AKKOR utasítások KÜLÖNBEN utasítások ELÁGAZÁS VÉGE. HA logikai kifejezés AKKOR utasítások KÜLÖNBEN HA logikai kifejezés AKKOR utasítások KÜLÖNBEN utasítások ELÁGAZÁS VÉGE. ELÁGAZÁS feltétel_1 AKKOR utasítássor_1 feltétel_2 AKKOR utasítássor_2 feltétel_n AKKOR utasítássor_n EGYÉB ESETBEN utasítássor_n+1 ELÁGAZÁS VÉGE. 5. Ciklusok Elöltesztelős CIKLUS AMÍG logikai kifejezés utasítássor CIKLUS VÉGE Hátultesztelős CIKLUS utasítássor AMÍG feltétel CIKLUS VÉGE Számlálós CIKLUS cv=k tól L ig utasítássor CIKLUS VÉGE. 33

34 6. Eljárás vagy függvény megadás: ELJÁRÁS eljárás_neve (paraméterek) utasítások ELJÁRÁS VÉGE Az eljárás vagy függvény hívása nevének és paramétereinek leírásával történik meg. A program egy kitüntetett szerepű eljárás (vagy függvény), neve meghatározott: PROGRAM neve: utasítás sorozat PROGRAM VÉGE. FÜGGVÉNY Függvénynév(formális paraméterek): függvényérték típusa utasítássor Függvénynév:=kifejezés FÜGGVÉNY VÉGE. Kódolás A kész terveket egy választott programozási nyelven kódoljuk. Vannak olyan szoftverek, amelyek a kódolást a terv alapján automatikusan elvégzik. Az elkészült forráskód olyan, mint egy épület esetében a tervrajz. A for ráskódból egy fordítóprogram hozza létre a futtatható gépi kódú programot. Tesztelés, hibakeresés, javítás Tesztelés: Minden program hibás. Az elkészült programot minimum két szempontból alaposan elemezni kell. Minden esetben helyesen működik e? Hatékony e? A hatékonyság három fő mérőszáma a tárhelyhasználat, a sebesség és a bonyolultság. Szinte lehetetlen minden hibát biztosan javítani, ezért a szoftverfejlesztés egyik központi kérdése a hibakeresés hibajavítás ciklus szerve zése. Hibajavítás: A felismert hibák kijavításához új specifikáció, új terv és újrakódolás lehet szükséges. A programtesztelés módszereit két csoportba oszthatjuk, aszerint, hogy a tesztelés során végrehajtjuk e a prog ramot vagy nem. Ha csak a program kódját vizsgáljuk, akkor statikus, ha a programot végre is hajtjuk a teszte lés során, akkor dinamikus tesztelésről beszélünk. Statikus tesztelési módszerek kódellenőrzés, formai ellenőrzés, tartalmi ellenőrzés, ellentmondás keresés, felhasználatlan objektumok, felhasználatlan változóérték, érték nélküli változó, végtelen ciklus, stb. Statikus (számítógép nélküli algoritmus, ill. forrásellenőrzés) 1. Szemantikai hiba: logikátlan lépések 2. Szintaktikai hiba: nem helyesen lett beírva a programba. Dinamikus (lefuttatjuk a programot) 34

35 Hibák észlelése (mi a hiba?) Nem indul el a program, Nem áll le a program, Megszakad a programfutás, Rossz eredményt ír ki, Nem ír ki semmit, Hibakeresés A hibakeresési módszerek kétféle kérdésre adhatnak választ: A bemenetnek mi az a része, amire hibásan működik a program? Hol található a programban a hibát okozó utasítás? Mire kell kicserélni a hibás részt, hogy a hibát megszüntessük? Hibakeresési eszközök kiírás: a program bizonyos helyeire elhelyezünk tesztkiírásokat. nyomkövetés: végrehajtott utasítások követése a programban, futás során az eredmény képernyő mellett a programszöveget is látnunk kell. A programszövegből éppen végre hajtott utasítást látjuk, vagy a programszövegben mutatja egy mutató az aktuális utasítást. adatnyomkövetés: nyomkövetés speciális esete. Akkor kapunk a képernyőn üzenetet, ha kijelölt változó(ka)t valami használja, módosítja. töréspontok elhelyezése: a töréspontok a program olyan utasításai, aminél végrehajtáskor meg kell állnia. A felhasználó információt szerezhet a program állapotáról és folytathatja a végrehajtást. lépésenkénti végrehajtás: olyan eszköz, amely a program minden utasítására egy törés pontot definiál. Tipikus hibák A hibakeresést nagyban megkönnyíti az, ha tudjuk, hogy mire figyeljünk. Szép számmal vannak olyan hibák, amelyeket sokan, sokszor követnek el. A hibakeresés első lépése lehet e tipikus hibák megvizsgálása. Ebben a fejezetben ezeket soroljuk fel vázlatszerűen. Gépelési hibák 0 számjegy és O betű keverése. Alapszavak különírása. Változónevek és alapszavak egybeírása. Elválasztójel hiánya vagy rossz helyre tevése vagy keverése (,;:). Sorokra tagolási hiba. Elágazásszervezési hibák Elágazás ágainak felcserélése. Sokirányú elágazás hibás feltételű kétirányúvá alakítása. Sokirányú elágazás nem létező egyéb ággal. Elágazáslezárási hiba (nincs, vagy rossz helyen van). Ciklusszervezési hibák Kezdő és lezáró utasítások rossz helyen vannak. Hibás ciklushatárok, lépésköz. 0 vagy nagyon kis valós szám lépésközű ciklus. Számlálós ciklus ciklusmagja akkor is lefut egyszer, ha nem kell. Kilépési feltételben szereplő változónak az első belépéskor még nincs értéke. Ciklusváltozó nem változtatása feltételes ciklusnál. Ciklusváltozó változtatása számlálós ciklusnál. Bemeneti adatok hibái Hibás típusú bemenő adat. 35

36 Kevesebb adat beolvasása, mint amit a program vár. Több adat beolvasása, mint amit a program vár. Nem megengedett típusú változó beolvasása. Kimeneti adatok hibái Hibás típusú kimenő adat. Kép utolsó sorába írás soremeléssel a kép elcsúszik. Kép jobb alsó pontjába írás a kép elcsúszik. Fájlok hibái Nem létező fájl megnyitása. A fájl nem ott van, ahol keressük. Nem adtuk meg a fájlnévben a kiegészítőt. Nem azonos a fájl szerkezete azzal, amit a program vár. Hibás fájlvége kezelés. Írásvédett fájlba írás. Változókkal kapcsolatos hibák Hatásköri hibák Láthatósági hibák Kezdőérték nélküli változó használata (a program előszörre, illetve másodszorra különbözőképpen fut hat) Konstans megváltoztatása Ciklusváltozó használata a cikluson kívül Kifejezések hibái Típuskeveredés. Túlcsordulás vagy alul csordulás (emiatt asszociativitási, disztributivitási hibák). Hibás zárójelezés. Nullával osztás, négyzetgyök, logaritmus negatív számból. Kerekítési hiba. Szimmetrikus logikai műveletek miatti hibák. Tömbindexhatár hibák, memóriaméret hibák, indexek felcserélése. Logikai formulák tagadásában az ÉS és a VAGY műveletek hibás tagadása. Eljárások hibái Aktuális paraméterek száma nem megfelelő. Aktuális paraméterek típusa nem megfelelő. Aktuális paraméterek sorrendje nem megfelelő. A függvényérték típusa nem megfelelő. Nincs függvényérték visszaadás a függvénydefinícióban vagy valamelyik ágán. Érték szerinti paraméter megváltoztatása nem jut vissza a hívóhoz. Mellékhatások problémái. Grafikai hibák Ablakrelativitás figyelembe nem vétele. Szövegvágás furcsaságai (teljes szövegre vágás). Képernyő vágás nélküli kezelése kívülre rajzolás miatti memória felülírás. Nem megfelelő grafikus kártya. Grafikus driver hiánya. Nem az aktuális grafikus kártya méretparamétereihez igazodó rajzolás. 36

37 Torzítási hibák (négyzet, kör). Hibaüzenetek értelmezése Melyik fájlban és hanyadik sorban van a hiba Traceback (most recent call last): File "feladat1.py", line 6, in <module> szam=rw_input("kérek egy negatív számot! ") NameError: name 'rw_input' is not defined File "feladat1.py", line 11 szam=szam+ ^ SyntaxError: invalid syntax A hibás rész Hibatípus megnevezése, itt nincs definiálva Melyik fájlban és hanyadik sorban van a hiba A hibás rész Hibatípus megnevezése, szintaxis hiba, ismeretlen szintaxis File "feladat1.py", line 10 print("a szám: +str(szam)) ^ SyntaxError: EOL while scanning string literal Melyik fájlban és hanyadik sorban van a hiba A hibás rész Hibatípus megnevezése, szintaxis hiba Hibakeresés (Bedugolás) A programozás nagyon összetett és, mint minden emberi tevékenység során, ennek során is számos hibát köve tünk el. Anekdotai okokból a programozási hibákat bug oknak nevezzük. A detektálásukra és javításukra hasz nált technikák együttesét debugnak nevezzük. Háromféle típusú hiba létezhet egy programban: szintaxishibák, szemantikai hibák, végrehajtás közben fellépő hibák. Bedugolás technikák Lépésenkénti végrehajtás A lépésenkénti végrehajtás segítségével programunknak mindig egyetlen sorát tudjuk végrehajtani. Ilyenkor egy egységnek nem egy utasítás, hanem egy sor számít, ha egy sorba több utasítást írunk, ezeket mind egy lé pésben fogja a gép végrehajtani. Töréspont A töréspont lényege, hogy a program elindítása előtt kijelölhetjük azt a sort, amelyiknél majd a végrehajtást szeretnénk megállítani. Változók és kifejezések pillanatnyi értékének figyelése A hibakeresés másik hatékony eszköze a változók tartalmának figyelése. Ezt a legáltalánosabb módon (amely minden programozási környezetben működik) úgy valósíthatjuk meg, hogy a változók tartalmát a program megfelelő helyein kiíratjuk a képernyőre. Ez azonban elég körülményes, hiszen egyrészt állandóan módosíta nunk kell a programszöveget, és a futtatás előtt kell döntenünk, hogy mely változók lesznek érdekesek szá munkra, másrészt egy összetettebb adat áttekinthető kiíratásához már egy kisebb programot kell írnunk. Kivételkezelés A kivételkezelés egy programozási mechanizmus, melynek célja a program futását szándékosan vagy nem szándékolt módon megszakító esemény (hiba) vagy utasítás kezelése. Az eseményt magát kivételnek (except ion) hívjuk. A hibaüzenet két részből áll, amit : választ el. Elöl van a hiba típusa, utána egy, a hibára vonatkozó specifikus információ következik. Számos esetben előre lehet látni, hogy bizonyos hibák léphetnek fel a program egyik vagy másik részében. Ezekbe a programrészekbe beépíthetünk olyan speciális utasításokat, amik csak akkor aktiválódnak, ha ezek hibák fellépnek. Az olyan magasszintű nyelvekben, mint amilyen a Python, lehetőség 37

38 van arra, hogy egy felügyelő mechanizmust kössünk egy egész utasításcsoporthoz és így egyszerűsítsük azok nak a hibáknak a kezelését, melyek ezen utasítások bármelyikében felléphetnek. A Python kivételkezelő mechanizmusa a try except else utasításcsoportot használja, ami lehetővé teszi egy hiba elfogását és egy erre a hibára nézve specifikus scriptrész végrehajtását. Ez a következő módon működik: A try t követő utasításblokkot a Python feltételesen hajtja végre. Ha az egyik utasítás végrehajtásakor hiba lép fel, akkor a Python törli a hibás utasítást és helyette az except et követő kódblokkot hajtja végre. Ha semmilyen hiba sem lép fel a try utáni utasításokban, akkor az else et követő kódblokkot hajtja végre (ha ez az utasítás je len van). A program végrehajtása mindegyik esetben a későbbi utasításokkal folytatódhat. try: except (NameError,TypeError): except: print 'Nem várt kivétel lépett fel' else: print 'semmilyen kivétel nem lépett fel' Példa: try: szam = int(raw_input("kérek egy számot:")) except ValueError: print "Nem számot adtál meg!" else: print "Számot adtál meg." Beépített hibajelzések AssertionError Az assert utasítás sikertelen. AttributeError Helytelen attribútumra való hivatkozás vagy értékadás. EOFError Közvetlen fájlvége, melyet input() vagy raw_input() generál. FloatingPointError ssikertelen lebegőpontos számítás. IOError I/O kapcsolatos I/O mûveletek hiba. ImportError Import' álási hiba, nem találja a modult vagy a nevet. IndexError Szekvencia indexelése nem az értéktartományon kívül esik. KeyError Nem létező táblaváltozó (dictionary típusú változó) kulcsra hivatkozunk. KeyboardInterrupt Felhasználó a megszakítás billentyû esetében (gyakran Control C'). MemoryError Kimerült visszaállíthatatlan memória. NameError Nem meghatározott lokális vagy globális név keresésekor. NotImplementedError Az örökölt osztályban a megvalósítandó absztrakt metódus nem valósult meg. OsError Az operáció rendszerrel kapcsolatos hiba. 38

39 OverflowError Nagyon nagy aritmetikai művelet esetében. RuntimeError Elavult mindenre használható módszer; helyette definiáljunk egy alkalmas hibaüzenetet. StopIteration Egy iterator next() metódusa sehova sem mutat. SyntaxError Az elemző szintaktikai hibát talált. SystemError Nem végzetes interpreterhiba, ún. "bug", kérjük jelentse. SystemExit Sys.exit()' meghívásakor. TypeError Beépített operátornak vagy függvénynek helytelen típust adunk át. UnboundLocalError A függvény vagy metódus megpróbál hozzáférni egy lokális változóhoz, de annak nincs értéke. ValueError Argumentum hiba esetén, melyet a TypeError nem tartalmaz vagy annál pontosabban meghatározott. ZeroDivisionError Osztásnál vagy modulo műveletnél 0 második argumentum esetében. Saját kivétel létrehozása class MyError(Exception): def init (self, value): self.value = value def str (self): return repr(self.value) Hatékonyságvizsgálat Hatékonyság fogalma A specifikációnak megfelelően elkészített, működőképes programjaink általában sok szempontból még nem tö kéletesek. A legtöbb kész program javítható: gyorsabbá tehető memóriaigénye csökkenthető programkódja egyszerűbbé tehető. A programok ilyen szempontból történő vizsgálatát hatékonyságvizsgálatnak nevezzük. A hatékonyabbra írás alapfeltétele a program helyes működése, hiszen egy rosszul működő program esetében nincs értelme hatékonyságról beszélni. A hatékonyságvizsgálat már az algoritmuskészítés idején megjelenik, de gyakran az elkészült forráskód haté konysága is javítható. A hatékonyság vizsgálata több szempontból is fontos: szűkös erőforrások esetén költségkímélés céljából a gyakorlati használhatóság miatt Hatékonyságvizsgálat szempontjai végrehajtási idő, helyfoglalás (memóriában, háttértárakon), bonyolultság. 39

40 Hatékonyságvizsgálat szintjei Globális hatékonyság A globális hatékonyság növelése az algoritmus hatékonyabbá tételét jelenti, ez tehát valójában a program tervezés része. Egy program tényleges hatékonyságát alapvetően a globális hatékonyság határozza meg. Lokális hatékonyság A programkód egyszerű transzformációit jelenti, általában a program működésének megértése nélkül, me chanikusan is elvégezhető. Jelentősége kisebb, mint a globális hatékonyságé, de nem elhanyagolható. Algoritmus hatékonysága jó algoritmus, ciklusok végrehajtási száma (egymásba ágyazott ciklusok nagyon lassítják), egy ciklus végrehajtási ideje, feltételvizsgálat száma, kivételesetek kiküszöbölése. Programkód hatékonysága jó adattípusok (kis helyfoglalás, gyors számolás a real számtípus nem szabványos, nem támogatja a koprocesszor), feltételek egyszerűsítése, lehetőleg ne használjunk különböző adattípusokat egy kifejezésben (átváltás miatt), függvények kiszámítását ritkán alkalmazzuk. Dokumentálás A program egy termék, és egy termékhez mindig tartozniuk kell különböző leírásoknak. Mire is lehet szükség egy program kapcsán? Először is egy leendő felhasználónak el kell döntenie, hogy milyen programot, akar használni. Ha a programot megvette, akkor el szeretné helyezni a számítógépén, majd használ ni szeretné, és a felhasználásban segítséget vár. Nemcsak a felhasználónak van szüksége dokumentációra, hanem a fejlesztőnek, karbantartónak is (nem véletle nül adnak például háztartási készülékeinkhez műszaki leírást is). Nyilvánvaló, hogy ez a két vagy többfajta dokumentáció másoknak szól, így nem egy egységes dokumentáció ról fogunk beszélni, hanem többfajta dokumentumról. Dokumentáció fajtái Fejlesztői dokumentáció A fejlesztői dokumentációt használja az, akinek a programban hibát kell keresnie, a hibát ki kell javítania, a programot hatékonyabbra kell írnia, át kell vinnie más gépre, át kell írnia más nyelvre, valamint tovább kell fej lesztenie. Az ő munkájuk megkönnyítése érdekében a fejlesztői dokumentációban szerepeljenek a következők: specifikációk, követelményanalízis (korlátozások, pl. megkívánt hatékonysági jellemzők, alkalmazan dó adatszerkezetek). A feladat és a megoldástól elvárt követelmények meghatározása. Ezt még a fel adat kitűzője adta, vagy vele történt megbeszélés során pontosodott a megoldás első lépéseként. a futási környezet leírása: számítógép, operációs rendszer, memóriaméret, (speciális) perifériaigény, grafikus kártya (felbontóképesség, színek száma ) fejlesztői környezet leírása: a választott programnyelv(ek), és verziószáma(i), eljáráskönyvtárak, uni tok (azaz a szükséges programdarabok fájljai). az algoritmusok és az adatok (típusok, osztályok, programkonstansok) leírása, ezek kapcsolata. Dön tések, más lehetőségek, érvek, magyarázatok. kód, implementációs szabványok (ún. kódolási szabályok, egyéni konvenciók), döntések; 40

41 tesztesetek, azaz milyen (jellegzetes) bemeneti adatokra, milyen eredménnyel válaszol a program. hatékonysági mérések (hatékonysági tesztesetek), megfontolások, javaslatok az esetleges hatéko nyabbra írásra. fejlesztési lehetőségek. a készítő adatai. Felhasználói dokumentáció Ezt a dokumentumot használja a felhasználó, az üzembe helyező, a betanító. Nekik szükségük van a következőkre: a feladat egy rövid összefoglaló leírás is kell az áttekintés miatt és egy részletes a pontos használat hoz. a futási környezet leírása: számítógép, operációs rendszer, memóriaméret, perifériaigény, grafikus kártya,... (megegyezik a fejlesztői dokumentáció ugyanilyen című részével). a használat leírása hogyan kell a programot betölteni/elindítani, milyen kérdéseket tesz fel, mik a le hetséges válaszok, mik a program egyes lépései, lehetőségei (nagyvonalú funkcionális leírás). bemenő adatok, eredmények, szolgáltatások részletes leírása: mit, mikor, milyen sorrendben kell megadni (részletes funkcionális leírás). mintaalkalmazás példafutás. A felhasználó főleg a betanító ennek alapján tudja előre gép nél kül elképzelni a programot. hibaüzenetek és a hibák lehetséges okai mi a teendő valamely hibaüzenet láttán. Látható ebből, hogy a felhasználói és a fejlesztői dokumentáció több közös jellemzőt tartalmaz. Programismertető A programismertető célja a vásárló, programkereső ember meggyőzése arról, hogy e program felel meg legin kább igényeinek. Ez a hangzatos, reklám jellegű stílus mellett a következőket igényli: a feladat rövid, szöveges leírása, áttekintési céllal. a program tulajdonságainak rövid leírása. minimális hardver és szoftver (operációs rendszer és az esetlegesen megkívánt egyéb, a programmal együtt nem szállított szoftverkellékek, pl. driverek, dll ek stb.) környezet. Installálási kézikönyv, operátori kézikönyv Nagyobb programok esetén külön installálási (üzembe helyezési) kézikönyvet mellékelnek, máskor ez a fel használói dokumentáció része. Ebben szerepel mindaz az információ, aminek segítségével egy több generáló lemezről a program elhelyezhető a gépünkön úgy, hogy az aktuális környezetben optimálisan működjön. (Ügyelni kell arra, hogy az installáció minél kevesebb számítástechnikai ismerettel végrehajtható legyen! Fel lehet használni olyan célprogramokat, amelyeket kifejezetten erre terveztek, de legalább egy batch programmal automatizálni kell. Ilyen automatizmus esetén is dokumentálni kell az installációs folyamat lépéseit.) Az operátori kézikönyv olyan rendszereknél különül el a felhasználói kézikönyvtől, ahol más a program fel használója és más a kezelője. Dokumentáció tulajdonságai Szerkezet A dokumentáció elsődleges célja segítségnyújtás a program leendő felhasználóinak, továbbfejlesztőinek. Ezért olyannak kell lennie, hogy minden számukra szükséges tudnivalóhoz könnyen hozzájuthassanak. Ehhez elsőd leges szempont természetesen, hogy a dokumentáció mindezeket tartalmazza, de a használatát egyéb követel mények betartásával jelentősen megkönnyíthetjük. Ezek a következők: a dokumentáció ne legyen túl hosszú, hiszen egy program használatához senki sem akar egy re gényt elolvasni; a dokumentáció ne legyen túl rövid, mert akkor tömörsége miatt érthetetlen lesz, s így használhatat lan; a dokumentáció legyen világosan tagolt, és a tagolás segítse elő az egyes tudnivalók gyors keresését; 41

42 a dokumentáció legyen tömör: az olvasója ne vesszen el a részletekben; a dokumentáció legyen olvasható: a túlságos (és kizárólagos) formalizálás az érthetőség rovására megy; a dokumentáció legyen pontos: az olvasója minden kérdésére tartalmazza a választ. Forma A dokumentáció használatát néhány formai jellemző nagyban megkönnyítheti. Ezek egyike a tartalomjegyzék. Másik, dokumentációkban ennél ritkábban használt, de néha kifejezetten nagy segítséget nyújtó eszköz az in dex. Az nyilvánvaló, hogy világos szerkezetű kell legyen: kitalálható mondanivalójú fejezetekre bontva. További stí lusjegyek megegyeznek bármely szakmai kiadványéval. Stílus A programismertető egyértelműen reklámcélra szolgál. Itt dicsérni kell a programot, kiemelve jó tulajdonságait. A felhasználói dokumentáció elsősorban részletes szöveges leírás, amely időnként lehet szájbarágó is. (Cél szerű figyelembe venni a várható felhasználói kört a leírás részletességének, a szájbarágósság szintjének meg tervezésénél. Például teljességgel fölösleges egy Windows környezetben futó program esetében az ablakkeze lésről általánosságban szólni.) A fejlesztői dokumentációban minden más szempontnál fontosabb a pontosság, emiatt ebben kerülhet elő a ma tematikai leírás, a formális specifikáció. Az installálási, illetve az operátori kézikönyv elsősorban utasítások, teendők pontos felsorolása, utalva a lehet séges válaszok következményeire. 42

43 Dokumentáció általános alakja Felhasználói dokumentáció Feladat Feladat megfogalmazása. Használat A program indítása: Honnan indul, mi a program neve. A program indítása: Egy lehetséges párbeszéd: A felhasználó mit lát." A program eredménye: Egy példa eredmény kiírása, amit a felhasználó látna. Hibalehetőség: Ha a program hibákat kezel, hogyan is teszi, mit fog tapasztalni a felhasználó. Fejlesztői dokumentáció Feladat Feladat megfogalmazása. Környezet Milyen gép, operációs rendszer, program szükséges hozzá. Forráskód A forráskód milyen néven, és hol található. Megoldás Fontosabb típusok Változók, konstansok megadása. Algoritmus A feladat megoldása mondatszerű algoritmus leírással. Kód A program kódja. Tesztelés Érvényes tesztesetek: helyes eredményhez vezet. Érvénytelen tesztesetek: Hibás adatok megadására példák. Hatékonysági tesztesetek {Egyelőre nincsenek.} Fejlesztési lehetőségek Hogyan lehet fejleszteni a programot. Készítő Program készítőjének neve 43

44 Példa dokumentációra Felhasználói dokumentáció Feladat A program olvasson be két számot, adja össze azokat, majd írja ki az összeget! Használat A program indítása: Dokumnetumok könyvtárban taláható osszeg.py Indítása Terminálból python osszeg.py prancs kiadásával. A program indítása: Egy lehetséges párbeszéd: Kérem az első számot: 12 Kérem az első számot: 3 A program eredménye: A két szám összege: 15 Hibalehetőség: Szám helyett szöveg megadása, a hiba nincs lekezelve. Fejlesztői dokumentáció Feladat A program olvasson be két számot, adja össze azokat, majd írja ki az összeget! Környezet Forráskód Dokumnetumok könyvtárban taláható osszeg.py Indítása Terminálból python osszeg.py prancs kiadásával. Megoldás Fontosabb típusok szam1, szam2, osszeg: Valós Algoritmus Program osszeg: Ki: Kérem az első számot: Be: szam1 Ki: Kérem a második számot: Be: szam2 osszeg=szam1+szam2 Ki: A két szám összege: Ki: osszeg Program vége Kód szam1=raw_input( Kérem az első számot: ) szam2=raw_input( Kérem a második számot: ) osszeg=szam1+szam2 print( A két szám összege +str(osszeg)) Tesztelés Érvényes tesztesetek: szam1=2, szam2=3, osszeg=5 szam1=-2, szam2=3, osszeg=1 Érvénytelen tesztesetek: szam1=a, szam2=2 Fejlesztési lehetőségek Szöveg típust ne olvashasson be. Készítő Dobosné Varsányi Anita 44

45 Strukturált program Böhm Jacopini tétel: (1966) A szekvencia, szelekció és az iteráció segítségével minden olyan algoritmus felépíthető, amelynek egy belépési és egy kilépési pontja van. A csak szekvenciákból, szelekciókból és iterációkból építkező programot strukturált programnak nevezzük. A strukturált programozásban a ciklusból való kiugrás fogalma ismeretlen. Ebből kö vetkezik, hogy a program minden szekvenciájának és így az egész programnak is egyetlen belépési és egyet len kilépési pontja van, ennélfogva a program lényegesen áttekinthetőbb. Szekvencia: egymás után végrehajtható utasítások sorozata. Szelekció: választás megadott tevékenységek közül. Iteráció: megadott tevékenységek ismételt végrehajtása. Típusok Nyelvek típusossága A típus egy algebrai struktúra: értékhalmazból és azon értelmezett műveletekből áll. A típusfogalom erőteljes sége alapján típus nélküli, típusos, erősen típusos nyelvekről. Gyengén és erősen típusos nyelvek Azokat a nyelveket, amelyekben kötelező minden használni kívánt változót deklarálni és minden adattípussal szigorúan csak olyan műveletet enged végezni, amely a típusra lehetséges, erősen típusos nyelvnek nevezzük. Ezzel szemben a gyengén típusos nyelvekben nem kötelező a változók deklarálása. A fordító az első érték adáskor, a kapott értékből állapítja meg a típust és a definiálást automatikusan elvégzi. A műveletek ellenőrzé sekor is kevésbé szigorú, ugyanis, ha találkozik egy olyan művelettel, amely az adott típussal nem elvégezhető (pl. karakterek szorzása), akkor megpróbálja az adatokat olyan típusúvá átalakítani, amelyre értelmezve van a művelet. A gyengén típusos nyelvek nagy hátránya, hogy a hibák felderítése hihetetlenül megnehezedik. Például, ha elír juk egy változó nevét, akkor azt hiszi a fordító, hogy egy új változót szeretnék használni. Az erősen típusos nyelvek esetén, ha elírjuk a változó nevét egy helyen, akkor szól a fordító, hogy ilyen nevű változót nem dekla ráltunk. Előnyük viszont, hogy nem kell "vacakolni" a deklarációval. Hosszabb programok esetén megéri az erősen típusos nyelvek használata. Gyengén típusos nyelv pl. a Visual Basic, JavaScript. Erősen típusos nyelv pl. a C++, JAVA, Delphi(Pascal) Típuskompatibilitás Mikor végezhető el a következő A:=B értékadás? Az egyértelmű válasz, akkor, ha azonos típusúak. Két típus azonos, ha szerkezetük azonos. Típuskényszerítés Ha kifejezésben különböző típusú tényezők szerepelnek, akkor vagy kötelező a felhasználónak típuskonverziós függvénnyel azonos típusúvá alakítani őket, vagy automatikus konverzió, típuskényszerítés történik. Altípus Olyan típus, amely értékeit egy másik típus értékhalmazából veszi, örökli a másik típus műveleteit, s a másik tí pussal minden esetben kompatibilis. Származtatott típus Ez egy másik típusból származó típus, értékeit a másik típus értékhalmazából veszi, műveleteit örökölheti az őstípustól, s az őstípussal nem ekvivalens típus. 45

46 Statikus és dinamikus típusok Statikusnak nevezünk egy típust, ha az adott típushoz tartozó értékek a memóriában mindig azonos helyet fog lalnak el. Dinamikus típushoz tartozó értékekhez futás közben különböző tárterület tartozik. Paraméteres típus Paraméteres típusok paraméterezhetők konstansokkal, változókkal, típusokkal. Adatok, adatszerkezetek Változó A változó egy elnevezett memória terület. Jellemzői: a neve, memóriacíme, típusa, pillanatnyi értéke. A válto zókat első használat előtt deklarálni kell, azaz meg kell adni a változó nevét és típusát. Ennek hatására a fordító automatikusan kijelöl egy (virtuális) memóriacímet ennek a változónak. Arról, hogy melyik cím lett lefoglalva a változó számára a programozónak nem kell tudnia, hiszen a programban mindenütt a változó nevével hivatko zunk a területre. Erre a területre eltárolhatunk adatot (ha már volt ott adat, akkor felülírva azt), azaz értéket adunk a változónak, illetve hivatkozhatunk a pillanatnyilag éppen ott található értékre. Tehát az érték megvizsgálható és módosítható. - A változó neve: nevek képzésének vannak szabályai, ezek természetesen programozási nyelvenként eltérő ek lehetnek. Legtöbb nyelvben a szabályok a következők: a nevek betűkből és számokból állhatnak, betűvel kell kezdődjenek (semmiképpen sem lehetnek bennük írásjelek vagy szünet!!). - A változó memóriacíme: nem kell ismernünk az értékét, de bizonyos nyelvekben felhasználjuk. - A változó pillanatnyi értéke: egy változónak a definiálás pillanatától kezdve van pillanatnyi értéke. Még akkor is ha még nem adtunk neki értéket (persze ez az érték nem valódi eltárolt érték), de ilyenkor nem cél szerű felhasználni a pillanatnyi értéket. A definiált, de még értéket nem kapott változókat inicializálatlan változóknak szokás nevezni. Egyes nyelvek fordító programjai nem engedik felhasználni az inicializálatlan változók értékét, míg más nyelveknél a programozó felelőssége, hogy ne használja. - A változó típusa: a típus egyrészt meghatározza a lefoglalt memóriaterület nagyságát, van 1 byte os, 2 byte os, 4 byte os, stb. másrészt meghatározza, hogy az adatot hogyan lehet kezelni, egész számként, valós számként, karakterkódként, stb. harmadrészt meghatározza, hogy milyen műveletek végezhetők az adattal. Konstans A konstans is egy memóriatartományt reprezentál, adott típusú értéket tárolhat, ez az érték megvizsgálható, de nem módosítható. Definíció, deklaráció A definíció és deklaráció szinte teljesen azonos fogalmak. Ha változó deklarálásáról beszélünk, akkor azt akar juk kifejezni, hogy megadjuk a fordító számára egy használni kívánt változó nevét és típusát. Ha változó defini álását emlegetünk változó deklarálása helyett, akkor azzal azt hangsúlyozzuk ki, hogy lefoglalódik egy hely a változónak a memóriában. Egy változót egyszer lehet definiálni, de bizonyos körülmények között előfordul, hogy többször deklaráljuk. Vagyis egyszer történhet egy változó számára helyfoglalás, de lehetséges, hogy többször is tudatnunk kell a fordítóval a változó nevét és típusát. (Például többmodulos programok esetén.) Inicializálás Inicializálásnak nevezzük, amikor egy változó definiálásával egyidejűleg értéket is adunk a változónak. (Nem összetévesztendő az inicializált változó fogalmával, lásd változó pillanatnyi értéke.) Deklarációkiértékelés A deklarációs rész végrehajtása kétféleképpen történhet, a statikus deklarációkiértékelés fordításkor elvégezhe tő, a dinamikus deklarációkiértékelés viszont csak futási időben. Azonosító A programozási nyelv objektumaihoz, konstansaihoz, változóihoz, típusokhoz, programegységeihez, fordítási 46

47 egységekhez rendelt nevet hívjuk azonosítónak. Az azonosítók elnevezésere a programozási nyelvek különböző szabályokat vezettek be. Általános szabály: az azonosítók betűkből és számjegyekből állhatnak. Védett azonosítók Programozási nyelvek egy része fordíthatóság miatt megtiltja, hogy alapszavait azonosítóként használjuk. Eze ket a nem használható azonosítókat nevezzük védett azonosítóknak. Azonosítók átlapolása (túlterhelés) Különböző objektumokat általában különböző azonosítóval jelöljük, de ez nem mindig van így. Két objektum neve lehet ugyanaz, ha a hatáskörük különböző. Hozzáférési jog Az adat módosíthatósága és lekérdezhetősége. Kezdőérték Kezdőértéknek nevezzük a memóriába képezéskor a lefoglalt helyre elhelyezett értéket. Hatáskör Egy azonosító hatáskörének nevezzük a programszöveg azon tartományát, amelyben a definíciója érvény ben van. Globális: minden eljárásból elérhető. Saját: Csak az adott eljárásban használható Lokális: Csak az őt közvetlenül tartalmazó eljárásban használható. Láthatóság A program azon része, ahol lehetséges a hozzáférés (egy lokális változó eltakarhat egy külső változót). Blokkstruktúra esetén egy programegység belsejében egy másik programegység az azonosítókat újradefini álhatja. Ekkor a belső azonosító hatáskörében eltakarja a külsőben definiált azonos nevű azonosítót. Azt a programszövegbeli tartományt, ahol az azonosítót semmi sem takarja, nevezzük láthatósági körnek. Ez vagy azonos a hatáskörrel, vagy része annak. Élettartam A futási idő azon része, ahol az azonosító ugyanazt az adatot jelenti. Statikus változónak nevezzük azokat a változókat, amelyek élettartalma a program teljes futási ideje. Ezeket a fordítóprogram egy statikus memó riahelyen helyezi el. Dinamikus változók a program futási idejének csak egy részében létezik. Típus Az alábbi adattulajdonságok összessége: értékhalmaz, műveletek, ábrázolás. Értékhalmaz Az a halmaz, amelyből a változó értéket vehet fel. 47

48 Adat csoportosítása (értékhalmaz szempontjából) Egyszerű típusok Szerkezetileg nem bontható tovább. Például: egész, valós, logikai, karakter, mutató (adat címe), felsorolás, intervallum. Összetett(strukturált) típusok Szerkezettel rendelkezik. Például: rekord (különböző típusú, de logikailag összetartozó típusok együttes kezelése), halmaz, szöveg (karakterek sorozata), sorozat, tömb (mátrix). Típus meghatározásnál megadjuk az értékhalmazát, a hozzátapadó műveletek, a relációk körét. Az elemi adattípusok lehetséges műveleteit 3 csoportba szokás sorolni: értékadó, típusátviteli: relációs, szelekciós (egy elem kiválasztásának módja), konstrukciós (hogyan képezzük), számosság (hány elemű az értékhalmaz), transzformációs (ugyanarra a típusra képez le, például +,,min, előző). Az összetett adattípusok műveletei további csoportokat alkothatnak: lekérdező (egy egy érték kiolvasása), bővítő (új adat felvétele), szűkítő (adat törlése), mozgató (kívánt adat kiválasztása), egyéb (hibakezelés, hány eleme van,...). A típus harmadik jellemzője az adatok memóriában történő tárolása. Egész típus Értékhalmaz (Min'Egész..Max'Egész) Műveletek +,, *, Div (egészosztás), ^ (pozitív egész kitevős hatványozás), Mod, - (unáris mínusz). Relációk =, <,, >,,. Ábrázolás ún. kettes komplemens kódú. 48

49 Valós típus Értékhalmaz????..???? (Min'Valós..Max'Valós nem definiáltak, vagy implementációfüggő) Műveletek +,, *, /, ^, - (unáris mínusz). Relációk =, <,,, >,. Ábrázolás ún. lebegőpontos ábrázolás (mint az alábbiakból kitűnik, pontosabb lenne, ha e típust racionálisnak neveznénk, mert csak racionális számot képes ábrázolni). Logikai típus Értékhalmaz Hamis..Igaz (Min'Logikai..Max'Logikai: Hamis, illetve Igaz) Műveletek Nem, és, vagy (a szokásos logikai műveletek). Relációk =, <,,, >, (a belső ábrázolásuk alapján). Ábrázolás 0 =Hamis 1 =Igaz(néha 1 =Igaz). Karaktertípus Értékhalmaz kódú jelek (Min'Karakter..Max'Karakter: a 0, illetve a 255 kódú karakter) Műveletek nincs. Relációk =, <,,, >, (a belső ábrázolásuk alapján). Ábrázolás Valamely ún. karakter készlet alapján. Példaként az ASCII karakter készletből lássunk néhány kód hozzárendelést: 0 31: ún. kontrollkarakterek; 32 64: szóköz, szokásos írásjelek, illetve számjegyek (48 57 = '0' '9'); 65 91: nagybetűk; 92 : kisbetűk, grafikus jelek (erősen implementációtól függően). Felsorolástípus Mindazon típusokat, amelyek értékkészletét konstansainak egyszerű fölsorolásával adhatjuk meg, diszkrét típusnak hívjuk. Speciálisan tehát ilyen az egész, a logikai, a karakter, de lehet bármilyen a program írója által kreált absztrakt konstansokat tartalmazó ún. absztrakt felsorolástípus is. 49

50 Értékhalmaz (konstans1, konstans2,, konstansn) (Min'Típus..Max'Típus: konstans1..konstansn) A konstansok maguk a típus értékkészletét meghatározó rendezett absztrakt értékek. Műveletek a rendezettségre építenek az alábbi függvények; nem értelmezett helyeken nem definiált az értékük: Következő (típusbeli kifejezés), Előző (típusbeli kifejezés), Rend (típusbeli kifejezés). A deklarációban a kezdőérték megadásához a korábbi szokás szerint használható a Típusnév nevű konstrukciós függvény. Emellett azonban a végrehajtáskor sokszor jó haszonnal jár az alábbi értelmezésű párja: Típusnév(0..Rend(Max'Típusnév)). Ez utóbbi függvény jelentése: a paraméterként megadottadik típusbeli konstans. Tehát mintha ez a Rendfüggvény inverzeként viselkednék! Relációk =, <,,, >, (a felsorolás sorrendje egyben a rendezés is). (Rész)Intervallumtípus (diszkrétből származtatott típus) Értékhalmaz konstans1..konstans2 (Min'Típus..Max'Típus: konstans1..konstans2) A származtatás által meghatározott bázistípus adott részhalmaza, helyesebben részintervalluma. Műveletek Ugyanazok, amik a bázistípuson értelmezettek (a felsorolástípusoknál említett típuskonstrukciós függ vényt itt nem definiáljuk; lásd a példa utáni megjegyzést!). Relációk Ugyanazok, amik a bázistípuson értelmezettek. Valós résztípus Értékhalmaz valós kons1... valós kons2 valós kons3 lépéssel (Min'Típus..Max'Típus: kons1... kons2) Olyan valósakat tartalmaz, amelyek előállíthatók a kons1+i*kons3 formulával, ahol i = 0..(kons2 kons1) / kons3. Műveletek Korlátozott valós műveletek (csak a formulával előállíthatók jöhetnek ki automatikus kerekítéssel, ha szükséges), vagy ha nem ilyen, akkor mint egyszerű valós értékkel lehet csak továbbszámolni. Relációk valós relációk. Rekord A rekord segítségével több (akár különböző) típusú adatot egyesíthetünk egyetlen egésszé. A rekord felhasz nálásával létesíthetünk egy újtípust, amely a definiáláskor felhasznált típusokból tevődik össze. Egy ilyen rekordtípusú adat kezeléséhez bevezettünk ún. konstrukciós és szelekciós műveleteket. Az előbbivel létre tudunk hozni ilyen típusú adatot, az utóbbiakkal az egyes összetevők hozzáférését biztosítjuk. Az egyes 50

51 összetevőknek egyedi nevet kell adni a definiáláskor, ami egyben a hozzáférést lehetővé tevő műveletben is elő fog bukkanni. Ezt hívják mezőnévnek, amit azonosít, azt mezőnek. Értékhalmaz alaptípus direktszorzata (pl. szöveg X egész) Műveletek értékadás, reláció (=, <, >), kiválasztás (ponttal jelöljük) Ábrázolás Mezőnként folytonos memóriaterületen Példa TDátum=Rekord(év,hó,nap:Egész) TSíkPont=Rekord(x,y:Valós) THallgató=Rekord(kód:Egész, név:szöveg, szül:tdátum) Változó: valaki: THallgató valaki.név a hallgató nevét jelenti Vektor/Tömb A programozásban a vektor a tömb más néven. A lényege, hogy sok azonos típusú elemet egyesítünk a vektor fogalmában egy adategységgé. Itt is egy típuskonstrukciós eszközről van szó, hasonlóan a rekordhoz, és épp úgy kell, legyen konstrukciós és szelekciós műveletének. Értékhalmaz Alaptípus iteráltja és a lineáris rendezettség jellemzi: pontosan egy megelőző és következő létezik. Műveletek Alaptípussal megegyezik, kiválasztás. Megadása név(indextípusok felsorolása:értéktípus) alakban történik. Példa TSíkPont=Tömb[1..2:Valós] [a korábbi síkbeli pontok egy másfajta tipizálása] TNevek=Tömb[1..MaxN:Szöveg] [MaxN db nevet tartalmazó vektorok típusa] Konstans O:TSíkPont(0,0) [konstans deklaráció: origó] Változó Névsor:TNevek [kezdőérték explicit megadása nélküli létrehozás] Mátrix A mátrix különlegessége a vektorhoz képest az, hogy nem egy, hanem kettő indexszel jelölhetők ki az elemei, azaz beszélhetünk a mátrix sorairól (ezt jelöltük ki az első indexével) és oszlopairól (ezt a második in dexe határozta meg). Nyilván a definiáláskor (de legkésőbb létrehozásakor) kell megadni a sorainak és oszlo painak a számát. Példa TMárix=Tömb[1..MaxN,1..MaxM:Valós] [egy MaxN*MaxM es mátrix tipizálása] TKeresztRejvény=Tömb[1..10,1..10:Karakter] [egy 10*10 es keresztrejtvény típusa] Változó m:tmátrix [kezdőérték explicit megadása nélküli létrehozás] rejtvény:tkeresztrejtvény [kezdőérték explicit megadása nélküli létrehozás] 51

52 Halmaz Értékhalmaz Az alaptípus iteráltja, amely rendelkezik a halmaz tulajdonsággal (minden elem különböző, nincs sor rendiség) Műveletek Értékadás, halmaz relációk, unió, metszet, különbség, eleme e, üreshalmaz (ez hozza létre), jele: []. Példa napok=(hétfő,kedd,szerda, csütörtök,péntek,szombat,vasárnap) Halmaztípus=HPélda napok=(hétfő,almaz(napok) vagy SET OF napok Szöveg Értékhalmaz Karakterek direkt szorzata, lehet fix hosszúságú, vagy változó. Műveletek Értékadás, reláció (karakter kódra), + (konkatenáció), jele(szöveg,i) a szöveg i dik karaktere, melyet ál talában 0 tól számolunk, esetleg szövegkezelő függvények. Példa Változó: s: szöveg s:= Ez egy példa Sorozat Értékhalmaz Alaptípus iteráltja és a lineáris rendezettség jellemzi: pontosan egy megelőző és következő létezik. Műveletek Az alaptípussal megegyezik, kiválasztás. Megadása: név(indextípus:értéktípus) alakban történik. A sorozatot egydimenziós tömbbel valósítjuk meg. Példa változó s: sorozat(1..10:egész) nem használatos helyette: változó s: tömb(1:10:egész), vagy tömb[1..10:egész] Ki: s(1) 52

53 Számábrázolások Számábrázolás Amikor a számítógépben egy értéket ábrázolunk, azt mindig adott méret u tárterületen tehetjük. Így nem kezel hetünk akármilyen számokat, az ábrázolás korlátja a felhasználható bitek száma, melyet mindig előre rögzíteni kell. Egy bájt bitjeit 0 tól 7 ig szokás számozni, ahol 0 a legalacsonyabb helyi értékű bit. Fixpontos ábrázolás Fixpontos szám ábrázolás során az ábrázolás előre rögzített kettedes jegy pontos, azaz a kettedes és egész je gyek száma adott. Ezt általában egész számok ábrázolását jelenti, mikor a kettedes jegyek száma nulla. Szokat lan ugyan, de elképzelhető a valós számok fixpontosábrázolása. Nemnegatív egész számok A decimálisan adott számot binárissá alakítjuk, majd tároljuk, a megadott méretű területen, hogy ezt valóban kitöltsük, balról nullákkal egészítjük ki a számot. Példa: A legkisebb ábrázolható szám n biten: 0 A legnagyobb ábrázolható szám n biten: 2n 1 Egész számok A negatív számok ábrázolásara három megoldás létezik, melyekből az utóbbi kettő használatos. 1. Előjeles egész szám ábrázolás Az előjeles ábrázolásnál a legmagasabb helyi értékű bitet előjel jelzésére tartjuk fenn. Megállapodás szerint a pozitív előjelnek a 0, míg a negatívnak az 1 es felel meg. A fennmaradó biteken a szám abszolút értékét tárol juk. Problémát jelent azonban, hogy nulla kétféle is létezik, +0 és 0, valamint a kivonás művelete viszonylag komplikáltan implementálható. Példa: A legkisebb ábrázolható szám n biten: 2n 1 1 A legnagyobb ábrázolható szám n biten: +2n Kettes komplemens A negatív számok helyett azok kettes komplemensének tárolását jelenti. A kettes komplemens az egyes komp lemensnél eggyel nagyobb szám, ahol az egyes komplemens egyszerűen a szám bitenkénti negáltja (amennyi ben bináris számról van szó). Egy ábrázolt szám legmagasabb helyi értékű bitje pontosan akkor 1, ha a szám negatív volt (bár nem tárolunk előjelet, ez mégis olyan egyszerűen megállapítható, mint az előjeles ábrázolás nál). A negatív számot úgy kapjuk vissza, hogy a kettes komplemens képzését visszafelé hajtjuk végre, avagy ismét a kettes komplemensét képezzük. Előnye, hogy a kivonást nem kell implementálni, ez egyszerűen negatív szám hozzáadását jelenti. A kettes komplemens előállítása közben túlcsordulás léphet fel, de ekkor a túlcsordult bittel nem foglalkozunk. Példa: 53

54 A legkisebb ábrázolható szám n biten: 2n 1 A legnagyobb ábrázolható szám n biten: +2n Feszített előjeles ábrázolás Szokás eltolásos vagy alapértékes ábrázolásként is emlegetni. A negatív számokat is úgy tároljuk, mintha pozi tívak lennének. Ezt úgy érjük el, hogy minden ábrázolni kívánt számhoz hozzáadunk egy előre rögzített c kons tans értéket. A legkisebb ábrázolható szám c lehet. Az összeadást elvégezve, így mindenképp nem negatív számot kapunk, melynek ábrázolása már ismertetésre került. Előnye, hogy lebegőpontos számításoknál, ha a ki tevőt így tároltuk el, az egyes számjegyek valódi helyi értékei könnyen kiszámíthatók. Az előjel megállapításá hoz azonban vissza kell alakítani a számot. Példa: A legkisebb ábrázolható szám n biten c = 2n 1 mellett: 2n 1 A legnagyobb ábrázolható szám n biten c = 2n 1 mellett: +2n 1 1 Lebegőpontos ábrázolás A lebegőpontos szám ábrázolás a számok hatványkitevős felírásán alapszik. e M ak e { 1, +1} Hogy e felírás egyértelmű legyen, M mindig kisebb kell legyen, mint 1, és az első nem egész jegy nem lehet 0. 1/a M < 1 A lebegőpontos szám többnyire bináris számok hatványkitevős alakja. Többféle megoldás létezik, melyből ket tőt nézünk meg, mindkét esetben az egyszeres pontosságú (4 bájton történő) ábrázolást tekintve: Hexadecimális alap Az IBM gépek a bináris számot hexadecimális alakban képezik le, és így végzik el a normálást, azaz a törtrész első hexadecimális jegyének kell nullánál nagyobbnak lennie. A legmagasabb helyi érték u bit mindig a szám előjele. Ezt követi a karakterisztika mely most 7 bites, így a maradék három bájton, a mantissza (M ) mint 6 számjegyű hexadecimális szám jelentkezik. A karakterisztika feszített előjeles, ahol c = 64. Példa: Bináris alap A PDP típusú gépek a bináris számot normálják. Ez azt jelenti, hogy az első kettedes jegy legyen nullánál na gyobb. Mivel bináris számoknál ez mindig az 1 es értéket fogja jelenteni, ennek tárolása felesleges, a fennmara dó egy bittel kibővíthetjük a karakterisztikát, mely így 8 bitesre duzzad. A karakterisztika eltolása c = 126 (ezt általában 128 nak kéne venni 8 bites feszített előjeles ábrázolás esetén, a konkrét példa azonban, melyet a ma napság is használt valós típus szolgáltat, nem ilyen). Így az ábrázolható számok: 1, , tartományba esnek és 7 8 tizedes jegyre pontosak. Példa: 54

55 Programozási tételek Programozási tétel fogalma A programozási tételek típusalgoritmusok, amelyek alkalmazásával garantáltan helyes megoldást adhatunk a programozási munka során gyakran előforduló, tipikus programozási feladatokra. A programozási tételek nem egyedi feladatokra, hanem feladatosztályokra adnak megoldást, ezért a megfogal mazásuk is általános. Azokat a típusalgoritmusokat tekintjük programozási tételeknek, melyeknek helyessége (matematikai jellegű módszerekkel) bizonyított. Tételek megfogalmazásának elemei Feladatkitűzés: az általános feladat szöveges formában Specifikáció: az általános feladatban szereplő adatok (intervallumok, függvények, relációk) megadása, elő és utófeltételek megadása Algoritmus: az általános specifikációban szereplő adatok segítségével megfogalmazott megoldás. Tételek alkalmazásának lépései Specifikáljuk a konkrét programozási feladatot. A specifikáció ismeretében eldöntjük, hogy az adott feladat programozási tétellel megoldható e. Ha igen, kiválasztjuk a megfelelő programozási tételt. Néha ez többféleképpen is megtehető. A tételben szereplő általános elemeket megfeleltetjük az aktuális feladat konkrét adatainak. A megfeleltetés és a tétel általános algoritmusa alapján behelyettesítés módszerével megadjuk az aktuális feladat megoldását. Tételek csoportosítása A programozási tételek a bemenő és kimenő adatok jellege szerint az alábbi módon csoportosíthatók: Egy sorozathoz egy értéket rendelő tételek. Ide soroljuk azokat is, amelyek egy sorozathoz néhány (kettő, három) egymással összefüggő értéket rendelnek. (Pl. lineáris keresés.) Egy sorozathoz egy sorozatot rendelő tételek. Pl. Rendezések, kiválogatás. Egy sorozathoz több sorozatot rendelő tételek. Pl. szétválogatás Több sorozathoz egy sorozatot rendelő tételek. Pl. Metszet, unió. Egy sorozathoz egy értéket rendelő tételek Összegzés tétele Kitűzés Adott egy sorozat, a sorozat elemein értelmezett egy + művelet. Feladat: Határozzuk meg a sorozat elemeinek az összegét! Specifikáció m,n: egész (tömb kezdő és vég indexe) f:[m..n] H-ból veszi elemeit, H-n értelmezett + művelet s: H (s a végeredmény) Előfeltétel: m,n, f adott, m<=n n Utófeltétel: s= f (i) i=m / azaz s tartalmazza az f függvény [m..n] intervallum elemeihez rendelt függvényértékeinek az összegét / Algoritmus Eljárás Összegez: s:=0 55

56 Ciklus i:=m-től n-ig s:=s+f(i) Ciklus vége Eljárás vége Megszámlálás tétele Kitűzés Adott egy sorozat, a sorozat elemein értelmezett egy T tulajdonság. Feladat: Határozzuk meg a sorozat T tulajdonságú elemeinek a számát! Specifikáció m,n: egész T:[m..n] -> logikai s: egész Előfeltétel: m,n, T adott, m<=n Utófeltétel: s n 1 i m T (i ) / azaz s tartalmazza az [m..n] intervallum azon elemeinek a számát, amelyekhez T igazat rendel / Algoritmus Eljárás Megszamlal: s:=0 Ciklus i:=m-től n-ig Ha T(i) akkor s:=s+1 Elágazás vége Ciklus vége Eljárás vége Eldöntés tétele Kitűzés Adott egy sorozat, a sorozat elemein értelmezett egy T tulajdonság. Feladat: Döntsük el, hogy van-e a sorozatban T tulajdonságú elem! Specifikáció m,n: egész T:[m..n] -> logikai L:Logikai Előfeltétel: m,n, T adott, m<=n Utófeltétel: L= i [m..n]:t(i) / azaz L igaz, ha létezik ( ) az [m..n] intervallumban olyan elem, amelyhez T igaz értéket rendel / Algoritmus Eljárás Eldontes: i:=m Ciklus amíg (i<=n) és nem(t(i)) i:=i+1 Ciklus vége L:=(i<=n) Eljárás vége 56

57 Kiválasztás tétele Kitűzés Adott egy sorozat, a sorozat elemein értelmezett egy T tulajdonság, és tudjuk, hogy van a sorozatban T tulajdonságú elem. Feladat: Határozzuk meg az első T tulajdonságú elem sorszámát! Specifikáció m,n: egész T:[m..n] -> logikai Ind:egész Előfeltétel: m,n, T adott, m<=n, i [ m.. n ]:T ( i ) / azaz, van olyan elem [m..n]-ben, amelyhez T igazat rendel / Utófeltétel: ind [m..n] és T (Ind ) és i [ m..ind 1]: nem(t (i)) /azaz az Ind az első (legkisebb) olyan elem az [m..n] intervallumban, amelyhez T igaz értéket rendel / Algoritmus Eljárás Kiválasztás: i:=m Ciklus amíg nem(t(i)) i:=i+1 Ciklus vége Ind:=i Eljárás vége Feladatok - határozzuk meg az A és B pozitív egészek legkisebb közös többszörösét! - Adott síkbeli pontok közül válasszuk ki az origótól legtávolabb lévő pontot! - Határozzuk meg az A..B egész intervallum elemei közül azt az egész számot, amelynek a legtöbb prímosztója van! (A>0) Egy sorozathoz egy sorozatot rendelő tétele Másolás, transzformálás tétele Kitűzés Adott egy sorozat, a sorozat elemein értelmezett egy függvény (transzformáció). Feladat: Másoljuk a sorozat elemeinek a transzformáltjait egy másik sorozatba. Specifikáció A:Tömb[1..Max]:HA N:egész / A és B elemszáma f: HA -> HB B:Tömb[1..Max]:HB Ef: A, N adott, 0<= N <= Max Uf: B adott és i [ 1.. N ]:( B [ I ]=f ( A [ I ]) ) / Azaz B tartalmazza az A elemeinek a transzformáltjait / Algoritmus Eljárás Masol: Ciklus i:=1-től N-ig B[i]:=f(A[i]) Ciklus vége Eljárás vége Feladatok - Állítsunk elő egy egészeket tartalmazó tömb elemei alapján egy másik tömböt, amely ugyanezen számok négyzeteit tartalmazza. - Állítsuk elő egy tömb elemeit fordított sorrendben egy másik tömbben! 57

58 Kiválogatás tétele Kitűzés Adott egy sorozat, a sorozat elemein értelmezett egy T tulajdonság. Feladat: Válogassuk ki a sorozat összes T tulajdonságú elemét! Specifikáció A:Tömb[1..Max]:H N:egész / A elemszáma B:Tömb[1..Max]:H DB:egész / B elemszáma Ef: A, N adott, 0<= N <= Max Uf: B adott és tartalmazza az A összes T tulajdonságú elemét, 0 <= DB <= N Algoritmus Eljárás Kivalogat: DB:=0 Ciklus i:=1-től N-ig Ha T(A[i]) akkor DB:=DB+1 B[DB]:=A[i] Elágazás vége Ciklus vége Eljárás vége Feladatok - Adott egy egészeket tartalmazó tömb. Válogassuk ki belőle azokat, amelyek az elemek átlagától legfeljebb 1-el térnek el. Egy sorozathoz több sorozatot rendelő tétel Szétválogatás tétele Kitűzés Adott egy sorozat, a sorozat elemein értelmezett egy T tulajdonság. Feladat: Válogassuk szét a sorozat T tulajdonságú, ill. nem T tulajdonságú elemeit! Specifikáció A:Tömb[1..Max]:H N:egész / A elemszáma B,C:Tömb[1..Max]:H BDB,CDB:egész / B, C elemszáma Ef: A, N adott, 0 <= N <= Max Uf: B, C adott; B tartalmazza az A összes T tulajdonságú elemét; C tartalmazza az A összes nem T tulajdonságú elemét; 0<= BDB <=N, 0<= CDB <=N Algoritmus Eljárás Szetvalogat: BDB:=0 CDB:=0 Ciklus i:=1-től N-ig Ha T(A[i]) akkor BDB:=BDB+1 B[BDB]:=A[i] Különben CDB:=CDB+1 C[CDB]:=A[i] Elágazás vége 58

59 Ciklus vége Eljárás vége Megjegyzés: a szétválogatás több (egymást kizáró) tulajdonság alapján, több vektorba is történhet. Feladat - Egy személyi adatokat (név, nem, telefonszám, fizetés) tartalmazó vektor rekordjait válogassuk szét: nemek szerint ill. fizetési kategóriák szerint ( ; ; ; nél több) Több sorozathoz egy sorozatot rendelő tételek Metszetképzés tétele Kitűzés Adott két sorozat, a sorozatokon belül egy-egy elem csak egyszer szerepel. Feladat: Határozzuk meg azt a sorozatot, amely a két sorozat közös elemeit tartalmazza. Specifikáció A,B:Tömb[1..Max]:H N,M:egész / A és B elemszáma C:Tömb[1..Max]:H L: egész / C elemszáma Ef.: A,B adott, elemeik egyediek; 0<=N<=Max, 0<=M<=Max Uf: C tartalmazza A és B közös elemeit, 0<=L<=Min(A,B) /a metszet legfeljebb annyi elemet tartalmaz, mint a kisebb elemszámú sorozat/ Algoritmus Elve: minden A-beli elemet keresünk a B tömbben. Ha egy A-beli megtalálható a B-ben, akkor felvesszük a közös elemek közé, a C-be. Eljárás Metszet: L:=0; Ciklus i:=1-től N-ig j:=1; / A[i] keresése B-ben Ciklus amíg j<=m és A[i]<>B[j] j:=j+1 Ciklus vége Ha j<=m akkor / Ha A[i] megtalálható B-ben L:=L+1 C[L]:=A[i] Elágazás vége Ciklus vége Eljárás vége Feladat Ismerjük a bostoni, ill. a New York-i maratoni futóversenyeken célba érkezők névsorát. Készítsük el azok névsorát, akik mindkét versenyen célba értek! Unióképzés tétele Kitűzés Adott két sorozat, a sorozatokon belül egy-egy elem csak egyszer szerepel. Feladat: Határozzuk meg azt a sorozatot, amely minden olyan elemet tartalmaz, amely legalább az egyiknek eleme. Specifikáció A,B:Tömb[1..Max]:H N,M:egész / A és B elemszáma C:Tömb[1..2*Max]:H 59

60 L: egész / C elemszáma Ef.: A,B adott; elemeik egyediek; 0<=N<=Max, 0<=M<=Max Uf: C tartalmazza az A és B sorozatok unióját, Max(A,B)<=L<=M+N Megjegyzés: a kimenő sorozat elemszáma legrosszab esetben 2*Max, ez akkor áll elő, ha A és B is Max elemet tartalmaz, és nincsen közös elemük. Algoritmus Elve: először A összes elemét átmásoljuk C-be. Majd B elemeit sorra vesszük, és mindazokat, amelyek nem szerepelnek az A tömbben, szintén C-be másoljuk. Eljárás Unio: Ciklus i:=1-től N-ig /A elemeinek másolása C-be C[i]:=A[i] Ciklus vége L:=N Ciklus j:=1-től M-ig i:=1 / B[j] keresése A-ban Ciklus i<=n és B[j]<>A[i] i:=i+1 Ciklus vége Ha (i>n) akkor / Ha B[j] nem szerepel A-ban L:=L+1 C[L]:=B[j] Elágazás vége Ciklus vége Eljárás vége Feladat Ismerjük a bostoni, ill. a New York-i maratoni futóversenyeken célba érkezők névsorát. Készítsük el azok névsorát, akik legalább az egyik versenyen célba értek! Összefuttatás tétele (UNIÓ) Az összefuttatás rendezett sorozatok rendezett unióját (metszetét, különbségét, szimmetrikus differenciáját) állítja elő. A rendezettség miatt az összefuttatás hatékonyabb, mint az egyszerű unió, metszet tétel. Az algoritmust először unióra fogalmazzuk meg. Kitűzés Adott két rendezett sorozat, a sorozatokon belül egy-egy elem csak egyszer szerepel. Feladat: Határozzuk meg a két sorozat rendezett unióját. Specifikáció A,B:Tömb[1..Max]:H N,M:egész / A és B elemszáma C:Tömb[1..2*Max]:H L: egész / C elemszáma Ef.: A,B adottak, elemeik egyediek és növekvően rendezettek; 0<=N<=Max, 0<=M<=Max Uf: C tartalmazza az A és B sorozatok rendezett unióját, Max(A,B)<=L<=M+N Algoritmus Az összefuttató algoritmus lényege (unió esetén), hogy a két bemenő sorozat aktuális elemeit összehasonlítva a kisebbik az eredménysorozatba kerül, és a kisebb elem sorozatában továbblépünk. Egyenlő elemek esetében az elem az eredménysorozatba kerül, és mindkét sorozatban lépünk. Ha az egyik sorozat elfogy, a másik maradék elemei bekerülnek az eredménysorozatba. Eljárás OsszefuttatUnio: i:=1 j:=1 l:=0 Ciklus amíg (i<=n) és (j<=m) l:=l+1 60

61 Elágazás A[i]<B[j] esetén C[l]:=A[i] i:=i+1 A[i]>B[j] esetén C[l]:=B[j] j:=j+1 A[i]=B[j] esetén C[l]:=A[i] /vagy C[l]:=B[j] i:=i+1 j:=j+1 Elágazás vége Ciklus vége / Az esetleg megmaradó elemek másolása C-be, a két ciklus közül legfeljebb az egyik hajtódik végre! / Ciklus k:=i-től N-ig /Csak akkor fut le, ha marad elem A-ban/ l:=l+1 C[l]:=A[k] Ciklus vége Ciklus k:=j-től M-ig /Csak akkor fut le, ha marad elem B-ben/ l:=l+1 C[l]:=B[k] Ciklus vége Eljárás vége Összefuttatás tétele (METSZET) Kitűzés Adott két rendezett sorozat, a sorozatokon belül egy-egy elem csak egyszer szerepel. Feladat: Határozzuk meg a két sorozat rendezett metszetét, azaz, azokat az elemeket, amelyek mindkét sorozatban szerepelnek. Specifikáció A,B:Tömb[1..Max]:H N,M:egész / A és B elemszáma C:Tömb[1..Max]:H L: egész / C elemszáma Ef.: A,B adottak, elemeik egyediek és növekvően rendezettek; 0<=N<=Max, 0<=M<=Max Uf: C tartalmazza az A és B sorozatok rendezett metszetét, 0<=L<=Min(A,B) Algoritmus Metszet esetén az algoritmus annyiban változik, hogy csak az egyező elemek kerülnek az eredménysorozatba, és a végén a két ciklus értelemszerűen elmarad. Eljárás OsszefuttatMetszet: i:=1 j:=1 l:=0 Ciklus amíg (i<=n) és (j<=m) Elágazás A[i]<B[j] esetén i:=i+1 /csak továbblép az A-ban A[i]>B[j] esetén j:=j+1 /csak továbblép a B-ban A[i]=B[j] esetén l:=l+1 /ez a sor az uniónál az elágazás előtt volt/ C[l]:=A[i] /vagy C[l]:=B[j] 61

62 i:=i+1 j:=j+1 Elágazás vége Ciklus vége Eljárás vége Feladat Határozd meg összefuttatással a rendezett A és B sorozatok különbségét! Keresési tételek Lineáris keresés tétele Kitűzés N elemű sorozat; sorozat elemein értelmezett T tulajdonság. Van e T tulajdonságú elem és ha van, akkor mi a sorszáma. (Eldöntés és kiválasztás együtt.) Rendelkezésre áll egy N elemű sorozat, és egy, a sorozat elemein értelmezett T tulajdonság. Olyan algoritmust kell írni, amely eldönti, hogy van e T tulajdonságú elem a sorozatban, s ha van, akkor megadja a sorszámát (ennyivel több mint az eldöntés tétele). Specifikáció N: egész, X: tömb[1..n:h], T:H logikai VAN: logikai, SORSZ: egész Ef.: N 0 Uf.: VAN=(?i(1 i N): T(X[i])) és VAN 1 SORSZ N és T(X[SORSZ]) Algoritmus Eljárás lin_keres: i:=1 Ciklus amíg i N és A(i) nem T tulajdonságú i:= i+1 Ciklus vége VAN:=(i N) Ha VAN akkor SORSZAM:=i Eljárás vége. Logaritmikus keresés tétele Általános feladat: N elemű rendezett sorozat; egy keresett elem (X). Szerepel-e a keresett elem a sorozatban és ha igen, akkor mi a sorszáma. Kihasználjuk, hogy a sorozat rendezett, így el tudjuk dönteni, hogy a keresett elem az éppen vizsgált elemhez képest hol helyezkedik el. Uf.: VAN ( i(1 i N): X[i]=Y) és VAN 1 SORSZ N és X[SORSZ]=Y és i(1 i<sorsz):x[i] Y és i(sorsz<i N): X[i] Y Algoritmus Eljárás log_keres: E:=1; U:=N Ciklus K:=[(E+U)/2] [E+U felének egész értéke] Elágazás Y<X[K] esetén U:=K-1 Y>X[K] esetén E:=K+1 62

63 Elágazás vége amíg E U és X[K]?Y Ciklus vége VAN:=(E U) Ha VAN akkor SORSZ:=K Eljárás vége. Megjegyzések: Azért hívják logaritmikus keresésnek, mert a ciklus lépésszáma kb. log N, sokkal hatékonyabb rendezett sorozatra, mint a lineáris keresés. Rendezések Egyszerű cserés rendezés A következő ötleten alapszik: hasonlítsuk össze az első elemet a sorozat összes többi mögötte levő elemével, és ha valamelyik kisebb nála, akkor cseréljük meg azzal! Így elérhetjük, hogy a sorozat első helyére a legkisebb elem kerüljön. Folytassuk ugyanezen az elven a sorozat második elemével, utoljára pedig az utolsó előttivel! i=1 5, 3, 9, 1, 7 3, 5, 9, 1, 7 3, 5, 9, 1, 7 1, 5, 9, 3, 7 1, 5, 9, 3, 7 i=2 1, 5, 9, 3, 7 1, 5, 9, 3, 7 1, 3, 9, 5, 7 1, 3, 9, 5, 7 i=3 1, 3, 9, 5, 7 1, 3, 5, 9, 7 1, 3, 5, 9, 7 i=4 1, 3, 5, 9, 7 1, 3, 5, 7, 9 Rendezés(N,X): Ciklus i=1-től N-1-ig Ciklus j=i+1-től N-ig Ha X[i]>X[j] akkor Csere(X[i],X[j]) Ciklus vége Ciklus vége Eljárás vége Minimumkiválasztásos rendezés Az előző módszer hibája a sok felesleges csere. Célszerűbb lenne az aktuális első elemet a mögötte levők közül egyedül a legkisebbel cserélni. Ehhez a rendező ciklus belsejében cserék helyett egy minimumkiválasztást kell csinálni. i=1 5, 3, 9, 1, 7 i=2 1, 3, 9, 5, 7 i=3 1, 3, 9, 5, 7 i=4 1, 3, 5, 9, 7 Rendezés(N,X): 63

64 Ciklus i=1-től N-1-ig MIN:=i Ciklus j=i+1-től N-ig Ha X[MIN]>X[j] akkor MIN:=j Ciklus vége Csere(X[i],X[MIN]) Ciklus vége Eljárás vége. Buborékos rendezés Hasonlítsuk egymással a szomszédos elemeket, és ha a sorrendjük nem jó, akkor cseréljük meg őket! Ezzel a módszerrel egy cikluslépés lefutása alatt a legnagyobb elem biztosan a sorozat végére kerül, és ezen kívül a nagyobb értékű elemek hátrafelé, a kisebbek pedig előrefelé mozdulnak el (innen van a buborékmódszer elnevezés). i=5 5, 3, 9, 1, 7 3, 5, 9, 1, 7 3, 5, 9, 1, 7 3, 5, 1, 9, 7 3, 5, 1, 7, 9 i=4 3, 5, 1, 7, 9 3, 5, 1, 7, 9 3, 1, 5, 7, 9 3, 1, 5, 7, 9 i=3 3, 1, 5, 7, 9 1, 3, 5, 7, 9 1, 3, 5, 7, 9 i=2 1, 3, 5, 7, 9 1, 3, 5, 7, 9 Rendezés(N,X): Ciklus i=n-től 2-ig -1-esével Ciklus j=1-től i-1-ig Ha X[j]>X[j+1] akkor Csere(X[j],X[j+1]) Ciklus vége Ciklus vége Eljárás vége. Beillesztéses rendezés Az eddigi módszerek mindegyike olyan volt, hogy a sorozatot felosztotta egy már kész, rendezett szakaszra, és a rendezést a másik szakasz elemei között folytatta. Másik jellemzőjük volt, hogy a rendezés elkezdéséhez már az összes elemnek rendelkezésre kellett állnia. Most a kártyakeveréshez hasonló elvből indulunk ki: egyetlen elem mindig rendezett; ha van egy rendezett részsorozatunk, akkor abba a nagyság szerinti helyére illesszük be a soron következő elemet! i=2 5, 3, 9, 1, 7 3, 5, 9, 1, 7 i=3 3, 5, 9, 1, 7 i=4 3, 5, 9, 1, 7 3, 5, 1, 9, 7 3, 1, 5, 9, 7 1, 3, 5, 9, 7 64

65 i=5 1, 3, 5, 9, 7 1, 3, 5, 7, 9 Rendezés(N,X): Ciklus i=2-től N-ig j:=i-1 Ciklus amíg j>0 és X[j]>X[j+1] Csere(X[j],X[j+1]); j:=j-1 Ciklus vége Ciklus vége Eljárás vége. Rekurzió A rekurzió egy programozási módszer. Azt az esetet nevezzük így, amikor egy eljárásban szerepló kód önmagát hívja meg. Fontos megjegyezni, hogy minden rekurzív algoritmus átalakítható nem rekurzívvá, azaz létezik ite ratív megoldása is. A rekurzív algoritmusok esetében meg kell találnunk a legegyszerűbb esetet (alapeset), amelyben a megoldás magától értetődik, majd találnunk kell egy olyan ismételt egyszerűsítési folyamatot (indukciós lépés), mely alapján véges lépésben eljuthatunk a legegyszerűbb esethez. Minden egyes lépésnél feltételezzük, hogy a kö vetkező, egyszerűbb esetnek már megvan a megoldása. Faktoriális Az egyik legegyszerűbb példa rekurzióra a faktoriális értékének kiszámítása. Az n faktoriálisa (jelölése: n!) alatt az első n darab pozitív egész szám szorzatát értjük, n = 1 esetén pedig 1 et. Szükségünk van egy alapesetre. Ez most az n = 1 lesz. Az indukciós lépés n > 1 esetén n * (n 1)!. Nem rekurzív algoritmus Az iteratív megoldás: fakt(n,r): def faktiter(n): R:=1 eredmeny = 1 Ciklus i:=1 től N ig while n > 1: R:=R*i eredmeny = eredmeny * n Ciklus vége. n = 1 Függvény vége. return eredmeny Rekurzív algoritmus fakt(n): Ha N=0 akkor return(1) Különben return(n*fakt(n 1)) Elágazás vége. Függvény vége. A rekurzív megoldás: def faktrekurz(n): if n == 1: return 1 return n * faktrekurz(n 1) Hanoi tornyai A játék szabályai szerint az első rúdról az utolsóra kell átrakni a korongokat úgy, hogy minden lépésben egy korongot lehet áttenni, nagyobb korong nem tehető kisebb korongra, és ehhez összesen három rúd áll rendelke zésre. Egy legenda szerint a világ megteremtésekor egy 64 korongból álló Hanoi torony feladványt kezdtek el játszani Brahma szerzetesei. A szabályok azonosak voltak a ma ismert Hanoi torony szabályaival. A legenda szerint amikor a szerzetesek végeznek majd a korongok átjuttatásával a harmadik rúdra, a kolostor összeomlik, és a világunk megszűnik létezni. A feladványban n korongot szeretnék mozgatni. Bontsuk egyszerűbb formára a problémánkat. Elsőként n 1 65

66 korongot átmozgatok a tartalék rúdra, majd a legalsót átmozgatom a célrúdra. Ezután az egészet átrakom a cél rúdra. Az algoritmus szerint itt megoldunk egy kisebb problémát (n 1 korong átmozgatása), majd megoldjuk az alapesetet (a legalsó átmozgatása a célrúdra), végül újra egy kisebb problémát oldok meg (áthelyezem a töb bit a célrúdra). Nézzük meg, hogy néz ki ez Pythonban: Algoritmus Hanoi(N,honnan,hova,tartalek) def tornyok(n, honnan, hova, tartalek): Ha N>0 akkor if n == 1: Hanoi(N 1,honnan,hova,tartalek) print(str(honnan) + '. rúdról átmozgatjuk Ki: N,honnan,hova a ', str(hova) + '. rúdra') Hanoi(N 1,tartalek,hova,honnan) else: Elágazás vége tornyok(n 1, honnan, tartalek, hova) Eljárás vége. tornyok(1, honnan, hova, tartalek) tornyok(n 1, tartalek, hova, honnan) Az alapesetben (n = 1) egyszerűen kiíratom a lépést, honnan mozgatom hová a korongot. Egyéb esetben egy kisebb rakást (egyet hagyok alul) átrakok a tartalék rúdra. Az ott maradt egy korongot átra kom a célrúdra. Végül a kisebb rakást átrakom a célrúdra. A legenda szerinti 64 korong esetében a megoldás lépés lenne. Ha egy szerzetes éjjel nappal dolgozna a feladaton másodpercenként egy lépést végrehajtva, akkor kicsit több mint 580 milliárd év alatt tudná megoldani a feladatot. Fibonacci számok Rekurzív algoritmus Fib(N): Ha N<=1 akkor return(1) Különben return(fib(n 1)+Fib(N 2)) def fibonacci(n): if n == 0: return 0 if n == 1: return 1 return fibonacci(n 1) +fibonacci(n 2) Ciklus átírása rekurzióvá Ciklust tartalmazó programok szerencsére mindig könnyen átírhatók rekurzióvá. A ciklusokat iterációvá, elágazássá kell alakítani. Eljárás(x): Ciklus amíg p(x) S(x) Ciklus vége Eljárás vége Rek_elj(x): Ha p(x) akkor S(x) Rek_elj(x) Elágazás vége Eljárás vége Eljárás(x): Ciklus S(x) amíg p(x) Ciklus vége Eljárás vége Rek_elj(x): S(x) Ha p(x) akkor Rek_elj(x) Elágazás vége Eljárás vége 66

67 Objektumorientált programozás Objektumorientált programozás fogalma Olyan programozási technika, amely a programokat objektumokból építi fel. A program működése tulajdonkép pen objektumok ( minden objektumnak megvan a jól meghatározott feladata ) kommunikációját jelenti. Legfon tosabb alapelvei: egységbezárás, öröklődés, polimorfizmus. A strukturált programozást felváltja az objektum orientált programozás. (Programozási paradigma Programozási mód. Alapvetően a program felépítésére használt eszközkészletet jelenti, vagyis milyen egységek képezik a program alkotóelemeit. (moduláris programozás, objektumorientált programozás, általánosított prog ramozás, aspektusorientált programozás stb.) Objektum orientált programozás Olyan programozási paradigma, amely a programokat objektumokból építi fel. A program működése tulajdon képpen objektumok kommunikációját jelenti. Legfontosabb alapelvei: egységbezárás, öröklődés, polimorfiz mus.) Objektumorientált nyelvek osztályozása tiszta objektumorientált nyelvek, hibrid nyelvek, objektum alapú nyelvek. Objektumorientált program jellemzői, alapfogalmak Osztály (Class) Az osztály egy felhasználói típus, amelynek alapján példányok (objektumok) hozhatók létre. Az osztály alapvetően adat és metódus (művelet) definíciókat tartalmaz. Példák: Egy osztályba sok diák jár, a programablakban több parancsgombot helyezhetünk el. Programjainkban gyakran sok objektum tárol ugyanolyan adatokat, és végez ugyanolyan tevékenységeket. Az egymáshoz hasonló objektumokat osztályokba soroljuk. A diák objektumosztály egy példánya (objektuma) Kovács István vagy Nagy Anna. A programablakban a parancsgomb (Button) objektumosztály példányait helyezzük el (Button1, Button2 stb.). Objektum (példány) Információt (adatokat) tárol és kérésre műveleteket végez. Van állapota, viselkedése és futásidőben azonosítha tó. Példák: Az iskolában diákok tanulnak. Egy diák adataihoz tartozik a neve, születési ideje, lakcíme, stb.. A diák a tan órán felel, hiányzást igazol, tornázik. A diák objektum modelljének ezeket az adatokat kell tartalmaznia, ezeket a tevékenységeket végezik. A grafikus felhasználói felület programozásakor is objektummal dolgozunk. Megadjuk például egy parancs gomb helyzetét, méretét, feliratát, elkészítjük eseménykezelő eljárásait. Felelősség Minden objektumnak megvan a jól meghatározott feladata, amelynek elvégzéséért felelős. Osztályozás Az objektum osztályokat viselkedésük szerint osztályokba soroljuk. Objektum osztály (típus) egy objektum minta, mely alapján objektum példányokat (objektumokat) hozhatunk létre. 67

68 Adatmező Az osztály minden objektum példányában megtalálható, kezelése és deklarálása a rekordmezőével megegyező. Metódus Az objektumon végzendő műveleteket definiáló eljárások és függvények. Azonos osztályhoz tartozó objektumpéldányok a metódusokat közösen használják. A Self paraméter jelöli, hogy éppen melyik példány adatmezőin kell műveletet végezni. Üzenet (Message, kérelem) Ezen keresztül kérjük meg az objektumokat különböző feladatok elvégzésére. Objektumhoz továbbított kérés. Válaszként az objektum végrehajtja a kért műveletet. Egységbezárás (Encapsulation) Az adatok és a metódusok osztályba való összezárását jelenti. Tulajdonképpen az objektum egységbe zárja az állapotot (adattagok értékei) a viselkedésmóddal (műveletekkel). Következmény: az objektum állapotát csak a műveletein keresztül módosíthatjuk. Információ elrejtése (Information Hiding) Az objektum elrejti az adatait és bizonyos műveleteit. Ez azt jelenti, hogy nem tudjuk pontosan, hogy egy ob jektumban hogyan vannak az adatok ábrázolva, sőt a műveletek implementációit sem ismerjük. Az információk elrejtése az objektum biztonságát szolgálja, amelyeket csak a ellenőrzött műveleteken keresztül érhetünk el. Öröklődés (Inheritance) (Származtatás, örökítés) Olyan osztályok között értelmezett viszony, amely segítségével egy általánosabb típusból (ősosztály) egy sajá tosabb típust tudunk létrehozni (utódosztály). Az utódosztály adatokat és műveleteket (viselkedésmódot) örö köl, kiegészíti ezeket saját adatokkal és műveletekkel, illetve felülírhat bizonyos műveleteket. A kód újrafel használásának egyik módja. Megkülönböztetünk egyszeres és többszörös örökítést. Helyettesíthetőség (Substitutability) Ha S altípusa a T típusnak (S osztályt a T osztályból származtatjuk), akkor a T osztálybeli példányokat helyette síthetjük S osztálybeli példányokkal, anélkül, hogy programunk helyességét veszélyeztetnénk. Dinamikus (késői) kötés Futásidejű hozzárendelése a hívott metódusnak az objektumhoz. (Pl. C++: virtuális függvények, Java: pél dánymetódusok) (Lassú) Statikus (korai) kötés Fordításidejű hozzárendelése a hívott metódusnak az objektumhoz. (Pl. C++: nem virtuális függvények, Java: osztálymetódusok statikus metódusok) (Gyors) Metódusok túlterhelés Több azonos nevű, különböző szignatúrájú függvény. A függvényhívás aktuális paraméterei meghatározzák, hogy melyik függvény fog meghívódni. Ezt már a fordításidőben eldől (statikus, fordításidejű kötés) Metódusok felülírása Egy osztályhierarchián belül az utódosztály újradefiniálja az ősosztály metódusát. (azonos név, azonos szig natúra). Ha ősosztály típusú mutatón vagy referencián keresztül érjük el az osztályhierarchia példányait és ezen keresztül meghívjuk a felülírt metódust, akkor futási időben dől el, hogy pontosan melyik metódus kerül meghívásra. (dinamikus, futásidejű kötés). 68

69 Absztrakt osztály Olyan osztály, amelynek van legalább egy absztrakt művelete. Felületet határoz meg és nem lehet példányosíta ni. Absztrakt osztály az absztrakt műveleteinek implementálását az utódosztályokra bízza. Konkrét osztály Olyan osztály, amely nem tartalmaz absztrakt műveletet. Példányosítható. Interfész (Interface) Viselkedésmódot definiál. Gyakorlatilag egy művelethalmaz deklarációját jelenti. Ha egy osztály implementál egy adott interfészt, akkor példányai az interfészben meghatározott viselkedéssel fognak rendelkezni. Csak konstans adattagokat tartalmazhat és minden tagja nyilvános. Objektum interfész (Object Interface) Meghatározza az objektummal végezhető műveletek halmazát Polimorfizmus (többalakúság) Ugyanarra az üzenetre különböző objektumok különbözőképpen reagálhatnak. Egy típuselméleti fogalom, amely szerint egy ősosztály típusú változó hivatkozhat ugyanazon közös ősosztályból származó (vagy ugyan azon interfészt megvalósító) osztályok példányaira. A polimorfizmus lehet statikus és dinamikus. Statikus polimorfizmus: metódusok túlterhelése, függvénysablonok, osztálysablonok. Satikus, fordítás idejű kötés. Dinamikus polimorfizmus: metódusok felülírása. Dinamikus, futásidejű kötés. Konstruktor (Constructor) Az a művelet, amely inicializálja az objektumot. Automatikusan hívódik. Egy osztályhoz annyiféle konstruktort készítünk, ahányféleképpen lehetővé tesszük a példányok inicializálását. Destruktor (Destructor) A konstruktorral ellentétes művelet, általában a konstruktorban lekötött erőforrásokat szabadítja fel. Az objek tum megsemmisítése előtt hajtódik végre és automatikusan hívódik. Függőség (Coupling) Komponensek közötti függőség mértéke. Megkülönböztetünk laza és szoros csatolású rendszereket. A laza csa tolású rendszerek esetében, a rendszer valamely komponensének változása nem vonja maga után a többi kom ponens módosítását. Osztályszintű (statikus) tagok (Class (Static) Members) Statikus tagok= statikus adattagok + statikus metódustagok A statikus adattagok, olyan adatok, amelyeket az adott osztály példányai közösen használnak (osztott). A statikus műveletek olyan műveletek, amelyek az argu mentumaikon illetve az osztály statikus adattagjain dolgoznak. Ezek a tagok már példányok létrehozása előtt használhatók. Aggregáció (Aggregation) Rész egész kapcsolat. A részek alkotják az egészet. Például az autó motor, váz és kerekek aggregációja. A ré szek túlélhetik az egészet. Kompozíció (Composition) Sajátos aggregáció, amikor a rész szorosan hozzátartozik az egészhez. A részek nem élik túl az egészet. Például az emberi agy szorosan hozzátartozik az emberhez. Delegálás (Delegation) 69

70 Implementációs mechanizmus, melynek során egy objektum továbbítja (delegálja) a kérést egy másik objektum fele. A delegált objektum fogja feldolgozni a kérést. Példa: Java eseménykezelés (az eseményfigyelő fele továbbítódik a kérés) Tároló (Konténer, Container) Olyan típus, amely objektumok tárolását biztosítja. A tárolási funkció mellett karbantartó műveleteket is bizto sít. Bejáró (Iterátor, Iterator) Olyan típus, amely pozíciót határoz meg egy halmazban (tároló, adatfolyam). Műveletein keresztül biztosítja a tároló bejárását, azaz a tárolt elemek egymás utáni feldolgozását. Statikus metódusok Az ilyen metódusok az örökléskor, csupán kicserélik az előd metódusát az újra, nincs hatással az objektum más részeire így nem változik meg teljesen annak tulajdonsága. Gondoljunk itt az objektum más részében elhe lyezkedő esetleg őt meghívó más metódusokra, akik nem az újat, hanem a régit fogják meghívni, a statikus megoldás következménye képen. Virtuális metódusok Ilyen típusú metódusokkal lehet megoldani az öröklés folyamaton keresztül a sokoldalúságot. Ez azt jelenti, hogy nem csak a régi metódust cseréli ki az újra, hanem az egész objektumot átnézve a régi metódusra muta tó összes hivatkozást átírja az új metódusra mutatóvá. Ezáltal megváltozik az egész objektum tulajdonsága, és az öröklés folyamatra nézve sokoldalúvá válik. Ha egy objektumban már használtuk a virtual kulcsszót, akkor annak utódaiban is kötelező. Futóverseny példa A futóverseny objektumai, a mezők és metódusok megadásával: Pályaobjektum: a versenypályát jelképezi. Hossz mező: a pálya hossza. A versenyzők használják fel a cél elérésének ellenőrzéséhez. Létrehoz metódus: a versenyzők számának megfelelően méretezi az ablakot, és kirajzolja a képernyőre a célvonalat. Az ablak szélessége alapján meghatározza a Hossz értékét. A versenyzők számát argumen tumként adjuk meg. Versenyzőobjektum: egy versenyző adatait és metódusait tartalmazza. Mezők: Mez: a versenyző mezének sorszáma. Szín: a versenyző mezének színe. Helyzet: a versenyző pozíciója a pályán. Színek(): a lehetséges színeket tartalmazó tömb. Vélszám: véletlen szám objektum a szín választásához, illetve a helyzet változtatásához. Metódusok: Létrehoz: inicializálja a mezőket. A metódus argumentuma a versenyző mezének sorszáma. A színt véletlenszerűen választja ki. Fut: lépteti a versenyzőt a verseny során. Véletlenszerűen választott mértékben megnöveli a Helyzet mező értékét. Ha a versenyző beér a célba, akkor hozzáadja a mez sorszámát a verseny objektum győzteseket tartalmazó halmazához. Kiír: megjeleníti a képernyőn a versenyző helyzetét. A Fut metódus hívja. Versenyobjektum: elindítja és vezérli a versenyt. 70

71 Mezők: Pálya: pályaobjektum. Győztesek: a győztesek mezének sorszámát tartalmazó halmaz. VersenyzőkSzáma: a versenyzők száma. Versenyzők(): a versenyzőobjektumokat tartalmazó tömb. Metódusok: Start: megkérdezi a felhasználótól a versenyzők számát, majd létrehozza a versenyzőobjektu mokat, és meghívja Létrehoz metódusukat. Létrehozza a pályaobjektumot, amelynek meghívja a Létrehoz metódusát. A Futás metódus hívásával elindítja a versenyt, a végén pedig az Eredmény metódussal kiíratja az eredményt. Futás: magát a versenyt jelképezi. Ciklussal lépteti a versenyzőket mindaddig, amíg valamelyi kük be nem ér a célba (egy cikluson belül esetleg egyszerre több is). Eredmény: a verseny végén kilistázza a győztes versenyzőket. Ehhez a Győztesek halmazt hasz nálja fel, melybe a célba érő versenyzők beírták mezük sorszámát. Vár: a megadott időtartamra leállítja a végrehajtást, egyébként a versenyt nem tudnánk követni a képernyőn. A Futás metódus hívja. Objektum orientált tervezés 1. Analízis (OOA), 2. Tervezés (OOT) 3. Programozás (OOP) Eymással kapcsolatban állnak, de különböző fogalmak Az OOA a felhasználói környezet modelljének kidolgozásával foglalkozik. Az OOT a követelményeket kielégítő rendszer modelljének kidolgozásával foglalkozik. Az OOP az OOT realizálásával foglalkozik egy OO nyelv (pl. Java, C++) segítségével. Ábrázolás osztálydiagramon Programunkban osztályokat definiálunk a tervben szereplő objektumok alapján. Az osztályok szerkezetét úgy nevezett osztálydiagrammal tesszük áttekinthetővé. Az osztálydiagram fontos eleme az objektumorientált prog ramok tervezését segítő UML nek (Unified Modeling Language: egységes modellező nyelv). Az osztálydiagram téglalapban tünteti fel az osztály nevét, mezőit és metódusait. A mezőket és metódusokat vízszintes vonallal választjuk el egymástól. A futóverseny leírása alapján jelöljük be az alábbi osztálydiagramra, hogy egy egy osztály objektumai mely másik osztály mezőit kérdezik le vagy módosítják, illetve mely metódusokat hívják! Melyik osztály objektuma hoz létre egy másik osztályhoz tartozó objektumot vagy objektumokat? Az osztálydiagramon csak az általunk definiált osztályokat tüntettük fel. Nem ábrázoltuk külön a fejlesztő rend szerben rendelkezésünkre álló osztályokat (véletlen szám, halmaz, tömb). Az osztálydiagramok mellett gyakran használják az objektumdiagramot is. Az objektumdiagram az objektumo 71

72 kat téglalapokban ábrázolja, feltüntetve az objektum nevét, osztályát, továbbá mezőinek értékét. Az objektum nevét, osztályát aláhúzzuk, és kettősponttal választjuk el egymástól. Ha nem lényeges az objektum neve, akkor el is hagyhatjuk. Objektumosztály definiálása, objektumok létrehozása Objektumosztályt az OSZTÁLY... OSZTÁLY VÉGE kulcsszavak között definiálunk a forráskódban. A definí cióban a mezők (változók) deklarációi és metódusok (alprogramok) definíciói szerepelnek a szokásos módon: OSZTÁLY Osztálynév változók (mezők) deklarálása eljárások, függvények (metódusok) definiálása OSZTÁLY VÉGE A TPálya osztály definíciója például (vázlatosan): OSZTÁLY TPálya VÁLTOZÓ Hossz MINT Egész ELJÁRÁS Létrehoz(VersenyzőkSzáma MINT Egész) az ablak méretének módosítása a célvonal kirajzolása ELJÁRÁS VÉGE OSZTÁLY VÉGE 72

73 Linux alapok Parancs általános alakja parancs kapcsolók paraméterek Könyvtárszerkezet abszolút útvonal: útvonal megadása a gyökérből kiindulva / gyökérkönyvtár relatív útvonal: útvonal megadása az aktuális könyvtárból kiindulva. aktuális könyvtár.. egy szinttel feljebb lévő könyvtár pwd kiírja az aktuális könyvtár abszolút elérési útját cd <könyvtár> <könyvtár> lesz az aktuális könyvtár, paraméter nélkül a home könyvtárba ugrik ls <kapcsolók> <lista> Kilistázza a listában megadott fájlokat és könyvtárakat (ha nincs lista, akkor olyan mintha. lett volna megadva) Kapcsolók l részletes lista a rejtett fájlokat is kiírja d a könyvtárakat ugyanúgy mint a fájlokat (nem a tartalmukat listázza ki) R a könyvtárakat rekurzívan r csökkenő betűrendben listáz mkdir <kapcsolók> <lista> Létrehozza a listában található könyvtárakat Kapcsolók p a teljes megadott útvonalat létrehozza m a könyvtár jogosultságainak megadása (oktális alak) (használat: m <jog>) rmdir <kapcsolók> <lista> Törli a listában megadott könyvtárakat Kapcsolók p a teljes megadott útvonalat törli mv <kapcsolók> <eredeti> <új> Átnevezi az <eredeti> nevű fájlt vagy könyvtárat <új> névre (ha nem létezik ilyen könyvtár) Kapcsolók b ha az új létezik, készít róla egy biztonsági mentést (<új>~néven) mv <kapcsolók> <lista> <újhely> Átmozgatja <lista> elemeit az <újhely> könyvtárba (aminek léteznie kell) Kapcsolók f kétes esetben nem kérdez i bármely kétes esetben megerősítést vár u csak a régebbi fájlokat írja felül 73

74 cp <kapcsolók> <eredeti> <új> Létrehoz egy <eredeti> nevű fájlból vagy könyvtárból egy másolatot <új> néven (ha nem létezik ilyen nevű könyvtár) Kapcsolók b ha az új létezik, készít róla egy biztonsági mentést (<új>~néven) cp <kapcsolók> <lista> <újhely> Átmozgatja a <lista> elemeit az <újhely> könyvtárba (aminek léteznie kell) Kapcsolók f kétes esetben nem kérdez i bármely kétes esetben megerősítést vár r R könyvtárakat rekurzívan átmásolja l másolás helyett linket készít s másolás helyett szimbolikus linket u csak akkor másol, ha a cél helyen régebbi fájlok vannak vagy az adott fájl hiányzik rm <kapcsolók> <lista> Törli a listában megadott fájlokat Kapcsolók f kétes esetben sem kérdez vissza i bármely kétes esetben megerősítést vár r R ha könyvtárnevet talál a listában, törli azt du <kapcsolók> <lista> Összeszámolja a könyvtárban található fájlok méretét Kapcsolók a a kimeneti listába a fájlok is bekerülnek s a méreteket összeadja m kilobyte ok helyett megabyte okban számol h az ember számára olvasható mértékegységek quota A felhasználó által használható lemezterület méretét írja ki. df A fájlrendszerek lemezhasználatáról készít jelentést. Kapcsolók h az ember számára olvasható mértékegységek Szövegfájlok cat <fájl> A <fájl> teljes tartalmát egyszerre kiírja a képernyőre more <fájl> A <fájl> teljes tartalmát oldalanként kiírja a képernyőre head <n> <fájl> A <fájl> első <n> sorát kiírja a képernyőre 74

75 tail <n> <fájl> A<fájl>utolsó <n> sorát kiírja a képernyőre grep <minta> <fájl> Kiírja a <fájl> azon sorait, amelyekben megtalálható a <minta> szövegrészlet more <fájl> A fájl teljes tartalmát oldalanként írja ki a képernyőre tee A bemenetként kapott szöveget a kimenetre írja. less <fájl> A fájl tartalmát görgethetően írja ki wc <kapcsolók> <fájl> Kiírja a <fájl> ban található byte ok/sorok/szavak számát Kapcsolók c a fájl méretét írja ki w a szavak számát írja ki l a sorok számát írja ki m a karakterek számát írja ki sort <kapcsolók> <fájl> A fájl sorait ábécé sorrendben írja ki. Kapcsolók r csökken sorrend (z a) Egyéb man <parancs> Előhozza a parancs részletes leírását file <fájl> Megadja a fálj típusát. echo <szöveg> Kiírja a szöveget. passwd A jelszó megváltoztatására szolgál. Jogosultságok Hozzáférések korlátozása. Tulajdonos (User), Csoport (Group), Többiek (Others) Olvasás (Read), Írás (Write), Végrehajtás (execution) chmod <kapcsolók> <jogosultság> <lista> Jogosultság <kinek><hogyan><mit> <kinek> a (all), u (user), g (group), o (others) <hogyan> + (megadás), (megvonás), = (beállítás) <mit> r (read), w (write), x, (execute) 75

76 <user><group><other> oktális számjegyek read: 4, write: 2, execute: 1 ezek összege a kód Kapcsolók c a változtatásokat jelenti R ha könyvtárat talál, rekurzívan beállítja a jogokat a könyvtárban található fájlokra és könyvtárakra is Mintaillesztés? egyetlen karaktert helyettesít * akárhány karaktert helyettesít [ ] a [ és ] között felsorolt karaktereket helyettesítheti \c a c speciális karaktert jelent \, szóköz, ',,?, *, [, ], ` Felhasználók finger Megadja, hogy ezen a gépen kik vannak bejelentkezve. finger <név> Felsorolja azokat a felhasználókat akiknek a neve vagy azonosítója megegyezik a <név> paraméterrel. Megadja, hogy a host gépen kik vannak bejelentkezve. who Megadja, hogy ki van bejelentkezve a gépre. Fingernél kevesebb adatot szolgáltat. w Mint, a who, de megmondja azt is, hogy ki min dolgozik. last Megmondja az utolsó néhány bejelentkezett felhasználót. exit Kapcsolat megszakítása. 76

77 Python Első lépések Az interpretert közvetlenül a parancssorból indíthatjuk (egy Linux shell ben, vagy Windows alatt egy DOS ablakból): elég, ha begépeljük a "python" parancsot (feltéve, hogy a program fel van telepítve)). Ha grafikus interface t használunk, mint a Windows, Gnome, WindowMaker vagy KDE, valószínűleg inkább egy «terminálablakban» fogunk dolgozni, vagy egy specializált fejlesztő környezetben, mint amilyen az IDLE. Terminálablakban a következő jelenik meg: Python (default, Apr , 13:05:18) [GCC 4.8.2] on linux Type "copyright", "credits" or "license()" for more information. >>> A >>> jel a fő prompt, ami azt jelzi, hogy az interpreter készen áll egy utasítás végrehajtására. Számolás Pythonban Az interpretert azonnal egyszerű számológépként használhatjuk. A +,, * és / aritmetikai operátorok össze adásra, kivonásra, szorzásra és osztásra valók. A zárójelek működnek. >>> >>> >>> 3*3 9 >>> 21/ >>> (5+4)*2/3 6.0 Adatok és változók Egy számítógépprogram lényegét az adatmanipulációk képezik. Ezek az adatok nagyon különbözőek lehetnek lényegében minden, ami digitalizálható), de a számítógép memóriájában végleg bináris számok véges sorozatá vá egyszerűsödnek. Ahhoz, hogy a program hozzá tudjon férni az adatokhoz, nagyszámú különböző típusú változót használ. Egy programozási nyelvben egy változó majdnem mindegy milyen változónévként jelenik meg, a számítógép szá mára egy memóriacímet jelölő hivatkozásról van szó, vagyis egy meghatározott helyről a RAM ban. Ezen a helyen egy jól meghatározott érték van tárolva. Ez az igazi adat, ami bináris számok sorozata formájá ban van tárolva, de ami az alkalmazott programozási nyelv szemében nem feltétlenül egy szám. Szinte bármi lyen «objektum» lehet, ami elhelyezhető a számítógép memóriájában, pl. egy egész, egy valós, egy komplex szám, egy vektor, egy karakterlánc, egy táblázat, egy függvény, stb. A programozási nyelv különböző változótípusokat (egész, valós, karakterlánc, lista, stb.) használ a különböző lehetséges tartalmak egymástól történő megkülönböztetésére. Változónevek és foglalt szavak A változóneveket mi választjuk meg, fontos, hogy jól válasszuk meg azokat. Rövid, kifejezik, hogy mit tartal maz a változó. Egy jó programozónak ügyelni kell arra, hogy az utasítássorait könnyű legyen olvasni. Pythonban a változóneveknek néhány egyszerű szabály van: A változónév az a z, A Z betűk és a 0 9 számok sorozata, aminek mindig betűvel kell kezdődni. Csak az ékezet nélküli betűk a megengedettek. A szóközök, a speciális karakterek, mint pl.: $, stb. nem használhatók, kivétel a _ (aláhúzás). A kis és nagybetűk különbözőnek számítanak. További szabály: nem használható változónévként az alább felsorolt 28 foglalt szó (ezeket a Python használja): 77

78 Értékadás, hozzárendelés Egy változót úgy definiálhatunk, hogy értéket rendelünk hozzá. A változóhoz való érték hozzárendelés vagy értékadás kifejezések egyenértékűek. Egy olyan műveletet jelölnek, amely kapcsolatot teremt a változónév és a változó értéke (tartalma) között. A Pythonban számos más nyelvhez hasonlóan a hozzárendelés műveletét az egyenlőségjel reprezentálja. >>> a=12 >>> a 12 >>> koszones="szia!" >>> koszones 'Szia!' >>> pi=3.14 >>> pi 3.14 Többszörös értékadás is létezik a Pythonban, több változónak ugyanazt az értéket adhatjuk vagy több változó nak egyszerre adhatunk különböző értéket: >>> szam1=szam2=2 >>> szam1 2 >>> szam2 2 >>> szam1,szam2,szo=23, 45.4,"alma" >>> szam1 23 >>> szam >>> szo 'alma' Változó értékének a kiírása Két lehetőségünk van az értékük képernyőre történő kiíratására. A billentyűzeten beírjuk a változó nevét, majd Entert nyomunk, kiíródik a változó értéke (promt nélkül) >>> a 34 >>> koszones 'Szia!' >>> pi 3.14 A másik lehetősé a print(változónév) parancs kiadása. >>> print(a) 34 >>> print(koszones) Szia! A kétféle kiíratási mód közötti különbség: a print utasítás csak a változó értékét írja ki, úgy ahogyan az kódolva volt, míg a másik módszer az idézőjeleket is. 78

79 Változók típusadása Nem szükséges a változók használata előtt a típusuk definiálása, elég ha hozzárendelünk egy értéket egy válto zónévhez. A Python a változót automatikusan azzal a típussal hozza létre, ami a legjobban megfelel az érték nek. A Python dinamikus típusadású nyelv, szemben a statikus típusadású nyelvekkel, ezekben a nyelvekben először mindig speciális utasításokkal deklarálni(definiálni) kell a változók nevét és típusát és csak ezután lehet tartalmat rendelni hozzájuk, aminek természetesen kompatibilisnek kell lenni a deklarált típussal. A type() függvénnyel a változók típusait íratjuk. >>> szam1=12 >>> szam2=3.23 >>> szo="körte" >>> szam1,type(szam1) (12, <class 'int'>) >>> szam2,type(szam2) (3.23, <class 'float'>) >>> szo,type(szo) ('körte', <class 'str'>) Típusok: int : egész float : lebegőpontos szám str : szöveg Operátorok és kifejezések Az értékeket és a rájuk hivatkozó változókat operátorok segítségével kifejezésekké kombináljuk. Példa: a, b = 2.5, 12 c = 4*a + b/2 Operátorok: *, + és / Operandusok: 3, 5 Változók: a,b,c Az operátorok speciális szimbólumok, amiket olyan egyszerű matematikai műveletek reprezentálására hasz nálunk, mint az összeadás vagy a szorzás. Az operandusok az értékek, amiket az operátorok segítségével kom binálunk. Hatványozás operátora **, modulo operátor: %, (egy számnak egy másik számmal való egészosztásából szár mazó maradékát adja meg) Logikai operátorok and és or vagy not tagadás Relációs operátorok : x == y egyenlő y nal x!= y nem egyenlő y nal x>y nagyobb, mint y x<y kisebb, mint y x >= y nagyobb, vagy egyenlő mint y x<= y kisebb, vagy egyenlő mint y A műveletek prioritása Ha egy kifejezésben egynél több operátor van, akkor a műveletek végrehajtásának sorrendje a prioritási szabá lyoktól függ. A Pythonban a prioritási szabályok ugyanazok, mint amiket matematikából tanultunk: Zárójelek. Ezek a legmagasabb prioritásúak. Azt teszik lehetővé, hogy az általunk kívánt sorrendben 79

80 történjen egy kifejezés kiértékelése. Így 2*(3 1) = 4, és (1+1)**(5 2) = 8. Hatványozás. A hatványok kiszámolására a többi művelet előtt kerül sor. Így 2**1+1 = 3 (és nem 4), és 3*1**10 = 3 (és nem 59049!). Szorzás és osztás, azonos prioritással. Ezeket az összeadás és kivonás előtt értékeli ki. Így 2*3 1 = 5 (és nem 4), és 2/3 1 = 1 (Emlékezzünk vissza, hogy alapértelmezésben a Python egészosztást végez.) Ha két operátor azonos prioritású, akkor a végrehajtásuk balról jobbra történik. Így az 59*100/60 kifejezésben először a szorzást, majd ezt követően, az 5900/60 osztást végzi el, aminek az eredménye 98. Ha először az osztást végezné el, akkor az eredmény 59 lenne (emlékezünk rá, hogy itt egy egészosztásról lenne szó). Szintaktikai szabályok Az utasítások és a blokkok határait a sortörés definiálja Több programozási nyelvben minden sort speciális karakterrel kell befejezni (pl. pontos vesszővel), a Python ban a sorvégjel ez a karakter. A Python komment, megjegyzés mindig a # karakterrel kezdődik és a LF (lin efeed) karakter között van, a fordító figyelmen kívül hagyja. A nyelvek többségében az utasításblokkot speciális jelekkel kell határolni (pl. begin és end utasításokkal). A Pythonban használnunk kell a sorugrásokat és a behúzásokat, ezeken kívül nincs más blokkhatároló. Összetett utasítás: fej, kettőspont, behúzott utasítások blokkja Az utasításblokkok mindig egy jól definiált utasítást tartalmazó fejsorhoz kap csolódnak (if, elif, else, while, def, stb.), ami kettősponttal végződnek. A blok kokat behúzás határolja: ugyanahhoz a blokkhoz tatozó utasítások sorait ponto san ugyanúgy kell behúzni (vagyis ugyanannyi betűközzel kell jobbra eltolva lenniük). A legkülső blokknak (azaz az első blokknak) a bal margónál kell lennie. Az első scriptek Az IDLE-t interaktív módban használtuk, azaz az utasításokat minden alkalommal közvetlenül az interpreterbe írtuk be anélkül, hogy azokat később egy fájlba mentettük volna. Ha az interpretert bezártuk, akkor az addig beírt utasítások eltűntek, később nem nyithatók meg. A programjaink, hogy később is meg legyenek valamilyen szövegszerkesztővel kell az utasításainkat szerkeszteni (pl. Linux: Joe-val, Nedit-tel, Kate-tel, MS-DOS: Edit-tel, Windows: Wordpad-del). Tehát írunk egy script-et, amit elmenthetünk, módosíthatunk, másolhatunk, mint bármilyen más szöveget, amit a számítógéppel kezelünk. Karakterkódolás Ékezetes és speciális karakterekre vonatkozó megjegyzés Az állomány elején kettős kereszttel bevezetve adjuk meg a karakterkódolás. Hagyományosan használjuk a * karaktereket is: # * coding: <encoding name> * Latin2 beállítása # coding: ISO A fő nyugat erópai nyelvek ékezetes karakterkészletét használjuk (francia, olasz, portugál, stb.) egy bájton kó dolva az ISO 8859 norma szerint. UTF 8 beállítása # coding: UTF 8 Az Unicodenak nevezett két bájtos kódolást használjuk (aminek az Utf 8 változata csak a speciális karaktereket kódolja két bájton, a standard ASCII karakterek egy bájton vannak kódolva). Egyre elterjedtebb, mivel lehetővé teszi mindenféle eredetű (görög, arab, ciril, japán, stb.) karakter együttlétezését ugyanabban a dokumentumban. 80

81 Interpreter Unix alapú rendszereken a legelső sorban megadhatjuk a python fordító útvonalát: #!/usr/bin/python # * coding: utf 8 * Így különböző python verziók használhatók. A hármas verziót például: #!/usr/bin/python3 # * coding: utf 8 * Olvashatjuk a környezetből is: #!/usr/bin/env python # * coding: utf 8 * Megjegyzés Egy soros megjegyzéseket tehetünk a kódba a # jel segítségével. A megjegyzések állhatnak utasítás után is # Megjegyés Adattípusok 1. Numerikus adattípusok Egész típus (integer) pl.: 3; 45; 2; 0 Valós v. lebegőpontos típus (float) pl.: 3.5; (tizedespontot használunk) Tizedesjegyek száma Valós szám, három tizedesjegy pontossággal ábrázolva. szam = print "Szám: %.3f" % szam Szám: Alfanumerikus adattípus Szöveg (karakterlánc, string) típus A string típusú adat bármilyen karaktersorozat, amit vagy szimpla idézőjelek (aposztrof), vagy dupla idézőjelek határolnak. Változóhasználat A változókat használatuk előtt nem kell deklarálni, egyszerűen csak használni kell. szam = 3 print "Teszt", szam Teszt 3 szam1 = 3 szam2 = 5 osszeg = szam1 + szam2 print "Összeg: ", osszeg Összeg: 8 szoveg1 = "Szeretem" szoveg2 = " az almát" kiirando = szoveg1 + szoveg2 print "Következtetés: ", kiirando Következtetés: Szeretem az almát 81

82 Típuskonverziós függvények A változók típusa attól függ milyen értéket adunk át számára. Ha egész típust adunk át akkor int lesz. Ha valós típust, akkor float. Ha szöveget akkor str. Ha szeretnénk tudni milyen típusú a változónk, akkor a type függvényt használhatjuk: print type(szam1) <type 'int'> print type(szoveg1) <type 'str'> Konvertáló függvények: str(vált) szöveggé, int(vált) egésszé, float(vált) valóssá. Kivitel A képernyőre a print utasítással írhatunk ki szöveget. Példák: print "Alma" Alma print 'Alma' Alma print print szam 20 A Python 3.x verziótól, csak zárójellel használhatjuk a print() utasítást: print("alma") Alma A print után vesszővel tagolva több paraméter is megadható: a=3 b=5 print "Szám: ", a Szám: 3 print Számok: a, b Számok: 3 5 print 34,"kg" 34 kg Escape szekvenciák Ha kiíratunk egy a karaktert, akkor a megjelenik a képernyőn. Egyes karaktereket a szokásostól eltérően is ér telmezhetünk. Megjelenés helyett valamilyen változást idézhetnek elő. Ha egy karakternek ilyen speciális jelen tést szeretnénk adni, azt az elé tett vissza per jellel jelezzük, és a továbbiakban escape szekvenciának nevezzük. A következő táblázat bemutatja, milyen escape szekvenciák vannak és azokat mire használjuk. Escape szekvencia Jelentés \\ vissza perjel megjelenítése \' aposztróf megjelenítése \" idézőjel megjelenítése \a ASCII csengőhang \b ASCII visszatörlés Backspace (BS) \f ASCII lapdobás (FF) \n ASCII soremelés (LF) \r ASCII kocsi vissza (CR) \t ASCII vízszintes tabulátor (TAB) \v ASCII függőleges tabulátor (VT) \ooo oktális érték \xhh hexadecimális érték 82

83 print("alma\bkörte") print("alma\nkörte") print("alma\tkörte") print("\144") almkörte alma körte alma körte d Az ord(ch) függvény bármilyen karaktert elfogad argumentumként. Visszatérési értékként a karakternek meg felelő ASCII kódot adja meg. Példa: szam = ord( A ) print szam 65. A chr(szam) függvény ennek pontosan az ellenkezőjét teszi. Az argumentumának 0 és 255 közé eső számnak kell lenni. Visszatérési értékként a megfelelő ASCII karaktert kapjuk meg. Példa: kar = chr(65) print kar 65 Kompozíciók Egy magsasszintű programozási nyelv egyik erőssége, hogy különböző elemek (változók, a kifejezések, utasítások) kombinálásával összetett utasításokat hozhatunk létre. Példa: összeadás és kiíratás kombinálása: print 3+2 Ez a nyilvánvalónak t űnő tulajdonság fogja lehetúvé tenni az összetett algoritmusok világos és tömör programozását. Példa: h, m, s = 15, 27, 34 print "az éjfél óta eltelt másodpercek száma = ", h* m*60 + s Van egy megszorítás arra nézve, hogy miket lehet kombinálni: amit egy kifejezésben az egyenlőségjel baloldalán helyezünk el, annak mindig egy változónak kell lenni, nem pedig egy kifejezésnek. Ez abból fakad, hogy az egyenlőségjelnek nem ugyanaz a jelentése, mint a matematikában. Így például az m + 1 = b utasítás szabálytalan. A matematikában viszont elfogadhatatlan a = a + 1 -et írni, pedig ez az írásmód igen gyakori a programozásban. Az a = a + 1 utasítás az a változó értékének eggyel történő megnövelését jelenti. Szövegkezelés Indexelés A karakterlánc összetett adattípus. Az egyes karakterekhez hozzáférhetünk, ha a karakterláncot tartalmazó vál tozó neve után szögletes zárójelbe írjuk a karakter karakterláncbeli pozíciójának megfelelő numerikus indexet. Az indexelés a nullától kezdődik. Példa: szoveg = Helló Világ! print szoveg[3] l Előfordulhat, hogy egy karakterlánc egy részét ki akarjuk venni, a Python erre a darabolás/kivágásnak nevezett egyszerű technika szolgál. Szögletes zárójelek között meg kell adni az elejét és végét, amihez hozzá szeretnénk férni. Az [n,m] szeletbe az n edik karakter beleértendő, de az m edik nem. Példa: szoveg = Helló Világ! print szoveg[0:6] Helló (az ékezetes karakterek 2 helyett foglalnak el) 83

84 Az első n karakter kivágása: szoveg[:n], az utolsó n karakter kivágása: szoveg[n:] Szöveg összefűzés (konkatenáció) Több szöveg típusú adatot a + jellel lehet összefűzni. Példa: a=3 print( Összesen +str(3)+ darab almát vettem. ) Összesen 3 darab almát vettem. Ismétlés A * operátorral lehet ismételni, utána meg kell adni hányszor legyen ismételve az adott karakterlánc. Példa: szoveg = Szia! ism = szoveg * 3 print ism Szia! Szia! Szia! Karakterlánc hossza Meghatározhatjuk egy karakterlánc hosszát (vagyis a karakterek számát) a len() függvény hívásával. Példa: szoveg = Helló Világ! print len(szoveg) 14 Benne van e? Meg tudjuk állapítani, hogy egy karakter(ek) benne van e egy karakterláncban. Példa: sor = "vi farkas más" if "farkas" in sor: print("van") else: print("nincs") van Karakterláncból adott karakterek elvétele lista A split() egy stringet alakít át substringek listájává. Mi adhatjuk meg argumentumként a szeparátor karaktert. Ha nem adunk meg semmit sem, akkor az alapértelmezett argumentumérték egy szóköz. Példa: k ="szia hello" l = k.split() print l ['szia','hello'] k ="abcccaabdcabcadb" l = k.split( a ) print l ['', 'bccc', '', 'bdc', 'bc', 'db'] Karakterláncból adott karakterek A join(lista) egyetlen karakterlánccá egyesít egy stringlistát. (Ez a metódus az split() inverze.)a szeparátor ka raktert (egy vagy több karaktert) az a string fogja megadni, amelyikre a metódust alkalmazzuk, az argumentu ma az egyesítendő stringek listája. Példa: k = ["szia","hello","szervusz"] print " ".join(k) szia hello szerbusz print " ".join(k) szia hello szervusz 84

85 Karakterláncban adott karakter(ek) első pozíciója A find(kar) megkeresi az adott substring első előfordulásának pozícióját egy karakterláncban. Példa: k = hello szia szervusz print k.find( sz ) 6 (Nullával kezdődik a szöveg indexelése!) print k.find( szerv ) 11 Karakterláncban adott substring előfordulása A count(kar) megszámolja az adott karakter(ek) előfordulásainak számát a karakterláncban. Példa: k = hello szia szervusz print k.count( sz ) 3 k = szia hello szia szervusz print k.count( szia ) 2 Kisbetűssé alakítás A lower() kisbetűssé alakít az adott karakterláncot. Példa: k = HELLO SZIA print k.lower() hello szia Nagybetűssé alakítás A upper() nagybetűssé alakítja a karakterláncot. Példa: k = hello szia print k.upper() HELLO SZIA Kezdő karaktert nagybetűssé A capitalize() a karakterlánc első betűjét nagybetűssé alakítja. Példa: k = hello világ! print k.capitalize() Hello világ! Kisbetű nagybetű megcserélés A swapcase() minden nagybetűt kisbetűssé, és minden kisbetűt naggyá alakítja. Példa: k = hello világ! print k.swapcase() Hello Világ! Felesleges karakter(ek) A strip() eltávolítja a karakterlánc elején és végén lévő megadott karaktereket. Ha nincs megadva akkor a szó közöket szedi le. Csak elejéről a lstrip(), csak a végéről a rstrip() függvényekkel lehet eltávolítani a felesleges karaktereket. Példa: k= Hello! print 0 +k.strip()+ 0 0Hello!0 print 0 +k.lstrip()+ 0 0Hello! 0 print 0 +k.rstrip()+ 0 0 Hello!0 Karakterek cseréje 85

86 A replace(mit, mire) karakterláncban valamennyi mit karaktert mire vel helyettesíti. Példa: k = abdcccadbcaadcbbada print k.replace( a, A ) AbdcccAdbcAAdcbbAdA Karakterláncban adott karakter indexe A index(c) megadja a c karakter karakterláncbeli első előfordulásának indexét. Példa: k = abcccadbcaadcbbada print k.index( d ) 6 (Nullával kezdődik a szöveg indexelése!) Kihagyott hely Ha formázott kivitelt használunk, akkor a formátum karaktersorozat után a szeparátor % jel karakter, a vessző helyett. Példa: szam = 3 print "Szám: %10d" % szam Szám: 3 print "Szám: %5d" % szam Szám: 3 Szöveg kiíratása nev = "körte" print "Név: %s" % nev Matematikai modul A matematikai modul használatához, importálnunk kell a math modult. A * karakterrel az math modul összes függvényét importáljuk, de megadhatunk egy vagy több függvényt is vesszővel elválasztva. import math print math.sqrt(9) Így importálva, mindig elé kell írni a math objektumnevet. Csak az sqrt függvényt importáltuk a math modulból. from math import sqrt print sqrt(9) A következőkben a sqrt() és a sin() függvényt is importáljuk: from math import sqrt,sin print sqrt(9) print sin(1 * pi / 180) Az összes függvény importálása: from math import * print sqrt(9) print sin(1 * pi / 180) Math modul factorial(x) exp(x) log(x) sqrt(x) cos(x) sin(x) tan(x) degress(x) faktoriális exponenciális logaritmus gyökvonás koszinusz radiánban szinusz radiánban tangens radiánban radiánt fokba konvertál 86

87 radians(x) pi() e() fokot radiánba konvertál pi értékét adja meg (3, ) e értékét adja meg (2,718281) Véletlen szám Ha véletlen számot szeretnénk használni a programunkban, akkor a importálnunk kell a random csomagot (im port random). Randrange Véletlen szám generálása a randrange függvénnyel lehetséges. Szintaxis: random.randrange([start], [stop], [step]) Példa: 0 tól 15 ig számok: print random.randrange(16) 9 Megadható alsó határ is. 5 től 11 ig számok: print random.randrange(5, 11) 6 Iterálva: # * coding: utf 8 * import random for szam in range(4): print random.randrange(3) A randrange nek lehet harmadik paramétere is, a lépés. Példa: print random.randrange(0,10,2) 2 A véletlen szám a 0; 2; 4; 6; 8 számok közül kerül ki. Randint Szintaxis: random.randint([start], [stop],) Visszatér egy egész N számmal, amely a <= N <= b. A randrange(a,b+1) formával azonos. Példa: # coding: utf 8 import random print random.randint(1,6) 2 Choice Szintaxis: random.choice(sorozat) A sorozatból választ egy elemet véletlenszerűen. Példa: # coding: utf 8 import random sorozat="abcde" print random.choice(sorozat) d Random Szintaxis: 87

88 random.random() Egy 12 darab tizedesjegyből álló lebegőpontos számot generál. Példa: Bevitel Adatok bekérése az input() függvénnyel lehetséges, a zárójelek közé magyarázószöveget lehet kiíratni a képer nyőre. Ebben az esetben a beolvasót adat típusa a hozzá legillőbb. szam = input("szám: ") print szam * 2 Szöveg típus a raw_input() függvény bármilyen is a beolvasott adat (egész, valós, szöveg) söveg típusú lesz. szoveg = raw_input("szöveg: ") Egész szám bekérése: eszam = int(raw_input("egész szám: ") Valós szám bekérése: vszam = float(raw_input("valós szám: ") Szekvencia utasítás1 utasítás2. A Python nyelvben fontos, hogy az utasításokat nem írhatjuk behúzással indoklás nélkül. Behúzással akkor ír hatjuk, hogy az utasítás egy szelekciós, iterációs vagy más blokk részét képezi. Logikai operátorok A logikai kifejezésekre, feltételekre alkalmazhatjuk a not (nem), az and (és) és az or (vagy) műveleteket. A mű veletek eredményeit a következő igazságtáblák szemléltetik, true = igaz, false = hamis. x not x true false false true x y true true true false false false true x and y true x y true true true false true false true false x or y true true false false false false false false Szelekció Általánosan if feltétel: utasítás(ok) if (szam<0): print( negatív ) Két ágú szelekció általánosan: if feltétel: utasítás(ok) else: utasítás(ok) 88

89 if (szam<0): print( negatív ) Több ágú szelekció általánosan: if feltétel: utasítás(ok) elif feltétel2: utasítás(ok) else: utasítás(ok) else: print( nem negatív ) if (szam<0): print( negatív ) elif (szam==0): print( nulla ) else: ( pozitív ) Iteráció Elöltesztelős ciklus (while) while feltétel: utasítás(ok) Számlálós ciklus (for) for cv range(k,l): utasítás(ok) i=0 while i < 3: i=i+1 print i, ". lépés" print "vége" 1. lépés 2. lépés 3. lépés vége for n in range(1, 3): Helló Világ! print "Helló Világ" Helló Világ! Intervallum [0,1,2,3,4,5,6,7,8,9] listát hozzuk létre. lista = range(10) for szam in lista: print szam Előállíthatunk 5 és 12 közötti számokat: range(5,13) [5, 6, 7, 8, 9, 10, 11, 12] 3 tól 15 ig, hármasával: range(3,16,3) [3, 6, 9, 12, 15] Lista bejárása nevsor = ['Anna','Bea','Kata','Móni','Szandra'] 0 Anna for i in range(len(nevsor)): 1 Bea print index, nevsor[i] 2 Kata 3 Móni 4 Szandra Időpont lekérdezése A time modul: import time helyiido = time.localtime(time.time()) print "Helyi idő: ", helyiido Helyi idő: time.struct_time(tm_year=2015, tm_mon=9, tm_mday=27, tm_hour=17, tm_min=27, tm_sec=8, tm_wday=6, tm_yday=270, tm_isdst=1) # Helyi idő formázva: 89

90 helyiido = time.asctime(time.localtime(time.time())) print "Helyi idő: ", helyiido Helyi idő: Sun Sep 27 17:27: A datetime modul import datetime Mai dátum, idő today(), time() most = date.today() mostido = date.time() print most Attribútumok: year, month, day print most.year datum = date(2003, 12, 2) print datum Dátumformátumok strftime(alak) %a A hét napjának rövidített neve. %A A hét napjának teljes neve. %b A hónap rövidített neve. %B A hónap teljes neve. %c Az alap dátum és idő formátum. %d A nap megjelenítése: %H Az óra megjelenítése(24 órás): %I Az óra megjelenítése (12 órás): %j Nap megjelenítése, év hanyadik napja: %m A hónap megjelenítése számmal: %M A perc megjelenítése: %p A megfelelő megjelenítése: AM vagy PM. %S A másodperc megjelenítése: %U A hét száma az évben (a vasárnap a hét első napja): %w A napok száma egy hétben: 0(vasárnap) 6. %W A hét száma az évben (a hétfő a hét első napja): %x Az alap dátum formátum. %X Az alap idő formátum. %y Az évszám megjelenítése, az utolsó két számjeggyel: %Y Az évszám megjelenítése pl %m %d %y %d %b %Y is a %A 27 Sep 2015 is a Sunday on on the %d day of %B. the 27 day of September. print most.strftime("%m %d %y. %d %b %Y is a %A on the %d day of %B.") Sep 2015 is a Sunday on the 27 day of September. A dátumok támogatják a naptári műveleteket. szuletesnap = date(1985, 10, 30) 90

91 kor = most szuletesnap # a most ot az elozo peldaban hataroztuk meg! print kor.days Összetett adattípusok Sorozatszerű típusok A Python terminológia szerint list (lista), dict (asszociatív tömb, szótár) és tuple (módosíthatatlan lista) típusok léteznek. Mivel nem kell definiálni a bennük szereplő adatok típusát, ezért int, float, string típusokat felváltva írhatunk bele, sőt még összetett típusokat (list, dict, tuple, complex) is. Elemei megváltoztathatóak. Lista (list) A Python többfajta összetett adattípust ismer, amellyel több különböző értéket csoportosíthatunk. A legsokolda lúbb a lista, amelynek elemeit vesszőkkel választjuk el, és szögletes zárójelek határolják. A lista elemeinek nem kell azonos típusúaknak lenniük. l = [ alma, körte, 3, 1.2] print l ['alma', 'körte', 1.2] Ahogy a karakterlánc indexek, úgy a lista indexek is 0 val kezdődnek, és a listákat is szeletelhetjük, összeil leszthetjük, stb. print(l[0]) 'alma' print(l[3]) 1.2 print(l[ 2]) 3 print(l[1: 1]) ['körte', 3] l2 = l[:2] + ['banán', 2*2] print(l2) ['alma', 'körte', 'banán', 4] print 2*l[:3] + ['Szia!'] ['alma', 'körte', 3, ''alma', 'körte', 3, 'Szia'] A karakterláncokkal ellentétben amelyek megváltoztathatatlanok a listák egyes elemeit módosíthatjuk: print l ['alma', 'körte', 3, 1.2] l[2] = l[2] + 12 print l ['alma', 'körte', 15, 1.2] A beépített len() függvény listákra is alkalmazható: print len(l) 4 A listák egymásba ágyazása is lehetséges: l1 = [2, 3] l2 = [1, l1, 4] len(l2) 3 print(l2[1]) [2, 3] print (l2[1][0]) 2 append(x) Egy elemet hozzáad a lista végéhez, megegyezik az lista[len(lista):] = [x] utasítással. lista = [12, 3, 2.4] lista.append(23) print lista [12, 3, 2.4, 23] extend(lista) A lista végéhez hozzáfűzi a lista nevű listát (mindegyik elemét egyenként), ugyanaz, mint a lista[len(lis ta):] = lista. lista1 = [12, 3, 2.4] lista2 = [2, 3.8] lista1.extend(lista2) print lista1 [12, 3, 2.4, 2, 3.8] 91

92 insert(i, x) Beszúr egy elemet az adott helyre. Az első argumentum az elem indexe, amely elé beszúrjuk, így lista.insert(0, x) a lista elejére szúr be, és a lista.insert(len(lista), x) ugyanazt jelenti mint az lista.append(x). lista = [12, 3, 2.4] lista.insert(1, 1) print lista [12, 1, 3, 2.4] remove(x) Eltávolítja a legelső olyan elemet a listából, amelynek értéke x. Hiba, ha nincs ilyen. lista = [12, 3, 2.4] lista.remove( 3) print lista [12, 2.4] pop([i]) Eltávolítja az adott helyen lévő elemet a listából, és visszaadja az értékét. Ha nem adtunk meg indexet, akkor az a.pop() az utolsó elemmel tér vissza. (Ekkor is eltávolítja az elemet.) (A függvény argumentum megadásánál használt szögletes zárójel azt jelenti, hogy a paraméter megadása tetszőleges, és nem azt, hogy a [] jeleket be kell gépelni az adott helyen.) lista = [12, 1, 5, 3, 2.4] a = lista.pop(3) print lista [12, 1, 5, 2.4] print a 3 index(x) Visszatér az első olyan elem indexével, aminek az értéke x. Hiba, ha nincs ilyen. lista = [12, 1, 5, 3, 2.4] a = lista.index(5) print a 2 count(x) Visszaadja x előfordulásának a számát a listában. lista = [5, 12, 1, 5, 5, 3, 2.4, 5] a = lista.count(5) print a 4 sort() Rendezi a lista elemeit. A rendezett lista az eredeti listába kerül. lista = [12, 1, 5, 3, 2.4] lista.sort() print lista [3, 1, 2.4, 5, 12] reverse() Megfordítja az elemek sorrendjét a listában szintén az eredeti lista módosul. lista = [12, 1, 5, 3, 2.4] lista.reverse() print lista [2.4, 3, 5, 1, 12] del Egy listaelem eltávolításának egyik módja, hogy az elem értéke helyett az indexét adjuk meg: ez a del utasí 92

93 tás. Ez arra is használható, hogy szeleteket töröljünk a listából (amit már megtettünk ezelőtt úgy, hogy a szeletnek az üres lista értékét adtuk). lista = [1, 1, 66.25, 333, 333, ] del lista[0] print lista [1, 66.25, 333, 333, ] del lista[2:4] print lista [1, 66.25, ] A del utasítást arra is használhatjuk, hogy az egész változót töröljük: del lista print lista NameError: name 'lista' is not defined Lista (tuple) Egy másik beépített sorozat, adattípus a tuple, amelynek elemeit vesszőkkel választjuk el, és kerek zárójelek ha tárolják. A lista elemeinek nem kell azonos típusúaknak lenniük. A lista elemeinek nem kell azonos típusúak nak lenniük. A tuple nem megváltoztatható adattípus( viszont lehetnek megváltoztatható elemei). t = (10, 11, 12, 13, szia! ) print t[0] 10 print t (10, 11, 12, 13, 'szia!') # A tuplékat egymásba ágyazhatjuk: u = t, (1, 2, 3, 4, 5) print u ((10, 11, 12, 13, 'szia!'), (1, 2, 3, 4, 5)) A tuple nem megváltoztatható, de lehetnek megváltoztatható elemei! lista = ['alma', 'eper', 'körte'] t = (1, 2, 3, lista) print t (1, 2, 3, ['alma', 'eper', 'körte']) t[0] = elso Traceback (most recent call last): File "lis.py", line 5, in <module> t[0] = 'elso' TypeError: 'tuple' object does not support item assignment #De a lista eleme változtatható! t[3][0] = 'elso' (1, 2, 3, ['elso', 'eper', 'körte']) A nulla vagy egy elemet tartalmazó tuple létrehozása: az üres zárójellel hozható létre a nulla elemű, az egy ele mű pedig az érték után tett vesszővel (nem elég, ha az értéket zárójelbe tesszük!). tures = () tegy = ('hello',) # figyeljünk a vesszőre a végén! print len(tures) 0 print len(tegy) 1 Halmazok (set) A Python a set adattípust (sets) is alaptípusként definiálja. a set: elemek rendezetlen halmaza, amelyben minden elem csak egyszer fordulhat elő. Alapvető használata: megadott elem meglétének ellenőrzése, elemek kettőzé sének kiszűrése. A set objektumok támogatják az olyan matematikai műveleteket, mint az egyesítés (union), közös metszet (intersection), különbség (difference), és a szimmetrikus eltérés (symmetric difference). Kosar egy lista, van benne ismétlődő elem: kosar = ['alma', 'narancs', 'alma', 'korte', 'narancs', 'banan'] Halmaz létrehozása: gyumolcsok = set(kosar) print gyumolcsok set(['banan', 'korte', 'alma', 'narancs']) A kosar listából képzett gyumolcsok halmazban minden kosarbeli elem egyszer szerepel! Benne vane egy adott elem: print 'narancs' in gyumolcsok True 93

94 print 'kakukkfu' in gyumolcsok False Példa: set/halmaz műveletek két szó egyedi betűin a = set('abracadabra') b = set('alacazam') # 'a'nak egyedi elemei print a set(['a', 'r', 'b', 'c', 'd']) # 'a'ban megvan, bből hiányzik print a b set(['r', 'd', 'b']) # vagy 'a'ban, vagy 'b'ben megvan print a b set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l']) # 'a'ban és 'b'ben is megvan print a & b set(['a', 'c']) # vagy 'a'ban, vagy 'b'ben megvan, de egyszerre mindkettőben nem print a ^ b set(['r', 'd', 'b', 'm', 'z', 'l']) Szótár (dict) A szótárakat más nyelvekben,,asszociatív tömböknek'' nevezik. Szemben a sorozatokkal amelyek számokkal vannak indexelve a tömböket kulcsokkal indexeljük, amely min denféle megváltoztathatatlan típus lehet; karakterláncok és számok mindig lehetnek kulcsok. Tuplék is használhatók kulcsnak, ha csak számokat, karakterláncokat vagy tuplékat tartalmaznak; ha egy tuple megvál toztatható objektumot tartalmaz közvetlenül vagy közvetve, akkor nem lehet kulcs. Listát nem lehet kulcsként használni, mert annak értékei az append(), extend() eljárásokkal, valamint a szeletelő vagy indexelt értékadásokkal (helyben) módosíthatók. Gondoljunk úgy a szótárra, mint kulcs: érték párok rendezetlen halmazára, azzal a megkötéssel, hogy a szótár ban a kulcsoknak egyedieknek kell lenniük. Egy kapcsos zárójelpárral egy üres szótárat hozhatunk létre: {}. Ha a zárójelbe vesszőkkel elválasztott kulcs:érték párokból álló listát helyezünk, akkor ez belekerül a szótárba; egy szótár tartalma is ilyen módon jelenik meg a kimeneten. A legfontosabb műveletek egy szótáron: eltárolni egy értéket egy kulccsal együtt, visszakapni egy értéket megadva a kulcsát. lehet törölni egy kulcs:érték párt a dellel. Ha olyan kulccsal tárolunk egy új értéket, amilyen kulcsot már használtunk, a kulcs az új értékre fog vonat kozni, a régi érték elveszik. Hiba, ha egy nemlétező kulcsra hivatkozol. A szótár objektum keys() eljárása a kulcsok listáját adja vissza véletlenszerű sorrendben (ha rendezni akarjuk, használjuk a sort() eljárást a kulcsok listájára). Ha ellenőrizni szeretnénk, hogy egy kulcs benne vane a szótárban, használjuk a szótárak has_key() eljárását. tel = {'János': 4098, 'Simon': 4139} tel['géza'] = 4127 print tel {'Simon': 4139, 'Géza': 4127, 'János': 4098} print tel['jános'] 4098 del tel['simon'] tel['pisti'] = 4127 print tel {'Géza': 4127, 'Pisti': 4127, 'János': 4098} print tel.keys() ['Géza', 'Pisti', 'János'] print tel.has_key('géza') True A dict() konstruktor közvetlenül tuplékban tárolt kulcsérték párok listájából is létre tudja hozni a szótárat. Ha a párok valamilyen mintát követnek, akkor listaműveletekkel rövidebb módon is megadhatjuk a kulcsérték lis tát. dict([('sape', 4139), ('guido', 4127), ('jack', 4098)]) {'sape': 4139, 'jack': 4098, 'guido': 4127} dict([(x, x**2) for x in (2, 4, 6)]) {2: 4, 4: 16, 6: 36} Mátrix megvalósítása 94

95 A mátrix egy egy kétdimenziós tömb, amit a list adattípussal valósítunk meg, listán belül listák. Mátrix létrehozásai: ma = [[1, 2, 3, 4, 5], [2, 3, 4, 5, 1], [3, 4, 5, 1, 2], [4, 5, 1, 2, 3], [5, 1, 2, 3, 4]] for i in range(0,5): [1, 2, 3, 4, 5] print ma[i] [2, 3, 4, 5, 1] [3, 4, 5, 1, 2] [4, 5, 1, 2, 3] [5, 1, 2, 3, 4] Függvény A Python a függvény kifejezést használja mind a valódi függvények, mind az eljárások jelölésére. Az eljárás olyan programkódrészlet, amely adattranszformációt hajt végre, vagy tevékenységet végez. Haszná latának igazi előnye akkor jelentkezik, amikor nagyobb programokban egy egy utasítássorozatot többször meg kell hívni. Az eljárások használata áttekinthetőbbé teszi a programot, és az esetleges hibák javítása is egyetlen helyen elvégezhető. Függvénynek nevezünk egy olyan alprogramot, aminek eredménye egyetlen jól körülhatárolt érték vagy objek tum. Ezt az értéket vagy objektumot a függvény visszatérési értékének nevezzük. Függvényeket a def szóval hozhatunk létre, ezután következik az általunk megadott függvénynév, majd zárójel ben a paraméterek, végül kettősponttal zárjuk a sort. Ezután jön a függvény belseje, ami az utasításokat tartal mazza, majd a return kifejezéssel adjuk meg a függvény visszatérési értékét. A függvények meghívásának álta lános formája: függvény_neve (argumentumok). # coding: utf 8 def osszeadas(szam1, szam2): eredmeny = szam1 + szam2 return eredmeny osszeg = osszeadas(3, 5) print(osszeg) 8 Beépített függvények Teljesség igénye nélkül néhány beépített függvény. abs(x) Egy szám abszolút értékét adja vissza. all(iterable) Igazat ad vissza, ha iterable minden eleme True igazságértékű. (vagy ha az iterable üres). any(iterable) Igazat ad vissza, ha iterable valamely eleme True igazságértékű. apply(f, args) Az < f > függvényt/metódust <args> argumentumokkal hívja meg. bin(x) Egy integer értéket átkonvertál bináris string gé. Ha x nem int objektum, akkor definiálnia kell az index () függvényt, amely integer értéket ad vissza. bool([x]) Egy tetszőleges objektumot átkonvertál bool ra, a szabványos igazságérték tesztelés szerint. Ha az x paraméter hiányzik, akkor False al tér vissza. callable(x) 1 értéket ad, ha x hívható, különben 0. chr(i) Egy karakter értékű stringet ad vissza, mely ASCII kódja megadott i egész szám. 95

96 cmp(x,y) Negatív, zéró, pozitív értéket add vissza, ha x <, ==, > y hoz viszonyítva. eval(s, globális, helyi ) Kiértékeli az < s > stringet az esetlegesen megadott < globális >, <helyi> érvényességi körökben található vál tozóknak megfelően. <s> ben nem lehet üres vagy újsor. <s> lehet kódobjektum is. Például: x = 1; incr_x = eval('x + 1') float(x) Az x számot lebegőpontos számmá konvertálja. hex(x) A számot hexadecimális stringgé konvertálja. int(x) Egy számot sima egész számmá (integer) konvertál. input([prompt]) Kiírja a prompt jelet, ha megadtuk. Beolvassa az input jelet és kiértékeli. len(s) s hosszát, elemszámát adja meg. long(x) Egy számot hosszú egész számmá konvertál (long integer). max(s) Egy nem üres szekvencia legnagyobb elemét adja vissza értékül. min(s) Egy nem üres szekvencia legkisebb elemét adja vissza értékül. oct(x) Egy számot oktális sztring értékké konvertál. ord(c) A <c> (1 hosszúságú sztring) ASCII kódját szolgáltatja. range(start [,end [, lépés]]) A >= start és < end értékek közötti egész számokból képzett listát ad vissza értékül. Egy argumentummal, lista 0 tól..<argumentum> 1 értékig. Két argumentummal, lista <start> értéktől..<end> 1 értékig. Három argumentummal, lista <start> értéktől <end> értékig <lépés> sel. raw_input([prompt]) A prompt értékét kiírja, ha megadott, majd stringet olvas be a standard inputról. round(x,n=0) x lebegőpontos értékét a tizedes pont után n számjegyre kerekítve adja vissza. str(objektum) Egy string értéket ad vissza, mely egy objektum jól nyomtatható reprezentációját adja vissza. type(objektum) Egy objektum típusát adja értékül. Például: if type(x) == type(''): print 'Ez egy sztring.' Műveletek fájlokkal Egy fájlt használat előtt meg kell találni, meg kell nyitni, amikor befejeztük a használatát, be kell zárni. Amíg nyitva van különböző információkat lehet belőle olvasni és lehet bele írni, de általában a kettőt nem tesszük egyszerre. A neve segítségével férünk hozzá (ami tartalmazhat egy könyvtárnevet is). A fájl tartalmát mindig tekinthetjük egy karaktersorozatnak, ami azt jelenti, hogy ezt a tartalmat, vagy annak bármely részét a karakterláncok keze lésére szolgáló függvények segítségével kezelhetjük. 96

97 A Python a fájlokat az aktuális könyvtárban fogja létrehozni és keresni. Ez szokás szerint az a könyvtár, ahol maga a script található, kivéve ha a scriptet egy IDLE shell ablakból indítjuk. Ez esetben az aktuális könyvtár az IDLE indításakor van definiálva (Windows alatt ennek a könyvtárnak a definíciója részét képezi az indító ikon tulajdonságainak). Ha az IDLE vel dolgozunk, akkor biztos, hogy a Pythont az aktuális könyvtárának megváltoztatására akarjuk majd kényszeríteni azért, hogy az megfeleljen az elvárásainknak. Ennek megtételéhez használjuk a következő utasításokat a session elején. (Most feltételezem, hogy a használni szándékozott könyvtár a /home/jules/exer cices). Használhatjuk ezt a szintaxist (vagyis szeparátorként a / karaktert nem pedig a \ karaktert). A Python au tomatikusan elvégzi a szükséges konverziókat annak megfelelően, hogy MacOS, Linuxban dolgozunk. >>> from os import chdir >>> chdir("/home/jules/exercices") Az első parancs az os modul chdir() függvényét importálja. Az os modul egy sor függvényt tartalmaz, amik az operációs rendszerrel (os = operating system) való kommunikációt teszik lehetővé, bármi is legyen az operációs rendszerünk. A második parancs a könyvtárat változtatja meg («chdir» «change directory»). A Pythonban a fájlokhoz való hozzáférést egy közbenső «fajl» biztosítja, amit az open() belsőfüggvény segítsé gével hozunk létre. Ennek a függvénynek a hívása után a fajl speciális metódusait használva olvasni és írni tu dunk a fájlban. Az alábbi példa bemutatja, hogyan nyitunk meg egy fájlt «írásra», jegyzünk be két karakterláncot, majd zárjuk le a fájlt. Jegyezzük meg, hogy ha a fájl még nem létezik, akkor automatikusan létre lesz hozva. Ha viszont a név egy már létező és adatokat tartalmazó fájlra vonatkozik, akkor a bejegyzendő karaktereket hozzáfogja fűzni a meglévőekhez. Ezt a gyakorlatot parancssorból végrehajthatjuk: >>> fajl = open('sajatfile','a') >>> fajl.write('szia, hello!') >>> fajl.write("hogy vagy?") >>> fajl.close() Az első sor egy «fajl» nevű fájlobjektumot hoz létre. Ez egy valódi fájlra hivatkozik, aminek a neve «sajatfile» lesz. Ne keverjük össze a fájl nevét a fájlobjektum nevével, amin keresztül hozzáférünk a fájlhoz. A gyakorlat során ellenőrizhetjük, hogy a rendszerünkben (az aktuális könyvtárban) egy «sajatfile» nevű fájlt (aminek a tartalmát bármelyik szövegszerkesztővel megnézhetjük) hozott létre a program. Az open() függvény két string típusú argumentumot vár. Az első a megnyitandó fájl neve, a második a megnyi tás módja. Az «a» azt jelenti, hogy «hozzáfűzés» (append) módban kell a fájlt megnyitni, azaz a bejegyzendő adatokat a fájl végéhez, a már esetleg ott lévő adatokhoz kell fűzni. A «w» (írásra) fájlmegnyitási módot is használhattuk volna, de ha ezt a módot használjuk, a Python mindig egy új (üres) fájlt hoz létre és az adatok írása ennek az üres fájlnak az elejétől kezdődik. Ha már létezik egy azonos nevű fájl, akkor azt előbb törli. A write() metódus végzi a fájlba írást. A kiírandó adatokat argumentumként kell megadni. Ezeket az adatokat sorban egymás után írja ki a fájlba (ezért beszélünk szekvenciális hozzáférésű fájlról). A write() minden új hí vása a már rögzített adatok után folytatja az írást. A close() metódus lezárja a fájlt. Ettől kezdve az mindenféle használatra rendelkezésre áll. Újra megnyitjuk a fájlt, de ez alkalommal «olvasásra», hogy vissza tudjuk olvasni az előző fejezetben rögzített információkat:>>> fajl = open('sajatfajl', 'r') >>> t = fajl.read() >>> print Szia, hello! Hogy vagy? >>> fajl.close() >>> fajl = open('sajatfajl', 'r') >>> t = fajl.read() >>> print Szia, hello! Hogy vagy? >>> fajl.close() Amint az várható a read() metódus kiolvassa a fájlbeli adatokat és egy «karakterlánc» (string) típusú változóba 97

98 teszi. Ha argumentum nélkül használjuk ezt a metódust, akkor az egész fájltartalmat beolvassa. «sajatfajl» an nak a fájlnak a neve, amit olvasni akarunk. A fájlt megnyitó utasításnak szükségszerűen hivatkozni kell erre a névre. Ha nem létezik a fájl, akkor egy hiba üzenetet kapunk. Példa: >>> fajl = open('sajatfajl','r') IOError: [Errno 2] No such file or directory: 'sajatfajl' Viszont semmilyen kikötést sem tettünk a fájlobjektum nevének megválasztására vonatkozóan. Ez egy tetszőle ges változónév. Így az első utasításunkban egy «fajl»nevű fájlobjektumot hoztunk létre, ami az olvasásra(«r» argumentum ) megnyitott «sajatfajl» valódi fájlra hivatkozik. A két beírt string most egyetlen stringként van a fájlban. Ez így természetes, mivel semmilyen elválasztóka raktert sem adtunk meg, amikor beírtuk őket a fájlba. A read() metódust argumentummal is használhatjuk. Az argumentum azt adja meg, hogy hány karaktert kell be olvasni a fájlban már elért pozíciótól: >>> fajl = open('sajatfajl', 'r') >>> t = fajl.read(7) >>> print t Szia, h >>> t = fajl.read(15) >>> print t ello! Hogy vag Ha a fájlban nincs annyi karakter hátra, mint amennyit az argumentum megad, akkor az olvasás a fájl végén egyszerűen leáll: >>> t = fajl.read(1000) >>> print t Szia, hello! Hogy vagy? Ha a fájl végén vagyunk, akkor a read() metódus egy üres stringet küld vissza: >>> t = fajl.read() >>> print t >>> fajl.close() A ciklusból való kilépésre szolgáló a break utasítás. Programhurkokra van szükségünk, amikor egy olyan fájlt kell kezelnünk, aminek nem ismerjük előre a tartalmát. Az alapelképzelés az, hogy részletekben olvassuk a fájlt mindaddig, amíg el nem érjük a fájl végét. Az egész fájlt átmásolja egy másik fájlba 50 karakteres részletekben: def masolfajl(forras, cel): fforras = open(forras, 'r') fcel = open(cel, 'w') while 1: txt = fforras.read(50) if txt =="": break fcel.write(txt) fforras.close() fcel.close() return Ha ellenőrizni akarjuk a függvény működését, két argumentumot kell megadni : az első az eredeti fájl neve, a második a másolat neve. Példa : masolfajle('forrasfajl','celfajl') A while utasítást mindig egy kiértékelendő feltétel követi. Amíg ez a feltétel igaz, addig fog a while utasítást követő utasításblokk végrehajtódni. Itt pedig a kiértékelendő feltételt egy állandó helyettesíti. Azt is tudjuk, hogy a Python minden nullától különböző numerikus értéket igaznak tekint. 98

99 Az így megalkotott while ciklus végtelen ciklus, mert a folytatásának a feltétele mindig igaz. Ez azonban meg szakítható a break utasítás hívásával, ami többféle kilépési mechanizmus elhelyezését teszi lehetővé ugyanabba a programhurokba: while <feltétel1> : különböző utasítások if <feltétel2> : break különböz ő utasítások if <feltétel3>: break stb. Könnyű belátni, hogy a masokfajl() függvényünkben a break utasítás csak akkor fog végrehajtódni, ha elértük a fájl végét. Egy szövegfájl egy olyan fájl, ami nyomtatható karaktereket és betűközöket tartalmaz egymást követő sorokba rendezve. A sorokat egy nem nyomtatható speciális karakter a «sorvége karakter» választja el egymástól. A Pythonnal nagyon könnyen kezelhetők az ilyen fajta fájlok. A következő utasítások egy négysoros szöveg fájlt hoznak létre: >>> f = open("szovegfajl", "w") >>> f.write("ez az első sor\nez a második sor\n") >>> f.write("ez a harmadik sor\nez a negyedik sor\n") >>> f.close() A szövegbe \n sorvége jelzéseket szúrunk be azokra a helyekre, ahol el akarjuk egymástól választani a szöveg sorokat. Enélkül a marker nélkül a karaktereket egymás után írnánk ki a fájlba. Az olvasási műveletek alatt a szövegfájl sorai külön külön nyerhetők vissza. A readline() metódus egyszerre csak egy sort olvas: >>> f = open('szovegfajl','r') >>> t = f.readline() >>> print t Ez az első sor >>> print f.readline() Ez a második sor A readlines() metódus az összes maradék sort egy szövegből álló listába teszi: >>> t = f.readlines() >>> print t ['Ez a harmadik sor\012', 'Ez a negyedik sor\012'] >>> f.close() A lista nyers formában jelenik meg, a karakterláncokat határoló aposztrófokkal és numerikus kód formájú spe ciális karakterekkel. A readlines() metódus lehetővé teszi, hogy egyetlen utasítással olvassunk el egy egész fájlt. Ez azonban csak akkor lehetséges, ha az olvasandó fájl nem túl nagy. (Mivel teljes egészében be fogja másolni egy változóba, vagyis a számítógép operatív memóriájába. ezért a memória méretének megfelelően nagynak kell lenni.) Ha nagy fájlokat kell kezelnünk, inkább a readline() metódust használjuk egy programhurokban. A readline() metódus egy karakterláncot ad vissza, míg a readlines() metódusa egy listát. A fájl végén a read line() egy üres stringet, míg a readlines() egy üres listát ad vissza. A következő függvényben úgy másolunk át egy szövegfájlt egy másik fájlba, hogy minden olyan sort kiha gyunk, ami # karakterrel kezdődik: def feltmasol(forras,cel): fforras = open(forras, 'r') fcel = open(cel, 'w') while 1: txt = fforras.readline() if txt =='': 99

100 break if txt[0]!= '#': fcel.write(txt) fforras.close() fcel.close() return A függvény hívásához két argumentumot kell megadni: az eredeti fájl nevét és annak a fájlnak a nevét, ami a másolatot fogja tartalmazni. Példa : feltmasol('forras.txt', 'cel.txt') A write() metódus argumentumának egy karakterláncnak kell lenni. Úgy tudunk más értéktípusokat elmenteni, hogy azokat először szöveggé alakítjuk, ezt a beépített str() függvény segítségével tehetjük meg. >>> x = 52 >>> f.write(str(x)) Ha a numerikus értékeket először karakterlánccá alakítjuk és így mentjük el azokat, akkor azt kockáztatjuk, hogy nem fogjuk tudni azokat helyesen visszaalakítani numerikus értékekké amikor majd a fájlból olvassuk. Példa: >>> a = 5 >>> b = 2.83 >>> c = 67 >>> f = open('sajatfajl', 'w') >>> f.write(str(a)) >>> f.write(str(b)) >>> f.write(str(c)) >>> f.close() >>> f = open('sajatfajl', 'r') >>> print f.read() >>> f.close() Nem tudjuk, hány érték is van a fájlban. Megoldás erre: importáljuk a pickle modult. A pickle modul dump() függvénye két argumentuma: változónév, fájlobjektum, amibe menteni fogjuk a válto zó értékét. A pickle.load() függvény a fordított irányú műveletet végzi el, vagyis visszaállít minden változót a típusával. >>> import pickle 5 <type 'int'> >>> f = open('sajatfajl', 'w') >>> t = pickle.load(f) >>> pickle.dump(a, f) >>> print t, type(t) >>> pickle.dump(b, f) 2.83 <type 'float'> >>> pickle.dump(c, f) >>> t = pickle.load(f) >>> f.close() >>> print t, type(t) >>> f = open('sajatfajl', 'r') 67 <type 'int'> >>> t = pickle.load(f) >>> f.close() >>> print t, type(t) Objektum orientált programozás Példa egy üres osztály definiálásra: class Pont: pass A Pont osztályból példányosítással (instanciation) hozhatunk létre új objektumokat. Jelölése a függvényhívá sokhoz hasonlóan történik: o = Pont() Az o objektum a Pont osztály egy példánya. 100

101 A létrehozott osztályunk üres és nem csinál semmit, de az osztályból példányosított objektumokhoz tetszőleges tartalmat rendelhetünk a dot notation, vagy pont operátoros minősített névmegadási rendszer segítségével. pont1 = Pont() pont2 = Pont() pont1.x = 3 pont1.y = 2 pont2.x = 3 pont2.y = 6 print(pont1.x, pont1.y) 54 print(pont2.x, pont2.y) 3 6 class Dolgozo: pass Anna.Nev = Lovas Anna Anna.Osztaly = beszerzés Anna.Fizetes = A metódus definiálása hasonlóan történik, mint a függvénynél. A def kulcsszó után megadjuk a metódus nevét, majd zárójelek közé helyezzük a paraméterlistát, végül pedig kettősponttal zárjuk. A függvények és a metódusok között különbség, hogy a metódusnak mindenképpen van legalább egy argumen tuma. Ennek a hagyományos elnevezése self. Osztályon belül a self mindig az aktuális objektumot jelöli. Ami kor a programunkból meghívjuk ezt a metódust, akkor viszont nem kell használnunk a self argumentumot, a Python gondoskodik erről helyettünk. class Pont: def koord(self,x,y): self.x = x self.y = y pont1 = Pont() pont2 = Pont() pont1.koord(2,3) pont.koord(1, 5) print(pont1.x,pont1.y) (2, 3) print(pont2.x,pont2.y) (1, 5) Hasznos lenne, ha minden új objektum alapértelmezetten rendelkezne a szükséges attribútumokkal. Az objek tumorientált nyelvek rendelkeznek egy speciális metódussal, a konstruktorral, amely az osztály példányosítá sakor hívódik meg. Feladata a példány kezdőértékeinek beállítása, inicializálás. Ennek a különleges metódus nak a neve minden esetben: init. Az elöl és hátul is dupla alsó vonás jelzi a parancsértelmezőnek, hogy egy különleges esettel van dolga. (A konstruktor metódus példányosításkor az objektum létrehozása után meghívódik, átadva a példányosításkor esetleg megadott paramétereket) class Pont: def init (self, x=0, y=0): self.elhelyez(x, y) def elhelyez(self, x, y): self.x = x self.y = y pont1 = Pont() pont2 = Pont() pont1.elhelyez(2,3) pont2.elhelyez(1, 5) print(pont1.x,pont1.y) (2, 3) print(pont2.x,pont2.y) (1, 5) Egy másik metódus a destruktor del, ez akkor hívodik meg ha az objektum megszűnik. 101

102 class a: def init (self): print "hello" def del (self): print "bye" b=a() b=none s=raw_input('nyomj le egy billentyűt!') Speciális metódusok Speciális metódusok bármely osztályra (class) vonatkozólag (s:self, o:más) init (s,argumentumok) objektum installálása del (s) meghívódik az objektum megszűnésekor (értéke 0 lesz) repr (s) repr() és... konverziók str (s) str() és 'print' kifejezések cmp (s, o) <, ==, >, <=, <>,!=, >=, is [not] implementálásakor hash (s) hash() és dictionary operátorok getattr (s, név) meghívódik, ha az attribútum keresés nem találja <nev> et. setattr (s, név, érték) meghívódik, ha attribútumnak adunk értéket. (benne ne használjuk a "self.név = érték" kifejezést,használjuk a "self. dict [név] = érték") delattr (s, név) meghívódik, hogy töröljük a <név> attribútumot. call (self, *argumentumok) meghívódik, amikor egy példányt függvényként hívunk meg. isinstance(ob1, ob2), ahol az első argumentum egy példányobjektum, a második pedig egy osztályobjektum vagy típusobjektum. Azt vizsgálja, hogy az ob1 az ob2 osztály egy példánya e, vagy, hogy az ob1 típusa meg egyezik e az ob2 típusával. issubclass(osztály1, osztály2), megvizsgálja, hogy az osztály1 az osztály2 alosztálya e. Egy osztály a saját al osztályának tekinthető. hasattr(obj, attr), ahol az első argumentum egy objektum, a második pedig egy karakterlánc. A függvény azt vizsgálja, hogy van e az objektumnak egy vagy több olyan attribútuma, amelynek a neve azonos az átadott ka rakterlánccal. Numerikus operátorok speciális metódusai (s: self, o: más) s+o = add (s,o) s o = sub (s,o) s*o = mul (s,o) s/o = div (s,o) s%o = mod (s,o) divmod(s,o) = divmod (s,o) pow(s,o) = pow (s,o) s&o = and (s,o) s^o = xor (s,o) s o = or (s,o) s<<o = lshift (s,o) s>>o = rshift (s,o) nonzero(s) = nonzero (s) (logikai teszteléskor használjuk) s = neg (s) +s = pos (s) abs(s) = abs (s) ~s = invert (s) (bit szerint) 102

103 int(s) = int (s) long(s) = long (s) float(s) = float (s) oct(s) = oct (s) hex(s) = hex (s) coerce(s,o) = coerce (s,o) A jobb oldali egyenlőségek minden bináris operátorra léteznek; azokat akkor hívjuk meg, amikor az osztály példánya az operátor jobb oldalán szerepel. a + 3 hívása add (a, 3) 3 + a hívása radd (a, 3) Szekvenciák és értéktáblák, általános műveletek kiegészítés (s: self, i: index vagy kulcs ) len(s) = len (s) objektum hossza, >= 0. 0 hosszúság == false s[i] = getitem (s,i) i indexű/kulcsú elem, 0 tól számítjuk. Szekvenciák, általános metódusok, kiegészítés: s[i]=v = setitem (s,i,v) del s[i] = delitem (s,i) s[i:j] = getslice (s,i,j) s[i:j]=szekv. = setslice (s,i,j,szekv.) del s[i:j] = delslice (s,i,j) == s[i:j] = [] 103

104 GUI tananyag A grafikus felhasználói felület vagy grafikus felhasználói interfész (angolul graphical user interface, röviden GUI). Eseményvezérelt programok Egy grafikus interface programok eseményvezéreltek. Az inicializálási szakasz után az ilyen típusú program várakozásba megy át és rábízza magát egy másik, többékevésbé mélyen a számítógép operációs rendszerébe integrált és állandóan m köd programra. Ez az eseményfogadó állandón figyeli a perifériákat (billentyűzetet, egeret, órát, modemet, stb.) és azonnal reagál rá, ha egy eseményt érzékel. Egy ilyen esemény lehet bármilyen felhasználói akció: az egér elmozdítása, billenty ű lenyomása, stb., de egy belsőesemény, vagy egy automatiz mus is lehet (például órajel). Amikor az eseményfogadó érzékel egy eseményt, akkor egy specifikus jelet küld a programnak, aminek azt fel kell ismerni, hogy reagáljon rá. Egy grafikus user interfaceprogram inicializálási szakasza olyan utasításokból áll, amik az interface különböző interaktív komponenseit helyezik el (ablakokat, gombokat, checkboxokat, stb.). Más utasítások a kezelendő üzeneteket definiálják: eldönthetjük, hogy a program csak bizonyos eseményekre reagáljon és a többit hagyja figyelmen kívül. Míg egy szöveges programban a működési szakasz olyan utasítás sorozatból áll, ami előre leírja azt a sor rendet, ahogyan a gépnek a különböző feladatait végre kell hajtania (még ha különböző végrehajtási utakról gondoskodunk is válaszul a végrehajtás során adódó különböző feltételekre), addig egy grafikus interface program működési fázisában csak független függvényeket találunk. Ezeket a program specifikusan akkor hívja, amikor egy meghatározott eseményt érzékel az operációs rendszer: vagyis azt a feladatot végzik el, amit erre az eseményre válaszul várunk a programtól és semmi mást. Ez alatt az eseményfogadó folyamatosan működik és esetleges más események bekövetkezésére vár. Ha más események következnek be, akkor megtörténhet, hogy egy második (vagy egy 3., egy 4.) függvény aktiválódik és az elsővel, ami még nem fejezte be működését, párhuzamosan kezd el működni. A modern operációs rend szerek és nyelvek lehetővé teszik ezt a párhuzamosságot, amit multitaskingnak is nevezünk. A programszöveg struktúrája nem adja meg közvetlenül az utasítások végrehajtási sorrendjét. Ez még inkább igaz a grafikus interfaceprogramokra, mivel a függvények hívásának sorrendje már sehol sincs leírva a prog ramban. A Pythonnal leginkább a Tkinter grafikus könyvtárat használják, ami a kezdetben a Tcl nyelv számára fejlesz tett Tk könyvtár egy adaptációja. Sok más igen érdekes grafikus könyvtárat ajánlottak a Pythonhoz : wxpy thon, pyqt, pygtk, stb. Lehet ség van a Java widgetek és a Windows MFC k használatára is. A Tkinternek hasonló (és ingyenes) verziói vannak Linux, Windows és Mac platformokra. 104

105 A használathoz a Tkinter modult telepíteni kell. Ahhoz, hogy a funkcióit használni tudjuk, a script valamelyik első sorának egy import utasítást kell tartalmaznia, ami a Tkinter modulban lévő valamennyi osztályt. from Tkinter import * Ablak Ez a kifejezés mást jelent a különböző kontextusban, de általánosságban arra vonatkozik, hogy egy téglalap alakú terület valahol a képernyő előtt. A Tkinter könyvtár egyik legalapvetőbb osztálya, a Tk() osztály mindent tartalmaz, ami különböző típusú, mé ret és színű, menüsoros vagy nélküli, stb. alkalmazásablakok létrehozásához szükséges. Ezt használjuk fel a grafikus alapobjektumunk, egy ablak létrehozására, ami a többi objektumot fogja tartalmazni. A Tk() zárójelé ben különböző opciókat adhatnánk meg, tehát a Tkinter modul Tk() osztályát használjuk és annak egy példá nyát (egy objektumát) hozzuk létre az ablakot. A mainloop() indítja el az ablakhoz kapcsolt eseményfogadót, ami arra kell, hogy az alkalmazásunk figyelje az egérkattintásokat, billentyű leütéseket, stb. Ez az az utasítás, amelyik valamilyen módon elindítja az alkalma zást. A neve (mainloop = f hurok) mutatja, az ablak objektum egyik metódusáról van szó, ami egy programhurkot aktivál. Ez a programhurok háttérprogramként folyamatosan működik és várja az operációs rendszer által kül dött üzeneteket. Folyamatosan lekérdezi a környezetét: a bemeneti perifériákat (egér, billentyűzet, stb.). Vala milyen esemény detektálásakor az illető eseményt leíró üzeneteket küld azoknak a programoknak, amiknek szükségük van arra, hogy tudjanak az illető esemény bekövetkezéséről. ablak = Tk() ablak.mainloop() Metódusok: tk.title( cím ): ablak címe. tk.geometry( widthxheight±x±y ): ablak méretének és helyének beállítása, szélességxmagasság, + ha a bal felső, jobb alsó saroktól számított pixelek száma. Ha nem állítunk be ablak méretet, akkor olyan nagyságú lesz az ablak mérete, hogy pontosan kiférjen minden komponens. ablak = Tk() ablak.title('fő ablak') ablak.geometry('500x ') ablak.mainloop() A Tkinter widget osztályai A Tkinter widget eknek 15 alaposztálya létezik, mindegyiknek számos beépített metódusa van, kapcsolhatunk hozzájuk eseményeket is. Button Klasszikus nyomógomb, valamilyen utasítás végrehajtásának az el idézésére használják. Canvas Különböző grafikus elemek elhelyezésére szolgáló felület. Rajzolásra, grafikus szerkesztek létrehozására és testre szabott widget ek implementálására is használ hatjuk. Checkbutton Egy jelöl négyzet, aminek két különböző állapota lehet (a négyzet ki van jelölve vagy nincs kijelölve). Egy klikkelés a widgeten állapotváltozást idéz el. Entry Adatbeviteli mez, amibe a felhasználó bármilyen szöveget beírhat. Frame Egy téglalap alakú felület az ablakban, ahova más widget eket tehetünk. Ez a fe lület színes lehet. Szegélye is lehet. Label Valamilyen szöveg (vagy címke) (esetleg egy kép). Listbox A felhasználónak általában valamilyen doboz formájában felajánlott válasz téklista. A Listbox ot úgy is konfigurálhatjuk, hogy vagy egy rádiógomb vagy 105

106 egy jelöl négyzet sorozatot tartalmazzon. Menu Menü. Lehet címsorhoz kapcsolódó legördül menü, vagy egy kattintás után akár hol feljövő úszó popup menü. Menubutton Menügomb, amit legördül menük implementálására használnak. Message Szöveg kiírását teszi lehetővé. A Label widget egy változata, ami lehetővé teszi, hogy a kiírt szöveg automatikusan egy bizonyos mérethez, vagy szélesség/magas ság arányhoz igazodjon. Radiobutton (Egy fekete pont egy kis körben.) Egy változó lehetséges értékeit reprezentálja. Az egyik rádiógombra való kattintás az annak megfelel értéket adja a változónak. Scale Egy kurzornak egy skála mentén való mozgatásával teszi láthatóvá egy változó értékének a változtatását. Scrollbar A görget sort más widget ekhez (Canvas, Entry, Listbox, Text) kapcsolva hasz nálhatjuk. Text Formázott szöveg kiírása. A felhasználónak is lehet vé teszi a kiírt szöveg formá zását. Képeket is be lehet szúrni. Toplevel Egy külön, felülre kiírt ablak. Geometria kezelése Minden Tkinter komponens (widgets) rendelkezik geometriát kezelő metódusokkal, amelynek célja a szülő komponensen (widgeten) való elhelyezés beállítása. A Tkinter a következő geometriakezelőkkel van felszerel ve: pack, grid és a place. Pack() Automatikus elhelyezés egymás alatt, a komponenseket blokkokba rendezi. A side argumentum megadásával TOP, BOTTOM, RIGHT, LEFT. komponens.pack(side=left) Grid() Az ablakot egy táblázatnak (rácsnak) tekinti, azt adjuk meg, hogy melyik sorába (row) és melyik oszlopába (column) akarjuk elhelyezni a widgeteket. A sorokat és oszlopokat úgy számozhatjuk, ahogy akarjuk: kezdhet jük nullától, egytől, vagy akármilyen számtól. A Tkinter figyelmen kívül hagyja az üres sorokat és oszlopokat. Ha nem adunk meg semmilyen sor vagy oszlopszámot, akkor az alapértelmezett érték nulla lesz. A sticky opció négy értéket vehet fel: N, S, W, E (a négy égtáj angolul). Ettől az értéktől függően lesznek a widgetek fentre, lentre, balra, vagy jobbra igazítva. pl.: komponens.grid(row=1, column=2) komponens.grid(row= 2, sticky=e) Place() Az adott pozícióban helyezzük el a komponenseket. Argumentumai: height/magasság, width/szélesség, elhelye zés vízszintes (x), függőleges (y) pixelben. komponens.place(x=20, y=50) Színek megadása A színek kétféleképpen adhatjuk meg, az angol elnevezéseikkel (pl. red, white), vagy színkóddal (pl. hexade cimális, fekete ). A megadás formája a következő: 106

107 'red' '#00ffff' 107

108 Karakter formázás Font Az objektumokon szereplő karakterek formázására az objektumok font paraméterével lehetséges. Paraméterek: family: betűtípus/család neve, size: betűméret, képpontban, weight: félkövér ('bold') vagy normál ('normal'), slant: dőlt ('italic') vagy normál ('roman'), underline: aláhúzott (1) vagy nem (0). 108

109 Kurzor alakjai Felirat Label Label() osztály mindenféle feliratot definiál, ezek arra használhatók, hogy különböző információkat írjunk az ablak belsejébe. változó_név=label(szülő, paraméter=érték,...) Paraméterei: az első argumentuma az az objektum amihez tartozik(masternek is nevezhetjük, a létrehozott objektumot slavejének). bg: felirat háttérszíne (background), bd: felirat szegélye pixelben (borderwidth), fg: szövegszín (foreground), font: szöveg tulajdonságai, image: feliratban elhelyezett kép, text: felirat szövege, justify: szöveg igazítása: LEFT, CENTER, NORMAL, height: magasság, nem pixel a mérete, hanem sor! width: szélesség, nem pixel a mérete, hanem karakter! padx: szöveg melletti margó, pady: szöveg feletti és alatti margó, textvariable: szöveg elhelyezhető egy StringVar objektumban, wraplength: milyen szélességnél legyen a sortörés. cimke = Label(ablak, text='szia!', fg='red') 109

110 Nyomógomb Button Button() osztály egy interaktív objektumot hozz létre, nyomógombot. változó_név=button(szülő, paraméterek,...) Paraméterei: az objektum amihez tartozik, text: a nyomógomb felirata, bg: gomb hátérszíne (background), bd: szegély pixelben, alapértelmezett 2, fg: szöveg színe (foreground), font: szöveg tulajdonságai, width: szélesség. Szöveg esetén sorokban, kép esetén pixelekben, height: a gomb magassága. Szöveg esetén sorokban, kép esetén pixelekben, cursor: a nyomógomb felett a kurzor alakjának beállítása, underline: hanyadik karakter legyen a gyorsbillentyű. relief: szegélytípus: SUNKEN, RAISED, GROOVE, RIDGE, activebackground : háttérszín, ha a gomb fölött van az egér, activeforeground : előtérszín, ha a gomb fölött van az egér, command : a gomb lenyomása által meghívott eljárás, highlightcolor : a fókusz színe, image : a gombon elhelyezett kép, justify : a szöveg igazítása: LEFT; CENTER; RIGHT, padx : a szöveg melletti margó, pady : a szöveg feletti és alatti margó, state : állapot: DISABLED, ACTIVE, NORMAL, wraplength : milyen szélességnél következzen be sortörés. gomb = Button(ablak, text='számol', bg='blue', fg='white', cursor='man', command=osszeg) Ha az ablakot szeretnénk gomb segítségével bezárni akkor a command értéke az ablak_neve.destroy. gomb = Button(ablak, text='bezár', command=ablak.destroy) Szövegbeviteli mező Entry Entry() osztály szövegbeviteli mezőt hoz létre, amibe bármilyen szöveget be illetve kiírhatunk. változó_név=entry(szülő, paraméter=érték,...) Paraméterei: az objektum amihez tartozik, bg: mező háttérszíne (background), fg: szövegszín (foreground), font: szöveg tulajdonságai, justify: szöveg igazítása: LEFT; CENTER; RIGHT, width: szélesség, karakterben megadva, exportselection : kijelölt szöveg automatikusan a vágólapra kerüljön e (0 vagy 1), highlightcolor : a fókusz színe, selectbackground: kijelölt szöveg háttérszíne, selectforeground : kijelölt szöveg színe, show : mi legyen látható? Jelszó esetén show="*", state : állapot: DISABLED, ACTIVE, NORMAL, 110

111 textvariable: a szöveg elhelyezhető egy StringVar osztályhoz tartozó objektumba, relief: szegélytípus: SUNKEN, RAISED, GROOVE, RIDGE, xscrollcommand : a mezőhöz vízszintesen egy gördítősávot rendelhetünk. mezo = Entry(ablak, justify='center', bd=8, fg='white', bg='green') Fontosabb metódusok delete (elso, utolso) : törli a szöveget az adott indexek között. get() : a mezőben lévő szöveget adja eredményül. icursor (index) : a kurzort az adott indexű karakter elé helyezi. insert ( index, szoveg) : a szöveget beszúrja az indextől kezdve. select_adjust (index) : a kijelölés adott sorszámú karakterét adja. select_clear() : Megszünteti a kijelölést. select_from (index) : Az adott indextől kezdve kijelöli a szöveget. select_present() : Ha van kijelölés, akkor igaz, ha nincs, akkor hamis. select_range ( elso, utolso ) : Az adott indexek között kijelöli a szöveget. select_to (index) : az adott karakterig kijelöli a szöveget. x = mezo1.get() y = int(mezo2.get()) mezo3.delete(0,end) mezo3.insert(0,'eredmény: '+str(2*y)) Példaprogramok 1. A program létrehozza a képen látható ablakot a komponensekkel, a Kilépés gombra kattintva az ablak bezáródik. # * coding: UTF 8 * from Tkinter import * ablak = Tk() ablak.title('adatok') cimke1 = Label(ablak, text = 'Vezetéknév:') cimke2 = Label(ablak, text = 'Keresztnév:') cimke3 = Label(ablak, text = 'Lakcím:') cimke4 = Label(ablak, text = 'Telefonszám:') mezo1 = Entry(ablak) mezo2 = Entry(ablak) mezo3 = Entry(ablak) mezo4 = Entry(ablak) kilep = Button(ablak, text = 'Kilépés', command = ablak.destroy) cimke1.grid(row = 0, column = 0) cimke2.grid(row = 1, column = 0) cimke3.grid(row = 2, column = 0) cimke4.grid(row = 3, column = 0) mezo1.grid(row = 0, column = 1) mezo2.grid(row = 1, column = 1) mezo3.grid(row = 2, column = 1) 111

112 mezo4.grid(row = 3, column = 1) kilep.grid(row = 4, column = 2) ablak.mainloop() 2. Az előző feladatra építve, a program beolvassa az adatokat, majd egy mezőbe kiíratja azokat együtt. A beolvasás és a kiíratás is egyegy gomb lenyomásának hatására történik. # * coding: UTF 8 * from Tkinter import * def rogzit(): vn = mezo1.get() kn = mezo2.get() lc = mezo3.get() tel = mezo4.get() x = vn+' '+kn+' '+lc+' '+tel kimezo.delete(0,end) kimezo.insert(0, x) ablak = Tk() ablak.title('adatok') ablak.geometry('420x ') cimke1 = Label(ablak, text = 'Vezetéknév:') cimke2 = Label(ablak, text = 'Keresztnév:') cimke3 = Label(ablak, text = 'Lakcím:') cimke4 = Label(ablak, text = 'Telefonszám:') kicimke = Label(ablak, text = 'Beolvasott adatok') mezo1 = Entry(ablak) mezo2 = Entry(ablak) mezo3 = Entry(ablak) mezo4 = Entry(ablak) kimezo = Entry(ablak) rog = Button(ablak, text = 'Rögzítés', command = rogzit) kilep = Button(ablak, text = 'Kilépés', command = ablak.destroy) cimke1.grid(row = 0, column = 0) cimke2.grid(row = 1, column = 0) cimke3.grid(row = 2, column = 0) cimke4.grid(row = 3, column = 0) kicimke.grid(row = 0, column = 2) mezo1.grid(row = 0, column = 1) mezo2.grid(row = 1, column = 1) mezo3.grid(row = 2, column = 1) mezo4.grid(row = 3, column = 1) kimezo.grid(row = 1, column = 2) rog.grid(row = 4, column = 1) kilep.grid(row = 4, column = 2) ablak.mainloop() 112

113 Jelölőnégyzet Checkbutton Többszörös választást tesz lehetővé. változó_név=checkbutton(szülő, paraméter=érték,...) Paraméterei: az objektum amihez tartozik, activebackground: háttérszín, ha a jelölőnégyzet fölött van az egér. activeforeground : előtérszín, ha a jelölőnégyzet fölött van az egér. bg : háttérszín. bd : szegély pixelekben, alapértelmezett 2. command : a jelölőnégyzet állapotának változásakor meghívott eljárás. font : a szöveg tulajdonságai. fg : szövegszín. height : A gomb magassága sorokban. Alapértelmezett: 1 highlightcolor : A fókusz színe. justify : a szöveg igazítása: LEFT; CENTER; RIGHT. offvalue: a kikapcsolt állapot értéke. onvalue : a bekapcsolt állapot értéke padx : a szöveg melletti margó. pady : a szöveg feletti és alatti margó. selectcolor : a kiválasztott jelölőnégyzet színe. state : állapot: DISABLED, ACTIVE, NORMAL. text : a felirat szövege. Sortörés ("\n"). underline: hanyadik karakter legyen a gyorsbillentyű. variable : az állapotot mutató IntVar objektum (0 vagy 1) width : szélesség. wraplength: milyen szélességnél következzen be sortörés. Fontosabb metódusok deselect() : nem lesz kiválasztva. select() : ki lesz választva. toggle() : ha ki volt választva, akkor nem lesz. Ha nem volt kiválasztva, akkor ki lesz. Rádiógomb Radiobutton Egyedi választást tesz lehetővé. változó_név=radiobutton(szülő, paraméter=érték,...) Paraméterei: az objektum amihez tartozik, activebackground : háttérszín, ha a rádiógomb fölött van az egér. activeforeground: előtérszín, ha a rádiógomb fölött van az egér. bg: háttérszín. command : a rádiógomb állapotának változásakor meghívott eljárás. font: a szöveg tulajdonságai. fg: szövegszín. height: a gomb magassága sorokban. Alapértelmezett: 1 highlightcolor : a fókusz színe. justify : a szöveg igazítása: LEFT; CENTER; RIGHT. padx : a szöveg melletti margó. pady: a szöveg feletti és alatti margó. selectcolor: a kiválasztott rádiógomb színe. 113

114 state: állapot: DISABLED, ACTIVE, NORMAL text: a felirat szövege. Sortörés ("\n"). textvariable: a rádiógomb állapotához tartozó StringVar objektum. underline: hanyadik karakter legyen a gyorsbillentyű. value : ha a rádiógomb állapota változik, akkor módosul az értéke. variable: a rádiógomb csoportjának közös IntVar vagy StringVar objektuma. width : szélesség. wraplength: milyen szélességnél következzen be sortörés. Példaprogramok 1. Írjunk olyan programot, amely attól függően számítja ki egy téglalap kerületét, illetve területét, hogy az adott jelöl négyzetben van e pipa! # * coding: UTF 8 * from Tkinter import * def szamol(): a = eval(mezo1.get()) b = eval(mezo2.get()) K = (a+b)*2 T = a*b mezo3.delete(0,end) mezo4.delete(0,end) if var1.get() == 1: mezo3.insert(0,str(k)) else: mezo3.insert(0,'') if var2.get() == 1: mezo4.insert(0,str(t)) else: mezo4.insert(0,'') ablak = Tk() ablak.title('téglalap') cimke1 = Label(ablak, text ='a: ') cimke2 = Label(ablak, text ='b: ') cimke3 = Label(ablak, text ='Kerület: ') cimke4 = Label(ablak, text ='Terület: ') var1 = IntVar() var2 = IntVar() jelolo1 = Checkbutton(ablak, text='kerület', variable = var1) jelolo2 = Checkbutton(ablak, text='terület', variable = var2) gomb1 = Button(ablak, text='kiszámolás', command=szamol) kilep = Button(ablak, text='kilépés', command=ablak.destroy) mezo1 = Entry(ablak) mezo2 = Entry(ablak) mezo3 = Entry(ablak) mezo4 = Entry(ablak) 114

115 cimke1.grid(row =1, column=1) cimke2.grid(row =2, column=1) cimke3.grid(row =6, column=1) cimke4.grid(row =7, column=1) jelolo1.grid(row=3, column=1) jelolo2.grid(row=4, column=1) gomb1.grid(row =5, column =2) mezo1.grid(row =1, column =2) mezo2.grid(row =2, column =2) mezo3.grid(row =6, column =2) mezo4.grid(row =7, column =2) kilep.grid(row =8, column =2) ablak.mainloop() 2. Írjunk olyan programot, amely attól függően számítja ki egy téglalap kerületét, illetve területét, hogy melyik rádiógomb van kijelölve! # * coding: UTF 8 * from Tkinter import * def szamol(): a = eval(mezo1.get()) b = eval(mezo2.get()) K = (a+b)*2 T = a*b mezo3.delete(0,end) if var.get() == 'ker': mezo3.insert(0,str(k)) if var.get() == 'ter': mezo3.insert(0,str(t)) ablak = Tk() ablak.title('téglalap') cimke1 = Label(ablak, text ='a: ') cimke2 = Label(ablak, text ='b: ') cimke3 = Label(ablak, text ='Eredmény: ') var = StringVar() radio1 = Radiobutton(ablak, text='kerület', value='ker', variable = var) radio2 = Radiobutton(ablak, text='terület', value='ter', variable = var) gomb1 = Button(ablak, text='kiszámolás', command=szamol) kilep = Button(ablak, text='kilépés', command=ablak.destroy) mezo1 = Entry(ablak) mezo2 = Entry(ablak) mezo3 = Entry(ablak) cimke1.grid(row =1, column=1) cimke2.grid(row =2, column=1) cimke3.grid(row =6, column=1) radio1.grid(row=3, column=1) radio2.grid(row=4, column=1) gomb1.grid(row =5, column =2) mezo1.grid(row =1, column =2) 115

116 mezo2.grid(row =2, column =2) mezo3.grid(row =6, column =2) kilep.grid(row =7, column =2) ablak.mainloop() Listadoboz Listbox Elemlisták kezelését teszi lehetővé. változó_név=listbox(szülő, paraméter=érték,...) Paraméterei: az objektum amihez tartozik, bg: háttérszín. font: a szöveg tulajdonságai.. fg: szövegszín. height: a doboz magassága sorokban. Alapértelmezett: 10. highlightcolor: a fókusz színe. relief: szegélytípus: SUNKEN, RAISED, GROOVE, RIDGE. selectbackground : a kijelölt szöveg háttérszíne. selectmode : meghatározza, hogy hány elemet lehet kijelölni és mozgatni. (BROWSE, SINGLE, MUL TIPLE, EXTENDED) width : szélesség karakterekben, alapértelmezett: 20. xscrollcommand : a listadobozhoz vízszintesen egy gördítősávot rendelhetünk. yscrollcommand : a listadobozhoz függőlegesen egy gördítősávot rendelhetünk. Fontosabb metódusok activate (index) : Kijelöli az adott indexű sort. curselection() : a kiválasztott elem sorszámát adja. delete (elso, utolso) : az adott indexek közé eső sorokat törli. get (elso, utolso) : az adott indexek közé eső sorokat adja vissza. insert (index, elemek) : sorok beszúrása az adott indextől kezdve. size() : a listadobozban lévő sorok számát adja. xview() : a vízszintesen hozzárendelt gördítősáv által tehető görgethetővé. yview() : a függőlegesen hozzárendelt gördítősáv által tehető görgethetővé. Példaprogramok 1. Írjunk olyan programot, amely képes egy szövegbeviteli mezőből elemeket beszúrni egy listadobozba, illetve képes törölni a listadoboz tartalmát! # * coding: UTF 8 * from Tkinter import * def torol(): lista1.delete(0,end) def hozzaad(): a = mezo1.get() lista1.insert(0,a) ablak = Tk() lista1 = Listbox(ablak) gomb1 = Button(ablak, text='hozzáad', command=hozzaad) 116

117 gomb2 = Button(ablak, text='töröl', command=torol) kilep = Button(ablak, text='kilépés', command=ablak.destroy) mezo1 = Entry(ablak) mezo1.grid(row =1, column =1) gomb1.grid(row =1, column =2) lista1.grid(row=2, column =1) gomb2.grid(row =2, column =2) kilep.grid(row=3, column =2) ablak.mainloop() 2. Írjunk olyan programot, amely képes egy szövegbeviteli mezőből elemeket beszúrni egy listadobozba, illetve képes a kijelölt elemeket törölni! # * coding: UTF 8 * from Tkinter import * def torol(): index = lista1.curselection() lista1.delete(index) def hozzaad(): a = mezo1.get() lista1.insert(0,a) ablak = Tk() lista1 = Listbox(ablak) gomb1 = Button(ablak, text='hozzáad', command=hozzaad) gomb2 = Button(ablak, text='töröl', command=torol) kilep = Button(ablak, text='kilépés', command=ablak.destroy) mezo1 = Entry(ablak) mezo1.grid(row =1, column =1) gomb1.grid(row =1, column =2) lista1.grid(row=2, column =1) gomb2.grid(row =2, column =2) kilep.grid(row=3, column =2) ablak.mainloop() Szövegdoboz Text Többsoros string formájú szövegbevitelt és szövegmanipulációt tesz lehetővé. változó_név=text(szülő, paraméter=érték,...) Paraméterei: az objektum amihez tartozik, bg: háttérszín. bd : szegély pixelekben, alapértelmezett 2. exportselection : a kijelölt szöveg automatikusan a vágólapra kerüljön e? (0 vagy 1) font : A szöveg tulajdonságai. fg: szövegszín. height: a doboz magassága sorokban. highlightcolor: a fókusz színe. 117

118 padx: a szöveg melletti margó. pady: a szöveg feletti és alatti margó. relief: szegélytípus: SUNKEN, RAISED, GROOVE, RIDGE. selectbackground: a kijelölt szöveg háttérszíne. tabs: a tabulátorpozíciók megadása. width : szélesség karakterekben. wrap : ezzel szabályozható, hogy a hosszú sorok, hogyan viselkedjenek (WORD, CHAR). xscrollcommand : a dobozhoz vízszintesen egy gördítősávot rendelhetünk. yscrollcommand : a dobozhoz függőlegesen egy gördítősávot rendelhetünk. Fontosabb metódusok delete(elso, utolso) : törli az indexek közötti szöveget. get( elso, utolso) : az adott indexek közötti szöveget adja vissza. insert(index, szoveg) : az adott indextől kezdve beszúrja a szöveget. Keret Frame Egy téglalap alakú felület az ablakban, ahova más komponenseket tehetünk, csoportosíthatjuk azokat. változó_név=frame(szülő, paraméter=érték,...) Paraméterei: az objektum amihez tartozik, bg : háttérszín. bd : szegély pixelekben, alapértelmezett 2. height: a keret magassága. relief : szegélytípus: SUNKEN, RAISED, GROOVE, RIDGE. width : szélesség. Címkével ellátott keret LabelFrame Címkével rendelkező téglalap alakú felület az ablakban, ahova más komponenseket tehetünk, csoportosíthatjuk azokat. változó_név=labelframe(szülő, paraméter=érték,...) Paraméterei: az objektum amihez tartozik, text: a felírat szövege. bg : háttérszín. bd : szegély pixelekben, alapértelmezett 2. height: a keret magassága. relief : szegélytípus: SUNKEN, RAISED, GROOVE, RIDGE. width : szélesség. Görgetősáv ScrollBar A Text és Listbox (vízszintes és függőleges) görgetését teszi lehetővé. Célszerű először egy frame et létrehozni a lista és a görgető csoportba foglalásához. változó_név=scrollbar(szülő, paraméter=érték,...) Paraméterei: az objektum amihez tartozik, activebackground : a csúszka és a nyilak színe, ha az egér fölöttük van. bg: a csúszka és a nyilak színe, ha az egér nincs fölöttük. command : a görgetés hatására meghívott eljárás. 118

119 highlightcolor: a fókusz színe. orient : a görgetősáv iránya (HORIZONTAL, VERTICAL) Példaprogramok 1. Írjunk olyan programot, amely egy listadobozba beszúr 100 darab, közötti véletlen számot, és el látja görgetősávval! (keret+listadoboz+görgetősáv) # * coding: UTF 8 * from Tkinter import * import random lista = [] for i in range(0,100): lista.append(random.randrange(100)) ablak = Tk() keret = LabelFrame(ablak) listdob = Listbox(keret) gorgeto = Scrollbar(keret) gorgeto.config(command = listdob.yview) listdob.config(yscrollcommand = gorgeto.set) kilep = Button(ablak, text ='Kilépés', command = ablak.destroy) keret.pack(side =TOP) gorgeto.pack(side =RIGHT, fill =Y) listdob.pack(side =LEFT, expand =YES, fill = BOTH) kilep.pack(side =BOTTOM) idx = 0 for i in range(100): idx = idx+1 listdob.insert(str(idx), str(i) +'. sor') ablak.mainloop() 2. Írjunk olyan programot, amely egy szövegdobozba beszúr 100 darab, közötti véletlen számot, és ellátja görgetősávval! (szövegdoboz + görget sáv) # * coding: UTF 8 * from Tkinter import * import random lista = [] for i in range(0,100): lista.append(random.randrange(100)) ablak = Tk() keret = Frame(ablak) szoveg = Text(keret) gorgeto = Scrollbar(keret) gorgeto.config(command = szoveg.yview) 119

120 szoveg.config(yscrollcommand = gorgeto.set) kilep = Button(ablak, text ='Kilépés', command = ablak.destroy) keret.pack(side =TOP) gorgeto.pack(side =RIGHT, fill =Y) szoveg.pack(side =LEFT, expand =YES, fill = BOTH) kilep.pack(side =BOTTOM) idx = 0 for i in range(0,100): idx = idx+1 szoveg.insert(str(idx)+'.0', str(i) +'. véletlenszám: '+str(lista[i])+'\n') ablak.mainloop() Csúszka Scale A csúszka lehetővé teszi a felhasználó számára, hogy számértéket csúszka segítségével határozza meg. Két típusa a vízszintes és a függöleges. változó_név=scale(szülő, paraméter=érték,...) Paraméterei: az objektum amihez tartozik, activebackground : a csúszka színe, ha az egér fölötte van. bg : a csúszka színe, ha az egér nincs fölötte. command : a görgetés hatására meghívott eljárás. font: a szöveg tulajdonságai. fg : szövegszín. from_: a csúszka kezdőértéke. highlightcolor: a fókusz színe. label : felirat megjelenítése. length: hosszúság, alapértelmezett 100 pixel. orient : a görgetősáv iránya (HORIZONTAL, VERTICAL) showvalue: az érték mutatása. sliderlength : a csúszka dobozának hosszúsága, alapértelmezett 30 pixel. tickinterval : a skálabeosztások távolsága. to : a csúszka végértéke. Fontosabb metódusok get() : a csúszkán beállított értékkel tér vissza. set(ertek) : beállítja a csúszka értékét. Példaprogramok 1. Írjunk olyan programot, amely két scale által meghatározott érték szorzatát írja ki egy szövegbeviteli mez be! # * coding: UTF 8 * from Tkinter import * def szoroz(): szam1 = csuszka1.get() szam2 = csuszka2.get() mezo1.delete(0,end) 120

121 mezo1.insert(0,str(szam1*szam2)) ablak = Tk() csuszka1 = Scale(ablak, from_ =1, to =10, tickinterval =1, orient=horizontal, length=200) csuszka2 = Scale(ablak, from_ =1, to =10, tickinterval =1, orient=horizontal, length=200) gomb1 = Button(ablak, text='szoroz', command=szoroz) kilep = Button(ablak, text='kilépés', command=ablak.destroy) mezo1 = Entry(ablak) csuszka1.pack() csuszka2.pack() gomb1.pack() mezo1.pack() kilep.pack() ablak.mainloop() Üzenet Message A Labelhöz képest több sor tárolására alkalmas. változó_név=message(szülő, paraméter=érték,...) Paraméterei: az objektum amihez tartozik, bg : háttérszín. font : a szöveg tulajdonságai. fg : szövegszín. justify : a szöveg igazítása: LEFT; CENTER; RIGHT. padx : a szöveg melletti margó. pady : a szöveg feletti és alatti margó. text: az üzenet szövege. Sortörés ("\n"). textvariable : a szöveg kezelését szolgáló StringVar objektum. wraplength : milyen szélességnél következzen be sortörés. Példaprogram Készítsünk a message widget segítségével olyan ablakot, amelyben a koszinusz tétel definíciója és formulája is szerepel, majd kiszámolhatjuk a c oldalt! # * coding: UTF 8 * from Tkinter import * from math import * def szamol(): a = eval(mezo1.get()) b = eval(mezo2.get()) szog = eval(mezo3.get()) szog = radians(szog) ered = a*a+b*b 2*a*b*cos(szog) ered = sqrt(ered) mezo4.delete(0,end) mezo4.insert(0,str(ered)) ablak = Tk() ablak.title('cosinus tétel') 121

122 ablak.geometry('500x ') szoveg1 = Message(ablak, text ='Tétel:\nBármely háromszögben az egyik oldal négyzetét meg kapjuk, ha a másik két oldal négyzetének összegéből kivonjuk e két oldal és az általuk közbezárt szög koszinuszának kétszeres szorzatát.', width =480) szoveg2 = Message(ablak, text ='Formulával:\nc*c=a*a+b*b 2*a*b*cos(szög) ', width = 480) cimke1 = Label(ablak, text='a oldal:') cimke2 = Label(ablak, text='b oldal:') cimke3 = Label(ablak, text='szög:') cimke4 = Label(ablak, text='c oldal:') mezo1 = Entry(ablak) mezo2 = Entry(ablak) mezo3 = Entry(ablak) mezo4 = Entry(ablak) gomb = Button(ablak, text='számol', command=szamol) kilep = Button(ablak, text='kilép', command=ablak.destroy) szoveg1.place(x=10, y=0) szoveg2.place(x=10, y=80) cimke1.place(x=20, y=130) mezo1.place(x=200, y=130) cimke2.place(x=20, y=150) mezo2.place(x=200, y=150) cimke3.place(x=20, y=170) mezo3.place(x=200, y=170) gomb.place(x=200, y=200) cimke4.place(x=20, y=270) mezo4.place(x=200, y=270) kilep.place(x=250, y=300) ablak.mainloop() Dialógusablakok tkmessagebox Üzenetablak A tkmessagebox modult üzenetdobozok megjelenítésére használjuk programokban. Ez a modul több függ vényt tartalmaz az üzenetek megjelenítésének variálásához. A használatához importálni kell a tkmessage Box modult. Szintaxis: tkmessagebox.ablaktipus(cím, üzenet[, opciók]) Ablaktípusok showinfo() : Infornáció megjelenítése showwarning() : Figyelmeztetés megjelenítése showerror() : Hibaüzenet megjelenítése askquestion() : Kérdés megjelenítése askokcancel() : OK, Mégsem (Az OK gomb visszatérési értéke True) askyesno() : Igen, Nem (Az Igen gomb visszatérési értéke True) askretrycancel() : Újra, Mégsem (Az Újra gomb visszatérési értéke True) 122

123 Cím: az üzenetablak címsorában látszik. Üzenet: a megjelenített üzenet. tkfiledialog Fájlkezelő ablak import tkfiledialog fajlnev = tkfiledialog.ablaktipus() Ablaktípusok askopenfilename() : Fájl megnyitása asksaveasfilename() : Fájl mentése tkcolorchooser Színválasztó ablak import tkcolorchooser szin = tkcolorchooser.askcolor() A visszatérési értéke két elemű. A [0] sorszámú elem a decimális rgb kód, az [1] sorszámú elem a hexadecimális rgb kód. Pl ((106, 150, 98), '#6a9662') Példaprogramok 1. Készítsünk olyan alkalmazást, amelyben egy kérdésre választ adva üzenetet kapunk, hogy válaszunk jó volt e? showinfo ablaktípussal megoldva: # * coding: UTF 8 * from Tkinter import * import tkmessagebox foablak = Tk() foablak.title('teszt') def avalasz(): tkmessagebox.showinfo('a válasz', 'Sajnos nem jól válaszoltál!') def bvalasz(): tkmessagebox.showinfo('b válasz', 'Gratulálok, helyesen válaszoltál!') kerdes = Label(foablak, text ='Mikor volt a Honfogalás?') gomb1 = Button(foablak, text = '869', command =avalasz) gomb2 = Button(foablak, text = '896', command =bvalasz) kilep = Button(foablak, text ='Kilépés', command =foablak.destroy) kerdes.grid(row =1, column =2) gomb1.grid(row =2, column =1) gomb2.grid(row =2, column =3) kilep.grid(row =3, column =2) foablak.mainloop() 2. Készítsünk olyan alkalmazást, amelyben egy kérdésre választ adva üzenetet kapunk, hogy válaszunk jó volt e? askyesno() ablaktípussal megoldva: #coding: UTF 8 from Tkinter import * import tkmessagebox import random 123

124 foablak = Tk() foablak.title('véletlenszám generátor') i=1 tovabb = 1 mezo = Entry(foablak) mezo.insert(0,str(random.randrange(100))) mezo.pack() while tovabb == 1: if tkmessagebox.askyesno('kérdés', 'Akarod folytatni!') == 1: i = i+1 mezo.delete(0,end) mezo.insert(0,str(random.randrange(100))) tovabb = 1 else: tovabb = 0 kilep = Button(foablak, text ='Kilépés', command =foablak.destroy) kilep.pack() foablak.mainloop() A feladatot megoldhatjuk még a askokcancel(), illetve askretrycancel() ablaktípusokkal is. 3. Készítsünk olyan alkalmazást, amelyben egy megadjuk az osztandót és osztót! Ha a nullával akarnánk osztani akkor hibaüzenet jelenik meg! showerror() ablaktípussal megoldva: #coding: UTF 8 * from Tkinter import * import tkmessagebox foablak = Tk() foablak.title('osztás') cimke1 = Label(foablak, text='osztandó:') cimke2 = Label(foablak, text='osztó:') cimke3 = Label(foablak, text='hányados:') mezo1 = Entry(foablak) mezo2 = Entry(foablak) mezo3 = Entry(foablak) def osztas(): a = float(mezo1.get()) b = float(mezo2.get()) if b == 0: tkmessagebox.showerror('hibaüzenet', 'Nem osztunk nullával!') mezo3.delete(0,end) mezo3.insert(0,'hiba!') else: mezo3.delete(0,end) mezo3.insert(0,str(a/b)) gomb = Button(foablak, text='számolás', command=osztas) 124

125 kilep = Button(foablak, text ='Kilépés', command =foablak.destroy) cimke1.grid(row =1, column =1) mezo1.grid(row =1, column=2) cimke2.grid(row =2, column =1) mezo2.grid(row =2, column=2) gomb.grid(row =3, column=2) cimke3.grid(row =4, column=1) mezo3.grid(row =4, column=2) kilep.grid(row =5, column=2) foablak.mainloop() A feladatot megoldhatjuk még a showwarning() ablaktípusokkal is. Többablakos alkalmazás Toplevel Többablakos alkalmazás akár Tk, akár Toplevel segítségével is készíthető. A Toplevel egy külön, felülre kiírt ablak. Példaprogram Készítsünk olyan alkalmazást, amelyben bekérjük egy téglatest egy csúcsba futó éleit, majd a felszínt és a térfogatot egy új ablakban írjuk ki! # * coding: UTF 8 * from Tkinter import * abl1 = Tk() abl1.title('a téglatest adatai') abl1.minsize(width =300, height=100) def ujablak(): abl2 = Toplevel(abl1) abl2.title('eredmények') abl2.minsize(width =300, height=100) sz1 = Label(abl2, text ='Felszín:') sz2 = Label(abl2, text ='Térfogat:') m1 = Entry(abl2) m2 = Entry(abl2) sz1.grid(row =1) sz2.grid(row =2) m1.grid(row =1, column =2, sticky =W) m2.grid(row =2, column =2, sticky =W) a = eval(mezo1.get()) b = eval(mezo2.get()) c = eval(mezo3.get()) felszin = 2*(a*b+a*c+b*c) terfogat = a*b*c m1.delete(0,end) m1.insert(0,str(felszin)) m2.delete(0,end) 125

126 m2.insert(0,str(terfogat)) kilep = Button(abl2, text='kilépés', command=abl2.destroy) kilep.grid(row =3, column = 2) abl2.mainloop() szoveg1 = Label(abl1, text ='a:') szoveg2 = Label(abl1, text ='b:') szoveg3 = Label(abl1, text ='c:') gomb1 = Button(abl1, text ='Számítás', command=ujablak) fkilep = Button(abl1, text='kilépés', command=abl1.destroy) mezo1 = Entry(abl1) mezo2 = Entry(abl1) mezo3 = Entry(abl1) szoveg1.grid(row =1) szoveg2.grid(row =2) szoveg3.grid(row =3) gomb1.grid(row =4, column= 2, sticky =W) mezo1.grid(row =1, column =2, sticky =W) mezo2.grid(row =2, column =2, sticky =W) mezo3.grid(row =3, column =2, sticky =W) fkilep.grid(row =4, column =3) abl1.mainloop() Menükészítés A menük definiálása egy ablakban, egy dedikált Frame segítségével történik. A Menubutton widget-tel lehet definiálni a menüsáv egy elemét és a Menu widget-tel lehet definiálni az elemhez kapcsolt parancsokat. Menubutton Menügomb activebackground : háttérszín, ha a menügomb fölött van az egér. activeforeground : előtérszín, ha a menügomb fölött van az egér. bg : háttérszín. bd : szegély pixelekben, alapértelmezett 2. fg : szövegszín. height: a menügomb magassága. highlightcolor: a fókusz színe. justify : a szöveg igazítása: LEFT; CENTER; RIGHT. image : a gombon elhelyezett kép. menu : a hozzárendelt menüobjektum. Általában a menu objektum kialakítása után config(menu = objektum) utólag állítjuk be. padx : a szöveg melletti margó. pady : a szöveg feletti és alatti margó. relief : szegélytípus: SUNKEN, RAISED, GROOVE, RIDGE. text : a felirat szövege. textvariable: a szöveg kezelését szolgáló StringVar objektum. underline : hanyadik karakter legyen a gyorsbillentyű. width : szélesség. Menu Menü activebackground : háttérszín, ha a menü fölött van az egér activeborderwidth : szegély vastagsága, ha a menü fölött van az egér 126

127 activeforeground : előtérszín, ha a menügomb fölött van az egér. bg : háttérszín. bd : szegély pixelekben. Alapértelmezett 2. font: a szöveg tulajdonságai. relief : szegélytípus: SUNKEN, RAISED, GROOVE, RIDGE. image : a menün elhelyezett kép. Fontosabb metódusok add_command (opciok) : menüparancs hozzáadása add_radiobutton(opciok) : rádiógombbal ellátott menüparancs hozzáadása add_checkbutton(opciok) : jelölőnégyzettel ellátott menüparancs hozzáadása add_cascade(opciok) : új almenü hozzáadása add_separator() : elválasztóvonal hozzáadása delete(elso, utolso) : adott tartományban lévő menüparancsok törlése entryconfig(index, opciok) : adott indexű bejegyzés módosítása index(item) : az adott elem indexét adja vissza. insert_separator (index) : beszúr az adott indexű helyre egy elválasztóvonalat Példaprogram Készítsünk olyan alkalmazást, amelyben menük segítenek annak a kiválasztásában, hogy egy téglatest felszínét vagy a térfogatát számítsuk ki, illetve, hogy a program készítőjének névjegyét tekintsük meg, vagy lépjünk ki a programból! # * coding: UTF 8 * from Tkinter import * #Névjegy ablak def nevjegy(): abl2 = Toplevel(foablak) uz2 = Message(abl2, text='téglatest felszín és térfogat számító program', width=300) gomb2 = Button(abl2, text='kilép', command=abl2.destroy) uz2.pack() gomb2.pack() abl2.mainloop() #Névjegy ablak vége #Felszín ablak def felszin(): def szamit(): a = eval(mezo1.get()) b = eval(mezo2.get()) c = eval(mezo3.get()) felszin = 2*(a*b+a*c+b*c) mezo4.delete(0,end) mezo4.insert(0,str(felszin)) abl3 = Toplevel(foablak) abl3.title('a téglatest felszíne') abl3.minsize(width =300, height=100) szoveg1 = Label(abl3, text ='a:') szoveg2 = Label(abl3, text ='b:') szoveg3 = Label(abl3, text ='c:') szoveg4 = Label(abl3, text ='Eredmény:') 127