# 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-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/inputoutput.rst:5
msgid "Input and Output"
msgstr "Input e Output"

#: tutorial/inputoutput.rst:7
msgid ""
"There are several ways to present the output of a program; data can be "
"printed in a human-readable form, or written to a file for future use. This "
"chapter will discuss some of the possibilities."
msgstr ""
"Ci sono diversi modi per presentare l'output di un programma; i dati possono "
"essere stampati in una forma leggibile dall'uomo o scritti in un file per un "
"uso futuro. Questo capitolo discuterà alcune delle possibilità."

#: tutorial/inputoutput.rst:15
msgid "Fancier Output Formatting"
msgstr "Formattazione Avanzata dell'Output"

#: tutorial/inputoutput.rst:17
msgid ""
"So far we've encountered two ways of writing values: *expression statements* "
"and the :func:`print` function.  (A third way is using the :meth:`~io."
"TextIOBase.write` method of file objects; the standard output file can be "
"referenced as ``sys.stdout``. See the Library Reference for more information "
"on this.)"
msgstr ""
"Finora abbiamo incontrato due modi di scrivere valori: *espressioni* e la "
"funzione :func:`print`. (Un terzo modo è utilizzare il metodo :meth:`~io."
"TextIOBase.write` degli oggetti file; il file di output standard può essere "
"referenziato come ``sys.stdout``. Vedi la Libreria di Riferimento per "
"ulteriori informazioni a riguardo.)"

#: tutorial/inputoutput.rst:22
msgid ""
"Often you'll want more control over the formatting of your output than "
"simply printing space-separated values. There are several ways to format "
"output."
msgstr ""
"Spesso desidererai avere più controllo sulla formattazione del tuo output "
"rispetto al semplice stampare valori separati da spazi. Ci sono diversi modi "
"per formattare l'output."

#: tutorial/inputoutput.rst:25
msgid ""
"To use :ref:`formatted string literals <tut-f-strings>`, begin a string with "
"``f`` or ``F`` before the opening quotation mark or triple quotation mark. "
"Inside this string, you can write a Python expression between ``{`` and ``}"
"`` characters that can refer to variables or literal values."
msgstr ""
"Per usare :ref:`formatted string literals <tut-f-strings>`, inizia una "
"stringa con ``f`` o ``F`` prima del segno di apertura della virgoletta o "
"della tripla virgoletta. Dentro questa stringa, puoi scrivere un'espressione "
"Python tra i caratteri ``{`` e ``}``, che possono riferirsi a variabili o "
"valori letterali."

#: tutorial/inputoutput.rst:37
msgid ""
"The :meth:`str.format` method of strings requires more manual effort.  "
"You'll still use ``{`` and ``}`` to mark where a variable will be "
"substituted and can provide detailed formatting directives, but you'll also "
"need to provide the information to be formatted. In the following code block "
"there are two examples of how to format variables:"
msgstr ""
"Il metodo :meth:`str.format` delle stringhe richiede più sforzo manuale. "
"Utilizzerai comunque ``{`` e ``}`` per indicare dove una variabile sarà "
"sostituita e potrai fornire direttive di formattazione dettagliate, ma "
"dovrai anche fornire le informazioni da formattare. Nel blocco di codice "
"seguente ci sono due esempi di come formattare variabili:"

#: tutorial/inputoutput.rst:52
msgid ""
"Notice how the ``yes_votes`` are padded with spaces and a negative sign only "
"for negative numbers. The example also prints ``percentage`` multiplied by "
"100, with 2 decimal places and followed by a percent sign (see :ref:"
"`formatspec` for details)."
msgstr ""
"Nota come i ``yes_votes`` sono riempiti con spazi e con un segno negativo "
"solo per i numeri negativi. L'esempio stampa anche ``percentage`` "
"moltiplicato per 100, con 2 cifre decimali e seguito da un segno di "
"percentuale (vedi :ref:`formatspec` per i dettagli)."

#: tutorial/inputoutput.rst:57
msgid ""
"Finally, you can do all the string handling yourself by using string slicing "
"and concatenation operations to create any layout you can imagine.  The "
"string type has some methods that perform useful operations for padding "
"strings to a given column width."
msgstr ""
"Infine, puoi gestire tutte le stringhe da solo usando operazioni di slicing "
"e concatenazione per creare qualsiasi layout tu possa immaginare. Il tipo "
"stringa ha alcuni metodi che eseguono operazioni utili per riempire le "
"stringhe a una determinata larghezza di colonna."

#: tutorial/inputoutput.rst:62
msgid ""
"When you don't need fancy output but just want a quick display of some "
"variables for debugging purposes, you can convert any value to a string with "
"the :func:`repr` or :func:`str` functions."
msgstr ""
"Quando non hai bisogno di un output sofisticato ma vuoi solo una rapida "
"visualizzazione di alcune variabili per scopi di debug, puoi convertire "
"qualsiasi valore in una stringa con le funzioni :func:`repr` o :func:`str`."

#: tutorial/inputoutput.rst:66
msgid ""
"The :func:`str` function is meant to return representations of values which "
"are fairly human-readable, while :func:`repr` is meant to generate "
"representations which can be read by the interpreter (or will force a :exc:"
"`SyntaxError` if there is no equivalent syntax).  For objects which don't "
"have a particular representation for human consumption, :func:`str` will "
"return the same value as :func:`repr`.  Many values, such as numbers or "
"structures like lists and dictionaries, have the same representation using "
"either function.  Strings, in particular, have two distinct representations."
msgstr ""
"La funzione :func:`str` è pensata per restituire rappresentazioni di valori "
"che siano abbastanza leggibili, mentre :func:`repr` è pensata per generare "
"rappresentazioni che possono essere lette dall'interprete (o genererà una :"
"exc:`SyntaxError` se non esiste una sintassi equivalente). Per oggetti che "
"non hanno una particolare rappresentazione per il consumo umano, :func:`str` "
"restituirà lo stesso valore di :func:`repr`. Molti valori, come i numeri o "
"strutture come liste e dizionari, hanno la stessa rappresentazione usando "
"entrambe le funzioni. Le stringhe, in particolare, hanno due "
"rappresentazioni distinte."

#: tutorial/inputoutput.rst:75
msgid "Some examples::"
msgstr "Alcuni esempi::"

#: tutorial/inputoutput.rst:98
msgid ""
"The :mod:`string` module contains a :class:`~string.Template` class that "
"offers yet another way to substitute values into strings, using placeholders "
"like ``$x`` and replacing them with values from a dictionary, but offers "
"much less control of the formatting."
msgstr ""
"Il modulo :mod:`string` contiene una classe :class:`~string.Template` che "
"offre un altro modo per sostituire valori nelle stringhe, utilizzando "
"segnaposti come ``$x`` e sostituendoli con valori da un dizionario, ma offre "
"un controllo molto minore sulla formattazione."

#: tutorial/inputoutput.rst:107
msgid "Formatted String Literals"
msgstr "Stringhe Formattate Letterali"

#: tutorial/inputoutput.rst:109
msgid ""
":ref:`Formatted string literals <f-strings>` (also called f-strings for "
"short) let you include the value of Python expressions inside a string by "
"prefixing the string with ``f`` or ``F`` and writing expressions as "
"``{expression}``."
msgstr ""
":ref:`Formatted string literals <f-strings>` (anche dette f-strings per "
"brevità) ti permettono di includere il valore di espressioni Python "
"all'interno di una stringa, prefissando la stringa con ``f`` o ``F`` e "
"scrivendo espressioni come ``{expression}``."

#: tutorial/inputoutput.rst:114
msgid ""
"An optional format specifier can follow the expression. This allows greater "
"control over how the value is formatted. The following example rounds pi to "
"three places after the decimal::"
msgstr ""
"Uno specificatore di formato opzionale può seguire l'espressione. Questo "
"permette un maggiore controllo su come il valore viene formattato. Il "
"seguente esempio arrotonda pi a tre cifre decimali::"

#: tutorial/inputoutput.rst:122
msgid ""
"Passing an integer after the ``':'`` will cause that field to be a minimum "
"number of characters wide.  This is useful for making columns line up. ::"
msgstr ""
"Passare un intero dopo ``':'`` farà sì che quel campo abbia una larghezza "
"minima di un certo numero di caratteri. Questo è utile per allineare le "
"colonne. ::"

#: tutorial/inputoutput.rst:133
msgid ""
"Other modifiers can be used to convert the value before it is formatted. ``'!"
"a'`` applies :func:`ascii`, ``'!s'`` applies :func:`str`, and ``'!r'`` "
"applies :func:`repr`::"
msgstr ""
"Possono essere usati altri modificatori per convertire il valore prima che "
"venga formattato. ``'!a'`` applica :func:`ascii`, ``'!s'`` applica :func:"
"`str`, e ``'!r'`` applica :func:`repr`::"

#: tutorial/inputoutput.rst:143
msgid ""
"The ``=`` specifier can be used to expand an expression to the text of the "
"expression, an equal sign, then the representation of the evaluated "
"expression:"
msgstr ""
"Lo specificatore ``=`` può essere usato per espandere un'espressione al "
"testo dell'espressione, un segno di uguale e poi la rappresentazione "
"dell'espressione valutata:"

#: tutorial/inputoutput.rst:152
msgid ""
"See :ref:`self-documenting expressions <bpo-36817-whatsnew>` for more "
"information on the ``=`` specifier. For a reference on these format "
"specifications, see the reference guide for the :ref:`formatspec`."
msgstr ""
"Vedi :ref:`self-documenting expressions <bpo-36817-whatsnew>` per maggiori "
"informazioni sullo specificatore ``=``. Per un riferimento su queste "
"specifiche di formato, consulta la guida di riferimento per :ref:"
"`formatspec`."

#: tutorial/inputoutput.rst:159
msgid "The String format() Method"
msgstr "Il Metodo String format()"

#: tutorial/inputoutput.rst:161
msgid "Basic usage of the :meth:`str.format` method looks like this::"
msgstr "L'uso di base del metodo :meth:`str.format` sembra così::"

#: tutorial/inputoutput.rst:166
msgid ""
"The brackets and characters within them (called format fields) are replaced "
"with the objects passed into the :meth:`str.format` method.  A number in the "
"brackets can be used to refer to the position of the object passed into the :"
"meth:`str.format` method. ::"
msgstr ""
"Le parentesi e i caratteri al loro interno (chiamati campi di formato) sono "
"sostituiti dagli oggetti passati nel metodo :meth:`str.format`. Un numero "
"nelle parentesi può essere usato per riferirsi alla posizione dell'oggetto "
"passato nel metodo :meth:`str.format`. ::"

#: tutorial/inputoutput.rst:176
msgid ""
"If keyword arguments are used in the :meth:`str.format` method, their values "
"are referred to by using the name of the argument. ::"
msgstr ""
"Se vengono utilizzati argomenti keyword nel metodo :meth:`str.format`, i "
"loro valori vengono referenziati usando il nome dell'argomento. ::"

#: tutorial/inputoutput.rst:183
msgid "Positional and keyword arguments can be arbitrarily combined::"
msgstr ""
"Gli argomenti posizionali e keyword possono essere combinati "
"arbitrariamente::"

#: tutorial/inputoutput.rst:189
msgid ""
"If you have a really long format string that you don't want to split up, it "
"would be nice if you could reference the variables to be formatted by name "
"instead of by position.  This can be done by simply passing the dict and "
"using square brackets ``'[]'`` to access the keys. ::"
msgstr ""
"Se hai una stringa di formato molto lunga che non vuoi dividere, sarebbe "
"utile poter riferire le variabili da formattare per nome invece che per "
"posizione. Questo può essere fatto semplicemente passando il dizionario e "
"usando le parentesi quadre ``'[]'`` per accedere alle chiavi. ::"

#: tutorial/inputoutput.rst:199
msgid ""
"This could also be done by passing the ``table`` dictionary as keyword "
"arguments with the ``**`` notation. ::"
msgstr ""
"Questo può essere fatto anche passando il dizionario ``table`` come "
"argomenti keyword usando la notazione ``**``. ::"

#: tutorial/inputoutput.rst:206
msgid ""
"This is particularly useful in combination with the built-in function :func:"
"`vars`, which returns a dictionary containing all local variables::"
msgstr ""
"Questo è particolarmente utile in combinazione con la funzione built-in :"
"func:`vars`, che restituisce un dizionario contenente tutte le variabili "
"locali::"

#: tutorial/inputoutput.rst:214
msgid ""
"As an example, the following lines produce a tidily aligned set of columns "
"giving integers and their squares and cubes::"
msgstr ""
"Ad esempio, le seguenti righe producono un insieme di colonne ordinatamente "
"allineate che danno interi e loro quadrati e cubi::"

#: tutorial/inputoutput.rst:231
msgid ""
"For a complete overview of string formatting with :meth:`str.format`, see :"
"ref:`formatstrings`."
msgstr ""
"Per una panoramica completa della formattazione delle stringhe con :meth:"
"`str.format`, vedi :ref:`formatstrings`."

#: tutorial/inputoutput.rst:236
msgid "Manual String Formatting"
msgstr "Formattazione Manuale delle Stringhe"

#: tutorial/inputoutput.rst:238
msgid "Here's the same table of squares and cubes, formatted manually::"
msgstr "Ecco la stessa tabella di quadrati e cubi, formattata manualmente::"

#: tutorial/inputoutput.rst:256
msgid ""
"(Note that the one space between each column was added by the way :func:"
"`print` works: it always adds spaces between its arguments.)"
msgstr ""
"(Nota che l'unico spazio tra ogni colonna è stato aggiunto dal modo in cui "
"funziona :func:`print`: aggiunge sempre spazi tra i suoi argomenti.)"

#: tutorial/inputoutput.rst:259
msgid ""
"The :meth:`str.rjust` method of string objects right-justifies a string in a "
"field of a given width by padding it with spaces on the left. There are "
"similar methods :meth:`str.ljust` and :meth:`str.center`. These methods do "
"not write anything, they just return a new string. If the input string is "
"too long, they don't truncate it, but return it unchanged; this will mess up "
"your column lay-out but that's usually better than the alternative, which "
"would be lying about a value. (If you really want truncation you can always "
"add a slice operation, as in ``x.ljust(n)[:n]``.)"
msgstr ""
"Il metodo :meth:`str.rjust` degli oggetti stringa giustifica a destra una "
"stringa in un campo di una data larghezza riempiendola con spazi sulla "
"sinistra. Esistono metodi simili :meth:`str.ljust` e :meth:`str.center`. "
"Questi metodi non scrivono nulla, restituiranno solo una nuova stringa. Se "
"la stringa di input è troppo lunga, non viene troncata, ma restituita "
"invariata; questo comprometterà l'allineamento delle colonne ma di solito è "
"meglio dell'alternativa, che sarebbe mentire su un valore. (Se desideri "
"davvero la troncatura, puoi sempre aggiungere un'operazione di slicing, come "
"in ``x.ljust(n)[:n]``.)"

#: tutorial/inputoutput.rst:268
msgid ""
"There is another method, :meth:`str.zfill`, which pads a numeric string on "
"the left with zeros.  It understands about plus and minus signs::"
msgstr ""
"C'è un altro metodo, :meth:`str.zfill`, che riempie una stringa numerica a "
"sinistra con zeri. Comprende i segni più e meno::"

#: tutorial/inputoutput.rst:280
msgid "Old string formatting"
msgstr "Vecchia formattazione delle stringhe"

#: tutorial/inputoutput.rst:282
msgid ""
"The % operator (modulo) can also be used for string formatting. Given "
"``'string' % values``, instances of ``%`` in ``string`` are replaced with "
"zero or more elements of ``values``. This operation is commonly known as "
"string interpolation. For example::"
msgstr ""
"L'operatore % (modulo) può essere usato anche per la formattazione delle "
"stringhe. Data ``'string' % values``, le istanze di ``%`` in ``string`` "
"vengono sostituite con uno o più elementi di ``values``. Questa operazione è "
"comunemente conosciuta come interpolazione delle stringhe. Ad esempio::"

#: tutorial/inputoutput.rst:291
msgid ""
"More information can be found in the :ref:`old-string-formatting` section."
msgstr ""
"Maggiori informazioni possono essere trovate nella sezione :ref:`old-string-"
"formatting`."

#: tutorial/inputoutput.rst:297
msgid "Reading and Writing Files"
msgstr "Lettura e Scrittura di File"

#: tutorial/inputoutput.rst:303
msgid ""
":func:`open` returns a :term:`file object`, and is most commonly used with "
"two positional arguments and one keyword argument: ``open(filename, mode, "
"encoding=None)``"
msgstr ""
":func:`open` restituisce un :term:`file object`, ed è più comunemente usato "
"con due argomenti posizionali e uno keyword: ``open(filename, mode, "
"encoding=None)``"

#: tutorial/inputoutput.rst:316
msgid ""
"The first argument is a string containing the filename.  The second argument "
"is another string containing a few characters describing the way in which "
"the file will be used.  *mode* can be ``'r'`` when the file will only be "
"read, ``'w'`` for only writing (an existing file with the same name will be "
"erased), and ``'a'`` opens the file for appending; any data written to the "
"file is automatically added to the end.  ``'r+'`` opens the file for both "
"reading and writing. The *mode* argument is optional; ``'r'`` will be "
"assumed if it's omitted."
msgstr ""
"Il primo argomento è una stringa che contiene il nome del file. Il secondo "
"argomento è un'altra stringa che contiene alcuni caratteri che descrivono il "
"modo in cui il file verrà utilizzato. *mode* può essere ``'r'`` quando il "
"file verrà solo letto, ``'w'`` per solo scrivere (un file esistente con lo "
"stesso nome verrà cancellato), e ``'a'`` apre il file per l'aggiunta dati; "
"qualsiasi dato scritto nel file viene automaticamente aggiunto alla fine. "
"``'r+'`` apre il file per sia lettura che scrittura. L'argomento *mode* è "
"opzionale; ``'r'`` sarà assunto se omesso."

#: tutorial/inputoutput.rst:325
msgid ""
"Normally, files are opened in :dfn:`text mode`, that means, you read and "
"write strings from and to the file, which are encoded in a specific "
"*encoding*. If *encoding* is not specified, the default is platform "
"dependent (see :func:`open`). Because UTF-8 is the modern de-facto standard, "
"``encoding=\"utf-8\"`` is recommended unless you know that you need to use a "
"different encoding. Appending a ``'b'`` to the mode opens the file in :dfn:"
"`binary mode`. Binary mode data is read and written as :class:`bytes` "
"objects. You can not specify *encoding* when opening file in binary mode."
msgstr ""
"Normalmente, i file vengono aperti in :dfn:`text mode`, ciò significa che "
"leggi e scrivi stringhe dal e nel file, che sono codificate in una specifica "
"*encoding*. Se *encoding* non è specificato, il valore predefinito dipende "
"dal sistema (vedi :func:`open`). Poiché UTF-8 è lo standard de facto "
"moderno, ``encoding=\"utf-8\"`` è raccomandato a meno che non si sappia che "
"è necessario utilizzare una diversa codifica. Aggiungendo una ``'b'`` al "
"mode, si apre il file in :dfn:`binary mode`. I dati in modalità binaria sono "
"letti e scritti come oggetti :class:`bytes`. Non puoi specificare *encoding* "
"quando apri file in modalità binaria."

#: tutorial/inputoutput.rst:335
msgid ""
"In text mode, the default when reading is to convert platform-specific line "
"endings (``\\n`` on Unix, ``\\r\\n`` on Windows) to just ``\\n``.  When "
"writing in text mode, the default is to convert occurrences of ``\\n`` back "
"to platform-specific line endings.  This behind-the-scenes modification to "
"file data is fine for text files, but will corrupt binary data like that in :"
"file:`JPEG` or :file:`EXE` files.  Be very careful to use binary mode when "
"reading and writing such files."
msgstr ""
"In modalità testo, il valore predefinito durante la lettura è convertire i "
"terminatori di riga specifici della piattaforma (``\\n`` su Unix, ``\\r\\n`` "
"su Windows) in solo ``\\n``. Quando si scrive in modalità testo, il valore "
"predefinito è convertire le occorrenze di ``\\n`` nei terminatori specifici "
"della piattaforma. Questa modifica dietro le quinte ai dati del file va bene "
"per i file di testo, ma corromperà i dati binari come quelli nei file :file:"
"`JPEG` o :file:`EXE`. Fai molta attenzione a usare modalità binaria quando "
"leggi e scrivi tali file."

#: tutorial/inputoutput.rst:343
msgid ""
"It is good practice to use the :keyword:`with` keyword when dealing with "
"file objects.  The advantage is that the file is properly closed after its "
"suite finishes, even if an exception is raised at some point.  Using :"
"keyword:`!with` is also much shorter than writing equivalent :keyword:"
"`try`\\ -\\ :keyword:`finally` blocks::"
msgstr ""
"È buona pratica usare la keyword :keyword:`with` quando si lavora con "
"oggetti file. Il vantaggio è che il file viene chiuso correttamente dopo che "
"la sua suite finisce, anche se viene generata un'eccezione a un certo punto. "
"Usare :keyword:`!with` è anche molto più breve che scrivere blocchi "
"equivalenti :keyword:`try`\\ -\\ :keyword:`finally`::"

#: tutorial/inputoutput.rst:356
msgid ""
"If you're not using the :keyword:`with` keyword, then you should call ``f."
"close()`` to close the file and immediately free up any system resources "
"used by it."
msgstr ""
"Se non stai usando la keyword :keyword:`with`, allora dovresti chiamare ``f."
"close()`` per chiudere il file e liberare immediatamente qualsiasi risorsa "
"di sistema utilizzata da esso."

#: tutorial/inputoutput.rst:361
msgid ""
"Calling ``f.write()`` without using the :keyword:`!with` keyword or calling "
"``f.close()`` **might** result in the arguments of ``f.write()`` not being "
"completely written to the disk, even if the program exits successfully."
msgstr ""
"Chiamare ``f.write()`` senza usare la keyword :keyword:`!with` o chiamare "
"``f.close()`` **potrebbe** risultare nel fatto che gli argomenti di ``f."
"write()`` non vengano completamente scritti sul disco, anche se il programma "
"termina con successo."

#: tutorial/inputoutput.rst:369
msgid ""
"After a file object is closed, either by a :keyword:`with` statement or by "
"calling ``f.close()``, attempts to use the file object will automatically "
"fail. ::"
msgstr ""
"Dopo che un oggetto file è stato chiuso, sia tramite un'istruzione :keyword:"
"`with`, sia chiamando ``f.close()``, i tentativi di utilizzare l'oggetto "
"file falliranno automaticamente. ::"

#: tutorial/inputoutput.rst:383
msgid "Methods of File Objects"
msgstr "Metodi degli Oggetti File"

#: tutorial/inputoutput.rst:385
msgid ""
"The rest of the examples in this section will assume that a file object "
"called ``f`` has already been created."
msgstr ""
"Gli altri esempi in questa sezione assumeranno che un oggetto file chiamato "
"``f`` sia già stato creato."

#: tutorial/inputoutput.rst:388
msgid ""
"To read a file's contents, call ``f.read(size)``, which reads some quantity "
"of data and returns it as a string (in text mode) or bytes object (in binary "
"mode). *size* is an optional numeric argument.  When *size* is omitted or "
"negative, the entire contents of the file will be read and returned; it's "
"your problem if the file is twice as large as your machine's memory. "
"Otherwise, at most *size* characters (in text mode) or *size* bytes (in "
"binary mode) are read and returned. If the end of the file has been reached, "
"``f.read()`` will return an empty string (``''``).  ::"
msgstr ""
"Per leggere i contenuti di un file, chiama ``f.read(size)``, che legge una "
"certa quantità di dati e li restituisce come una stringa (in modalità testo) "
"o un oggetto bytes (in modalità binaria). *size* è un argomento numerico "
"opzionale. Quando *size* è omesso o negativo, verranno letti e restituiti "
"tutti i contenuti del file; è un tuo problema se il file è due volte più "
"grande della memoria del tuo computer. Altrimenti, al massimo *size* "
"caratteri (in modalità testo) o *size* byte (in modalità binaria) vengono "
"letti e restituiti. Se la fine del file è stata raggiunta, ``f.read()`` "
"restituirà una stringa vuota (``''``).  ::"

#: tutorial/inputoutput.rst:402
msgid ""
"``f.readline()`` reads a single line from the file; a newline character "
"(``\\n``) is left at the end of the string, and is only omitted on the last "
"line of the file if the file doesn't end in a newline.  This makes the "
"return value unambiguous; if ``f.readline()`` returns an empty string, the "
"end of the file has been reached, while a blank line is represented by "
"``'\\n'``, a string containing only a single newline.  ::"
msgstr ""
"``f.readline()`` legge una singola riga dal file; un carattere di newline "
"(``\\n``) viene lasciato alla fine della stringa e viene omesso solo "
"sull'ultima riga del file se il file non termina con un newline. Questo "
"rende il valore di ritorno non ambiguo; se ``f.readline()`` restituisce una "
"stringa vuota, la fine del file è stata raggiunta, mentre una linea vuota è "
"rappresentata da ``'\\n'``, una stringa contenente solo un newline.  ::"

#: tutorial/inputoutput.rst:416
msgid ""
"For reading lines from a file, you can loop over the file object. This is "
"memory efficient, fast, and leads to simple code::"
msgstr ""
"Per leggere le righe da un file, puoi iterare sull'oggetto file. Questo è "
"efficiente in termini di memoria, veloce e porta a un codice semplice::"

#: tutorial/inputoutput.rst:425
msgid ""
"If you want to read all the lines of a file in a list you can also use "
"``list(f)`` or ``f.readlines()``."
msgstr ""
"Se vuoi leggere tutte le righe di un file in una lista puoi anche usare "
"``list(f)`` o ``f.readlines()``."

#: tutorial/inputoutput.rst:428
msgid ""
"``f.write(string)`` writes the contents of *string* to the file, returning "
"the number of characters written. ::"
msgstr ""
"``f.write(string)`` scrive i contenuti di *string* nel file, restituendo il "
"numero di caratteri scritti. ::"

#: tutorial/inputoutput.rst:434
msgid ""
"Other types of objects need to be converted -- either to a string (in text "
"mode) or a bytes object (in binary mode) -- before writing them::"
msgstr ""
"Altri tipi di oggetti devono essere convertiti -- o in una stringa (in "
"modalità testo) o in un oggetto bytes (in modalità binaria) -- prima di "
"scriverli::"

#: tutorial/inputoutput.rst:442
msgid ""
"``f.tell()`` returns an integer giving the file object's current position in "
"the file represented as number of bytes from the beginning of the file when "
"in binary mode and an opaque number when in text mode."
msgstr ""
"``f.tell()`` restituisce un intero che indica la posizione corrente "
"dell'oggetto file nel file, rappresentata come numero di byte dall'inizio "
"del file quando in modalità binaria e un numero opaco quando in modalità "
"testo."

#: tutorial/inputoutput.rst:446
msgid ""
"To change the file object's position, use ``f.seek(offset, whence)``.  The "
"position is computed from adding *offset* to a reference point; the "
"reference point is selected by the *whence* argument.  A *whence* value of 0 "
"measures from the beginning of the file, 1 uses the current file position, "
"and 2 uses the end of the file as the reference point.  *whence* can be "
"omitted and defaults to 0, using the beginning of the file as the reference "
"point. ::"
msgstr ""
"Per cambiare la posizione dell'oggetto file, usa ``f.seek(offset, whence)``. "
"La posizione è calcolata sommando *offset* a un punto di riferimento; il "
"punto di riferimento è selezionato dall'argomento *whence*. Un valore "
"*whence* di 0 misura dall'inizio del file, 1 usa la posizione corrente del "
"file, e 2 usa la fine del file come punto di riferimento. *whence* può "
"essere omesso e predefinito a 0, utilizzando l'inizio del file come punto di "
"riferimento. ::"

#: tutorial/inputoutput.rst:465
msgid ""
"In text files (those opened without a ``b`` in the mode string), only seeks "
"relative to the beginning of the file are allowed (the exception being "
"seeking to the very file end with ``seek(0, 2)``) and the only valid "
"*offset* values are those returned from the ``f.tell()``, or zero. Any other "
"*offset* value produces undefined behaviour."
msgstr ""
"Nei file di testo (quelli aperti senza una ``b`` nella stringa di modalità), "
"sono consentiti solo i seek relativi all'inizio del file (con l'eccezione "
"del seek alla fine del file con ``seek(0, 2)``) e gli unici valori *offset* "
"validi sono quelli restituiti da ``f.tell()``, o zero. Qualsiasi altro "
"valore *offset* produce un comportamento non definito."

#: tutorial/inputoutput.rst:471
msgid ""
"File objects have some additional methods, such as :meth:`~io.IOBase.isatty` "
"and :meth:`~io.IOBase.truncate` which are less frequently used; consult the "
"Library Reference for a complete guide to file objects."
msgstr ""
"Gli oggetti file hanno alcuni metodi aggiuntivi, come :meth:`~io.IOBase."
"isatty` e :meth:`~io.IOBase.truncate` che sono meno frequentemente usati; "
"consulta la Libreria di Riferimento per una guida completa agli oggetti file."

#: tutorial/inputoutput.rst:479
msgid "Saving structured data with :mod:`json`"
msgstr "Salvare dati strutturati con :mod:`json`"

#: tutorial/inputoutput.rst:483
msgid ""
"Strings can easily be written to and read from a file.  Numbers take a bit "
"more effort, since the :meth:`~io.TextIOBase.read` method only returns "
"strings, which will have to be passed to a function like :func:`int`, which "
"takes a string like ``'123'`` and returns its numeric value 123.  When you "
"want to save more complex data types like nested lists and dictionaries, "
"parsing and serializing by hand becomes complicated."
msgstr ""
"Le stringhe possono essere facilmente scritte su e lette da un file. I "
"numeri richiedono un po' più di sforzo, poiché il metodo :meth:`~io."
"TextIOBase.read` restituisce solo stringhe, che dovranno essere passate a "
"una funzione come :func:`int`, che prende una stringa come ``'123'`` e "
"restituisce il suo valore numerico 123. Quando vuoi salvare tipi di dati più "
"complessi come liste annidate e dizionari, il parsing e la serializzazione "
"manuale diventano complicati."

#: tutorial/inputoutput.rst:490
msgid ""
"Rather than having users constantly writing and debugging code to save "
"complicated data types to files, Python allows you to use the popular data "
"interchange format called `JSON (JavaScript Object Notation) <https://json."
"org>`_.  The standard module called :mod:`json` can take Python data "
"hierarchies, and convert them to string representations; this process is "
"called :dfn:`serializing`.  Reconstructing the data from the string "
"representation is called :dfn:`deserializing`.  Between serializing and "
"deserializing, the string representing the object may have been stored in a "
"file or data, or sent over a network connection to some distant machine."
msgstr ""
"Piuttosto che avere utenti che scrivono e fanno debug costantemente di "
"codice per salvare tipi di dati complicati nei file, Python ti permette di "
"usare il popolare formato di interscambio dati chiamato `JSON (JavaScript "
"Object Notation) <https://json.org>`_. Il modulo standard chiamato :mod:"
"`json` può prendere gerarchie di dati Python e convertirle in "
"rappresentazioni di stringhe; questo processo è chiamato :dfn:"
"`serializzazione`. Ricostruire i dati dalla rappresentazione di stringa è "
"chiamato :dfn:`deserializzazione`. Tra la serializzazione e la "
"deserializzazione, la stringa che rappresenta l'oggetto può essere stata "
"memorizzata in un file o dato, o inviata su una connessione di rete a una "
"macchina lontana."

#: tutorial/inputoutput.rst:501
msgid ""
"The JSON format is commonly used by modern applications to allow for data "
"exchange.  Many programmers are already familiar with it, which makes it a "
"good choice for interoperability."
msgstr ""
"Il formato JSON è comunemente usato dalle applicazioni moderne per "
"permettere lo scambio di dati. Molti programmatori sono già familiari con "
"esso, il che lo rende una buona scelta per l'interoperabilità."

#: tutorial/inputoutput.rst:505
msgid ""
"If you have an object ``x``, you can view its JSON string representation "
"with a simple line of code::"
msgstr ""
"Se hai un oggetto ``x``, puoi visualizzare la sua rappresentazione JSON "
"della stringa con una semplice riga di codice::"

#: tutorial/inputoutput.rst:513
msgid ""
"Another variant of the :func:`~json.dumps` function, called :func:`~json."
"dump`, simply serializes the object to a :term:`text file`.  So if ``f`` is "
"a :term:`text file` object opened for writing, we can do this::"
msgstr ""
"Un'altra variante della funzione :func:`~json.dumps`, chiamata :func:`~json."
"dump`, semplicemente serializza l'oggetto in un oggetto :term:`text file`. "
"Quindi se ``f`` è un oggetto :term:`text file` aperto per la scrittura, "
"possiamo fare questo::"

#: tutorial/inputoutput.rst:519
msgid ""
"To decode the object again, if ``f`` is a :term:`binary file` or :term:`text "
"file` object which has been opened for reading::"
msgstr ""
"Per decodificare l'oggetto di nuovo, se ``f`` è un oggetto :term:`binary "
"file` o :term:`text file` che è stato aperto per la lettura::"

#: tutorial/inputoutput.rst:525
msgid ""
"JSON files must be encoded in UTF-8. Use ``encoding=\"utf-8\"`` when opening "
"JSON file as a :term:`text file` for both of reading and writing."
msgstr ""
"I file JSON devono essere codificati in UTF-8. Usa ``encoding=\"utf-8\"`` "
"quando apri il file JSON come :term:`text file` sia per la lettura che per "
"la scrittura."

#: tutorial/inputoutput.rst:528
msgid ""
"This simple serialization technique can handle lists and dictionaries, but "
"serializing arbitrary class instances in JSON requires a bit of extra "
"effort. The reference for the :mod:`json` module contains an explanation of "
"this."
msgstr ""
"Questa semplice tecnica di serializzazione può gestire liste e dizionari, ma "
"serializzare istanze di classi arbitrari in JSON richiede un po' di sforzo "
"extra. Il riferimento per il modulo :mod:`json` contiene una spiegazione di "
"questo."

#: tutorial/inputoutput.rst:534
msgid ":mod:`pickle` - the pickle module"
msgstr ":mod:`pickle` - il modulo pickle"

#: tutorial/inputoutput.rst:536
msgid ""
"Contrary to :ref:`JSON <tut-json>`, *pickle* is a protocol which allows the "
"serialization of arbitrarily complex Python objects.  As such, it is "
"specific to Python and cannot be used to communicate with applications "
"written in other languages.  It is also insecure by default: deserializing "
"pickle data coming from an untrusted source can execute arbitrary code, if "
"the data was crafted by a skilled attacker."
msgstr ""
"Contrariamente a :ref:`JSON <tut-json>`, *pickle* è un protocollo che "
"permette la serializzazione di oggetti Python arbitrariamente complessi. "
"Come tale, è specifico per Python e non può essere usato"

#: tutorial/inputoutput.rst:299
msgid "built-in function"
msgstr "funzione incorporata"

#: tutorial/inputoutput.rst:299
msgid "open"
msgstr "apri"

#: tutorial/inputoutput.rst:299
msgid "object"
msgstr "oggetto"

#: tutorial/inputoutput.rst:299
msgid "file"
msgstr "file"

#: tutorial/inputoutput.rst:481
msgid "module"
msgstr "modulo"

#: tutorial/inputoutput.rst:481
msgid "json"
msgstr "json"