# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2019, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-05-30 08:10+0200\n"
"PO-Revision-Date: 2024-05-30 09:19+0200\n"
"Last-Translator: Alessandro Cucci <alessandro.cucci@gmail.com>\n"
"Language-Team: \n"
"Language: it_IT\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"X-Generator: Poedit 2.2.1\n"

#: tutorial/modules.rst:5
msgid "Modules"
msgstr "Moduli"

#: tutorial/modules.rst:7
msgid ""
"If you quit from the Python interpreter and enter it again, the definitions "
"you have made (functions and variables) are lost. Therefore, if you want to "
"write a somewhat longer program, you are better off using a text editor to "
"prepare the input for the interpreter and running it with that file as input"
" instead.  This is known as creating a *script*.  As your program gets "
"longer, you may want to split it into several files for easier maintenance."
"  You may also want to use a handy function that you've written in several "
"programs without copying its definition into each program."
msgstr ""
"Se chiudi l'interprete Python e lo riapri, le definizioni che hai fatto "
"(funzioni e variabili) vengono perse. Pertanto, se vuoi scrivere un "
"programma un po' più lungo, è meglio usare un editor di testo per preparare "
"l'input per l'interprete e eseguirlo con quel file come input. Questo è "
"conosciuto come creare uno *script*. Man mano che il tuo programma diventa "
"più lungo, potresti volerlo dividere in diversi file per una manutenzione "
"più facile. Potresti anche voler usare una funzione utile che hai scritto in"
" diversi programmi senza copiarne la definizione in ciascun programma."

#: tutorial/modules.rst:16
msgid ""
"To support this, Python has a way to put definitions in a file and use them "
"in a script or in an interactive instance of the interpreter. Such a file is"
" called a *module*; definitions from a module can be *imported* into other "
"modules or into the *main* module (the collection of variables that you have"
" access to in a script executed at the top level and in calculator mode)."
msgstr ""
"Per supportare questo, Python ha un modo per mettere definizioni in un file "
"e usarle in uno script o in un'istanza interattiva dell'interprete. Tale "
"file è chiamato un *modulo*; le definizioni di un modulo possono essere "
"*importate* in altri moduli o nel *modulo principale* (la collezione di "
"variabili a cui hai accesso in uno script eseguito al livello superiore e in"
" modalità calcolatrice)."

#: tutorial/modules.rst:22
msgid ""
"A module is a file containing Python definitions and statements.  The file "
"name is the module name with the suffix :file:`.py` appended.  Within a "
"module, the module's name (as a string) is available as the value of the "
"global variable ``__name__``.  For instance, use your favorite text editor "
"to create a file called :file:`fibo.py` in the current directory with the "
"following contents::"
msgstr ""
"Un modulo è un file contenente definizioni e istruzioni Python. Il nome del "
"file è il nome del modulo con il suffisso :file:`.py` aggiunto. All'interno "
"di un modulo, il nome del modulo (come stringa) è disponibile come valore "
"della variabile globale ``__name__``. Ad esempio, usa il tuo editor di testo"
" preferito per creare un file chiamato :file:`fibo.py` nella directory "
"corrente con il seguente contenuto::"

#: tutorial/modules.rst:45
msgid ""
"Now enter the Python interpreter and import this module with the following "
"command::"
msgstr ""
"Ora entra nell'interprete Python e importa questo modulo con il seguente "
"comando::"

#: tutorial/modules.rst:50
msgid ""
"This does not add the names of the functions defined in ``fibo``  directly "
"to the current :term:`namespace` (see :ref:`tut-scopes` for more details); "
"it only adds the module name ``fibo`` there. Using the module name you can "
"access the functions::"
msgstr ""
"Questo non aggiunge i nomi delle funzioni definite in ``fibo`` direttamente "
"all'attuale :term:`namespace` (vedi :ref:`tut-scopes` per maggiori "
"dettagli); aggiunge solo il nome del modulo ``fibo`` lì. Utilizzando il nome"
" del modulo puoi accedere alle funzioni::"

#: tutorial/modules.rst:62
msgid ""
"If you intend to use a function often you can assign it to a local name::"
msgstr ""
"Se intendi usare una funzione spesso puoi assegnarla a un nome locale::"

#: tutorial/modules.rst:72
msgid "More on Modules"
msgstr "Più sui Moduli"

#: tutorial/modules.rst:74
msgid ""
"A module can contain executable statements as well as function definitions. "
"These statements are intended to initialize the module. They are executed "
"only the *first* time the module name is encountered in an import statement."
" [#]_ (They are also run if the file is executed as a script.)"
msgstr ""
"Un modulo può contenere istruzioni eseguibili così come definizioni di "
"funzioni. Queste istruzioni sono intese per inizializzare il modulo. Sono "
"eseguite solo la *prima* volta che il nome del modulo viene incontrato in "
"un'istruzione d'importazione. [#]_ (Sono anche eseguite se il file è "
"eseguito come script.)"

#: tutorial/modules.rst:79
msgid ""
"Each module has its own private namespace, which is used as the global "
"namespace by all functions defined in the module. Thus, the author of a "
"module can use global variables in the module without worrying about "
"accidental clashes with a user's global variables. On the other hand, if you"
" know what you are doing you can touch a module's global variables with the "
"same notation used to refer to its functions, ``modname.itemname``."
msgstr ""
"Ogni modulo ha il proprio namespace privato, che è utilizzato come il "
"namespace globale da tutte le funzioni definite nel modulo. Pertanto, "
"l'autore di un modulo può usare variabili globali nel modulo senza "
"preoccuparsi di collisioni accidentali con le variabili globali di un "
"utente. D'altra parte, se sai quello che stai facendo puoi toccare le "
"variabili globali di un modulo con la stessa notazione utilizzata per "
"riferirsi alle sue funzioni, ``modname.itemname``."

#: tutorial/modules.rst:86
msgid ""
"Modules can import other modules.  It is customary but not required to place"
" all :keyword:`import` statements at the beginning of a module (or script, "
"for that matter).  The imported module names, if placed at the top level of "
"a module (outside any functions or classes), are added to the module's "
"global namespace."
msgstr ""
"I moduli possono importare altri moduli. È consuetudine, ma non "
"obbligatorio, posizionare tutte le istruzioni :keyword:`import` all'inizio "
"di un modulo (o script, se è per questo). I nomi dei moduli importati, se "
"posizionati a livello superiore di un modulo (fuori da qualsiasi funzione o "
"classe), sono aggiunti al namespace globale del modulo."

#: tutorial/modules.rst:91
msgid ""
"There is a variant of the :keyword:`import` statement that imports names "
"from a module directly into the importing module's namespace.  For example::"
msgstr ""
"Esiste una variante dell'istruzione :keyword:`import` che importa nomi da un"
" modulo direttamente nel namespace del modulo importante. Ad esempio::"

#: tutorial/modules.rst:98
msgid ""
"This does not introduce the module name from which the imports are taken in "
"the local namespace (so in the example, ``fibo`` is not defined)."
msgstr ""
"Questo non introduce il nome del modulo da cui provengono le importazioni "
"nel namespace locale (quindi nell'esempio, ``fibo`` non è definito)."

#: tutorial/modules.rst:101
msgid "There is even a variant to import all names that a module defines::"
msgstr ""
"Esiste anche una variante per importare tutti i nomi che un modulo "
"definisce::"

#: tutorial/modules.rst:107
msgid ""
"This imports all names except those beginning with an underscore (``_``). In"
" most cases Python programmers do not use this facility since it introduces "
"an unknown set of names into the interpreter, possibly hiding some things "
"you have already defined."
msgstr ""
"Questo importa tutti i nomi eccetto quelli che iniziano con un underscore "
"(``_``). Nella maggior parte dei casi i programmatori Python non utilizzano "
"questa funzione poiché introduce un insieme sconosciuto di nomi "
"nell'interprete, nascondendo possibilmente alcune cose che hai già definito."

#: tutorial/modules.rst:112
msgid ""
"Note that in general the practice of importing ``*`` from a module or "
"package is frowned upon, since it often causes poorly readable code. "
"However, it is okay to use it to save typing in interactive sessions."
msgstr ""
"Nota che in generale la pratica di importare ``*`` da un modulo o pacchetto "
"è disapprovata, poiché spesso causa codice poco leggibile. Tuttavia, è "
"accettabile usarla per risparmiare battitura nelle sessioni interattive."

#: tutorial/modules.rst:116
msgid ""
"If the module name is followed by :keyword:`!as`, then the name following "
":keyword:`!as` is bound directly to the imported module."
msgstr ""
"Se il nome del modulo è seguito da :keyword:`!as`, allora il nome che segue "
":keyword:`!as` è legato direttamente al modulo importato."

#: tutorial/modules.rst:125
msgid ""
"This is effectively importing the module in the same way that ``import "
"fibo`` will do, with the only difference of it being available as ``fib``."
msgstr ""
"Questo importa effettivamente il modulo nello stesso modo in cui lo farebbe "
"``import fibo``, con l'unica differenza che sarà disponibile come ``fib``."

#: tutorial/modules.rst:128
msgid ""
"It can also be used when utilising :keyword:`from` with similar effects::"
msgstr ""
"Può anche essere utilizzato quando si utilizza :keyword:`from` con effetti "
"simili::"

#: tutorial/modules.rst:137
msgid ""
"For efficiency reasons, each module is only imported once per interpreter "
"session.  Therefore, if you change your modules, you must restart the "
"interpreter -- or, if it's just one module you want to test interactively, "
"use :func:`importlib.reload`, e.g. ``import importlib; "
"importlib.reload(modulename)``."
msgstr ""
"Per ragioni di efficienza, ogni modulo viene importato una sola volta per "
"sessione dell'interprete. Pertanto, se cambi i tuoi moduli, devi riavviare "
"l'interprete -- o, se è solo un modulo che vuoi testare interattivamente, "
"usa :func:`importlib.reload`, es. ``import importlib; "
"importlib.reload(modulename)``."

#: tutorial/modules.rst:147
msgid "Executing modules as scripts"
msgstr "Esecuzione di moduli come script"

#: tutorial/modules.rst:149
msgid "When you run a Python module with ::"
msgstr "Quando esegui un modulo Python con ::"

#: tutorial/modules.rst:153
msgid ""
"the code in the module will be executed, just as if you imported it, but "
"with the ``__name__`` set to ``\"__main__\"``.  That means that by adding "
"this code at the end of your module::"
msgstr ""
"il codice nel modulo sarà eseguito, proprio come se lo avessi importato, ma "
"con ``__name__`` impostato su ``\"__main__\"``. Ciò significa che "
"aggiungendo questo codice alla fine del tuo modulo::"

#: tutorial/modules.rst:161
msgid ""
"you can make the file usable as a script as well as an importable module, "
"because the code that parses the command line only runs if the module is "
"executed as the \"main\" file:"
msgstr ""
"puoi rendere il file utilizzabile sia come script che come modulo "
"importabile, poiché il codice che analizza la linea di comando viene "
"eseguito solo se il modulo è eseguito come file \"principale\":"

#: tutorial/modules.rst:170
msgid "If the module is imported, the code is not run::"
msgstr "Se il modulo è importato, il codice non viene eseguito::"

#: tutorial/modules.rst:175
msgid ""
"This is often used either to provide a convenient user interface to a "
"module, or for testing purposes (running the module as a script executes a "
"test suite)."
msgstr ""
"Questo è spesso usato sia per fornire un'interfaccia utente comoda a un "
"modulo, sia per scopi di test (eseguire il modulo come script esegue una "
"suite di test)."

#: tutorial/modules.rst:182
msgid "The Module Search Path"
msgstr "Il percorso di ricerca del modulo"

#: tutorial/modules.rst:186
msgid ""
"When a module named :mod:`!spam` is imported, the interpreter first searches"
" for a built-in module with that name. These module names are listed in "
":data:`sys.builtin_module_names`. If not found, it then searches for a file "
"named :file:`spam.py` in a list of directories given by the variable "
":data:`sys.path`.  :data:`sys.path` is initialized from these locations:"
msgstr ""
"Quando un modulo chiamato :mod:`!spam` è importato, l'interprete cerca prima"
" un modulo built-in con quel nome. Questi nomi di moduli sono elencati in "
":data:`sys.builtin_module_names`. Se non viene trovato, allora cerca un file"
" chiamato :file:`spam.py` in una lista di directory data dalla variabile "
":data:`sys.path`. :data:`sys.path` è inizializzata da queste posizioni:"

#: tutorial/modules.rst:192
msgid ""
"The directory containing the input script (or the current directory when no "
"file is specified)."
msgstr ""
"La directory contenente lo script di input (o la directory corrente quando "
"non è specificato alcun file)."

#: tutorial/modules.rst:194
msgid ""
":envvar:`PYTHONPATH` (a list of directory names, with the same syntax as the"
" shell variable :envvar:`PATH`)."
msgstr ""
":envvar:`PYTHONPATH` (una lista di nomi di directory, con la stessa sintassi"
" della variabile di shell :envvar:`PATH`)."

#: tutorial/modules.rst:196
msgid ""
"The installation-dependent default (by convention including a ``site-"
"packages`` directory, handled by the :mod:`site` module)."
msgstr ""
"Il valore predefinito dipendente dall'installazione (per convenzione include"
" una directory ``site-packages``, gestita dal modulo :mod:`site`)."

#: tutorial/modules.rst:199
msgid "More details are at :ref:`sys-path-init`."
msgstr "Maggiori dettagli sono disponibili in :ref:`sys-path-init`."

#: tutorial/modules.rst:202
msgid ""
"On file systems which support symlinks, the directory containing the input "
"script is calculated after the symlink is followed. In other words the "
"directory containing the symlink is **not** added to the module search path."
msgstr ""
"Su file system che supportano i collegamenti simbolici, la directory "
"contenente lo script di input viene calcolata dopo che il collegamento "
"simbolico è stato seguito. In altre parole la directory contenente il "
"collegamento simbolico **non** è aggiunta al percorso di ricerca del modulo."

#: tutorial/modules.rst:206
msgid ""
"After initialization, Python programs can modify :data:`sys.path`.  The "
"directory containing the script being run is placed at the beginning of the "
"search path, ahead of the standard library path. This means that scripts in "
"that directory will be loaded instead of modules of the same name in the "
"library directory. This is an error unless the replacement is intended.  See"
" section :ref:`tut-standardmodules` for more information."
msgstr ""
"Dopo l'inizializzazione, i programmi Python possono modificare "
":data:`sys.path`. La directory contenente lo script in esecuzione è "
"posizionata all'inizio del percorso di ricerca, davanti al percorso della "
"libreria standard. Ciò significa che gli script in quella directory saranno "
"caricati invece dei moduli con lo stesso nome nella directory della "
"libreria. Questo è un errore a meno che la sostituzione non sia "
"intenzionale. Vedi la sezione :ref:`tut-standardmodules` per maggiori "
"informazioni."

#: tutorial/modules.rst:219
msgid "\"Compiled\" Python files"
msgstr "File Python \"compilati\""

#: tutorial/modules.rst:221
msgid ""
"To speed up loading modules, Python caches the compiled version of each "
"module in the ``__pycache__`` directory under the name "
":file:`module.{version}.pyc`, where the version encodes the format of the "
"compiled file; it generally contains the Python version number.  For "
"example, in CPython release 3.3 the compiled version of spam.py would be "
"cached as ``__pycache__/spam.cpython-33.pyc``.  This naming convention "
"allows compiled modules from different releases and different versions of "
"Python to coexist."
msgstr ""
"Per velocizzare il caricamento dei moduli, Python memorizza nella cache la "
"versione compilata di ciascun modulo nella directory ``__pycache__`` sotto "
"il nome :file:`module.{version}.pyc`, dove la versione codifica il formato "
"del file compilato; contiene generalmente il numero di versione di Python. "
"Ad esempio, nella versione CPython 3.3, la versione compilata di spam.py "
"verrebbe memorizzata nella cache come ``__pycache__/spam.cpython-33.pyc``. "
"Questa convenzione di denominazione permette ai moduli compilati di versioni"
" diverse e rilasci diversi di Python di coesistere."

#: tutorial/modules.rst:229
msgid ""
"Python checks the modification date of the source against the compiled "
"version to see if it's out of date and needs to be recompiled.  This is a "
"completely automatic process.  Also, the compiled modules are platform-"
"independent, so the same library can be shared among systems with different "
"architectures."
msgstr ""
"Python controlla la data di modifica della sorgente rispetto alla versione "
"compilata per vedere se è obsoleta e deve essere ricompilata. Questo è un "
"processo completamente automatico. Inoltre, i moduli compilati sono "
"indipendenti dalla piattaforma, quindi la stessa libreria può essere "
"condivisa tra sistemi con diverse architetture."

#: tutorial/modules.rst:234
msgid ""
"Python does not check the cache in two circumstances.  First, it always "
"recompiles and does not store the result for the module that's loaded "
"directly from the command line.  Second, it does not check the cache if "
"there is no source module.  To support a non-source (compiled only) "
"distribution, the compiled module must be in the source directory, and there"
" must not be a source module."
msgstr ""
"Python non controlla la cache in due circostanze. Primo, ricompila sempre e "
"non memorizza il risultato per il modulo caricato direttamente dalla linea "
"di comando. Secondo, non controlla la cache se non esiste il modulo "
"sorgente. Per supportare una distribuzione senza sorgente (solo compilata), "
"il modulo compilato deve essere nella directory sorgente e non deve esserci "
"un modulo sorgente."

#: tutorial/modules.rst:241
msgid "Some tips for experts:"
msgstr "Alcuni consigli per esperti:"

#: tutorial/modules.rst:243
msgid ""
"You can use the :option:`-O` or :option:`-OO` switches on the Python command"
" to reduce the size of a compiled module.  The ``-O`` switch removes assert "
"statements, the ``-OO`` switch removes both assert statements and __doc__ "
"strings.  Since some programs may rely on having these available, you should"
" only use this option if you know what you're doing.  \"Optimized\" modules "
"have an ``opt-`` tag and are usually smaller.  Future releases may change "
"the effects of optimization."
msgstr ""
"Puoi usare le opzioni :option:`-O` o :option:`-OO` sul comando Python per "
"ridurre la dimensione di un modulo compilato. L'opzione ``-O`` rimuove le "
"istruzioni assert, l'opzione ``-OO`` rimuove sia le istruzioni assert che le"
" stringhe __doc__. Poiché alcuni programmi possono fare affidamento su "
"queste, dovresti usare questa opzione solo se sai quello che stai facendo. I"
" moduli \"ottimizzati\" hanno un tag ``opt-`` e sono solitamente più "
"piccoli. I futuri rilasci possono cambiare gli effetti dell'ottimizzazione."

#: tutorial/modules.rst:251
msgid ""
"A program doesn't run any faster when it is read from a ``.pyc`` file than "
"when it is read from a ``.py`` file; the only thing that's faster about "
"``.pyc`` files is the speed with which they are loaded."
msgstr ""
"Un programma non gira più velocemente quando è letto da un file ``.pyc`` "
"rispetto a quando è letto da un file ``.py``; l'unica cosa che è più veloce "
"nei file ``.pyc`` è la velocità con cui vengono caricati."

#: tutorial/modules.rst:255
msgid ""
"The module :mod:`compileall` can create .pyc files for all modules in a "
"directory."
msgstr ""
"Il modulo :mod:`compileall` può creare file .pyc per tutti i moduli in una "
"directory."

#: tutorial/modules.rst:258
msgid ""
"There is more detail on this process, including a flow chart of the "
"decisions, in :pep:`3147`."
msgstr ""
"Ci sono maggiori dettagli su questo processo, incluso un diagramma di flusso"
" delle decisioni, in :pep:`3147`."

#: tutorial/modules.rst:265
msgid "Standard Modules"
msgstr "Moduli Standard"

#: tutorial/modules.rst:269
msgid ""
"Python comes with a library of standard modules, described in a separate "
"document, the Python Library Reference (\"Library Reference\" hereafter).  "
"Some modules are built into the interpreter; these provide access to "
"operations that are not part of the core of the language but are "
"nevertheless built in, either for efficiency or to provide access to "
"operating system primitives such as system calls.  The set of such modules "
"is a configuration option which also depends on the underlying platform.  "
"For example, the :mod:`winreg` module is only provided on Windows systems. "
"One particular module deserves some attention: :mod:`sys`, which is built "
"into every Python interpreter.  The variables ``sys.ps1`` and ``sys.ps2`` "
"define the strings used as primary and secondary prompts::"
msgstr ""
"Python viene fornito con una libreria di moduli standard, descritta in un "
"documento separato, il Python Library Reference (\"Library Reference\" da "
"qui in avanti). Alcuni moduli sono incorporati nell'interprete; questi "
"forniscono accesso a operazioni che non fanno parte del core del linguaggio "
"ma sono comunque incorporate, sia per efficienza che per fornire accesso a "
"primitive del sistema operativo come le chiamate di sistema. Il set di tali "
"moduli è un'opzione di configurazione che dipende anche dalla piattaforma "
"sottostante. Ad esempio, il modulo :mod:`winreg` è fornito solo sui sistemi "
"Windows. Un particolare modulo merita attenzione: :mod:`sys`, che è "
"incorporato in ogni interprete Python. Le variabili ``sys.ps1`` e "
"``sys.ps2`` definiscono le stringhe usate come prompt primario e "
"secondario::"

#: tutorial/modules.rst:292
msgid ""
"These two variables are only defined if the interpreter is in interactive "
"mode."
msgstr ""
"Queste due variabili sono definite solo se l'interprete è in modalità "
"interattiva."

#: tutorial/modules.rst:294
msgid ""
"The variable ``sys.path`` is a list of strings that determines the "
"interpreter's search path for modules. It is initialized to a default path "
"taken from the environment variable :envvar:`PYTHONPATH`, or from a built-in"
" default if :envvar:`PYTHONPATH` is not set.  You can modify it using "
"standard list operations::"
msgstr ""
"La variabile ``sys.path`` è una lista di stringhe che determina il percorso "
"di ricerca dell'interprete per i moduli. È inizializzata a un percorso "
"predefinito preso dalla variabile di ambiente :envvar:`PYTHONPATH`, o da un "
"predefinito incorporato se :envvar:`PYTHONPATH` non è impostato. Puoi "
"modificarla usando le operazioni standard delle liste::"

#: tutorial/modules.rst:307
msgid "The :func:`dir` Function"
msgstr "La funzione :func:`dir`"

#: tutorial/modules.rst:309
msgid ""
"The built-in function :func:`dir` is used to find out which names a module "
"defines.  It returns a sorted list of strings::"
msgstr ""
"La funzione built-in :func:`dir` è usata per scoprire quali nomi definisce "
"un modulo. Restituisce una lista ordinata di stringhe::"

#: tutorial/modules.rst:338
msgid ""
"Without arguments, :func:`dir` lists the names you have defined currently::"
msgstr ""
"Senza argomenti, :func:`dir` elenca i nomi che hai definito attualmente::"

#: tutorial/modules.rst:346
msgid ""
"Note that it lists all types of names: variables, modules, functions, etc."
msgstr ""
"Nota che elenca tutti i tipi di nomi: variabili, moduli, funzioni, ecc."

#: tutorial/modules.rst:350
msgid ""
":func:`dir` does not list the names of built-in functions and variables.  If"
" you want a list of those, they are defined in the standard module "
":mod:`builtins`::"
msgstr ""
":func:`dir` non elenca i nomi delle funzioni e variabili built-in. Se vuoi "
"una lista di questi, sono definiti nel modulo standard :mod:`builtins`::"

#: tutorial/modules.rst:389
msgid "Packages"
msgstr "Pacchetti"

#: tutorial/modules.rst:391
msgid ""
"Packages are a way of structuring Python's module namespace by using "
"\"dotted module names\".  For example, the module name :mod:`!A.B` "
"designates a submodule named ``B`` in a package named ``A``.  Just like the "
"use of modules saves the authors of different modules from having to worry "
"about each other's global variable names, the use of dotted module names "
"saves the authors of multi-module packages like NumPy or Pillow from having "
"to worry about each other's module names."
msgstr ""
"I pacchetti sono un modo di strutturare il namespace dei moduli di Python "
"usando \"nomi di moduli puntati\". Ad esempio, il nome del modulo "
":mod:`!A.B` designa un sottomodulo chiamato ``B`` in un pacchetto chiamato "
"``A``. Proprio come l'uso dei moduli salva gli autori di diversi moduli dal "
"preoccuparsi dei nomi delle variabili globali degli altri, l'uso dei nomi di"
" moduli puntati salva gli autori di pacchetti multi-modulo come NumPy o "
"Pillow dal preoccuparsi dei nomi dei moduli degli altri."

#: tutorial/modules.rst:399
msgid ""
"Suppose you want to design a collection of modules (a \"package\") for the "
"uniform handling of sound files and sound data.  There are many different "
"sound file formats (usually recognized by their extension, for example: "
":file:`.wav`, :file:`.aiff`, :file:`.au`), so you may need to create and "
"maintain a growing collection of modules for the conversion between the "
"various file formats. There are also many different operations you might "
"want to perform on sound data (such as mixing, adding echo, applying an "
"equalizer function, creating an artificial stereo effect), so in addition "
"you will be writing a never-ending stream of modules to perform these "
"operations.  Here's a possible structure for your package (expressed in "
"terms of a hierarchical filesystem):"
msgstr ""
"Supponiamo che tu voglia progettare una collezione di moduli (un "
"\"pacchetto\") per la gestione uniforme dei file audio e dei dati audio. Ci "
"sono molti formati di file audio diversi (di solito riconosciuti dalla loro "
"estensione, ad esempio: :file:`.wav`, :file:`.aiff`, :file:`.au`), quindi "
"potresti aver bisogno di creare e mantenere una collezione crescente di "
"moduli per la conversione tra i vari formati di file. Ci sono anche molte "
"operazioni diverse che potresti voler eseguire sui dati audio (come il "
"mixaggio, l'aggiunta di eco, l'applicazione di una funzione equalizzatrice, "
"la creazione di un effetto stereo artificiale), quindi, in aggiunta, "
"scriverai una serie interminabile di moduli per eseguire queste operazioni. "
"Ecco una possibile struttura per il tuo pacchetto (espressa in termini di "
"filesystem gerarchico):"

#: tutorial/modules.rst:436
msgid ""
"When importing the package, Python searches through the directories on "
"``sys.path`` looking for the package subdirectory."
msgstr ""
"Quando importa il pacchetto, Python cerca nelle directory su ``sys.path`` "
"cercando la sottodirectory del pacchetto."

#: tutorial/modules.rst:439
msgid ""
"The :file:`__init__.py` files are required to make Python treat directories "
"containing the file as packages (unless using a :term:`namespace package`, a"
" relatively advanced feature). This prevents directories with a common name,"
" such as ``string``, from unintentionally hiding valid modules that occur "
"later on the module search path. In the simplest case, :file:`__init__.py` "
"can just be an empty file, but it can also execute initialization code for "
"the package or set the ``__all__`` variable, described later."
msgstr ""
"I file :file:`__init__.py` sono richiesti per fare in modo che Python tratti"
" le directory contenenti il file come pacchetti (a meno che non si utilizzi "
"un :term:`namespace package`, una funzionalità relativamente avanzata). "
"Questo impedisce alle directory con un nome comune, come ``string``, di "
"nascondere inavvertitamente moduli validi che si trovano più avanti nel "
"percorso di ricerca del modulo. Nel caso più semplice, :file:`__init__.py` "
"può essere solo un file vuoto, ma può anche eseguire codice di "
"inizializzazione per il pacchetto o impostare la variabile ``__all__``, "
"descritta più avanti."

#: tutorial/modules.rst:447
msgid ""
"Users of the package can import individual modules from the package, for "
"example::"
msgstr ""
"Gli utenti del pacchetto possono importare moduli individuali dal pacchetto,"
" ad esempio::"

#: tutorial/modules.rst:452
msgid ""
"This loads the submodule :mod:`!sound.effects.echo`.  It must be referenced "
"with its full name. ::"
msgstr ""
"Questo carica il sottomodulo :mod:`!sound.effects.echo`. Deve essere "
"referenziato con il suo nome completo.::"

#: tutorial/modules.rst:457
msgid "An alternative way of importing the submodule is::"
msgstr "Un modo alternativo di importare il sottomodulo è::"

#: tutorial/modules.rst:461
msgid ""
"This also loads the submodule :mod:`!echo`, and makes it available without "
"its package prefix, so it can be used as follows::"
msgstr ""
"Questo carica anche il sottomodulo :mod:`!echo`, e lo rende disponibile "
"senza il prefisso del pacchetto, quindi può essere usato come segue::"

#: tutorial/modules.rst:466
msgid ""
"Yet another variation is to import the desired function or variable "
"directly::"
msgstr ""
"Un'ulteriore variazione è importare direttamente la funzione o la variabile "
"desiderata::"

#: tutorial/modules.rst:470
msgid ""
"Again, this loads the submodule :mod:`!echo`, but this makes its function "
":func:`!echofilter` directly available::"
msgstr ""
"Ancora una volta, questo carica il sottomodulo :mod:`!echo`, ma rende "
"direttamente disponibile la sua funzione :func:`!echofilter`::"

#: tutorial/modules.rst:475
msgid ""
"Note that when using ``from package import item``, the item can be either a "
"submodule (or subpackage) of the package, or some  other name defined in the"
" package, like a function, class or variable.  The ``import`` statement "
"first tests whether the item is defined in the package; if not, it assumes "
"it is a module and attempts to load it.  If it fails to find it, an "
":exc:`ImportError` exception is raised."
msgstr ""
"Nota che quando usi ``from package import item``, l'elemento può essere un "
"sottomodulo (o sottopacchetto) del pacchetto, o qualche altro nome definito "
"nel pacchetto, come una funzione, classe o variabile. L'istruzione "
"``import`` testa prima se l'elemento è definito nel pacchetto; se non lo è, "
"assume che sia un modulo e tenta di caricarlo. Se non riesce a trovarlo, "
"viene sollevata un'eccezione :exc:`ImportError`."

#: tutorial/modules.rst:482
msgid ""
"Contrarily, when using syntax like ``import item.subitem.subsubitem``, each "
"item except for the last must be a package; the last item can be a module or"
" a package but can't be a class or function or variable defined in the "
"previous item."
msgstr ""
"Al contrario, quando usi una sintassi come ``import "
"item.subitem.subsubitem``, ciascun elemento tranne l'ultimo deve essere un "
"pacchetto; l'ultimo elemento può essere un modulo o un pacchetto ma non può "
"essere una classe, funzione o variabile definita nell'elemento precedente."

#: tutorial/modules.rst:491
msgid "Importing \\* From a Package"
msgstr "Importare \\* Da un Pacchetto"

#: tutorial/modules.rst:495
msgid ""
"Now what happens when the user writes ``from sound.effects import *``?  "
"Ideally, one would hope that this somehow goes out to the filesystem, finds "
"which submodules are present in the package, and imports them all.  This "
"could take a long time and importing sub-modules might have unwanted side-"
"effects that should only happen when the sub-module is explicitly imported."
msgstr ""
"Ora cosa succede quando l'utente scrive ``from sound.effects import *``? "
"Idealmente, si spera che questo vada in qualche modo nel filesystem, trovi "
"quali sottomoduli sono presenti nel pacchetto e li importi tutti. Questo "
"potrebbe richiedere molto tempo e l'importazione di sottomoduli potrebbe "
"avere effetti collaterali indesiderati che dovrebbero accadere solo quando "
"il sottomodulo viene importato esplicitamente."

#: tutorial/modules.rst:501
msgid ""
"The only solution is for the package author to provide an explicit index of "
"the package.  The :keyword:`import` statement uses the following convention:"
" if a package's :file:`__init__.py` code defines a list named ``__all__``, "
"it is taken to be the list of module names that should be imported when "
"``from package import *`` is encountered.  It is up to the package author to"
" keep this list up-to-date when a new version of the package is released.  "
"Package authors may also decide not to support it, if they don't see a use "
"for importing \\* from their package.  For example, the file "
":file:`sound/effects/__init__.py` could contain the following code::"
msgstr ""
"L'unica soluzione è che l'autore del pacchetto fornisca un indice esplicito "
"del pacchetto. L'istruzione :keyword:`import` utilizza la seguente "
"convenzione: se il codice di :file:`__init__.py` di un pacchetto definisce "
"una lista denominata ``__all__``, essa è considerata la lista dei nomi dei "
"moduli che dovrebbero essere importati quando si incontra ``from package "
"import *``. È compito dell'autore del pacchetto mantenere aggiornata questa "
"lista quando viene rilasciata una nuova versione del pacchetto. Gli autori "
"dei pacchetti possono anche decidere di non supportarla, se non vedono "
"un'utilità per l'importazione \\* dal loro pacchetto. Ad esempio, il file "
":file:`sound/effects/__init__.py` potrebbe contenere il seguente codice::"

#: tutorial/modules.rst:513
msgid ""
"This would mean that ``from sound.effects import *`` would import the three "
"named submodules of the :mod:`!sound.effects` package."
msgstr ""
"Questo significherebbe che ``from sound.effects import *`` importerebbe i "
"tre sottomoduli denominati del pacchetto :mod:`!sound.effects`."

#: tutorial/modules.rst:516
msgid ""
"Be aware that submodules might become shadowed by locally defined names. For"
" example, if you added a ``reverse`` function to the "
":file:`sound/effects/__init__.py` file, the ``from sound.effects import *`` "
"would only import the two submodules ``echo`` and ``surround``, but *not* "
"the ``reverse`` submodule, because it is shadowed by the locally defined "
"``reverse`` function::"
msgstr ""
"Tieni presente che i sottomoduli potrebbero essere ombreggiati da nomi "
"definiti localmente. Ad esempio, se aggiungi una funzione ``reverse`` al "
"file :file:`sound/effects/__init__.py`, ``from sound.effects import *`` "
"importerebbe solo i due sottomoduli ``echo`` e ``surround``, ma *non* il "
"sottomodulo ``reverse``, perché è oscurato dalla funzione ``reverse`` "
"definita localmente.::"

#: tutorial/modules.rst:532
msgid ""
"If ``__all__`` is not defined, the statement ``from sound.effects import *``"
" does *not* import all submodules from the package :mod:`!sound.effects` "
"into the current namespace; it only ensures that the package "
":mod:`!sound.effects` has been imported (possibly running any initialization"
" code in :file:`__init__.py`) and then imports whatever names are defined in"
" the package.  This includes any names defined (and submodules explicitly "
"loaded) by :file:`__init__.py`.  It also includes any submodules of the "
"package that were explicitly loaded by previous :keyword:`import` "
"statements.  Consider this code::"
msgstr ""
"Se ``__all__`` non è definito, l'istruzione ``from sound.effects import *`` "
"*non* importa tutti i sottomoduli del pacchetto :mod:`!sound.effects` nello "
"spazio dei nomi corrente; si limita ad assicurare che il pacchetto "
":mod:`!sound.effects` sia stato importato (eventualmente eseguendo qualsiasi"
" codice di inizializzazione in :file:`__init__.py`) e quindi importa solo i "
"nomi definiti nel pacchetto. Questo include qualsiasi nome definito (e "
"sottomoduli esplicitamente caricati) nel file :file:`__init__.py`. Include "
"anche eventuali sottomoduli del pacchetto che sono stati esplicitamente "
"caricati da precedenti istruzioni di :keyword:`import`. Considera questo "
"codice::"

#: tutorial/modules.rst:545
msgid ""
"In this example, the :mod:`!echo` and :mod:`!surround` modules are imported "
"in the current namespace because they are defined in the "
":mod:`!sound.effects` package when the ``from...import`` statement is "
"executed.  (This also works when ``__all__`` is defined.)"
msgstr ""
"In questo esempio, i moduli :mod:`!echo` e :mod:`!surround` sono importati "
"nello spazio dei nomi corrente perché sono definiti nel pacchetto "
":mod:`!sound.effects` quando viene eseguita l'istruzione ``from...import``. "
"(Questo funziona anche quando è definito ``__all__``.)"

#: tutorial/modules.rst:550
msgid ""
"Although certain modules are designed to export only names that follow "
"certain patterns when you use ``import *``, it is still considered bad "
"practice in production code."
msgstr ""
"Sebbene certi moduli siano progettati per esportare solo nomi che seguono "
"certi schemi quando usi ``import *``, è comunque considerata una cattiva "
"pratica nel codice di produzione."

#: tutorial/modules.rst:554
msgid ""
"Remember, there is nothing wrong with using ``from package import "
"specific_submodule``!  In fact, this is the recommended notation unless the "
"importing module needs to use submodules with the same name from different "
"packages."
msgstr ""
"Ricorda, non c'è nulla di sbagliato nell'usare ``from package import "
"specific_submodule``! Infatti, questa è la notazione raccomandata a meno che"
" il modulo importante non debba usare sottomoduli con lo stesso nome da "
"pacchetti differenti."

#: tutorial/modules.rst:563
msgid "Intra-package References"
msgstr "Riferimenti Intra-pacchetto"

#: tutorial/modules.rst:565
msgid ""
"When packages are structured into subpackages (as with the :mod:`!sound` "
"package in the example), you can use absolute imports to refer to submodules"
" of siblings packages.  For example, if the module "
":mod:`!sound.filters.vocoder` needs to use the :mod:`!echo` module in the "
":mod:`!sound.effects` package, it can use ``from sound.effects import "
"echo``."
msgstr ""
"Quando i pacchetti sono strutturati in sottopacchetti (come il pacchetto "
":mod:`!sound` nell'esempio), puoi usare importazioni assolute per riferirti "
"a sottomoduli di pacchetti fratelli. Ad esempio, se il modulo "
":mod:`!sound.filters.vocoder` deve utilizzare il modulo :mod:`!echo` nel "
"pacchetto :mod:`!sound.effects`, può usare ``from sound.effects import "
"echo``."

#: tutorial/modules.rst:571
msgid ""
"You can also write relative imports, with the ``from module import name`` "
"form of import statement.  These imports use leading dots to indicate the "
"current and parent packages involved in the relative import.  From the "
":mod:`!surround` module for example, you might use::"
msgstr ""
"Puoi anche scrivere importazioni relative, con la forma dell'istruzione di "
"importazione ``from module import name``. Queste importazioni utilizzano "
"punti di testa per indicare i pacchetti corrente e genitore coinvolti "
"nell'importazione relativa. Dal modulo :mod:`!surround`, ad esempio, "
"potresti usare::"

#: tutorial/modules.rst:580
msgid ""
"Note that relative imports are based on the name of the current module.  "
"Since the name of the main module is always ``\"__main__\"``, modules "
"intended for use as the main module of a Python application must always use "
"absolute imports."
msgstr ""
"Nota che le importazioni relative si basano sul nome del modulo corrente. "
"Poiché il nome del modulo principale è sempre ``\"__main__\"``, i moduli "
"destinati all'uso come modulo principale di un'applicazione Python devono "
"sempre usare importazioni assolute."

#: tutorial/modules.rst:586
msgid "Packages in Multiple Directories"
msgstr "Pacchetti in Directory Multiple"

#: tutorial/modules.rst:588
msgid ""
"Packages support one more special attribute, :attr:`__path__`.  This is "
"initialized to be a list containing the name of the directory holding the "
"package's :file:`__init__.py` before the code in that file is executed.  "
"This variable can be modified; doing so affects future searches for modules "
"and subpackages contained in the package."
msgstr ""
"I pacchetti supportano un altro attributo speciale, :attr:`__path__`. Questo"
" è inizializzato per essere una lista contenente il nome della directory che"
" contiene il :file:`__init__.py` prima che il codice in quel file venga "
"eseguito. Questa variabile può essere modificata; farlo influenza le "
"ricerche future per moduli e sottopacchetti contenuti nel pacchetto."

#: tutorial/modules.rst:594
msgid ""
"While this feature is not often needed, it can be used to extend the set of "
"modules found in a package."
msgstr ""
"Sebbene questa funzione non sia spesso necessaria, può essere utilizzata per"
" estendere il set di moduli trovati in un pacchetto."

#: tutorial/modules.rst:599
msgid "Footnotes"
msgstr "Note"

#: tutorial/modules.rst:600
msgid ""
"In fact function definitions are also 'statements' that are 'executed'; the "
"execution of a module-level function definition adds the function name to "
"the module's global namespace."
msgstr ""
"In realtà anche le definizioni di funzione sono 'istruzioni' che vengono "
"'eseguite'; l'esecuzione di una definizione di funzione a livello di modulo "
"aggiunge il nome della funzione allo spazio dei nomi globale del modulo."

#: tutorial/modules.rst:267 tutorial/modules.rst:348
msgid "module"
msgstr "modulo"

#: tutorial/modules.rst:184
msgid "search"
msgstr "cerca"

#: tutorial/modules.rst:184
msgid "path"
msgstr "percorso"

#: tutorial/modules.rst:267
msgid "sys"
msgstr "sys"

#: tutorial/modules.rst:348
msgid "builtins"
msgstr "builtins"

#: tutorial/modules.rst:493
msgid "__all__"
msgstr "__all__"