INDICE

Creiamo una infrastruttura di lavoro

In [ ]:
a=1
b=2
print(a*b)

Primi passi in modalita' interattiva

Utilizzare lo shell IDLE, installato insieme all'interprete:
Useremo python in modalita' interattiva, dove >>> e' il simbolo del prompt python

Digitare:

In [2]:
print("Ciao mondo")
Ciao mondo

print e' una funzione che in questo caso accetta come parametro una stringa e la 'stampa' sullo shell interattivo.

Le funzioni help e print

In [3]:
help(print)
Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file: a file-like object (stream); defaults to the current sys.stdout.
    sep:  string inserted between values, default a space.
    end:  string appended after the last value, default a newline.

NOTE:

definizione di variabili

Quindi digitare le seguenti istruzioni:

In [4]:
a=1
b=2*a
c=3.0
d='questa  è  una stringa'
print(a)
print(b)
print(c)
print(d)
1
2
3.0
questa  è  una stringa
In [6]:
type(a)
type(c)
Out[6]:
builtins.float

Se provo ad usare una variabile z che non esiste (o che non e' visibile nel contesto in cui lavoro, ne parleremo poi), l'interprete segnala un NameError:

In [ ]:
#z*a

le funzione type ed un primo incontro con alcuni tipi di base

In [7]:
a=3
b=2*a
print("tipo di b = ",type(b))
tipo di b =  <class 'int'>
In [8]:
c=3.0
print("tipo di c = ",type(c))
tipo di c =  <class 'float'>
In [9]:
d='questa  è  una stringa'
print("tipo di d = ",type(d))
tipo di d =  <class 'str'>

Operatori sui tipi di base

  • Python definisce anche degli operatori che lavorano sui tipi di base (nell'esempio la somma e la moltiplicazione per gli interi e per le stringhe, sono definiti nella Python standard library)
  • In [11]:
    print(a)
    print(a*b)
    
    3
    18
    
    In [12]:
    b='ciao '
    print(b+b)
    
    ciao ciao 
    
    In [13]:
    print(b*4)
    
    ciao ciao ciao ciao 
    

    Alcuni link utili sui tipi di base e sulle funzioni standard

    Cosa mette a disposizione l'interprete 'nudo e crudo'?

    per capirlo introduciamo una nuova funzione.

    La funzione dir

    Facciamo adesso la conoscenza con la funzione predefinita dir:

    In [14]:
    help(dir)
    
    Help on built-in function dir in module builtins:
    
    dir(...)
        dir([object]) -> list of strings
        
        If called without an argument, return the names in the current scope.
        Else, return an alphabetized list of names comprising (some of) the attributes
        of the given object, and of attributes reachable from it.
        If the object supplies a method named __dir__, it will be used; otherwise
        the default dir() logic is used and returns:
          for a module object: the module's attributes.
          for a class object:  its attributes, and recursively the attributes
            of its bases.
          for any other object: its attributes, its class's attributes, and
            recursively the attributes of its class's base classes.
    
    

    dir()

    Come dice la documentazione, la funzione dir, se invocata senza argomenti, indica i nomi definiti nel contesto (scope) corrente: La funzione dovrebbe restituire una 'lista' che contiene i seguenti nomi:

    Dove i nomi a,b e c sono quelli delle variabili che abbiamo definito noi.
    Per capire meglio a cosa sono associati questi nomi possiamo utilizzare sia le funzioni help e type, gia' viste in precedenza, sia la funzione dir stessa

    In [ ]:
    #__name__
    type(__name__)
    
    In [ ]:
    print(__name__)
    

    name e' quindi il nome di una stringa che ha come contenuto "__main"
    In questo particolare caso "__main
    " e' il nome del contesto di lavoro principale dell'interprete nel quale si opera in modalita' interattiva
    Piu' in generale "__main__" e' il nome assegnato al programma principale eseguito dall'interprete (questa cosa sara' + chiara in seguito).

    dir(oggetto)

    dir e' una funzione molto utile per capire quali sono le proprieta' (attributi) che caratterizzano una generica variabile (oggetto):

    In [15]:
    a=1 #creo un intero
    print(type(a))
    print(dir(a))
    
    <class 'int'>
    ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
    
    In [16]:
    i=-1
    abs(i)
    
    Out[16]:
    1

    il modulo builtins

    Passiamo a __builtins__:

    In [17]:
    #builtin
    print( type(__builtin__))
    
    <class 'module'>
    

    Si tratta di un modulo cioe' di un pacchetto software di python che integra nuove funzioni o anche nuovi tipi di oggetti.
    Nel caso di __builtins__ , si tratta dell'unico modulo che viene sempre caricato dall'interprete quando questo e' usato e definisce i tipi e le funzioni predefinite

    Se uso la funzione dir passandogli come parametro il nome __builtins__ ottengo una lista in cui ci sono tutti i nomi (di funzioni e tipi di dato ad esempio) definiti nel modulo

    In [18]:
    print(dir(__builtin__))
    
    ['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BufferError', 'BytesWarning', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '__IPYTHON__', '__IPYTHON__active', '__build_class__', '__debug__', '__doc__', '__import__', '__name__', '__package__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'dreload', 'enumerate', 'eval', 'exec', 'filter', 'float', 'format', 'frozenset', 'get_ipython', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
    

    Verifichiamo che le funzioni ed i tipi di dato che abbiamo usato fino ad ora siano effettivamente definiti in __builtins__:

    In [19]:
    print('int' in dir(__builtin__))
    print('float' in dir(__builtin__))
    print('str' in dir(__builtin__))
    print('help' in dir(__builtin__))
    print('dir' in dir(__builtin__))
    print('type' in dir(__builtin__))
    print('-'*20)
    print('xxx' in dir(__builtin__))
    
    True
    True
    True
    True
    True
    True
    --------------------
    False
    

    Importazione di moduli

    Oltre alle funzioni ed ai tipi predefiniti ci sono migliaia di moduli aggiuntivi che estendono le funzionalita' del linguaggio.
    I moduli possono essere suddivisi sostanzialmente in due categorie:

    Una terza categoria e' costituita dai moduli che eventualmente creeremo noi.

    Un esempio di modulo standard : math

    Il modulo math, come tutti gli altri moduli standard, e' distribuito insieme all'interprete

    In [21]:
    import math
    
    In [23]:
    #help(math)
    

    Oltre alla funzione help e' possibile utilizzare la funzione dir passandogli come argomento il nome del modulo ed otterremo l'elenco di tutto cio' che e' definito nel modulo stesso:

    In [24]:
    print(dir(math))
    
    ['__doc__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']
    

    Per utilizzare una delle funzioni definite nel modulo math si usa la sintassi math.funzione

    In [25]:
    math.cos(0.0)
    
    Out[25]:
    1.0
    In [26]:
    math.cos(math.pi/2.0) #in questo caso abbiamo usato anche la costante math.pi
    
    Out[26]:
    6.123233995736766e-17

    Verifichiamo che il nome math e' stato aggiunto al contesto di lavoro corrente.

    In [27]:
    'math' in dir()
    
    Out[27]:
    True

    Primi passi con gli script

    Fino ad ora abbiamo usato l'interprete in modalita' interattiva. Vediamo adesso cosa e' uno script.

    Uno script e' un file di testo che contiene istruzioni di python e che puo' essere eseguito dall'interprete.

    Ad uno script e pi ù in generale ad un programma scritto in python si associa l'estensione .py

    creo uno script

    Usiamo IDLE (ma va bene qualsiasi editor di testo):

    Se dal men ù file proviamo a salvare (il file vuoto), su windows IDLE propone di default la cartella di installazione di Python (C:/Python32/ nel mio caso).
    E' comodo creare nella cartella di installazione un collegamento alla nostra cartella principale in modo da velocizzare le operazioni di apertura/salvataggio dei files.

    Creare un file helloworld.py nella cartella work.

    scrivo nel file alcune delle semplici istruzioni che abbiamo gia' visto intervallandole a commenti

    i commenti

    # è il carattere di commento ed e' valido anche in modalita' interattiva oltre che quando scriviamo script o programmi su file di testo.

    In [ ]:
    #commento a riga intera
    import math #commento sullo
    #stampo su standartout "hello world"
    print("hello world")
    #creo una variabile a
    a = math.cos(math.pi/6.)
    #stampo la variabile a
    print("cos(pi/6)=",a)
    

    Eseguire uno script

    da IDLE

    Se si utilizza IDLE basta utilizzare Men ù run --> run module (o tasto F5)

    Come risultato nella finestra interattiva dell'interprete viene stampato l'output del codice.

    NOTA BENE:

    da un generico shell interattivo di python

    In [ ]:
    exec(open('C:/python/corso/materialexcorsopyton/work/helloworld.py').read())
    

    per ora non si capisce
    Nelle prossime lezioni vedremo tutte le funzioni usate (exec, open ed il metodo read dell'oggetto file)
    vedi anche qui per una conversazione su un forum a proposito.

    NOTA: il path completo dello script non e' necessario se lo script e' nella la cartella di lavoro di python (in genere quella dalla quale si e' invocato l'interprete).

    NOTA: cos &ìgrave; facendo una variabile b istanziata prima dell'esecuzione dello script e' accessibile anche dopo l'esecuzione dello script stesso:

    da prompt dei comandi

    Da un generico prompt dei comandi del sistema operativo:

    Nota per utenti wondows: come aprire uno shell MS-DOS in una specifica cartella

    Per aprire uno shell MS-DOS in una specifica cartella (senza necessita' di cambiare cartella con il comando chdir) è utile la funzione 'Open command prompt here' di windows:

    Alternativamente, fissata la cartella di interesse (ad esempio work) creare un file con estensione bat che contiene una sola riga:

    cmd.exe "%1"

    doppio clic sull'icona

    per evitare che il prompt si chiuda immediatamente aggiungere la chiamata a funzione
    input("ciao ciao")
    alla fine dello script

    script di python eseguibili in unix

    vedi qui