Python (programozási nyelv)

Ez az oldal még szerkesztés alatt van (formailag)! Vezérlési szerkezetek, utasítások-ig van megformázva.

Python

Tartalom:

1. Változók, kifejezések
2. Végrehajtási mechanizmus
3. Vezérlési szerkezetek, utasítások
4. Eljárások, függvények
5. Típusok
6. Kivételkezelés
7. Objektum-orientáltság támogatása (osztályok, öröklődés)
8. Szabványos könyvtárak

A PYTHON:

A Python egy hatékony és könnyen tanulható programozási nyelv. Magasszintű adatstruktúrái, az objektum-orientáltság egyszerű megközelítése, elegáns szintaxisa, dinamikus típusossága és interpreteres mivolta ideális script-nyelvvé teszi. Ezek a tulajdonságok teszik alkalmassá gyors fejlesztői munkákra, nagyobb projektek összefogására. A Python a Stichting Matematikai Centrumban, Amsterdamban (Hollandia) készült. Nevét a Monty Python csoportról kapta. Az interpreter és a szabványos könyvtárak forrás- és (a legtöbb platformra) bináris kódjai szabadon elérhetőek. C,C++ vagy más C-ből hívható nyelven megírt függvényekkel és adattípusokkal az interpreter könnyen bővíthető. Rövid programok írása gyors, egyszerű és jól áttekinthető. Jelenlegi legfrissebb verziója: 2.3

Változók, kifejezések

Egy Python program azonosító aláhúzással vagy betűvel kezdődhet, és utána tetszőleges hosszan állhat aláhúzás, betű vagy szám. A változókat nem kell deklarálni, mivel azok az első használatukkor automatikusan létrejönnek. Ha jobb oldalon hivatkozunk először egy változóra (ami még nem létezik), akkor NameError kivétel váltódik ki. A kis- és nagybetűket megkülönbözteti egymástól. A következő felsorolásban találhatóak a foglalt kulcsszavak, melyek nem lehetnek azonosítók:

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

Vannak azonosítók, amik speciális jelentéssel bírnak, de ezek nem kulcsszavak. Ezeket a következő táblázat tartalmazza. Azonosítók speciális jelentése:

Jelentés

_*	 Nem lett importálva a from module import * által
__*__	 rendszer által definiált név
__*	 osztályok privát nevei

A nyelvben található operátorok:

+
-
*
**
/
%
<<
>>
&
|
^
~
<
>
<=
>=
==
!=
<>

A nem egyenlő jelölésére használhatjuk a <> és a != egyaránt., bár a != jelölés az ajánlott. (Az <> egy régi maradvány, ami a későbbiekben ki fog kerülni a nyelvből.)

Operátorok precedenciája

or --> logikai VAGY
and --> logikai ÉS
not x --> logikai negáció
in, not --> inidentitás tesztek
is, is not --> összehasonlítások
<, <=, >, >=, <>, !=, = --> tartalmazás tesztek
| --> aritmetikai VAGY
^ --> aritmetikai XOR
& --> aritmetikai ÉS
<<, >> --> shift-elések
+, - --> összeadás, kivonás
*, /, % --> szorzás, osztás, maradék
+x, -x --> plusz, mínusz (előjel)
~x --> aritmetikai negáció
x.attribute --> attributum hivatkozás
x[index] --> subscription
x[index:index] --> slicing
f(arguments, ...) --> függvény hívás
(expressions . . .) --> zárójel vagy vektor display
[expressions . . .] --> lista display
{key:datum, . . .} --> könyvtár display
expression --> sztring konverzió

A felsoroláson felülről lefelé haladva, növekszik az operátorok precedenciája. Az azonos dobozban lévők azonos precedenciájúak, balról-jobbra asszociatívan. Kivételek ez alól az összehasonlító operátorok, amiket úgy kell használni, mint a matematikában:

x < y <= z # x < y and y <= z, csak az y-t egyszer értékeli ki.

               # a z-t nem fogja, ha x < y nem teljesül

A nyelv felismert néhány escape szekvenciát, ezek a következők: Escape szekvencia --> Jelentése

\newline --> figyelmen kívül hagyja
\\ --> Backslash(\)
\' --> Single quote (')
\" --> Double quote(")
\a --> ASCII Csengő (BEL)
\b --> ASCII Backspace (BS)
\f --> ASCII Lapdobás (FF)
\n --> ASCII Soremelés (LF)
\r --> ASCII Carriage Return (CR)
\t --> ASCII vízszintes Tab (TAB)
\v --> ASCII függőleges Tab (VT)
\ooo --> ASCII karakter ooo oktális értékkel
\xxx... --> ASCII karakter xxx... hexadecimális értékkel

Az értékadás szabályai bonyolultak, részletezésre majd az utasításoknál kerül sor. Néhány példa, ami helyes:

a,b = b,a # megcseréli a-t és b-t c = []; d = [] # c és d két különböző üres lista c = d = [] # c és d ugyanazt az objektumot jelöli

A Pythonban immutable objektumok vannak, amiknek az értékét nem lehet megváltoztani, valószínűleg ezek helyettesítik a konstansokat, amik ebben a nyelvben nincsenek. (pl. az integerek) Az objektumok felszabadításáról egy automatikus szemétgyűjtő algoritmus gondoskodik, bár ennek minősége implementációtól függ.

Végrehajtási mehanizmus

A kódblokk (code block) egy python programszöveg-rész, mely egységként végrehajtható, egymásba ágyazható illetve egy kódblokk meghívhat egy másikat. A kódblokkok a következőek:

 modul
 függvénytörzs
 osztály definíció
 interaktívan begépelt parancs
 parancsfile (melyet standard inputként vagy első argumentumként kapott az interpreter)
 -c opció után megadott parancs
 exec utásításnak vagy eval beépített függvénynek átadott string argumentum
 execfile beépített függvény által beolvasott file
 input beépített függvény által beolvasott és kiértéklet kifejezés

A kódblokk egy végrehajtási keretben (execution frame) hajtódik végre. Egy végrehajtási keret adminisztratív információt tartalmaz (hibakeresés esetére), meghatározza, hogy hol és hogyan folytatódjon a végrehajtás a kódblokk lefutása után és definiálja a lokális és a globális névtartományt (amely befolyásolja a kódblokk végrehajtását).

A megfeleltetést az azonosítók és objektumok között a névtartomány (name space) hivatott létre hozni. Egy konkrét névtartományra több végrehajtási keret is hivatkozhat.

Egy névtartományt érintő műveletek:

 BINDING  név lekötése egy objektumhoz
 REBINDING  megváltoztatni egy lekötést
 UNBINDING  törölni egy lekötést

Funkciójukban ekvivalensek a szótárakkal, ezért gyakran így is valósítják meg őket.

Vezérlési szerkezetek, utasítások

Szekvencia A Python program logikai sorokból áll, amit egy NEWLINE jellel zárunk le. Az utasítások nem nyúlhatnak túl a logikai sorokon, kivéve, ha azt a szintaxis megengedi. Ilyen esetekre példa:

 (explicit line joining) 
   if a < b \
       and c < d \     # itt nem lehet megjegyzés!!!
       and e > f : return 1
 (implicit line joining)

Gömbölyű, szögletes vagy kapcsos zárójeles kifejezéseket írhatunk több fizikai sorba a \ kiírása nélkül: honap = ['Jan','Feb', # itt lehet megjegyzés

        'Mar','Apr']

elágazás

Az elágazás szintaxisa: if <kif> : <suite> (elif < kif > : < suite >)* [else : < suite >] ahol a < suite >:

 pontosvesszőkkel elválaszott utasítások (egy logikai sorban)  új beljebbkezdésben szereplő utasítások (ameddig a beljebbkezdés tart) A Pythonban az utasítások csoportosítását un. beljebbkezdésekkel (indent) oldjuk meg (A beljebbkezdéseknek nincs fix mérete.), mivel itt nincs se BEGIN-END, se { } zárójel pár, ezért tömörebb (rövid áttérés után) és könnyebben olvasható kódot eredményez. Így például a csellengő else probléma egy különös megoldását láthatjuk: if < kif >:

   if < kif2 >:
       < utasítások >

else # ez az else a külsö if-hez tartozik

   < utasítások >

Ez a kis példa kiválóan szemlélteti az előbb említett csoportosítását az utasításoknak. Látható, hogy az első if-hez tartozik az else, s jól szemlélteti, hogy az un. kiljebbkezdéseknek konzisztensnek kell lenni. Példa hibás python kódra rossz beljebb- ill. kiljebbkezdések miatt:

 def perm(l):  # hiba: első sor már beljebb van kezdve

for i in range(len(l)): # hiba: nincs bekezdés

   s = l[:i] + l[i+1:]
       p = perm(l[:i] + l[i+1:])   # hiba: felesleges bekezdés
       for x in p:
           r.append(l[i:i+1] +x)
         return r  # inkonzisztens bekezdés-vég

ciklus (for, while) While: while <kif> : <suite> [else : <suite>] A while a hagyományos elöltesztelős ciklus. Az else-ága akkor fut le, ha a ciklusfeltétel nem teljesül Kiugrási lehetőségek a ciklusból:  break - rögtön a ciklus utáni utasításra kerül a vezérlés  continue - a ciklusfeltétel tesztelésére ugrik a vezérlés Nincs GOTO utasítás! Nincs lehetőség egyszerre több ciklusból való kiugrásra. For: for <target_list> in <kif_list> : <suite> [else : <suite>] A <kif_list> kiértékelésekor egy sorozatot kell kapni. Ennek minden elemét hozzárendeli a <target_list>-hez és végrehajtja a <suite> részt. Ha a sorozat kiürült, akkor lefut az esetleges else ág. Ha a for ciklust a hagyományos értelemben szeretnénk használni, akkor jön jól a range() függvény: >>>range(10) [0,1,2,3,4,5,6,7,8,9]

>>>range(5,10) [5,6,7,8,9] >>>range(0,10,3) [0,3,6,9] >>>range(-1,-10,-3) [-1,-4,-7] A magon belül módosíthatjuk a sorozatot, de ez csúnya hibákhoz vezethez, ugyanis egy számláló mutatja a következő feldolgozandó elemet, és egy beszúrás vagy törlés ebből a listából megkavarhatja a folyamatot. Megoldás: ideiglenes másolat készítése (pl. slice használata) for x in a[:]:

   if x < 0 : a.remove(x)

Egyszerű utasítások Cak felsorolás szinten: assert, értékadás, pass, del, print, return, raise, break, continue, import, global, exec. A legfontosabb talán az értékadás. assignment_stmt: (target_list "=")+ expression_list target_list: target ("," target)* [","] target: identifier | "(" target_list ")" | "[" target_list "]"

              | attributeref | subscription | slicing

Eljárások, függvények Függvény definiálásának szintaxisa: def <fvnév> ( <paramlist> ) : <suite> Az eljárás egy speciális függvény, amely a NONE értéket adja vissza. A függvény törzsét a következő sorban beljebbkezdve kell megadni. A törzs opcionálisan kezdődhet egy string literállal, ami a függvény dokumentáció-stringje (docstring). Végrehajtáskor a törzsben csak a lokális változók láthatóak, azonban, ha, kiadjuk a global utasítást, megnevezhetünk globális változókat, melyek ezután már láthatóak a törzsben. A Pythonban érték szerinti paraméterátadás van. (bár az objektum-referencia szerinti jobb leírás volna, ugyanis ha például egy lista az argumentum, akkor a függvény által végzett változtatásokat látni fogja a hívó. (pl. listaelem beszúrását) A függvények átnevezésére természetesen van lehetőség: pl. van egy fib nevű függvényünk (egy paramétere van) >>>f = fib Ezután már f-ként is hivatkozhatunk erre a függvényre. Az argumentumoknak alapértéket is megadhatunk, amit a definiáláskor létező értékek alapján vesznek fel: i=5 def f(arg = i):print arg i=6 f() 5-öt fog kiírni. Egy paraméterre kétféleképpen hivatkozhatunk, Név és pozíció szerint. Viszont ha egyszer hivatkoztunk név szerint, utána már nem lehet pozíció szerint. Egy argumentumnak kétszer nem adhatunk értéket. Lehetőség van változó argumentumszámú függvény definiálására is. A változó számú argumentumok előtt lehet néhány normális argumentum is. Például:

   def fprintf(file, format, *args):
       file.write(format % args)

Típusok

A python típus-hierarchiája  None - Ennek a típusnak egyetlen igazságértéke van, ami a HAMIS. Az érték hiányának jelölésére használják (pl. egy olyan függvény, ami nem ad vissza értéket). Csak egy objektum van ilyen értékkel, amit a beépített None névvel tudunk elérni.  Ellipsis - Hasonlóan a None-hoz, a típusnak egyetlen értéke van, és csak egy objektumnak van ilyen értéke, ami a beépített Ellipsis névvel érhető el. A None-nal szemben ennek az igazságértéke igaz.  Szám - A numerikus objektumok értékeit nem változtathatjuk meg (immutable)  Egész (integer) - Ennek két fajtája található meg a Pythonban, a plain integer és a long integer.  plain integer - egy gépi szó méretén ábrázolható egész számok (de minimum 32 bit) kettes komplemensben.  long integer - az egész számok tényleges megvalósítása (azért a virtuális memória mérete mégis korlátot szab, hogy mekkora számokkal dolgozhatunk :)  Lebegőpontos számok - float - géptől függő dupla-pontosságú lebegőpontos számok. A határok és a túlcsordulás kezelése a C implementációtól és a gép architektúrájától függ.  Komplex szám - complex - két float számpárral van megvalósítva. (z.real, z.imag)  Sorozat (Sequence) - Véges természetes számokkal indexelt rendezett halmazok reprezentációja. Egy a sorozat i-dik eleme: a[i]. Sorozatokon értelmezve van a szeletelés (slicing): a[i:j] olyan k indexű elemek sorozata, ahol i <= k < j. Kifejezésben használva a szelet (slice) egy azonos típusú sorozat lesz (az indexelése 0-tól kezdve).  Nemmódosítható sorozat (Immutable sequence) - Nevéből adódóan létrehozás után az objektum nem változhat.  String - A stringek elemei a karakterek, habár nincs külön karakter típus. A karakter egy egyelemű string.  Vektor (Tuple) - Egy vektor elemei tetszőleges Python objektumok lehetnek, amiket vesszővel elválasztva egymás után írva adhatunk meg (Két vagy több elem esetén). pl. a = 1,'hello',[1,2,3] Egyelemű vektort (singleton) a kifejezés utáni vessző rakásával definiálhatunk (pl. v = 1,). Üres vektor megadása: v = ().  Módosítható sorozat (Mutable sequence):  Lista - Egy lista elemei, mint a vektor esetében, tetszőleges python objektumok lehetnek. Lista megadása: a kifejezéseket vesszővel elválasztva szögletes zárójelek közé rakjuk. (pl. [1,'hello',[1,2,3]]) Üres lista: []. Az opcionális array modul egy másik példa a módosítható sorozat típusra.  Leképezés (Mapping) - Tetszőleges indexhalmazbeli elemekkel indexelt objektumok véges halmaza. a[k] a "k"-val indexelt elem az "a" leképezésből.  Szótár (Dictionary) - A szótár módosítható (mutable). Kulcsként csak olyan típusértékeket lehet megadni, melyek objektum identitás alapján hasonlítódnak össze és nem érték alapján. Szótárakat kapcsos zárójelek közé rakva kulcs:elem -párok vesszővel elválasztott listájaként adhatunk meg. (pl. {1:['hello'],2:['világ']}) Az opcionális könyvtári modul dbm, gdbm, bsddb további példa leképezés típusra.  Hívható típus (Callable) - Ezek azok a típusok, melyekre alkalmazható a függvényhívás művelet.  felhasználó által definiált függvény (user-defined function) - Ezeket a függvény objektumokat a felhasználó függvény definícióval (def) hozza létre.  felhasználó által definiált metódus (user-defined method) - Ez az objektum tartalmaz egy osztályt, egy példányát az osztálynak (vagy None) és egy felhasználó által definiált függvényt.  beépített függvény (built-in function) - Egy ilyen objektum lényegében nem más, mint egy kis csomagolás egy C függvény körül. Az argumentumok számát és típusát a C függvény határozza meg.  beépített metódus (built-in method) - Ez a beépített függvény tartalmaz egy objektumot, amit extra argumentként átad a C függvénynek.  Osztály (Class)  Osztály példány (Class instance)  Modul (Module)  Fájl (File)  Belső típusok (Internal types) - csak a teljesség kedvéért Kód objektum (Code object) Keret objektum (Frame object) (Traceback object) (Slice object) A típusoknál nincs rekord, unió, halmaz, mutató típus. Saját adattípust, mint osztályobjektumot létre hozhatunk, de elég furcsa módon (lásd osztályok).

Kivételkezelés Lekezeletlen kivétel esetén kiíródik a kiváltó programsor, a verem felderítésének (stack backtrace) módszerével. Kivétel lekezelése:

   try ... except vagy try ... finally

try...except: Ha fellép egy kivétel a try blokkban, ami meg van említve egy except ágban, akkor a vezérlés az except ágnak adódik. Az except ág lefutása után a try blokk utáni részen folytatódik a program (nincs lehetőség folytatni a hibánál). Tovább adódik a külső try blokknak (ha van külső try blokk), ha nincs ebben a try blokkban lekezelve a fellépett kivétel, vagy az except ágban is kiváltódik egy. Ha nem lép fel semmilyen kivétel a try blokkban, akkor a vezérlés else ágra kerül. Tehát a try blokknak lehet else ágat írni. Létrehozhatunk saját kivételeket és vannak előre definiált kivételek is. A kivételek paraméterezhetőek, típusuktól függően más és más paraméterük lehet (több paramétert listában kell átvenni). például: try:

   spam()

except NameError,x:

   print 'name',x,'undefined'

Egyszerre csak egy except ág fut le, és ha utolsónak írunk egy szimpla except ágat, akkor az elfogja az összes kivételt. Több kivétel esetén zárójelbe téve vesszővel felsorolva adhatjuk meg: try:

...

except (NameError,TypeError):

...

except:

   print 'Nem várt kivétel lépett fel'

else

   print 'semmilyen kivétel nem lépett fel'

A try blokk a blokkban hívott függvények által kiváltott kivételt is lekezeli! például: def this_fails():

   x=1/0

try:

   this_fails()

except ZeroDivisionError, detail:

   print 'Handling run-time error:',detail

output: Handling run-time error: intgeger division or modulo Kivétel kiváltására a raise utasítás alkalmazható. raise NameError,'Hello' A második argumentum a kivételkezelő paramétere lesz. Saját kivétel létrehozása (egy változónak string értéket kell adni, tehát érdemes, hogy a változó nevét adjuk): my_exc = 'my_exc' try:

   raise my_exc

except my_exc:

   print 'Na, most boldog lehetek'

A try...finally blokk finally része mindenképpen lefut, ez egy rendberakási lehetőség. Ha kivétel lép fel, akkor a finally rész lefutása után a kivétel újra kiváltódik. A finally rész akkor is lefut, ha break vagy return utasítással hagyjuk el a try blokkot. Egy try blokknak lehet except ága, vagy finally ága, de egyszerre a kettő nem lehet, viszont egymásba ágyazhatjuk a try blokkokat. Létrehozhatunk kivételosztályokat is.

Osztályok, öröklődés A Python osztálymechanizmusának tervezésénél a szempont az volt, hogy minimális szintaktikai és szemantikai újdonságokat vezessenek be. C++ és a Modula-3 osztálymechanizmusának a keveréke. Többszörös öröklődésre is lehetőséget ad, a származtatott osztály átdefiniálhatja az ősosztálya(inak) metódusait, egy metódus hívhatja az ősosztály metódusát ugyanazon a néven. Az objektumok tartalmazhatnak privát adatokat. C++ hasonlóságok, hogy minden osztálymember (az adatmembereket is beleértve) publikus, és minden memberfüggvény virtuális. Nincs speciális konstruktor vagy destruktor. Modula-3-hoz hasonlóan nincs lehetőség röviden hivatkozni egy objektum memberére. Az osztályok maguk is objektumok - valójában a Pythonban minden adattípus objektum. (Azonban nem minden objektumnak van osztálya! Pl.: file, integer, lista,...) De beépített típusokat nem bővíthet a felhasználó (nem örökölhet tőlük). A legtöbb beépített operátor újrahasználható osztálymembernek. Ugyanarra az objektumra több néven is lehet hivatkozni, lehet alias neveket csinálni. Osztálydefiníció: class ClassName:

   statement-1
   ...
   statement-N

Pélául:

class MyClass:

   "Egy egyszerű példa osztály"
   i = 42
   def f(x):
       return 'hello world!'

Az osztálynak mielőtt hatása lenne, a vezérlésnek rá kell futnia az osztálydefinícióra, így akár egy if-ágban is lehet osztálydefiníció! Az osztály-objektum az osztálydefiníció végén automatikusan létrejön. Példányosítani úgy tudunk, mintha egy paraméter nélküli függvényt hívnánk meg ( x = MyClass() ). Az adat attribútumok, mint lokális változók, nem előre definiálandók: első használatukkor jönnek létre. Példa: x = MyClass x.counter = 1 while x.counter < 10:

   x.counter = x.counter * 2

print x.counter del x.counter Ez a kis példa 16-ot ír ki (nem a legegyszerűbb módon), és semmilyen nyoma nem marad az osztályban, hisz a del utasítással töröltük. Metódus attribútum:  x.f helyes hivatkozás, hisz MyClass.f egy függvény  x.i helytelen, hiszen MyClass.i nem függvény x.f nem ugyanaz, mint MyClass.f! x.f egy metódus objektum, nem függvényobjektum. x.f() - ki fogja írni: hello world. Ugyanis az objektum, mint első argumentum átadódik a függvénynek, azaz x.f() ekvivalens MyClass.f(x) -el. További megjegyzések:  az adat attribútumok felülírják az ugyanolyan nevű metódus attribútumot! Ezért célszerű valamilyen névkonvencióval kizárni az ilyen lehetőséget.  nincs lehetőség az adatelrejtésre - az adat attribútumokat éppúgy elérik a metódusok, mint az objektum kliensei.  az előbbi megjegyzés lehetővé teszi, hogy kliensek elrontsák az invariánst, ha meglévő adat attribútumot írnak. Ezt kerülni kell, mivel a nyelv nem nyújt rá lehetőséget.  ha létezik egy __init__() metódusa az osztálynak, akkor példányosításkor az objektum létrehozása után meghívódik, átadva a példányosításkor esetleg megadott paramétereket:

   class Complex:
       def __init__(self, realpart, imagpart):
           self.r = realpart
           self.i = imagpart

   x = Complex(3.0,-4.5)

(többszörös) öröklődés class DerivedClassName([modulename.]Base1[,[[modulename.]Base2,...]) Ha egy hivatkozást nem talál az aktuális osztályban, akkor Base1-ben keresi,ha Base1-ben sincs, akkor Base1 őseiben. Ezután ha még mindig nem találta, akkor Base2-ben kezdi el keresni, és így tovább. Rekord vagy struct-szerű objektumok létrehozása: class Dolgozo:

   pass        # ez egy űres osztálydefiníció

John = Dolgozo() John.nev = 'John Cosinus' John.osztaly = 'Matematikai reszleg' John.fizetes = 42000 A kivételek lehetnek osztályok és nem csak string objektumok. Forma: raise instance vagy raise Class, instance. Egy except klóz kompatibilis a kivétellel, ha ugyanabban az osztályban vannak vagy a kivétel egy ősosztályban van. Példa: class B:

   pass

class C(B):

   pass

class D(C):

   pass

for c in [B,C,D]:

   try:
       raise c()
   except D:
       print "D"
   except C:
       print "C"
   except B:
       print "B"

Az eredmény B,C,D ebben a sorrrendben. Ha azonban az except ágakat fordítva írtuk volna, akkor az eredmény B,B,B lett volna, mert a legelső illő except ág aktivizálódik.

Szabványos könyvtárak

A Pythonnak igen kiterjedt és széleskörű standard könyvtára van, amit még kiegészítenek az egyéb (mások által) megírt publikus modulok. A könyvtár adattípusokat tartalmaz, amelyeket egyébként a nyelv magjának tekintenek (pl. számok és listák). Tartalmaz még beépített függvényeket és kivételeket, melyeket használni lehet import nélkül, viszont a legnagyobb része természetesen modulokban van. Ezek egy részét C-ben írták meg, és be van építve az interpreterbe, másokat python forráskódban kell importálni.

A modulok listája:

__builtin__
__main__
aifc
al
AL
anydbm
array
audioop
base64
BaseHTTPServer
Bastion
binascii
binhex
cd
cgi
CGIHTTPServer
cmath
code
commands
copy
copy_reg
crypt
ctb
dbm
DEVICE
dis
dumbdbm
EasyDialogs
errno
exceptions
fcntl
findertools
fl
FL
flp
fm
fnmatch
formatter
FrameWork
ftplib
gdbm
getopt
gl
GL
glob
gopherlib
grp
gzip
htmllib
httplib
ic
imageop
imgfile
imghdr
imp
jpeg
keyword
locale
mac
macconsole
macdnr
macfs
MacOS
macostools
macpath
macspeech
mactcp
mailbox
mailcap
marshal
math
md5
mimetools
mimify
MiniAEFrame
mpz
ni
nntplib
operator
os
parser
pdb
pickle
posix
posixfile
posixpath
pprint
profile
pstats
pwd
Queue
quopri
rand
random
re
regex
regsub
resource
rexec
rfc822
rgbimg
rotor
select
sgmllib
shelve
signal
SimpleHTTPServer
site
socket

SocketServer
soundex
stat
string
StringIO
struct
sunaudiodev
symbol
sys
syslog
tempfile
TERMIOS
termios
thread
time
token
traceback
types
urllib
urlparse
user
UserDict
UserList
uu
whichdb
whrandom
xdrlib
xmllib
zlib