# 3. Un’introduzione informale a Python

Nei seguenti esempi, input e output si distinguono per la presenza o meno del prompt (>>> e …): per ripetere l’esempio, è necessario digitare tutto dopo il prompt, quando questo è presente; le righe che non iniziano con un prompt vengono emesse dall’interprete. Si noti che un prompt secondario su una linea da solo in un esempio significa che è necessario digitare una riga vuota; questo viene utilizzato per terminare un comando a più righe.

Molti degli esempi di questo manuale, anche quelli inseriti al prompt interattivo, includono commenti. I commenti in Python iniziano con il carattere hash, `#``, e si estendono fino alla fine della riga. Un commento può apparire all’inizio di una riga o dopo uno spazio bianco o codice, ma non all’interno di una stringa. Un carattere hash all’interno di una stringa letterale è solo un carattere. Poiché i commenti servono solo a chiarire il codice e non sono interpretati da Python, possono essere omessi quando si scrivono gli esempi.

Alcuni esempi:

    # this is the first comment
    spam = 1  # and this is the second comment
              # ... and now a third!
    text = "# This is not a comment because it's inside quotes."

## 3.1. Usare Python come calcolatrice

Proviamo con alcuni semplici comandi di Python. Avviare l’interprete e attendere il prompt primario, `>>>``. Non dovrebbe volerci molto.

### 3.1.1. Numeri

L’interprete agisce come una semplice calcolatrice: è possibile digitare un’espressione per scrivere il valore. La sintassi dell’espressione è semplice: gli operatori `+`, `-`, `*` e `/` funzionano come nella maggior parte degli altri linguaggi (per esempio, Pascal o C); le parentesi (`()`) possono essere utilizzate per il raggruppamento. Per esempio:

    >>> 2 + 2
    4
    >>> 50 - 5*6
    20
    >>> (50 - 5*6) / 4
    5.0
    >>> 8 / 5  # division always returns a floating point number
    1.6

I numeri interi (es. `2`, `4`, `20`) hanno tipo `int`, quelli in virgola mobile (es. `5.0`, `1.6`) hanno tipo `float`. Torneremo a parlare ancora dei tipi numerici più avanti nel tutorial.

La divisione (`/`) restituisce sempre un float. Per fare floor division e ottenere un risultato intero (scartando qualsiasi cifra decimale) si può usare l’operatore `//`; per calcolare il resto si può usare `%`:

    >>> 17 / 3  # classic division returns a float
    5.666666666666667
    >>>
    >>> 17 // 3  # floor division discards the fractional part
    5
    >>> 17 % 3  # the % operator returns the remainder of the division
    2
    >>> 5 * 3 + 2  # result * divisor + remainder
    17

Con Python, è possibile utilizzare l’operatore `**` per calcolare le potenze 1:

    >>> 5 ** 2  # 5 squared
    25
    >>> 2 ** 7  # 2 to the power of 7
    128

Il segno uguale (`=`) è usato per assegnare un valore ad una variabile. Successivamente, nessun risultato viene visualizzato prima della successiva richiesta:

    >>> width = 20
    >>> height = 5 * 9
    >>> width * height
    900

Se una variabile non è stata ”definita» (a cui è stato assegnato un valore), usarla vi darà un errore:

    >>> n  # try to access an undefined variable
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    NameError: name 'n' is not defined

C’è pieno supporto per i numeri in virgola mobile; gli operatori con operandi di tipo misto convertono l’intero in un numero in virgola mobile:

    >>> 4 * 3.75 - 1
    14.0

In modalità interattiva, l’ultima espressione stampata viene assegnata alla variabile ``_`. Questo significa che quando si utilizza Python come calcolatrice da tavolo, è un po” più facile continuare i calcoli, ad esempio:

    >>> tax = 12.5 / 100
    >>> price = 100.50
    >>> price * tax
    12.5625
    >>> price + _
    113.0625
    >>> round(_, 2)
    113.06

Questa variabile deve essere trattata dall’utente in sola lettura. Non va assegnato esplicitamente un valore ad essa — si dovrebbe invece creare una variabile locale indipendente con lo stesso nome, mascherando così la variabile built-in e il suo comportamento magico.

Oltre a `int` e `float`, Python supporta altri tipi di numeri, come `Decimal` e `Fraction`. Python ha anche il supporto incorporato per complex numbers, e usa il suffisso `j` o `J` per indicare la parte immaginaria (es. `3+5j`).

### 3.1.2. Stringa

Oltre ai numeri, Python può anche manipolare le stringhe, che possono essere espresse in diversi modi. Possono essere racchiuse in citazioni singole (`'...'`) o doppie (`"..."`) con lo stesso risultato 2. `\` può essere usato per l’escaping:

    >>> 'spam eggs'  # single quotes
    'spam eggs'
    >>> 'doesn\'t'  # use \' to escape the single quote...
    "doesn't"
    >>> "doesn't"  # ...or use double quotes instead
    "doesn't"
    >>> '"Yes," they said.'
    '"Yes," they said.'
    >>> "\"Yes,\" they said."
    '"Yes," they said.'
    >>> '"Isn\'t," they said.'
    '"Isn\'t," they said.'

Nell’interprete interattivo, la stringa di output è racchiusa tra virgolette e i caratteri speciali vengono preceduti con backslash. Anche se a volte può sembrare diverso dall’input (le virgolette allegate potrebbero cambiare), le due stringhe sono equivalenti. La stringa è racchiusa tra virgolette se la stringa contiene una singola citazione e non citazioni doppie, altrimenti è racchiusa tra virgolette singole. La funzione `print()` produce un output più leggibile, omettendo le citazioni allegate e stampando i caratteri speciali:

    >>> '"Isn\'t," they said.'
    '"Isn\'t," they said.'
    >>> print('"Isn\'t," they said.')
    "Isn't," they said.
    >>> s = 'First line.\nSecond line.'  # \n means newline
    >>> s  # without print(), \n is included in the output
    'First line.\nSecond line.'
    >>> print(s)  # with print(), \n produces a new line
    First line.
    Second line.

Se non si desidera che i caratteri preceduti da `\` siano interpretati come caratteri speciali, è possibile utilizzare le cosiddette raw strings aggiungendo un `r` prima del primo apice:

    >>> print('C:\some\name')  # here \n means newline!
    C:\some
    ame
    >>> print(r'C:\some\name')  # note the r before the quote
    C:\some\name

Le lettere letterali delle stringhe possono estendersi su più linee. Un modo è quello di usare gli apici tripli: `"""..."""` o `'''...'''`. La fine delle linee sono automaticamente incluse nella stringa, ma è possibile evitare che ciò avvenga aggiungendo un `\` alla fine della linea. Il seguente esempio:

    print("""\
    Usage: thingy [OPTIONS]
         -h                        Display this usage message
         -H hostname               Hostname to connect to
    """)

produce il seguente output (si noti che la nuova linea iniziale non è inclusa):

    Usage: thingy [OPTIONS]
         -h                        Display this usage message
         -H hostname               Hostname to connect to

Le stringhe possono essere concatenate (incollate insieme) con l’operatore `+` e ripetute con `*`:

    >>> # 3 times 'un', followed by 'ium'
    >>> 3 * 'un' + 'ium'
    'unununium'

Due o più letterali di tipo stringa (cioè quelli racchiusi tra virgolette) posizionati uno accanto all’altro sono automaticamente concatenati.

    >>> 'Py' 'thon'
    'Python'

Questa funzione è particolarmente utile quando si vogliono separare stringhe lunghe:

    >>> text = ('Put several strings within parentheses '
    ...         'to have them joined together.')
    >>> text
    'Put several strings within parentheses to have them joined together.'

Questo funziona solo con due letterali, ma non con variabili o expression:

    >>> prefix = 'Py'
    >>> prefix 'thon'  # can't concatenate a variable and a string literal
      File "<stdin>", line 1
        prefix 'thon'
                    ^
    SyntaxError: invalid syntax
    >>> ('un' * 3) 'ium'
      File "<stdin>", line 1
        ('un' * 3) 'ium'
                       ^
    SyntaxError: invalid syntax

Se volete concatenare variabili o una variabile e un letterale, usate `+`:

    >>> prefix + 'thon'
    'Python'

Le stringhe possono essere indicizzate (sottoscritte), e il primo carattere ha indice 0. Non esiste un tipo carattere specifico; un carattere è semplicemente una stringa di dimensione uno:

    >>> word = 'Python'
    >>> word[0]  # character in position 0
    'P'
    >>> word[5]  # character in position 5
    'n'

Gli indici possono anche essere numeri negativi, per iniziare a contare da destra:

    >>> word[-1]  # last character
    'n'
    >>> word[-2]  # second-last character
    'o'
    >>> word[-6]
    'P'

N.B. Poiché -0 è uguale a 0, gli indici negativi partono da -1.

Oltre all’indicizzazione, è supportato anche lo slicing. Mentre l’indicizzazione è usata per ottenere i singoli caratteri, lo slicing permette di ottenere una sottostringa:

    >>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
    'Py'
    >>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
    'tho'

Si noti come l’inizio sia sempre incluso, e la fine sempre esclusa. Questo fa sì che `s[:i] + s[i:]` è sempre uguale a `s`:

    >>> word[:2] + word[2:]
    'Python'
    >>> word[:4] + word[4:]
    'Python'

Nello slice gli indici hanno degli utili valori predefiniti; un primo indice omesso è zero, un secondo indice omesso è uguale alla dimensione della stringa che si sta tagliando:

    >>> word[:2]   # character from the beginning to position 2 (excluded)
    'Py'
    >>> word[4:]   # characters from position 4 (included) to the end
    'on'
    >>> word[-2:]  # characters from the second-last (included) to the end
    'on'

Un modo per ricordare come funzionano le fette è quello di pensare agli indici come al punto tra caratteri, con il bordo sinistro del primo carattere numerato 0. Poi il bordo destro dell’ultimo carattere di una stringa di caratteri n ha l’indice n, per esempio:

     +---+---+---+---+---+---+
     | P | y | t | h | o | n |
     +---+---+---+---+---+---+
     0   1   2   3   4   5   6
    -6  -5  -4  -3  -2  -1

La prima riga di numeri dà la posizione degli indici 0…6 nella stringa; la seconda riga dà i corrispondenti indici negativi. La porzione da i a j è costituita da tutti i caratteri tra i bordi contrassegnati rispettivamente con i e j.

Per gli indici non negativi, la lunghezza di una fetta è la differenza degli indici, se entrambi sono entro i limiti. Per esempio, la lunghezza di `word[1:3]` è 2.

Il tentativo di utilizzare un indice troppo grande comporta un errore:

    >>> word[42]  # the word only has 6 characters
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    IndexError: string index out of range

Tuttavia, gli indici delle sottostringhe fuori range (che superano la lunghezza della stringa) sono gestiti a modo quando vengono utilizzati per l’affettamento:

    >>> word[4:42]
    'on'
    >>> word[42:]
    ''

Le stringhe Python non possono essere modificate — sono immutable. Pertanto, l’assegnazione di una posizione indicizzata nella stringa comporta un errore:

    >>> word[0] = 'J'
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'str' object does not support item assignment
    >>> word[2:] = 'py'
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'str' object does not support item assignment

Se avete bisogno di una stringa diversa, dovreste crearne una nuova:

    >>> 'J' + word[1:]
    'Jython'
    >>> word[:2] + 'py'
    'Pypy'

La funzione integrata `len()` restituisce la lunghezza di una stringa:

    >>> s = 'supercalifragilisticexpialidocious'
    >>> len(s)
    34

Vedi anche

Text Sequence Type — str

  Le stringhe sono esempi di tipi di sequenze, e supportano le operazioni comuni supportate da questi tipi di dato.

String Methods

  Un gran numero di metodi per le trasformazioni di base e la ricerca sono supportati dalle stringhe.

Formatted string literals

  Stringhe con expression incorporate.

Format String Syntax

  Informazioni sulla formattazione delle stringhe con `str.format()`.

printf-style String Formatting

  Il vecchio metodo di formattazione, quello che prevede un template a sinistra dell’operatore `%` è descritto più dettagliatamente qui.

### 3.1.3. Liste

Python conosce un certo numero di tipi di dati composti, usati per raggruppare altri valori. La più versatile è la lista, che può essere scritta come una lista di valori separati da virgola (elementi) tra parentesi quadre. Gli elenchi possono contenere elementi di tipo diverso, ma di solito gli elementi hanno tutti lo stesso tipo.

    >>> squares = [1, 4, 9, 16, 25]
    >>> squares
    [1, 4, 9, 16, 25]

Like strings (and all other built-in sequence types), lists can be indexed and sliced:

    >>> squares[0]  # indexing returns the item
    1
    >>> squares[-1]
    25
    >>> squares[-3:]  # slicing returns a new list
    [9, 16, 25]

All slice operations return a new list containing the requested elements. This means that the following slice returns a shallow copy of the list:

    >>> squares[:]
    [1, 4, 9, 16, 25]

Gli elenchi supportano anche operazioni come la concatenazione:

    >>> squares + [36, 49, 64, 81, 100]
    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

A differenza delle stringhe, che sono immutable, le liste sono di tipo mutable, cioè è possibile modificarne il contenuto:

    >>> cubes = [1, 8, 27, 65, 125]  # something's wrong here
    >>> 4 ** 3  # the cube of 4 is 64, not 65!
    64
    >>> cubes[3] = 64  # replace the wrong value
    >>> cubes
    [1, 8, 27, 64, 125]

Potete anche aggiungere nuovi elementi alla fine della lista, usando il metodo `append()` (vedremo di più riguardo i metodi più avanti):

    >>> cubes.append(216)  # add the cube of 6
    >>> cubes.append(7 ** 3)  # and the cube of 7
    >>> cubes
    [1, 8, 27, 64, 125, 216, 343]

L’assegnazione a uno slice è anche possibile, per cambiare anche la dimensione della lista o cancellarne gli elementi completamente:

    >>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
    >>> letters
    ['a', 'b', 'c', 'd', 'e', 'f', 'g']
    >>> # replace some values
    >>> letters[2:5] = ['C', 'D', 'E']
    >>> letters
    ['a', 'b', 'C', 'D', 'E', 'f', 'g']
    >>> # now remove them
    >>> letters[2:5] = []
    >>> letters
    ['a', 'b', 'f', 'g']
    >>> # clear the list by replacing all the elements with an empty list
    >>> letters[:] = []
    >>> letters
    []

La funzione `len()` si applica anche alle liste:

    >>> letters = ['a', 'b', 'c', 'd']
    >>> len(letters)
    4

E” possibile nidificare liste (creare liste contenenti altre liste), ad esempio:

    >>> a = ['a', 'b', 'c']
    >>> n = [1, 2, 3]
    >>> x = [a, n]
    >>> x
    [['a', 'b', 'c'], [1, 2, 3]]
    >>> x[0]
    ['a', 'b', 'c']
    >>> x[0][1]
    'b'

## 3.2. Primi passi di programmazione

Naturalmente, possiamo usare Python per compiti più complicati che sommare insieme due più due. Per esempio, possiamo scrivere una prima sottosequenza della Successione di Fibonacci come segue:

    >>> # Fibonacci series:
    ... # the sum of two elements defines the next
    ... a, b = 0, 1
    >>> while a < 10:
    ...     print(a)
    ...     a, b = b, a+b
    ...
    0
    1
    1
    2
    3
    5
    8

Questo esempio introduce diverse nuove funzionalità.

- La prima riga contiene una assegnazione multipla: le variabili `a` e `b` ottengono simultaneamente i nuovi valori 0 e 1. Sull’ultima riga viene usata di nuovo, dimostrando che le espressioni sul lato destro sono tutte valutate prima di una qualsiasi delle assegnazioni. Le espressioni del lato destro sono valutate da sinistra a destra.

- Il ciclo `while` viene eseguito finché la condizione (qui: `a < 10`) rimane vera. In Python, come in C, qualsiasi valore intero diverso da zero è vero; zero è falso. La condizione può anche essere una stringa o un valore di lista, infatti qualsiasi sequenza; qualsiasi cosa con una lunghezza diversa da zero è vera, le sequenze vuote sono false. Il test utilizzato nell’esempio è un semplice confronto. Gli operatori di confronto standard sono scritti come in C: `<` (minore di), `>` (maggiore di), `==` (uguale a), `<=` (minore o uguale a), `>=` (maggiore o uguale a) e `!=` (diverso da).

- Il corpo del ciclo è indentato: l’indentazione è il modo di Python di raggruppare le istruzioni. Al prompt interattivo, è necessario digitare un tab o spazio/i per ogni riga rientrata. In pratica si prepara un input più complicato per Python con un editor di testo; tutti gli editor di testo seri hanno una funzione di auto-indentazione. Quando un’istruzione composta è inserita nella shell interattiva, deve essere seguita da una riga vuota per indicare il completamento (poiché l’analizzatore non può indovinare quando si è digitata l’ultima riga). Si noti che ogni riga all’interno di un blocco di base deve essere rientrata della stessa quantità.

- La funzione `print()` scrive il valore dell’argomento o degli argomenti che le vengono passati. Si differenzia dal solo scrivere l’espressione che si vuole scrivere (come abbiamo fatto in precedenza negli esempi della calcolatrice) per il modo in cui gestisce argomenti multipli, numeri in virgola mobile e stringhe. Le stringhe vengono stampate senza virgolette e viene inserito uno spazio tra gli elementi, in modo da poter formattare bene le cose, in questo modo:

      >>> i = 256*256
      >>> print('The value of i is', i)
      The value of i is 65536

  L’argomento end può essere usato per evitare la nuova linea dopo l’output, o terminare l’output con una stringa diversa:

      >>> a, b = 0, 1
      >>> while a < 1000:
      ...     print(a, end=',')
      ...     a, b = b, a+b
      ...
      0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

Note

1

  Poiché `**` ha una precedenza superiore a `-`, `-3**2`` sarà interpretato come `-(3**2)` e quindi risulterà in `-9`. Per evitare questo e ottenere `9`, è possibile utilizzare `(-3)**2`.

2

  A differenza di altri linguaggi, i caratteri speciali come `\n` hanno lo stesso significato sia con apici singoli (`’…’`) che doppi (`”…”`). L’unica differenza tra i due è che all’interno delle stringhe ad apici singoli non c’è bisogno di aggiungere il carattere di escaping prima del `"` (ma bisogna inserirlo prima di un `\'`) e viceversa.