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
-------------

The interpreter acts as a simple calculator: you can type an
expression at it and it will write the value.  Expression syntax is
straightforward: the operators "+", "-", "*" and "/" can be used to
perform arithmetic; parentheses ("()") can be used for grouping. For
example:

   >>> 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.

Division ("/") always returns a float.  To do *floor division* and get
an integer result you can use the "//" operator; to calculate the
remainder you can use "%":

   >>> 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  # floored quotient * 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. Text
-----------

Python can manipulate text (represented by type "str", so-called
"strings") as well as numbers.  This includes characters ""!"", words
""rabbit"", names ""Paris"", sentences ""Got your back."", etc. ""Yay!
:)"". They can be enclosed in single quotes ("'...'") or double quotes
(""..."") with the same result [2].

>>> 'spam eggs'  # single quotes
'spam eggs'
>>> "Paris rabbit got your back :)! Yay!"  # double quotes
'Paris rabbit got your back :)! Yay!'
>>> '1975'  # digits and numerals enclosed in quotes are also strings
'1975'

To quote a quote, we need to "escape" it, by preceding it with "\".
Alternatively, we can use the other type of quotation marks:

   >>> '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.'

In the Python shell, the string definition and output string can look
different.  The "print()" function produces a more readable output, by
omitting the enclosing quotes and by printing escaped and special
characters:

   >>> s = 'First line.\nSecond line.'  # \n means newline
   >>> s  # without print(), special characters are included in the string
   'First line.\nSecond line.'
   >>> print(s)  # with print(), special characters are interpreted, so \n produces 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

There is one subtle aspect to raw strings: a raw string may not end in
an odd number of "\" characters; see the FAQ entry for more
information and workarounds.

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'

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'

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'

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.

  f-strings
     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]

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]

You can also add new items at the end of the list, by using the
"list.append()" *method* (we will see more about methods later):

   >>> 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]

Simple assignment in Python never copies data. When you assign a list
to a variable, the variable refers to the *existing list*. Any changes
you make to the list through one variable will be seen through all
other variables that refer to it.:

   >>> rgb = ["Red", "Green", "Blue"]
   >>> rgba = rgb
   >>> id(rgb) == id(rgba)  # they reference the same object
   True
   >>> rgba.append("Alph")
   >>> rgb
   ["Red", "Green", "Blue", "Alph"]

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

   >>> correct_rgba = rgba[:]
   >>> correct_rgba[-1] = "Alpha"
   >>> correct_rgba
   ["Red", "Green", "Blue", "Alpha"]
   >>> rgba
   ["Red", "Green", "Blue", "Alph"]

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
==================================

Of course, we can use Python for more complicated tasks than adding
two and two together.  For instance, we can write an initial sub-
sequence of the Fibonacci series as follows:

   >>> # 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.
