python-docs-it/tutorial/modules.po at 3.12 · python/python-docs-it

910 lines (821 loc) · 42 KB
# 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.
"Project-Id-Version: Python 3.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-06-01 22:23+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
"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."
"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
"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)."
"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
"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::"
"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
"Now enter the Python interpreter and import this module with the following "
"command::"
"Ora entra nell'interprete Python e importa questo modulo con il seguente "
"comando::"
#: tutorial/modules.rst:50
"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::"
"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
"If you intend to use a function often you can assign it to a local name::"
"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
"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.)"
"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
"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``."
"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
"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."
"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
"There is a variant of the :keyword:`import` statement that imports names "
"from a module directly into the importing module's namespace.  For example::"
"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
"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)."
"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::"
"Esiste anche una variante per importare tutti i nomi che un modulo "
"definisce::"
#: tutorial/modules.rst:107
"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."
"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
"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."
"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
"If the module name is followed by :keyword:`!as`, then the name following :"
"keyword:`!as` is bound directly to the imported module."
"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
"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``."
"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
"It can also be used when utilising :keyword:`from` with similar effects::"
"Può anche essere utilizzato quando si utilizza :keyword:`from` con effetti "
#: tutorial/modules.rst:137
"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)``."
"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
"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::"
"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
"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:"
"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
"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)."
"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
"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:"
"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
"The directory containing the input script (or the current directory when no "
"file is specified)."
"La directory contenente lo script di input (o la directory corrente quando "
"non è specificato alcun file)."
#: tutorial/modules.rst:194
":envvar:`PYTHONPATH` (a list of directory names, with the same syntax as the "
"shell variable :envvar:`PATH`)."
":envvar:`PYTHONPATH` (una lista di nomi di directory, con la stessa sintassi "
"della variabile di shell :envvar:`PATH`)."
#: tutorial/modules.rst:196
"The installation-dependent default (by convention including a ``site-"
"packages`` directory, handled by the :mod:`site` module)."
"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
"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."
"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
"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."
"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
"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."
"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
"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."
"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
"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."
"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
"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."
"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
"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."
"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
"The module :mod:`compileall` can create .pyc files for all modules in a "
"directory."
"Il modulo :mod:`compileall` può creare file .pyc per tutti i moduli in una "
"directory."
#: tutorial/modules.rst:258
"There is more detail on this process, including a flow chart of the "
"decisions, in :pep:`3147`."
"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
"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::"
"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
"These two variables are only defined if the interpreter is in interactive "
"Queste due variabili sono definite solo se l'interprete è in modalità "
"interattiva."
#: tutorial/modules.rst:294
"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::"
"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
"The built-in function :func:`dir` is used to find out which names a module "
"defines.  It returns a sorted list of strings::"
"La funzione built-in :func:`dir` è usata per scoprire quali nomi definisce "
"un modulo. Restituisce una lista ordinata di stringhe::"
#: tutorial/modules.rst:338
"Without arguments, :func:`dir` lists the names you have defined currently::"
"Senza argomenti, :func:`dir` elenca i nomi che hai definito attualmente::"
#: tutorial/modules.rst:346
"Note that it lists all types of names: variables, modules, functions, etc."
"Nota che elenca tutti i tipi di nomi: variabili, moduli, funzioni, ecc."
#: tutorial/modules.rst:350
":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`::"
":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
"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."
"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
"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):"
"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
"When importing the package, Python searches through the directories on ``sys."
"path`` looking for the package subdirectory."
"Quando importa il pacchetto, Python cerca nelle directory su ``sys.path`` "
"cercando la sottodirectory del pacchetto."
#: tutorial/modules.rst:439
"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."
"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
"Users of the package can import individual modules from the package, for "
"example::"
"Gli utenti del pacchetto possono importare moduli individuali dal pacchetto, "
"ad esempio::"
#: tutorial/modules.rst:452
"This loads the submodule :mod:`!sound.effects.echo`.  It must be referenced "
"with its full name. ::"
"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
"This also loads the submodule :mod:`!echo`, and makes it available without "
"its package prefix, so it can be used as follows::"
"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
"Yet another variation is to import the desired function or variable "
"directly::"
"Un'ulteriore variazione è importare direttamente la funzione o la variabile "
"desiderata::"
#: tutorial/modules.rst:470
"Again, this loads the submodule :mod:`!echo`, but this makes its function :"
"func:`!echofilter` directly available::"
"Ancora una volta, questo carica il sottomodulo :mod:`!echo`, ma rende "
"direttamente disponibile la sua funzione :func:`!echofilter`::"
#: tutorial/modules.rst:475
"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."
"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
"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."
"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
"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."
"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
"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::"
"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
"This would mean that ``from sound.effects import *`` would import the three "
"named submodules of the :mod:`!sound.effects` package."
"Questo significherebbe che ``from sound.effects import *`` importerebbe i "
"tre sottomoduli denominati del pacchetto :mod:`!sound.effects`."
#: tutorial/modules.rst:516
"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::"
"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
"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::"
"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 "
#: tutorial/modules.rst:545
"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.)"
"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
"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."
"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
"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."
"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
"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``."
"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
"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::"
"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
"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."
"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
"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."
"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
"While this feature is not often needed, it can be used to extend the set of "
"modules found in a package."
"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
"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."
"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__"
Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Uh oh!

FilesExpand file tree

modules.po

Latest commit

History

modules.po

File metadata and controls
