A __builtin__ modult rendszerint nem kell külön importálni, automatikusan elérhető mindenhonnan.
Ha már írtál viszonylag hoszabb Python programot, akkor tudod, hogy az import utasítással lehet külső modulokat importálni (vagy ennek a from-import formájával). Amit lehet hogy nem tudsz, hogy az import valójában az __import__ beépített függvényt hívja meg az importálás végrehajtásához.
Ezt a függvényt közvetlenül is meghívhatod. Ez akkor jön jól, ha például egy karakterláncban van meg az importálandó modul neve, mint például a következő példában, ahol minden modult importálunk, aminek a neve “-modul”-ra végződik.
A következő megoldások modul objektummal térnek vissza, és NEM az aktuális névtérbe importálnak. Itt van egy példa, hogy lehet közvetlenül az aktuális névtérbe importálni! JAVÍTANDÓ, MÉG NEM LÉTEZIK A CÍM: http://pythonlib.pergamen.hu/examples/nyelvtan.php#nyelvtan_modul_importalas_karakterlanccal_aktualis_nevterbe.py
Vegyük észre, hogy az importált modulok nevében kötőjel (-) található. Ez egy egyedi lehetőség, mivel a hagyományos import utasításnak kötőjelet tartalmazó modulnevet nem adhatunk át.
# File: __builtin___karakterlanccal_megadott_modulok_importalasa.py import glob, os modulok = [] for modul_file in glob.glob("*-modul.py"): try: modul_nev, kiterjesztes = os.path.splitext(os.path.basename(modul_file)) modul = __import__(modul_nev) modulok.append(modul) except ImportError: pass # a nem importalhato modulok figyelmen kivul hagyasa # say hello to all modules for modul in modulok: print modul modul.hello() print "*"*20
# File: __builtin___karakterlanccal_megadott_modulok_importalasa.out <module 'teszt1-modul' ... > szia! ******************** <module 'teszt2-modul' ... > szia! ********************
A két importált modulban egyetlen hello() függvény volt, print”szia!” utasítással.
Ez a példa bemutatja, hogy hogyan érhetünk el egy függvény objektumot, ha karakterláncként adjuk meg a modul és az elérendő függvény nevét.
# File: __builtin___egy_fuggveny_importalasa_karakterlancbol.py def getfunctionbyname(module_name, function_name): module = __import__(module_name) # a modult itt importaljuk return getattr(module, function_name) # a fuggvenyobjektum visszaadasa print repr(getfunctionbyname("dumbdbm", "open"))
# File: __builtin___egy_fuggveny_importalasa_karakterlancbol.out <function open at 0x00EC0BB0>
A reload a modul objektumhoz rendelt modulnevet használja, nem pedig egy változónevet. Ez azt jelenti, hogy ha nem egy átnevezett modulról van szó, akkor a reload meg fogja találni az eredeti modult.
Egy modul importálásakor a modulban lévő utasítások egyszer végrehajtódnak, a függvényobjektumok létrejönnek. Fontos, hogy ilyenkor a modul újrafordítódik, és az új modul a régi modul helyébe kerül a modulok nyilvántartásában. Jó tudni, hogy ha osztálypéldányokat definiáltál a régi modulban lévő osztályok alapján, és újratöltöd a modult, a példányok a régi definíciót fogják használni. Ha a from-import importálási formát használtad, az így importált függvények a RÉGI moduldefiníciót fogják használni!
# File: __builtin___reload.py import time print reload(time)
# File: __builtin___reload.out <module 'time' (built-in)>
Ne feledjük, egy szám vagy egy szöveg is objektum – ha a dir(objektum) utasítást kiadjuk, az objektum attribútumait listázza ki, vagyis az objektum metódusait, attribútumait (hozzá tartozó függvényeket és belső változókat)!
# File: __builtin___dir02.py >>> szam=7 >>> def hello(): print "hello" >>> dir() # kiír minden objektumot, ami az aktuális névtérben található. # mivel a függvény is az, és a változók is, azokat is kijelzi ['__builtin__', '__doc__', '__name__', 'hello', 'szam']
A szam és a szoveg objektum attribútumai, és példa az attribútumok felhasználására:
# File: __builtin___dir.py #!/usr/bin/python szam = 1 szoveg = "alma" print dir(szam) print "\n"*3 # hely a kiirasok kozott print dir(szoveg)
# File: __builtin___dir.out ['__abs__', '__add__', '__and__', '__class__', '__cmp__', '__coerce__' , '__delattr__', '__div__', '__divmod__', '__doc__', '__float__', '__f loordiv__', '__getattribute__', '__getnewargs__', '__hash__', '__hex__ ', '__init__', '__int__', '__invert__', '__long__', '__lshift__', '__m od__', '__mul__', '__neg__', '__new__', '__nonzero__', '__oct__', '__o r__', '__pos__', '__pow__', '__radd__', '__rand__'... ['__add__', '__class__', '__contains__', '__delattr__'... ...'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', ' isupper', 'join', 'ljust', 'lower', 'lstrip', 'replace', 'rfind', 'rin dex', 'rjust', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith' , 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill'] >>> szam = -1 >>> szam.__abs__() 1 >>> szoveg="alma" >>> szoveg.__add__(" Vadalma") 'alma Vadalma' # az eredeti szoveg nem valtozik meg, # a visszateresi ertek módosul: ehhez adodott hozza a Vadalma
A vars() függvény – ha paraméter nélkül hívod meg, egy szótárral tér vissza, ami az összes – helyi névtérben látható objektumot tartalmazza. Jó tudni, hogy működik a % karakterlánc formázó operátor: ha a % jobboldali argumentuma /most a vars()/ egy szótár, vagy más leképezhető típusú objektum, akkor a formázó kifejezésnek tartalmaznia KELL a kulcsot – a kulcshoz tartozó érték kerül beillesztésre
# File: __builtin___vars.py #!/usr/bin/python konyvcim = "A C programozasi nyelv" szerzo = "Brian W. Kernighan es Dennis M. Ritchie" oldalszam = 292 print "Most olvasom '%(konyvcim)s' cimu konyvet, amit %(szerzo)s irt - osszesen %(oldalszam)s oldal." % vars()
# File: __builtin___vars.out Most olvasom 'A C programozasi nyelv' cimu konyvet, amit Brian W. Kern ighan es Dennis M. Ritchie irt - osszesen 292 oldal.
Az effbot.org-on lévő eredeti a type() használatát bővebben kifejti, én ennél többnek nem láttam értelmét.
# File: __builtin___type.py #!/usr/bin/python szoveg = "alma" if type(szoveg) == type(""): print "ez karakterlánc!" # itt a szoveg valtozorol elmeletileg nem tudjuk hogy micsoda, # de ha a típusa egyezik a jobboldali ismert karakterlánccal # (nem számít hogy üres), akkor a baloldali is karakterlánc print isinstance(szoveg, basestring) # True-lesz # basestring: az str és a unicode szülõosztálya # - ha a változó a basestring egy példánya, akkor szöveg.
Az eval() függvény egy út (a több közül) Python kód végrehajtására a programon belül.
Egy egyszerű példa:
# File: __builtin___eval01.py #!/usr/bin/python print eval("__import__('os').getcwd()", {})
# File: __builtin___eval01.out /var/www/python_lib/examples
Az eval() – ha Python utasításokat adunk neki – végrehajtja azokat. Az utasítás lehet egyszerű szám, számtani művelet, vagy akár egy beépített függvény is.
# File: __builtin___eval02.py #!/usr/bin/python def kiir(utasitas): eredmeny = eval(utasitas) print utasitas, "=>", eredmeny, type(eredmeny) kiir("1") kiir("1.0") kiir("'szoveg'") kiir("1.0 + 2.0") kiir("'*' * 10") kiir("len('alma')")
# File: __builtin___eval02.out 1 => 1 <type 'int'> 1.0 => 1.0 <type 'float'> 'szoveg' => szoveg <type 'str'> 1.0 + 2.0 => 3.0 <type 'float'> '*' * 10 => ********** <type 'str'> len('alma') => 4 <type 'int'>
Az eval() függvény csak egyszerűbb kifejezésekkel működik. Nagyobb kódblokkok kezeléséhez a compile() és exec() függvényeket használd. Szintaktikai ellenőrzés a compile()-vel:
# File: __builtin___compile01.py #!/usr/bin/python NAME = "script.py" BODY = """ prnt 'kesore jar az ido' """ try: compile(BODY, NAME, "exec") except SyntaxError, v: print "syntax error:", v, "in", NAME
# File: __builtin___compile01.out syntax error: invalid syntax (script.py, line 2) in script.py
Ha a fordítás sikeres, a compile() egy kód-objektumot ad vissza, mely az exec() utasítással végrehajtható:
# File: __builtin___compile02.py #!/usr/bin/python BODY = """ print 'egy hangya, bevezetésképp...' """ code = compile(BODY, "<script>", "exec") print code exec code
# File: __builtin___compile02.out <code object ? at 0x402111e0, file "<script>", line 2> egy hangya, bevezetésképp...
Létezik egy execfile() nevű függvény, amellyel betölthetünk egy kódot fájlból, lefordíthatjuk, és végre is hajthatjuk. Egy példa, és az execfile() szimulációja exec()-el:
# File: __builtin___execfile01.py #!/usr/bin/python execfile("hello.py") # itt keletkezik az elso kimenet def EXECFILE(filename, locals=None, globals=None): exec compile(open(filename).read(), filename, "exec") in locals, globals EXECFILE("hello.py")
# File: __builtin___execfile01.out szia! szia!
You must be logged in to post a comment.