Tutorial su Python
******************

Python è un linguaggio di programmazione potente e facile da imparare.
Dispone di strutture di dati efficienti e di alto livello e di un
approccio semplice ma efficace alla programmazione orientata agli
oggetti. La sintassi elegante e la tipizzazione dinamica di Python,
insieme alla sua natura interpretata, ne fanno un linguaggio ideale
per lo scripting e il rapido sviluppo di applicazioni in molte aree
per la maggior parte delle piattaforme.

L'interprete Python e l'ampia libreria standard sono liberamente
disponibili in forma di codici sorgenti o binari per tutte le
principali piattaforme dal sito web di Python,
https://www.python.org/, e possono essere distribuiti gratuitamente.
Lo stesso sito contiene anche distribuzioni e link a molti moduli,
programmi e strumenti Python di terze parti gratuiti e documentazione
aggiuntiva.

L'interprete Python è facilmente ampliabile con nuove funzioni e tipi
di dati implementati in C o C+++ (o altri linguaggi richiamabili da
C). Python è adatto anche come linguaggio di estensione per
applicazioni personalizzabili.

Questo tutorial introduce il lettore in modo informale ai concetti di
base e alle caratteristiche del linguaggio e del sistema Python. Aiuta
ad avere un interprete Python a portata di mano per un'esperienza
pratica, ma tutti gli esempi sono autonomi, così il tutorial può
essere letto anche off-line.

Per una descrizione degli oggetti e dei moduli standard, si veda The
Python Standard Library. The Python Language Reference fornisce una
definizione più formale del linguaggio.  Per scrivere le estensioni in
C o C+++, si legga Extending and Embedding the Python Interpreter e
Python/C API Reference Manual. Ci sono anche diversi libri che coprono
Python in profondità.

Questo tutorial non vuole essere completo e coprire ogni singola
caratteristica, come pure ogni caratteristica usata comunemente.
Invece, introduce molte delle caratteristiche più importanti di
Python, e vi darà una buona idea sullo stile del linguaggio. Dopo
averlo letto, sarete in grado di leggere e scrivere moduli e programmi
Python, e sarete pronti per saperne di più sui vari moduli della
libreria Python, i quali sono descritti in The Python Standard
Library.

Anche il Glossary vale la pena di essere sfogliato.

* 1. Stuzzichiamo il tuo appetito

* 2. Uso dell'interprete di Python

  * 2.1. Invocazione dell'interprete

    * 2.1.1. Passare Argomenti

    * 2.1.2. Modalità Interattiva

  * 2.2. L'interprete e il suo ambiente

    * 2.2.1. Codifica del codice sorgente

* 3. Un'introduzione informale a Python

  * 3.1. Usare Python come calcolatrice

    * 3.1.1. Numeri

    * 3.1.2. Stringa

    * 3.1.3. Liste

  * 3.2. Primi passi di programmazione

* 4. More Control Flow Tools

  * 4.1. "if" Statements

  * 4.2. "for" Statements

  * 4.3. The "range()" Function

  * 4.4. "break" and "continue" Statements, and "else" Clauses on
    Loops

  * 4.5. "pass" Statements

  * 4.6. Defining Functions

  * 4.7. More on Defining Functions

    * 4.7.1. Default Argument Values

    * 4.7.2. Keyword Arguments

    * 4.7.3. Special parameters

      * 4.7.3.1. Positional-or-Keyword Arguments

      * 4.7.3.2. Positional-Only Parameters

      * 4.7.3.3. Keyword-Only Arguments

      * 4.7.3.4. Function Examples

      * 4.7.3.5. Recap

    * 4.7.4. Arbitrary Argument Lists

    * 4.7.5. Unpacking Argument Lists

    * 4.7.6. Lambda Expressions

    * 4.7.7. Documentation Strings

    * 4.7.8. Function Annotations

  * 4.8. Intermezzo: Coding Style

* 5. Data Structures

  * 5.1. More on Lists

    * 5.1.1. Using Lists as Stacks

    * 5.1.2. Using Lists as Queues

    * 5.1.3. List Comprehensions

    * 5.1.4. Nested List Comprehensions

  * 5.2. The "del" statement

  * 5.3. Tuples and Sequences

  * 5.4. Sets

  * 5.5. Dictionaries

  * 5.6. Looping Techniques

  * 5.7. More on Conditions

  * 5.8. Comparing Sequences and Other Types

* 6. Modules

  * 6.1. More on Modules

    * 6.1.1. Executing modules as scripts

    * 6.1.2. The Module Search Path

    * 6.1.3. "Compiled" Python files

  * 6.2. Standard Modules

  * 6.3. The "dir()" Function

  * 6.4. Packages

    * 6.4.1. Importing * From a Package

    * 6.4.2. Intra-package References

    * 6.4.3. Packages in Multiple Directories

* 7. Input and Output

  * 7.1. Fancier Output Formatting

    * 7.1.1. Formatted String Literals

    * 7.1.2. The String format() Method

    * 7.1.3. Manual String Formatting

    * 7.1.4. Old string formatting

  * 7.2. Reading and Writing Files

    * 7.2.1. Methods of File Objects

    * 7.2.2. Saving structured data with "json"

* 8. Errors and Exceptions

  * 8.1. Syntax Errors

  * 8.2. Exceptions

  * 8.3. Handling Exceptions

  * 8.4. Raising Exceptions

  * 8.5. User-defined Exceptions

  * 8.6. Defining Clean-up Actions

  * 8.7. Predefined Clean-up Actions

* 9. Classes

  * 9.1. A Word About Names and Objects

  * 9.2. Python Scopes and Namespaces

    * 9.2.1. Scopes and Namespaces Example

  * 9.3. A First Look at Classes

    * 9.3.1. Class Definition Syntax

    * 9.3.2. Class Objects

    * 9.3.3. Instance Objects

    * 9.3.4. Method Objects

    * 9.3.5. Class and Instance Variables

  * 9.4. Random Remarks

  * 9.5. Inheritance

    * 9.5.1. Multiple Inheritance

  * 9.6. Private Variables

  * 9.7. Odds and Ends

  * 9.8. Iterators

  * 9.9. Generators

  * 9.10. Generator Expressions

* 10. Brief Tour of the Standard Library

  * 10.1. Operating System Interface

  * 10.2. File Wildcards

  * 10.3. Command Line Arguments

  * 10.4. Error Output Redirection and Program Termination

  * 10.5. String Pattern Matching

  * 10.6. Mathematics

  * 10.7. Internet Access

  * 10.8. Dates and Times

  * 10.9. Data Compression

  * 10.10. Performance Measurement

  * 10.11. Quality Control

  * 10.12. Batteries Included

* 11. Brief Tour of the Standard Library --- Part II

  * 11.1. Output Formatting

  * 11.2. Templating

  * 11.3. Working with Binary Data Record Layouts

  * 11.4. Multi-threading

  * 11.5. Logging

  * 11.6. Weak References

  * 11.7. Tools for Working with Lists

  * 11.8. Decimal Floating Point Arithmetic

* 12. Virtual Environments and Packages

  * 12.1. Introduction

  * 12.2. Creating Virtual Environments

  * 12.3. Managing Packages with pip

* 13. What Now?

* 14. Interactive Input Editing and History Substitution

  * 14.1. Tab Completion and History Editing

  * 14.2. Alternatives to the Interactive Interpreter

* 15. Floating Point Arithmetic:  Issues and Limitations

  * 15.1. Representation Error

* 16. Appendix

  * 16.1. Interactive Mode

    * 16.1.1. Error Handling

    * 16.1.2. Executable Python Scripts

    * 16.1.3. The Interactive Startup File

    * 16.1.4. The Customization Modules
