Python è un interprete. Niente di strano trattandosi di un linguaggio di scripting. A differenza di altri però può essere utilizzato interattivamente. Eseguendo python dalla riga di comando (che sia Unix o NT) otteniamo il prompt (in questo caso su NT):

PythonWin 1.5.1 (#0, Apr 13 1998, 20:22:04) [MSC 32 bit (Intel)]
on win32
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>>

Dopo il >>> possiamo digitare dei comandi e quindi eseguire delle semplici operazioni:

>>> 2+2
4

>>> a=5
>>> a+1
6

>>> def sum(a,b): return a+b
>>> sum(4,5)
9

Come si vede, il Python è innanzitutto un valutatore di espressioni, ma consente di assegnare variabili e definire delle funzioni. Fin qui niente di eccezionale. Ora però cominciamo a fare qualcosa un po' più audace.

>>> __builtins__

<module '__builtin__'>

>>> dir(__builtins__)

['ArithmeticError', … OMISSIS …

'abs', 'apply', 'callable', 'chr', 'cmp', 'coerce',
'compile', 'complex', 'delattr', 'dir', 'divmod', 'eval',
'execfile', 'filter', 'float', 'getattr', 'globals', 'hasattr',
'hash', 'hex', 'id', 'input', 'int', 'intern', 'isinstance',
'issubclass', 'len', 'list', 'locals', 'long', 'map', 'max', 'min',
'oct', 'open', 'ord', 'pow', 'range', 'raw_input', 'reduce',
'reload', 'repr', 'round', 'setattr', 'slice', 'str', 'tuple',
'type', 'vars', 'xrange']

La variabile __builtins__ è di tipo modulo, come dice il messaggio ottenuto dalla sua valutazione; si tratta del modulo che contiene tutti i builtins, ovvero le funzioni predefinite del sistema. Per vedere il contenuto di un modulo (o di un qualsiasi namespace in generale - un modulo è un particolare namespace) posso usare il builtin dir, che in questo caso mi consente di elencare tutti gli altri builtin. I builtin sono funzioni immediatamente disponibili senza particolari operazioni. Continuiamo le nostre esplorazioni, provando ad utilizzare un builtin.

>>> open
<built-in function open>
>>> x = open('c:\autoexec.bat')
<open file 'c:\autoexec.bat', mode 'r' at 870920>
>>> dir(x)
['close', 'closed', 'fileno', 'flush', 'isatty',
'mode', 'name', 'read', 'readinto', 'readline', 'readlines',
'seek', 'softspace', 'tell', 'truncate', 'write', 'writelines']
>>> x.readline

<built-in method readline of file object at 8745d0>
>>> x.readline()
'rem - By Windows 95 Network - C:\\WINDOWS\\net start\012'

Vediamo se vi è chiaro quello che ho fatto: open è un builtin; infatti valutando open mi viene comunicato che si tratta di una funzione builtin (un oggetto quindi di tipo diverso dal modulo visto prima); questo oggetto può essere usato invocandolo con un parametro, ovvero il nome di un file: così facendo ottengo un altro oggetto che rappresenta un file aperto. Per utilizzare il file lo salvo in una variabile e provo ad esaminarne il contenuto con dir,scoprendo che l'oggetto contiene al suo interno una serie di funzioni (o più correttamente metodi). Provo ad utilizzare la readline, che è una funzione e non una proprietà e quindi invoco la funzione, senza parametri, ottenendo quello che mi aspetto: la prima riga del file AUTOEXEC.BAT che ho aperto.

I builtin sono immediatamente disponibili, ma si tratta di un caso particolare: in generale le funzioni è necessario importarle. Come è possibile accedere ai metodi di un oggetto, è anche possibile accedere alle funzioni presenti in un file, o meglio modulo. Per usare le funzioni di un modulo, occorre importarlo. Vediamo subito come si fa, esaminando il modulo per le espessioni regolari (un assoluto must per chi vuole utilizzare il Python come un sostituto per il Perl).

>>> re
Traceback (innermost last):
 File "<stdin>" , line 0, in ?
NameError: re

>>> import re
>>> re
<module 're'>
>>> match
Traceback (innermost last):
 File "<stdin>" , line 0, in ?
NameError: match

>>> from re import match
>>> match
<function match at 850e90>

Non ci interessa in questa sede il funzionamento del modulo re, per il momento ci limitiamo ad esaminanare il meccanismo di importazione. Inizialmente re non è disponibile, lo diventa dopo che eseguiamo import re. A questo punto possiamo vedere il modulo, ma le funzioni in esso contenute (che in questo caso non sono metodi) sono accessivibili solo con la sintassi puntata: re.match. È però possibile rendere accessibile definitivamente una funzione senza dove specificare il modulo con la sintassi from re import match. Notare che in questo modo viene resa disponibile per l'accesso immediato soltanto una funzione, anche se possono essere importate tutte (ma in generale, a meno di moduli semplici, non è il caso).