"Kezdőknek!! Thor Kalapácsának Modellezés"
Részletek a hírekben!
 
   
 
 
Naprakész hírek...                                         240 fórumozó...                                         Számos magyar oktatóanyag...                                         Videóanyagok magyarul is...                                         Letölthető fájlok...                                         Textúrák...                                         Összegyűjtött linkek...
 
  Rólunk
Hírek
Fórum
Kihívás
Kapcsolatok
Galéria
Aktuális, 2015
2014, 2013
2012, 2011
2010, 2009
Leírások
Kezdő leckék
Haladó leckék
Egyéb leírás
Billentyűk
Videóanyagok
Kezdő videók
Haladó videók
Egyéb videók
Tippek, trükkök
Letöltés
BLEND fájlok
Textúrák
Linkajánló
Archivum
Projektek
BlendRace SokoTruck
Flipper MB game
 
 

Blender leírások és oktató anyagok

 

Készítette: Hevér Zsolt, no sp-KUKAC-m

Átformázva STX formátumba, kiegészítve: Dragugyi Tanyiló, dragugyi-KUKAC-freemail.hu - 2002.09.23
 - v.hu.1.52

Közzé tette: stewet (2010)

PYTHON MINI REFERENCIA

Keszült Chris Hoffmann, choffman-KUKAC-vicorp.com " A Python Quick Reference v.1.2 című művének és a Python dokumentáció felhasználásával.

Ezen referencia segítséget szeretne nyújtani a nyelv alapjainak megismerésében. A Python programozását legkönnyebben a Python dokumentáció segítségével tanulhatjuk meg az adott verziónak megfelelően. A Python dokumentációt a Python programcsomaghoz mellékelve találjuk meg, vagy le is tölthetjük a Python honlapról .

.

Tartalomjegyzék

[1] A Python-fordító indítása

    python  [-diuv]  [-c parancs | script | - ]  [argumentumok]
 
-d  Bekapcsolja a hibakereső szintaktikai elemzőjét, kimeneti hibaellenőrzést   végez. (Csak programozásban jártasabbaknak ajánlott, fordítási opcióktól   függ.)  
-i  Ha első értékeként egy script-et adunk meg vagy a -c opciót használjuk,   akkor a script vagy a parancs végrehajtása után interaktív módba megy át. Nem   olvassa a $PYTHONSTARTUP fájlt. Hasznos lehet globális változók   vagy a verem állapotának vizsgálatára, ha a script végrehajtásakor hiba   történt.  
-s Interaktívmódban a kifejezések automatikus nyomtatását letiltja.  
-u A standard kimenet (stdout) és a standard hibakimenet (stderr) üzeneteit   azonnal kiírja, a pufferolás kikapcsolva.  
-v  Üzenetet ad egy modul inicializálásáról, feltüntetve annak helyét (fájlnév   vagy beépített modul) és a hívó modulját.  
-c parancs  
Parancsot adhatunk meg végrehajtásra. (Részletesebben a következő   fejezetben.) Ennek hatására opcionális listát vár, melyeket a parancs   argumentumaiként értelmez.  
-  bármi más, amit opcióként adunk meg a python scripthez vagy parancshoz, de   az interpreter maga azt nem értelmezi opcióként.

script - itt a végrehajtandó python nyelven írt programot jelenti.

argumentumok - értékeket adunk a scriptnek vagy a parancsnak ("sys.argv"-ből olvasható ki az értéke).

Ha sem script, sem parancs nincs megadva, akkor a Python interaktív módba lép. Ekkor a "readline" csomagot használja bemeneti adatok olvasására.

[2] Környezeti változók

 
PYTHONPATH  
A keresési utak alapbeállítása, a modulok elérését teszi lehetővé.   Formátum a shell $PATH változójának értékével megegyezik: egy   vagy több könyvtárnak a neve, szóköz nélkül, kettősponttal elválasztva.  
PYTHONSTARTUP  
Ha ez egy olvasható fájl neve, az ebben a fájlban található Python   parancsok az interaktív mód promptjának megjelenése előtt végrehajtódnak.  
PYTHONDEBUG  
Ha nem üres, akkor jelentése azonos a -d opcióéval.  
PYTHONINSPECT  
Ha nem üres, akkor jelentése azonos az -i opcióéval.  
PYTHONSUPPRESS  
Ha nem üres, akkor jelentése azonos az -s opcióéval.  
PYTHONUNBUFFERED  
Ha nem üres, akkor jelentése azonos az -u opcióéval.  
PYTHONVERBOSE  
Ha nem üres, akkor jelentése azonos a -v opcióéval.

[3] Jelen dokumentumban használt fogalmak

 
flag  
olyan speciális változó, amely csak két értéket vehet fel: igen, nem  
programblokk  
kifejezések sorozata, új sorokkal tagolva. Minden kifejezésnek azonos   bekezdési szinten kell lennie, az összetettebb kifejezések belső   programblokkjainak kivételével  
string  
karakterek sorozatából álló egység  
szekvencia  
egy string, lista vagy tuple  
token  
a progranyelv szempontjából egy értelmezhető és értelmes egység  
tuple  
változó típus. Olyan lista, amelynek bármely eleme maga is lehet további   lista  
< x >  
a szintaktikai leírásban az "x"-ként megjelölt \\\'token\\\'-re utal  
[ xxx ]  
a szintaktikai leírásban az "xxx" választhatóságát jelöli  
x == > y  
jelentése: < x > értéke < y >  
x < = > y  
jelentése: "x értéke megegyezik az "y" értékével (azzal ekvivalens)

[4] Fontos lexikai elemek és szabályok

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

NULL byte (000) nem a string végét jelenti; NULL jelet használhatjuk a sztirgekben, de nem olyan jelentéssel bír, mit a C nyelvben!!

Stringek (és a tuple típusú változó) megváltoztathatatlanok ( immutable): azokat nem lehet módosítani.

long integer (korlátozalan pontossággal megadhatóak): 1234567890L

octal integer: 0177, 0177777777777777777L hex integer: 0xFF, 0xFFFFFFFFFFFFFFFFFFL

float: 3.14e-10

0, 1, 2 stb. hosszúságú tuple típusú változók: () (1,) (1,2) # ha a hossza > 0, akkor a zárójelek megadása nem kötelező

0, 1, 2 stb. hosszúságú listák: \\\'[ ]\\\' [1 ] [1,2]

0, 1, 2 stb. hosszúságú dictionary (szótár) típusú változók: {} {1 : \\\'első\\\'} {1 : első, \\\'következő\\\': \\\'második\\\'}

A nyelv 0 alapú indexelést alkalmaz. Negatív értékű indexek (általában) egy szekvencia végétől visszafelé számított helyet jelölnek.

Szekvencia szelet [ kezdődik-a-megadott-indexnél : de-kisebb-mint-a megadott index ]. Alapértelmezett kezdőérték 0; alapértelmezett végérték a szekvencia-hossza. :

    a = (0,1,2,3,4,5,6,7)     a[3]   ==> 3     a[-1]  ==> 7     a[2:4] ==> (2, 3)     a[1:]  ==> (1, 2, 3, 4, 5, 6, 7)
    a[:3]  ==> (0, 1, 2)     a[:]   ==> (0,1,2,3,4,5,6,7) # a szekvenciáról másolatot készít

[5] Alaptípusok és -műveletek

Összehasonlítás (bármilyen típusok között értelmezett)

Táblázatos formában:

        < kisebb, mint
        <= kisebb vagy egyenlő, mint
        > nagyobb, mint       
>= nagyobb vagy egyenlő, mint
        == egyenlő       
!= nem egyenlő ( "<>" is megengedett) is objektumok azonossága (objektumok azonosak-e, nem az értékeik)
is not tagadott objektumazonosság

X < Y < Z < W jelentése megegyezik a várttal (nem úgy, mint a C nyelvben)

Logikai (boolean) értékek és műveletek

Táblázatos formában:

        hamis (false) értékek   
None, 0 számjegy, üres szekvenciák és értéktáblák
        igaz (true) értékek minden más érték not X
        ha X hamis akkor 1, különben 0
     X or Y   ha X hamis akkor Y, különben X
       X and Y  ha X hamis akkor X, különben Y
  (az \\\'or\\\', \\\'and\\\' csak akkor veszi figyelembe a második argumentumot,
   ha annak kiértékelése szükséges a végeredmény szempontjából)

None

A függvények alaphelyzetben - ha más nincs meghatározva - None-t adnak vissza. A Python interaktív használatakor a bemeneti adatok kiérétkelésekor a None értéket eredményező adatok esetében semmilyen értéket sem ír ki.

Numerikus típusok:

float, integer és long integer

A float típus kétszeres pontosságú C számként került megvalósításra.

Az integer típus C hosszú egész számként került megvalósításra.

A long integer korlátlan méretű (méretét a rendszer erőforrásai határozzák meg).

Minden numerikus típusra vonatkozó műveletek

        abs(x) -> x abszolút értéke
        int(x) -> x értékét integer típusra konvertáljuk
        long(x) -> x értékét long integer típusra konvertáljuk
        float(x) -> x értékét lebegőpontos számmá konvertáljuk
        -x x értékét negáljuk
        +x  x változatlan
        x + y -> x és y összege
        x - y -> x és y különbsége
        x * y -> x és y szorzata
        x / y -> x és y hányadosa
        x % y -> x / y maradéka
        divmod(x, y) -> eredménye (x/y, x%y) tuple típusú változó
        pow(x, y) -> x y-adik hatványa (xy)

Bitműveletek integer és long integer típusú változókon

. :

        ~x -> x invertálása (1-es komplemens)
        x ^ y -> x és y változók értékeire bitenkénti kizáró VAGY
        x & y -> x és y változók értékeire bitenkénti kizáró ÉS
        x | y -> x és y változók értékeire bitenkénti VAGY
        x << n -> x bitjeinek eltolása balra n bittel
        x >> n -> x bitjeinek eltolása jobbra n bittel

Hibaüzenetek (kivétkezelés) numerikus műveletek esetén:

    TypeError -- Nem-numerikus típusú változókra alkalmazott aritmetikai műveletek esetében
    OverflowError --  Numerikus értékkorlát túllépése
    ZeroDivisionError -- akkor kapjuk ezt az üzenetet, ha div vagy modulo operátor második argumentumaként 0-t adunk meg.

Minden szekvencia típusú változóra (lista, tuple, string) alkalmazható operátorok

. :

        len(s)         s hossza
        min(s)         legkisebb értékű elem s-ben
        max(s)         legnagyobb értékű elem s-ben
        x in s         1 ha s egy elme azonos x-szel, különben 0
        x not in s     0 ha s egy elme azonos x-szel, különben 1
        s + t          s és t konkatenációja
        s * n, n * s   s-t n-szer konkatenálja össze
        s[i]           s i-edik eleme, kezdőérték 0
        s[i:j]         s i-től j-ig vett része
        Egy szelet i indextől j indexig, de a j-edik elemet már nem tartalmazza.
        A szelet i alapbeállítás szerinti értéke 0, j alapbeállítás szerinti értéke len(s),
        negatív érték esetén a szekvencia jobb végétől számítódjuk

Módosítható szekvenciákra (listákra) vonatkozó operátorok

. :

        s[i] = x -> s i-edik elemét x-re cseréljük
        s[i:j] = t -> s i-től j-ig tartó szeletét t-re cseréljük
        del s[i:j] -> szeletet törlünk (azonos a s[i:j] = [] művelettel)
        s.append(x) -> x-et az s lista végéhez fűzzük
        s.count(x) -> azon indexek számát adja vissza, melyekre s[i] == x, (vagyis x előfordulási számát)
        s.index(x) -> x legkisebb indexű előfordulásának helyét adja vissza, (vagyis a legkisebb i-t, melyre s[i] == x)
        s.insert(i, x) -> i-edik elem x lesz, a korábbi i-edik elem az i+. elem stb.
        s.remove(x) -> azonos a del s[s.index(x)] művelettel
        s.reverse() -> s listát megfordítja (helyben)
        s.sort() -> rendezi a listát (helyben), Opcionális paraméter: két argumentumos függvény -1, 0 vagy 1
                       értékkel tér vissza, attól függően, hogy az arg1>,==,
IndexError kivéthibát kapunk, ha a szekvencia indextartománya érvénytelen értékhatárt jelöl.

Operátorok értéktáblás változókra (dictionary típus)

. :

        len(a) -- a-ban található elemek száma
        a[k] -- a k kulcsú eleme
        a[k] = x a[k]  értéke x lesz
        del a[k] -- a[k] -t a-ból eltávolítjuk, kivesszük
        a.items() -- a elempárjainak (kulcs, érték) listáját adja vissza
        a.keys() --  a kulcsainak listáját adja vissza értékül
        a.values() -- a értékeinek listáját adja vissza értékül
        a.has_key(k) -- 1 ha a-ban van k nevű kulcs, különben 0

TypeError kivéthibát kapunk, ha a kulcs helytelen értékű.

KEYError kivéthibát kapunk, ha nem létező kulcsot szeretnénk olvasni.

Stringformázó operátorok (%)

C nyelvben is használatos sprintf kódok használata

Támogatott operátorok: %, c, s, i, d, u, o, x, X, e, E, f, g, G.

Szélesség és pontosság lehet egy * annak meghatározására, hogy egy egész számmal megadott érték az aktuális szélességet vagy pontosságot jelöli.

A -, +, szóköz, # és 0 jelzőkarakterek értelmezettek.

%s bármilyen típusú argumentumot stringgé fog konvertálni (str() függvényt használva):

           a = %s -ban van %04d szoros idézőjel. % (Python, 3)
           a ==> Python-ban van 0003 szoros idézőjel

A jobb oldalon lehet értéktáblás változó:

           a = %(lang)s -ban van %(c)04d szoros idézőjel. % {c:3, lang:Python}

(vars() függvény nagyon alkalmas arra, hogy azt jobb oldalon használjuk.)

Fájlobjektum

Az open() beépített függvénnyel hozzuk létre, de más modul függvényével is létrehozható.

Fájl objektum operátorai:

        f.close(x) -- lezárja az f fájlt.
        f.fileno(x) -- visszaadja a fájlleíró azonosítót (fd) az f fájlra.
        f.flush(x) -- kiüríti a fájl belső pufferét.
        f.isatty() -- 1, ha fájlt tty típusú eszközhöz kapcsolták, máskülönben 0.
        f.open(x) --  ha nem létezik, akkor létrehozza, egyébként megnyitja a fájlt.
        f.read([méret]) -- legalább a méretnek megfelelő mennyiségű adatot olvas a fájlból
és azt string objektumként adja vissza. Ha nem adunk méretet, akkor a fájl végéig olvas.
        f.readline() -- egy teljes sort olvas a fájlból.
        f.readlines() --  a fájl végéig olvas a readline() operátorral és a beolvasott sorokból álló listát adja vissza értékül.
f.seek(offset, whence=0) -- beállítja a keresési pozíciót a fájlban, mint a stdio fseek() függvénye
                        whence == 0 , akkor abszolút indexelést használ,
                         whence == 1 , akkor az offset értékkel megadott értékkel
                                      a jelenlegi pozícióhoz képest,
                        whence == 2 , akkor az offset értékkel megadott értékkel
                                      a a fájl végéhez viszonyítva.
        f.tell()        visszaadja az olvasófej jelenlegi pozícióját a fájlban.
        f.write(str)    az str stringet a fájlba írja.
        f.writelines(list)  a list stringlistát a fájlba írja

Kivétkezelés fájlműveletek esetén

 
EOFError  
Elérte a fájl végét olvasás közben (sokszor kaphatjuk ezt az üzenetet, ha   például fájlként tty-t nyitottunk meg).  
IOError  
Más I/O-val kapcsolatos I/O műveleti hiba.

[6] Magasabbszintű objektumok

Erről a dokumentációban, melyet mindig a programhoz mellékelnek, található részletesebb információ. A dokumentáció a http://www.python.org/ honlapjáról külön is letölthető.

[7] Kifejezések

Általános::

   pass --  Nem csinál semmit, nulla kifejezés
   = --  Értékadó operátor. Tuple, lista típusú változókat ki tud csomagolni
                első, második = a[0:2 ]; [e, m ] = range(2)
   del -- Megszünteti egy név és objektum, attribútumok és objektumok stb. kapcsolatát
   print [ [, ]*[,] --  a sys.stdout-ra ír. Az argumentumok közé szóközöket rak.
Soremelést végez, hacsak nem vessző található a kifejezés végén.
A print utasítást nem kell interaktív üzemmódban használni, egy kifejezés értéke annak beírása után automatikusan
kiíródik, hacsak értéke nem None.
    exec [in [,]] -- Végrehajta -et a megadott érvényességi körben.
Alapbeállítása az aktuális érvényességi kör. (x) lehet string, fájl objektum vagy függvény objektum.

Vezérlési szerkezetek

Az alábbiak:

    if : 
     [elif : ]*
     [else: utasításblokk]
                     -- szokásos if/else_if/else kifejezés
    while :
     [else: ]
                      -- szokásos while kifejezés. Az else utasításblokk a ciklusból való kilépés
                        után hajtódik végre, hacsak a ciklusból nem break utasítással léptünk ki
    for in :
     [else: ]
                      -- a ciklus a   szekvencia szerint iterál,  minden
                        elemhez a változót rendeli. Az else utasításblokk a ciklusból való
                        kilépés után hajtódik végre, hacsak a ciklusból nem break utasítással
                        léptünk ki
    break            -- azonnal kilép a for vagy a while ciklusból
    continue         -- azonnal a for vagy a while ciklus következő iterációs lépésére áll    return []
                     -- visszatér a függvényhívásból (vagy metódushívásból) és az
                        adja vissza. Ha az eredményérték nem kerül megadásra, akkor a None értéket adja vissza

Kivételkezelés

Az alábbiak:

    try: <1. utasításblokk>
     [except [ [, <érték>]: <2. utasításblokk>]+
     [else: <3. utasításblokk>]
                      -- az < 1. utasításblokk > végrehajtásra kerül. Ha kivéthiba történik, akkor megnézi,
                        hogy az  except részben megadott < kivét > -e. Ha megfelel, vagy nem adtunk
                        meg kivéttípust, akkor végrehajtja a 2. utasításblokkot. Ha nem történt kivéthiba,
                        az 1. utasításblokk lefutásakor, akkor az else után álló 3. utasítás-
                        blokkot végrehajtja. Ha a hiba valamilyen értékkel jelentkezik, akkor azt a
                         <érték> változóba rakja. lehet kivéttípusok megadása tuple típusú
                        változóban, pl. except (KEYError, NameError), értéke: print értéke
    try: <1. utasításblokk>
     finally: <2. utasításblokk>
                      -- az <1. utasításblokk> végrehajtódik. Ha nem volt kivéthiba, akkor végrehajtja a
                        <2. utasításblokkot> (még akkor is, ha az <1. utasításblokkból> return,
                        break vagy continue kifejezéssel léptünk ki.) Ha kivéthiba történt, akkor
                        végrehajtja a <2. utasításblokkot> és azonnal kivétjelzést ad
    raise [,<értéke>]
                      -- egy típusú kivéthibát generál az opcionálisan megadott <érték>
                        paraméterrel
    A kivéthiba egyszerű string objektum. Egyszerűen új string előállításával hozhatjuk létre.::
                     az_én_hibám = Valamit rosszul végeztél el.
                     try:
                           if rossz:
                                 raise az_én_hibám, rossz
                      except az_én_hibám, értéke:
                           print Jaj!, értéke

A név érvényességének kifejezései

Az alábbiak:

    import  [, ]*
                     -- modulokat importál. A modul elemeire a modul nevének megadásával kell
                        hivatkozni: "import sys; print sys.argv"
    from import <1.azonosító> [, <2.azonosító>]*
                     -- nevű modulból azonosítókat importál. A megnevezés nem
                         minősített:  "from sys import argv; print argv"
    from   import *
                     -- nevű modulból minden nevet importál kivéve azokat,
                        melyek aláhúzásjellel "_" kezdődnek: "from sys import *; print argv"
    global <1.azonosító> [, <2.azonosító>]*
                     -- azonosítók a globális érvényességi körből valók (szokásos jelentése a modulból),
                        nem a helyi érvényességi körből (szokásosan jelentése csak függvényekben van).
                     -- Pl. egy függvényben nincs "global" érvényességi körű kifejezés, tegyük fel,
                        hogy az "a" egy olyan név értékadáskor, melyet még eddig nem használtak fel
                        a függvényben vagy a modulban.
                        Ha az "a" -ból próbálunk olvasni -> NameError.
                        Ha az "a" -ba próbálunk írni -> létrehozza az "a"-t a függvény helyi változójaként
                        Ha "a"-t nem definiáltuk a függvényben, de a modulban definiált, akkor
                        ha az "a"-ból próbálunk olvasni, akkor az az értékét a modulból kapja,
                        ha az "a" -ba próbálunk írni -> létrehozza az "a"-t a függvény helyi változójaként.
                        De ne feledjük, hogy az "a[0]=3" keresni fogja az "a", és a globális
                       "a"-t fogja használni, ha nincs helyi "a".

Függvények definiálása

Az alábbiak:

     def  ([]) : 
                     --  létrehoz egy függvényobjektumot és hozzárendeli a < függvényazonosító> -t
     ==> [[, ]*] [ = <érték>
               [,< azonosító > = < érték >] * ] [ * < azonosító >]
     Például:
              def test (p1, p2 = 1+, *maradék):
                      -- Paraméterek "=" jellel alapértelmezett értéket jelölnek (<érték> a
                         függvény definiálásakor kerül kiértékelésre). Ha a lista
                         "*"-val végződik, akkor az értékét tuple típusú
                         változóként tölti fel minden további átadott paramétert felhasználva
                         (változó argumentumlista is megengedett).

Osztály (Class) definiálása

Az alábbiak:

    class  [(<1. ősosztály> [,<2. ősosztály>]*)] : 
                      -- Létrehoz egy class objektumot és hozzárendeli az .
                         Az tartalmazhatja a class metódusok helyi függvénydefinícióit
                         és az osztály attribútumainak értékadásait tartalmazhatja.
    Például:
             class osztályom (class1, class_list[3]): ...
                         Létrehoz egy class objektumot, mely a mind a "class1" osztályból, mind a
                         kiértékelt "class_list[3]" osztályból. Az új class objektum neve az osztályom
                         lesz.
            A class metódusainak első argumentuma mindig a példányobjektum, ezt hagyományosan "self"-nek
            nevezzük. (Futásidő alatt a különböző példányok ez alapján azonosítják be magukat.) Az
             "__init__()" eljárást mindig meghívjuk, amikor létrehozzuk egy példányát. Példányát a class
            objektum meghívásával hozhatjuk létre az esetleges argumentumok megadásával.
            A jelenlegi implementációban beépített class nem lehet ős, azaz abból nem származtathatunk.
            De azokat be lehet "csomagolni", lásd __getattr__() az alábbiakban.
    Például:
             class os:
                def __init__(self, nev="os"): self.nev = nev
                def print_nev(self): print "En", self.nev,"vagyok."
             class osbol_szarmaztatott(os):
                def __init__(self, nev): self.nev = nev
               def print_nev(self): print "Te", self.nev,"vagy."
               def os_meghivasa(self): os.print_nev(self)
              nev_nelkul=os()
              nev_nelkul.print_nev()
              nevvel=os("leszarmazott")
              nevvel.print_nev()
              orokolt=osbol_szarmaztatott("masodik leszarmazott")
              orokolt.print_nev()
              orokolt.os_meghivasa()
     Eredménye:
             En os vagyok.
             En leszarmazott vagyok.
             Te masodik leszarmazott vagy.
             En masodik leszarmazott vagyok.
             A szülő ős (itt ékezetek nélkül "os") osztály metódusát közvetlenül meghívjuk és átadjuk
             a "self" paraméter megadásával (lásd a "class osbol_szarmaztatott(os)" és
             "orokolt.os_meghivasa()" programrészletet).
             Sok más speciális metódus is rendelkezésre áll aritmetikai operátorok, szekvenciák,
             értéktáblák indexelésének stb. megvalósítására.

Egyéb

Az alábbiak:

    lambda []: 
                      -- Névtelen függvényt hoz létre. A -nek kifejezésnek kell lennie,
                         nem utasításnak (például nem "if xx:...", "print xxx", stb.) és ezért nem
                         tartalmazhat új sort.
                         Többnyire a filter(), map(), reduce() függvényeknél használjuk.

[8] Beépített eljárások

Az alábbiak:

   abs(x)
             Egy szám abszolút értékét adja vissza.
   apply(f, args)
     Az függvényt/metódust argumentumokkal hívja meg.
   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.
   cmp(x,y)
           Negatív, zéró, positív értéket add vissza, ha x <, ==, > y -hoz viszonyítva.
    coerce(x,y)
        Tuple típusú változót ad vissza eredményül a két argumentumot egy közös típusra  konvertálva.
   compile(string, fájlnév, fajta)
                       értékét kódobjektummá konvertálja ( code object).
                       -et hibafeljegyzésre használjuk, bármilyen string lehet.
                      vagy eval ha a egy sima folyamat, különben exec- nek kell
                      lennie.
   dir([object])      Ha nincs argumentuma, akkor a jelenlegi érvényességi kör szimbólumtáblájában
                      található nevek listáját adja vissza értékül.
                      Egy modul, osztály (class) vagy osztálypéldány (class instance) objektum
                      értékkel történő meghívásakor annak az attribútum szótárában található nevek
                      listáját adja vissza értékül.
   divmod(a,b)
        (a/b, a%b) tuple típusú változót szolgáltat eredményül.