Informatika2-2012/Eloadas08

A MathWikiből
A lap korábbi változatát látod, amilyen Stma (vitalap | szerkesztései) 2012. április 5., 17:24-kor történt szerkesztése után volt.

Tartalomjegyzék

Python-ról általában

A Python egy olyan általános körben használható magas szintű programozási nyelv, aminek az egyik alap elve az olvasható kód írása egy nagyon tiszta szintaxis használatával. 1991-ben alkotta meg Guido Van Rossum.

További jellemzők

  • objektum orientált (imperatív, procedurális), funkcionális
  • sok beépített modul a fejlesztés megkönnyítésére
  • dinamikus típus kezelés
  • automatikus memóriakezelés
  • többféle megvalósítás (CPython, Jython, IronPython, PyPy, Python for S60)
  • open-source a főbb platformokra

Python kód futtatása

A kód futtatható interpreter konzolon belül és külső fájlban tárolva. A tavalyi előadást mint ismétlés ajánlom átnézni. (Tananyag része!)

Python szintaktika és az értelmezése

  • változók definiálása és egyben deklarálása az = operátorral típus definiálása nélkül
  • minden változó egy objektumként jelenik meg a háttérben aminek a típusát a type(obj) függvénnyel kérhetjük el.
  • azonos kódblokkokat azonos behúzással jelöljük
  • kódblokk kezdetét a : jelzi
  • megjegyzést a # karakterrel tudsz beírni, ami azt jelenti, hogy a sorban utána lévő karaktereket már nem veszi figyelembe a fordító (sok helyen láthatsz olyat, hogy hivatkozás nélküli string-kel csinálják)
  • lista másolása a MyLista[:] kifelyezéssel tehetjük meg. Fontos mivel több referencia használatával a lista módosításával esetleg olyan eredményt kaphatunk amire nem számítunk.
  • egyszerre több elem inicializálása a=b=c=1
  • a sorozat elemei kiszedhetőek a, b = [4, 5]. Fontos hogy az összes elemre kell változót írnunk!
  • az előbbi struktúrát átültethetjük több változó több változóval való értékadására
  • használható a 5 <= summa < 10 kifejezés is, ami olyan mintha kiírnánk a summa >= 5 and summa < 10

Code style PEP 8 alapján

  • használj mindig 4 space-t minden egyes szinthez
  • a nagyobb kódrészeket tagold üres sorokkal (függvény, osztály, nagyobb kód blokk)
  • használj space-t a vesző után és az operátorok mellett
  • használj docstring-et és ahol lehet a megjegyzés a saját sorára vonatkozzon
  • ahol lehet használj ASCII karakterkódolást
  • 80 karakternél ne legyen hosszabb egy sor
  • CamelCase elnevezési konvenciót kövesse az osztályok neve és lower_case_with_underscores a függvények nevei

Docstring

Ahogy már említettük, a hivatkozás nélküli string elemet szokás használni megjegyzések írására és dokumentálásra.

"""This is a class of example.

TODO: needs implementation. """

Első sort nagybetűvel kezdjük és pontal zárjuk. Egy összefoglaló mondat legyen. Majd egy üres sort hagyva részletesen leírhatunk minden funkciót amit az osztály vagy függvény tartalmaz.

Adattípusok

  • None - a semmi programbeli megvalósulása
  • numerikus
    • egész
    • lebegőpontos
    • (complex)
    • long
    • boolean
  • sorozatok - elemeik egész számmal indexelhetőek
    • módosíthatatlanok
      • string
      • tuple
>>> t = ()
>>> t
()
>>> t = tuple()
>>> t
()
>>> t = (1,2,'')
>>> t
(1, 2, '')
>>> t = 3,4,5,''
>>> t
(3, 4, 5, '')
>>> t[2]
5
>>> t.count(5)
1
>>> t.index(5)
2
    • módosíthatóak
      • lista
>>> l = []
>>> l
[]
>>> l = list()
>>> l
[]
>>> l = [1, "p", ['k'], 2.5]
>>> l
[1, 'p', ['k'], 2.5]
>>> l += [1]
>>> l
[1, 'p', ['k'], 2.5, 1]
>>> l.pop()
1
>>> l
[1, 'p', ['k'], 2.5]
>>> l.reverse()
>>> l
[2.5, ['k'], 'p', 1]
>>> l.count(1)
1
>>> l.insert(1,1)
>>> l.count(1)
2
>>> l
[2.5, 1, ['k'], 'p', 1]
>>> l.remove(1)
>>> l
[2.5, ['k'], 'p', 1]
  • halmazok
    • halmaz (set)
  • térképezés
    • szótár (dict)

Fontos tudni, hogy a numerikus és a módosíthatatlan sorozatok úgymond "változtathatatlanok" ami annyit tesz, hogy ha egy elemre több hivatkozásunk van, akkor ha az egyiket megváltoztatom akkor az új értékkel keletkezik egy új elem a memóriában és a hivatkozás már erre fog mutatni. (Ez a felhasználó számára láthatatlan!)

Ezek az alapvetően használt elemek, ezen felül van meg sok egyéb amelyek közül a legfontosabb az osztályok amiket később fogunk venni. Ha többet akartok tudni a python adatmodelljéről akkor itt találtok leírást róla.

változók névadásánál a következő szabályok vonatkoznak:

  • a név betüvel vagy aláhúzással kezdődhet: [_a-zA-Z] - ez egy reguláris kifejezés ami megegyezik a leírt feltétellel
  • a név további karakterei az előbbin felül lehet szám is: [_a-zA-Z0-9]
  • elméletileg bármilyen hosszú lehet a név
  • név nem lehet foglalt szó
  • nagybetü kisbetü érzékeny, tehát a val1 név nem azonos a Val1 névvel

Másképp leírva:

identifier ::= (letter|"_") (letter | digit | "_")*

letter  ::= lowercase | uppercase

lowercase  ::= "a"..."z"

uppercase  ::= "A"..."Z"

digit  ::= "0"..."9"

A foglalt szavak:

and del from not while as elif global or with assert else if pass yield break except import print class exec in raise continue finally is return def for lambda try

Operátorok

Operátorok precedenciája

Az operátorok között, mint a matematikában itt is, van precedenciai sorrend:

Operator Description
lambda Lambda expression
if – else Conditional expression
or Boolean OR
and Boolean AND
not x Boolean NOT
in, not in, is, is not, <, <=, >, >=, <>, !=, == Comparisons, identity test, including membership test
|
Bitwise OR
^ Bitwise XOR
& Bitwise AND
<<, >> Shifts
+, -
Addition and subtraction
*, //, /, % Multiplication, division, remainder
+x, -x, ~x
Positive, negative, bitwise not
** Exponentiation
x[index], x[index:index], x(arguments...), x.attribute Subscription, slicing, call, attribute reference
(expressions...), [expressions...], {key:datum...}, `expressions...` Binding or tuple display, list display, dictionary display, string conversion

A sage, python a kifejezéseket balról jobbra értékeli ki, kivéve az értékadásnál, amikor előbb a jobb oldalt értékeli ki, majd a ball oldalt.

pl.:

logikai kifejezés elemeit ha mar felesleges nem értékeli ki

Vezérlési elemek

A vezérlési elemeket az előző félévben a SAGE-el kapcsolatban már átnéztük, ezeket kell tudni. Info1 kapcsolódó diái

Összefoglalva:

Elágazás

  • if (elif, else)

Ciklusok

  • while (else)
  • for (else)
  • break, continue

Hasznos segítőeszközök

Ciklusok során a következő nyelvi elemeket találhatjuk hasznosnak:

  • range(x,z,y), xrange(x,y,z)
    - ezekkel számlistákat tudunk előállítani. első paraméter a mettől, a második a meddig és a harmadik a lépésköz. Csak a meddig paraméter a kötelező, a kezdet alapból 0 és a lépésköz pedig 1. Nagy listák esetén az xrange optimálisabb kódot eredményez
  • enumerate(x)
    - ennek segítségével az elemekkel megkapjuk a listában betöltött helyüket is
  • d.iteritems()
    - segítségével a szótár egy elemének kulcsával és értékével tér vissza
  • zip(list, ...)
    - segítségével a paraméterként kapott sorozatok elemeit csoportosítja elhelyezkedésük szerint.
  • reversed(list)
    - segítségével a paraméterként kapott felsorolás elemeit megfordító objektummá alakítja
  • sorted(sorozat)
    - segítségével a paraméterként kapott felsorolás elemeit rendezett listában visszaadja
  • len(sorozat)
    - segítségével a sorozat hosszát kaphatjuk meg

függvények definiálása és használata

Amikor függvényeket definiálunk, akkor igazán nem fut le semmilyen létrehozott kod, csak egy ellenőrzés, amivel kizárja az interpreter a szintaktikai hibákat (olyan hiba ami a kod szövegéből ered).

A függvényben megírt kód csak a függvény hívásakor fut le és a változói akkor lesznek kiértékelve.

def fvdef():
  pass # a pass egy olyan parancs ami nem csinal semmit
  return x**2-1

Itt meg nem futott le semmi csak a fuggvény hívásakor.

fvdef()

Maga a függvényben definiált kód csak a meghívásakor fut le.

Meghívni a függvényt a függvény nevével lehet, úgy hogy utána a zárójelben megadjuk a paraméterként szánt értékeket. (Ha nem kell megadni paramétert akkor csak üres zárójelet használunk... "()")

alapértelmezett paraméter érték

Ha csak simán definiálunk egy függvényt amiket paraméterekkel lehet csak használni, akkor azok a paraméterek kötelezöek

def a_d_test(fv, vert):
  return fv * vert
 
a_d_test(5)
 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: a_d_test() takes exactly 2 arguments (1 given)

Ezért lehetséges alapértelmezett értékeket beállítani a definiálás során, ez az érték egyszer értékelődik ki és utána mindig az lesz az alapértelmezett.


def a_d_test(fv, vert = 1):
  return fv * vert
 
a_d_test(5)
5

Fontos hogy azok a paraméterek amiket alapértelmezett értékkel akarunk ellátni a paraméterezésben hátulról kell beilleszteni.

SyntaxError: non-default argument follows default argument

kulcsszavas paraméter érték

Lehetséges a paraméterek neveivel is átadni a kívánt elemeket:

a_d_test(vert=2, fv=2)

Itt is fontos, hogy ha valamit kulcsszóval akarunk átadni, akkor azt a függvény hívás paraméterlistájának végétől kell feltölteni.

tetszőleges paraméter kezelése

Lehetőség van tetszőleges paramétert kezelni a *<nev> paraméter elkérésével

def as_many(*args):
  for i in args:
    print i,
 
as_many('trali', 'fari')
trali fari

tetszőleges nevesített paraméterek

def as_many_as(**args):
  for k,v in args.iteritems():
    print k, "erteke: ", v
 
as_many_as(elso='trali', masodik='fari')
elso erteke:  trali
masodik erteke:  fari

Ahogy láthatjuk itt nevet adhatunk az értéknek és nem csak a pozíciója határozza meg hogy mihez is lehet kötni az elemet. Fontos hogy mivel nem számíthatunk hogy megkapjuk-e azt a paramétert a függvény hívásakor ezért mindig ellenőrizzük annak meglétét.

Változók érvényességi köre

A nevek egy változóra hivatkoznak. Egy blokk olyan programrész, ami egy egységként hajtódik végre. A mi esetünkben egy függvény törzse blokk (de egy parancs is blokként értelmezett).

Egy blokk futtatása úgynevezett "futtatási keretben" történik (administrációs és futtatási okokból).

A scope a láthatóságát jelenti az adot változónak.

  • ha változót deklarálunk egy blokkon belül akkor annak láthatósága arra a blokra korlátozódik
  • ha a blokkon belül újabb blokkot hozunk létre, akkor ott is értelmezett lesz a változó, kivéve ha a belső blokkon belül azt nem definiáljuk felül, azaz nem adunk értéket neki
  • továbbá ha a külső blokkbeli változót szeretnénk használni, majd annak értéket adni a belső blokkban, az hibát fog okozni, mert ugyan bárhol deklarálhatunk változót, de blokkon belül a deklaráció előtt nem lehet használni azt a változót.
def fv():
  return a
 
a=7
fv()

Látható, hogy a külső blokkban deklarált "a" változó látható a függvényen belül is.

a=7
def sz2():
  a=2
  return a
 
print a
print sz2()
print a

Latható, hogy ha a belső blokkon belül deklarálunk már létező névvel új változót, akkor az csak a belső blokkon belül lesz értelmezett.

a=7
def sz3():
  b=a
  a=6
  return b
 
Traceback (click to the left of this block for traceback)
...
UnboundLocalError: local variable 'a' referenced before assignment

Látszik, hogy "a" ugyan létezik, de mivel a belső blokkon belül újra deklaráljuk, igy a deklaráció előtt nem használhatjuk azt.

A hiba egyszerű de nem szép megoldására a python a global kulcsszót adja a kezünkbe.

a=7
def sz3():
  global a
  b=a
  a=6
  return b

Programtervezési irányelveket követve az előző hibát más eszközökkel kell megoldani.

Program struktúra

A python lehetőséget ad bonyolult program szétdarabolására hogy az átláthatóbb legyen a fejlesztők számára A csomagok és a modulok kialakításával érhetjük el a darabolást.

csomag

Kiszervezhető és akár önmagukban is futtatható nagyobb független kódrészletekre használatos. Egy adott területhez tartozó feladatokat látja el. Általában több modul és alcsomagokat tartalmaz.

Pl: numpy - "NumPy is the fundamental package for scientific computing with Python."

Mitől lesz valami csomag? Csomaggá az a könyvtár változhat ami tartalmazza a __init__.py fájlt. Ez a fájl jelzi az fordító számára, hogy egy csomagról van szó. A __init__.py üresen is elég, de vannak extra változók amiket lehet használni a csomag könnyebb használata érdekében (__all__, __path__, ...)

modul

Kisebb egybefüggő programrészek egysége. Maga a python programot tartalmazó file egy modult képez.

A modul neve a file nevével egyezik amiben van a kód. Így pl.: a protak.py programfájlban lévő modulra a protak névvel tudunk hivatkozni. A modul nevét a programon belül a __name__ változóval érjük el. Fontos, hogy ha a modult mint program indítjuk akkor a __name__ értéke __main__ lesz! Ezt fel lehet használni pl.:

tortin.py fájl tartalma:

  def mainp():
    print "This is the main"
 
  def elp():
    print 'This is not the main'
 
  if __name__ == '__main__':
    mainp()
  else:
    elp()

Majd hivjuk meg konzolbol a

python tortin.py

illetve interpreterből...

import tortin

(A modul elnevezést szokás használni még azokra a csomagokra is amiket különálló általános problémákat lehet kezelni pl. numpy és azokra amik kiterjesztési csomagok azaz más nyelvhez (pl.: C) való kapcsolódást valósít meg.)

csomagok és modulok felhasználása (import)

A programrészeket felhasználhatjuk a programon belül akárhol, ha azt jelezzük a fordítónak.

A python-on belül ezt az import vagy a from és az import kulcsszavakkal tehetjük meg a következő módon.

  import sys
  from sys import stdin
  from sys import maxint as mi
  from mymodule import *
  • az import sys paranccsal az összes sys modul alatt elérhető függvényhez és változóhoz hozzáférünk. pl.: sys.maxint vagy sys.ps1
  • az from sys import stdin paranccsal a programon használhatjuk a sys modulban definiált stdin változót a saját nevén, azaz a fájlon belül elérhető a stdin változó.
  • a from sys import maxint as mi nagyon hasonló az előzőhöz csak itt meg megadtuk azt is hogy a mi modulunkban mi a maxint változót a mi néven akarjuk elérni.
  • végül a from mymodule import * sorral azt adtuk meg, hogy mymodule minden eleme (kivéve a "_" karakterrel kezdődőek) elérhetőek legyenek. A * használata csomag import esetén kerülendő, modul esetén is megfelelő figyelemmel!

relatív import útvonalak

Bonyolultabb csomagokban ahol több alcsomag és sok-sok modul található az egymáshoz való hivatkozásokhoz használhatunk relatív útvonalakat.

  from . import torti
  from .. import kerek
  from ..vaz import orr

modul és csomag nevek feloldása

Az fordító először a

  1. beépített modulok között keres, ha ott nem találja, akkor
  2. sys.path - ban lévő útvonalakat próbálja végig ami a következőképpen épül fel:
    1. az indítás könyvtárába
    2. PYTHONPATH

elérhető elemek

Az elérhető elemeket egy adott modulon belül a dir() függvénnyel listázhatjuk ki

Megjegyzések

Személyes eszközök