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
- A Python-fordító indítása
- Környezeti változók
- Jelen dokumentumban használt fogalmak
- Fontos lexikai elemek és szabályok
- Alaptípusok és -műveletek
- Magasabbszintű objektumok
- Kifejezések
- Beépített eljárások
- Beépített kivétkezelés
- Speciális eljárások saját osztályokhoz
- Fontosabb modulok
- Az alaprendszer többi modulja
- Néhány tanács a munkakörnyezet felderítéséhez
- A python hibakereső
[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
$PYTHONSTARTUPfá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
$PATHvá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
-dopcióéval. PYTHONINSPECT- Ha nem üres, akkor jelentése azonos az
-iopcióéval. PYTHONSUPPRESS- Ha nem üres, akkor jelentése azonos az
-sopcióéval. PYTHONUNBUFFERED- Ha nem üres, akkor jelentése azonos az
-uopcióéval. PYTHONVERBOSE- Ha nem üres, akkor jelentése azonos a
-vopcióé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
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
- Érvénytelen elemek token-ben (csak stringben érvényesek): -KUKAC- $ ?
- Kifejezésnek egysorosnak kell lennie. Egy kifejezést több sorba a "\\" jel segítségével tördelhetjük (utána rögtön soremelés-karakter kell, hogy szerepeljen ) ugyanúgy, mint a C nyelvben. Kivétel: kifejezést mindig törhetünk, ha az ( ),
[ ], vagy{ }jelpárok, vagy háromszoros idézőjelpárok között van. - Több kifejezés is szerepelhet egy sorban, ha azokat pontosvesszővel (";") választjuk el.
- A megjegyzések a "#" jellel kezdődnek és a sor végéig tartanak.
- Azonosítók: (betű|"_") (betű|számjegy|"_") * Python azonosítók, kulcsszavak, attribútumok stb. Kiértékelésekor a Python különbséget tesz kis- és nagybetű között.
- Stringek:
"egy string" \\\'egy másik string\\\'
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ő.
- Modulok (Module Objects)
- Osztályok (Class Objects)
- Típusok (Type Objects)
- Hívható típusok (Callable types)
- Felhasználó által definiált (Python-ban írt)
- Felhasználó által definiált függvény objektum
- Felhasználó által definiált metódus objektum
- Beépített (C-ben írt)
- Beépített függvény objektum
- Beépített metódus objektum
- Belső típusok (Internal Types)
- Kódok (Code Objects)
- Keretek (Frame Objects)
- Nyomkövetők (Traceback Objects)
[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
forin :
[else:]
-- a ciklus aszekvencia szerint iterál, minden
elemhez avá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>]
-- egytí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"
fromimport <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"
fromimport *
--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+
-- 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.
Aztartalmazhatja 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)
Azfü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.
