Bevezető előadás

A számítási folyamatok

• A számítógépben: számítási folyamatok
• Ezek adatokat manipulálnak
• A működésüket programok vezérlik

Milyenek?

• Nem láthatóak, nem foghatóak meg – de igaziak
• Értelmes munkát végeznek, kérdésekre válaszolnak, pénzt mozgatnak bankok között, járműveket vezetnek

Honlap, adminisztrációs portál

Az információ hiteles forrása: https://infopy.eet.bme.hu/

Konzultáció: kérdések, nagy házi stb.

Saját laborvezetők! A portálon lehet üzenetet írni.

Oktatás: kétféle óra

• Előadás: ez most itt
• Labor: géptermi órák – önálló munka, programozás
• Labor átjelentkezés: első két héten, fogadó oktató beleegyezésével
• Labormunka feltöltése

Az előadásokra épülnek a laborok. Ezt figyelembe véve készült a tematika is. Ezért lesz az jellemző a félévben, hogy a laborokon vett feladatok régebbi, egy-két héttel előbbi előadásanyaghoz kötődnek. A laborokra készülve, az előadásanyagot megértve érdemes menni, különben haszontalan az ott töltött idő.

A labor órákhoz fognak kötődni a kis ZH-k és a nagy házi feladat is. A laborokon az egyik oktatótok feladata lesz a kis ZH-k javítása, a másik a nagy házi feladat konzultálása és értékelése – de természetesen bármelyik laborvezetőt megkereshetitek a kérdéseitekkel!

Számonkérések a félév közben

• Részvétel: jelenlét előadáson és laboron
• KZH: kisebb feladatok, 20–25 soros programok írása
• NZH: kb. 4–5× KZH
• NHF: egyénileg írt program dokumentációval
• Szorgalmik: megajánlott jegy szerezhető

Vizsgaidőszakban

• Vizsga a teljes anyagból; jegy a vizsgadolgozat és NHF alapján
• Megajánlott jegy, nem kell vizsgázni, ha jó ZH-k + szorgalmik

• Laborra hozhattok saját gépet, de a laborgépeket megbontani nem szabad. (nem dughatod a laptopodra a laborban lévő monitort, egeret, billentyűzetet stb.)
• WiFi kapcsolatot intézd el ld. bme intranet
• Saját gépen zárthelyit zárthelyit nem lehet írni
• Minden eshetőségre felkészülve ismerni kell az IDLE-t.

Algoritmusok

Amikor a tudást, ismeretanyagokat szeretnénk csoportosítani, azt megtehetjük annak „deklaratív” vagy „imperatív” jellege szerint.

Példa: egy szám négyzetgyöke

A programozásban általában kapunk egy feladatot – egy feladatot pontosan leíró specifikációt. Ez legtöbbször deklaratívan adott. Nekünk kell kitalálni a hozzá tartozó imperatív megoldást, azaz egy módszert, amellyel a bemenetből a kimenet előállítható.

Specifikáció: mit kell csináljon

• Mi lesz a bemenete, mi a kimenete, mi ezek között az összefüggés
• Ez általában deklaratívan adott

Gépek bemenettel
és kimenettel

Algoritmus: hogyan csinálja

• A megoldás „lépésről lépésre” leírása: imperatív módon
• Ezt nekünk kell kitalálni.
  Nincs rá általános módszer.

Művészet? Tudomány? Mérnöki feladat?

Nincs olyan általános módszer, amely segítségével egy algoritmus szisztematikusan kidolgozható lenne. Vagyis amellyel egy deklaratívan („mi igaz”) adott problémára imperatív („hogyan kell csinálni”) megoldás lenne adható. Hogy ez vajon művészet, tudomány vagy mérnöki feladat, azt nem lehet 100%-osan eldönteni:

• Egyrészről tudomány, ahogyan azt az angol neve is mutatja: computer science. Az algoritmusok kezelhetőek matematikailag. Helyességük bizonyítható, tulajdonságaik (pl. időigény) számszerűsíthetőek.
• Másrészről művészet, hiszen a kidolgozásuk gyakran ötletelésen, felismeréseken múlik. Az egyik leghíresebb programozásról szóló könyv „A számítógépprogramozás művészete” című sorozat (Donald Knuth: The Art of Computer Programming). A címe mindent elmond.
• Harmadrészt mérnöki feladat, éppen annyira, mint egy autót megtervezni. Figyelni kell arra, hogy a részegységek ne zavarják egymást. Irányítani kell a csapatok munkáját, méghozzá úgy, hogy egymástól függetlenül is tudjanak dolgozni. Vannak szabványok, amelyeket követni kell.

A programozás során rengeteg olyan problémával találkozunk, amelyek rendszeresen felmerülnek. Vannak jól bevált megoldások, amelyeket érdemes újra és újra felhasználni. Egy jó programozó bármikor tud mondani többféle módszert is arra, hogyan lehet egy névsort ábécébe rendezni, sőt azt is tudja, mikor melyik módszer a gyorsabb. Ezért sokszor, amikor programozunk, már megtanult algoritmusokat kódolunk csak le.

Algoritmus

Módszer a feladat megoldására.

• Utasítássorozat megengedett lépésekből
• Mechanikusan végrehajtható
• Véges sok lépésből áll
• Mindig egyértelműen adott a következő lépés
• Minden időpontban véges sok memória kell

A papíron összeadás és a prímtényezős felbontás olyan algoritmusok, amelyeket általános iskolában tanítanak. Vegyük észre, hogy mind kimerítik a fenti feltételeket: mechanikusan végrehajthatóak, mindig pontosan definiálják a következő lépést – és valamilyen bonyolult probléma megoldását adják meg úgy, hogy közben egyszerű lépéseket használnak.

 175
+343
────
 518

20│2
10│2
 5│5
 1│ 

A programozásban a módszerek, algoritmusok szöveges leírását adjuk meg.

Kérj egy számot a felhasználótól, legyen ez N.
A értéke legyen 1.
Ellenőrzés: Ha N=1, ugorj előre a „vége” címkéhez.
Legyen A értéke mostantól A·N.
N értékét csökkentsd 1-gyel.
Ugorj vissza az „ellenőrzés” címkéhez.
Vége: Írd ki A értékét.

A szöveges leírás (pszeudokód) tartalmazza:

• A megjegyzett számok listáját: ezek a változók.
• Az elvégzett műveleteket: szorzás, csökkentés.
• A lépések sorrendjét meghatározó utasításokat és döntési pontokat: a vezérlést.

Ezzel megadjuk az algoritmust. Vegyük észre, hogy teljesen mechanikusan végrehajtható lépésekről van szó: egyszerű, matematikai jellegű lépéseket végzünk. Szorzást kell elvégezni, egyenlőséget vizsgálni stb.

Próbáld is ki az algoritmust, számítsd ki a 4 faktoriálisát az utasításokat követve! Jegyezd föl papírra az A és az N értékét; ha azt kéri az algoritmust, hogy módosítsd, akkor radírozd ki, és írd a jegyzeteidhez az új számot.

# legnagyobb közös osztó
a = int(input("a? "))
b = int(input("b? "))

while b != 0:
    t = b
    b = a % b
    a = t

print("lnko =", a)

Mint mikor angolul vagy németül tanulunk: a számítógép nyelvének elemeit meg kell tanulni.

Programozási nyelv

• A Python nyelvet fogjuk használni (3.0: Guido van Rossum, 2008.)
• Egyike azon nyelveknek, amit elsőként tanítanak

A Python nyelvet eredetileg Guido van Rossum fejlesztette ki, 1991-ben jelent meg először. Azóta több szabványosított változata lett. A jelenlegi változata a 3.x-s verzió, amelynek első változata 2008-ben jelent meg. (Még néha használják a 2.x-set is, de azt 2020-ban végleg nyugdíjazták.) Ebben a tárgyban, ebben a félévben >=3.6 verziójú Python-t használunk. Ez amúgy 2016-ban jelent meg.

A programozás alapjai

A tradicionális első program forráskódja:

# üdvözlet
print("Helló, világ!")

Helló, világ!

# Számológép
print("Eredmény:", 2*3)

Hogy beszélni tudjunk róla, hogyan dolgoznak fel a programok adatokat, meg kell ismernünk a típus fogalmát.

Típus

Az értékkészlet és a műveletek együttese.

• A változóknak is van típusa – ez adja meg az értékkészletet és a végezhető műveleteket is.
• A típusok szinte minden programozási nyelvben megtalálhatóak.

A kifejezések a programjaink legalapvetőbb építőkövei: műveleteket végeznek el. Ezeket ismerjük a matematikából is: összeadás, kivonást stb., de a programozásban sokkal többféle lesz.

Kifejezések és típusok

A műveletek adott típusokon végezhetőek el, és az eredménynek is van valamilyen típusa. Ezek azonban nem feltétlenül ugyanazok. Például egy szám+szám művelet eredménye is szám, de egy szám<szám összehasonlítás logikai, igaz/hamis típusú eredményt ad. Lehetséges az is, hogy egy művelet két operandusának típusa sem egyezik meg: időpont+időtartam→időpont. Pl. 12:15+30 perc=12:45.

A kifejezésekről

• Meg kell feleljenek a nyelvtani szabályoknak
• Fontos a típus, hogy értelme legyen egy kifejezésnek!
  • Ha X szám, X+3 értelmes.
  • Ha X szöveg, X+3 értelmetlen.

A kifejezés értelmességéhez, helyességéhez szükséges az is, hogy az egyes műveleti jelek (operátorok) mellett megfelelő típusú operandusok legyenek. Az 1-HAMIS kifejezés hiába tűnik helyesnek nyelvtanilag (a mínusz jel mindkét oldalán egy érték van), mégis értelmetlen, mert egy egész számból nem lehet kivonni egy logikai értéket. Ugyanígy értelmetlen az 1+"alma" kifejezés is.

Mi az a változó?

Egy eltárolt, megjegyzett érték, amelynek nevet adunk.

• Egy változó egy dolgot jegyez meg, ezért minden megjegyzett dologhoz külön változó kell.
• A programnak időbeliséget adnak: miattuk számít a műveletek sorrendje!

X értéke legyen 5.     értékadás (írás)

Leírom X-et.           kiértékelés (olvasás): „5”

X értéke legyen X+1.   kifejezés kiértékelése, aztán értékadás

Leírom X-et.           ez „6” lesz

A program futása során, egyes időpontokban más lehet az értékük: ugyanaz a művelet más eredményt adhat egy másik pillanatban. Emiatt fontossá válik a műveletek sorrendje. Fontos gondolat, hogy ez az értékadás miatt van. Ha nem létezne értékadás, akkor ez nem lenne így. Például az alábbi képletben teljesen mindegy, hogy melyik tényező értékét számítjuk ki előbb: (3+4)×(6-9)×(12-4-6+5). Haladhatunk balról jobbra, jobbról balra, vagy akár kezdhetjük a középső 6-9-cel is. Ezzel szemben a fenti programkódban láthatóan számít az, hogy a növelés előtt vagy után írjuk le az X változó értékét.

Vannak statikusan és dinamikusan típusos programozási nyelvek. A Python nyelv dinamikusan típusos.

Ez azt jelenti, hogy a változóknak nem kell előre megadni a típusát, sőt egy adott nevű változó típusa is változhat a program futása közben.

x = 12
print("Értéke:", x)  # Értéke: 12

x = "alma"
print("Értéke:", x)  # Értéke: alma

Általában viszont egy változóval ilyet nem szoktunk csinálni. A változónak a programban meghatározott szerepe, célja van, ami alapján nevet is adtunk neki. A szerepéből pedig következik a típusa is; egy ember neve sosem lesz egész szám, a kör sugara pedig nem lesz szöveg. Emiatt valószínűleg nem logikus az a program, ahol egy egész típusú változó egyszercsak szöveggé változik.

A statikusan típusos nyelvekben a fentiek ellenkezője igaz. Ott a programkódban meg kell adnunk előre minden egyes változó típusát, és az a típus nem változhat a program futása alatt.

Feladat: írjunk programot, amelyik nevén üdvözli a felhasználót!

Hogy hívnak? Pistike

Szia, Pistike!

Ne legyen szóköz a név és a felkiáltójel között!

Ez az első interaktív programunk, amely nem csak kiír valamit, hanem kérdez is a felhasználótól – sőt az eredmény a felhasználó által adott bemenő adattól függ.

Az eddigiek alapján ehhez szükségünk lesz egy változóra. Előbb beolvassuk a nevet egy input() segítségével, utána pedig kiírjuk az üzenetet a print()-tel.

nev = input("Hogy hívnak? ")
print("Szia, " + nev + "!")     # egy paramétere van!

+ operátor sztringek között: összefűzés, konkatenálás (concatenation).

Ha a print("Szia,", nev, "!") sort írnánk, akkor Szia, Pistike ! lenne az eredmény, vagyis a felkiáltójel előtt zavaróan egy szóköz lenne még. Ezt a megoldásban úgy kerüljük el, hogy egyetlen egy sztringet állítunk elő, amelyben összefűzzük a + operátorral (művelettel) a három sztringet, a Szia köszönést, a nevet és a felkiáltójelet. Az összefűzésnél nem kerül szóköz a darabok közé, pl. "alma" + "fa" értéke almafa lesz. Így a felkiáltójel előtt nem lesz szóköz, a vessző után viszont mi tettünk.

print("Szia, " + input("Hogy hívnak? ") + "!")

Az operandusok típusától függően eltérő lehet a működés.

Számok esetén összeadás, sztringek esetén összefűzés történik.

print(1 + 2)
print("alma" + "fa")

3
almafa

Típusokkal kapcsolatos hibák

print("alma" + 123)     # hibát dob

Traceback (most recent call last):
  File "proba.py", line 5, in <module>
    print("alma" + 123)
TypeError: must be str, not int

Egy sztring és egy szám nem adható össze, ezért hibát dob a program: TypeError.

a = input("a? ")
b = input("b? ")

print("a+b =", a + b)

a? 2
b? 3
a+b = mi lesz itt?

Mi az oka annak, hogy 23 íródott ki? Az, hogy az input() által visszaadott érték sztring típusú. Így sztring lesz a-ban és b-ben is, még akkor is, ha a felhasználó számjegyeket gépelt be. Márpedig sztringeket úgy kell összefűzni, hogy egymás után írjuk a bennük tárolt karaktereket; így lesz "23" (huszonhárom, vagyis valójában kettő-három) az eredmény, nem pedig 5. Ha a felhasználó almát és fát gépel be, akkor nem is tűnik furcsának az eredmény, "almafa".

Mi a teendő, ha mégis a két szám összegét szeretnénk kiírni, 2+3 = 5?

a = input("a? ")
b = input("b? ")

print("a+b =", int(a) + int(b))

A beolvasott sztringeket számmá kell konvertálni.

a = int(input("a?"))
b = int(input("b?"))

print("a+b =", a+b)

s = input()

int(s)          # nem csinál semmit, értelmetlen

print(s + "!")  # működik, mert s egy sztring

import math

print("Mennyi a kör sugara?")
sugar = float(input())

print("Kerület =", 2 * sugar * math.pi)
print("Terület =", sugar**2 * math.pi)

Mennyi a kör sugara?
4.5
Kerület = 28.274333882308138
Terület = 63.61725123519331

print(3, 1416)  # két külön szám, 3 és 1416

print(3.1416)   # egy szám, a π közelítő értéke

A vezérlési szerkezetek

Elemi lépések, műveletek a számítógépen

• Kiírunk valamit a képernyőre
• Adatot kérünk a felhasználótól
• Kiszámítunk valamit
• …

PROGRAM
    KIÍR: "Helló, világ!" egyetlen elemi lépés
PROGRAM VÉGE

Mit csinál a program?

• A program kifejezésekkel kiszámol értékeket
• Ezeket eltárolhatja változókba vagy kiírhatja a kimenetére
• A számítások sorrendjét a vezérlési szerkezetek adják meg

3211 │ 13
 247 │ 13
  19 │ 19
   1 │   

Például egy prímtényezős felbontás algoritmusában nem mondhatjuk azt, hogy „oszd el a számot a legkisebb prímszámmal”. Legalábbis amíg nem mondtuk meg azt, nem raktuk össze kiértékelésekből és értékadásokból, hogy hogyan lehet megkeresni a legkisebb prímszámot, ami osztja a bal oldalit.

Folyamatábra

léptet

Program

   print("Oldalhossz?")   
   a = int(input())   
   t = a*a   
   print("Terület =", t)   

Működés

a: 
t: 

A programok vezérlési szerkezetét grafikusan is megadhatjuk. A folyamatábra (flow chart) és a struktogram ennek két elterjedt módja. A folyamatábrán a nyilak mutatják a lépések sorrendjét.

Mire használjuk itt a változót? Arra, hogy megjegyezzük a felhasználótól származó értéket – és később a négyzetét.

Feladat: Írjunk programot, amely kér egy számot a felhasználótól.
Mondja meg, hogy páros-e vagy nem.

A programsorok végrehajtása feltételhez (igazságértékhez) köthető.

Folyamatábra

léptet

Program

   szam = int(input())   
   if szam % 2 == 0:   
       print("páros")       ha igen
   else:
       print("páratlan")    ha nem

Működés

szam: 

if feltétel:   utána kettőspont
    utasítás
else:          opcionális
    utasítás

Feladat: írjunk programot, amelyik kiírja a számokat 1-től 10-ig.

KIÍR: 1
KIÍR: 2
KIÍR: 3
…
KIÍR: 8
KIÍR: 9
KIÍR: 10

Probléma

• Egyrészt: kipontozás? Ez nem szép megoldás. Sorminta!
• Másrészt: mi van akkor, ha a felhasználó kellene megmondja, meddig kellenek a számok? A program forráskódja nem függhet a bemenetétől!

A programozásban inkább ne!

Ciklus (loop): programrész ismétlése, amíg egy feltétel fennáll.

Folyamatábra

léptet

Program

   print("Meddig írjam ki?")   
   n = int(input())   

   x = 1   
   while x <= n:   
       print(x, end=" ")   
       x = x+1   

   print(".")   

Működés

n: 
x: 

while feltétel:
    utasítás

Ciklusfeltételek

• A ciklus bennmaradási feltétele logikai kifejezés
• Újra és újra kiértékelődik minden iterációban
• Ha teljesül, végrehajtódik a törzs, ha nem, a ciklus után folytatódik a program

Hányszor hajtódnak végre?

• Ahányszor a feltétel teljesül
• Ez lehet 0 is: a törzs egyszer sem hajtódik végre
• A feltétel előbb-utóbb hamissá kell váljon, különben végtelen ciklus (infinite loop) keletkezik

A feltétel hamissá kell váljon előbb-utóbb: praktikusan ez azt is jelenti, hogy a ciklusváltozónak, ha van, az egyes iterációk között változnia kell. Különben ugyanaz marad az értéke, és a ciklus feltételének igazságértéke sem fog változni! Ha nincs olyan utasítás a ciklusban, amely a ciklusváltozó értékét változtatja, az gyanús.

Számok kiírása 1-től 10-ig:

i = 1
while i <= 10:
    print(i)
    i = i+1

i = 0   # :(
while i <= 9:   # :(
    i = i+1
    print(i)    # :(

x = 1          # mit keres ez itt :(
y = 1
while y <= 5:
    while x <= 5:
        print(x*y, end="\t")
        x = x+1
    print()
    x = 1      # mit keres ez itt :(
    y = y+1

y = 1
while y <= 5:
    x = 1      # itt a helye! :)
    while x <= 5:
        print(x*y, end="\t")
        x = x+1
    print()
    y = y+1

y = 1
while y <= 10:
    x = 1
    while x <= 5:
        print(x * y, end="\t")
        x = x+1
    print()     # új sor
    y = y+1

1       2       3       4       5   
2       4       6       8       10  
3       6       9       12      15  
4       8       12      16      20  
5       10      15      20      25  
...

print("Hello,\nvilág!")

Helló,
világ!

print("London Anglia fővárosa.")
print("\"London\" egy hat betűs szó.")

London Anglia fővárosa.
"London" egy hat betűs szó.

print('London Anglia fővárosa.')
print('"London" egy hat betűs szó.')

London Anglia fővárosa.
"London" egy hat betűs szó.

Strukturált programok (structured programs)

• Amelyek szekvenciából, elágazásból és ciklusból épülnek fel
• Matematikailag bizonyított: minden számítógéppel megoldható feladat megoldható így!

Programvezérlés (control flow)

Az utasítások végrehajtásának sorrendje.

• Alapvetően egymás után, de ez megváltoztatható vezérlési szerkezetekkel (control structure).
• Speciális programbeli utasítások tartoznak hozzájuk: ezek a vezérlésátadó utasítások (control flow statement).

A vezérlési szerkezetek lényege az, hogy valamilyen döntés (egy feltétel teljesülése) alapján máshol folyatódik általuk a program végrehajtása – nem a sorban következő utasításnál. A Python egyébként nem is enged mást, csak ezeket a vezérlési szerkezeteket. Nem ugrálhatunk ide-oda a programunkban, nem írhatunk ún. spagetti kódot.

A spagetti kóddal az a baj, hogy az ugrásoknál sose tudni, mire valók, mi a céljuk. Elágazást szeretnénk, elvégezni egy műveletet vagy átugrani, kihagyni? Vagy azért ugrunk valahova, mert meg szeretnénk ismételni valamit? Folyton keresgélni kell a kódban, hogy előre vagy hátrafelé ugrunk, beleugrunk egy műveletsor belsejébe, kiugrunk belőle, megszakítva azt.

A vezérlési szerkezeteknek az is az értelme, hogy jelezni tudjuk, miért ugrunk, mire használjuk az ugrást. Amikor visszaugrunk egy pontra a programban, általában azért tesszük, hogy megismételjünk egy műveletet, műveletsort. Ha előrefelé, azt pedig azért, hogy kihagyjunk egy műveletet, hogy feltételhez kössük annak végrehajtását. Különböztessük meg ezeket, rendeljünk ezekhez különálló vezérlésátadó utasításokat! Ha így teszünk, sokkal érthetőbb lesz a programunk.

Érdemes ezen nyelvi elemek neveit magyarul és angolul is ismerni; a szakirodalomban és a gép hibaüzeneteiben rengeteget találkozunk velük.

A számokat és a sztringeket összefoglaló néven literálisoknak nevezzük (literal). Ezek azok a részek a forráskódban, amiket szó szerint kell érteni. Egy változónál ez nem igaz, mert a változóval igazából a benne tárolt értéket hivatkozzuk meg valójában.

szám ::= nemnulla számjegy*
számjegy ::= "0" | nemnulla
nemnulla ::= "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"