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