# 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/controlflow.rst:5

msgid "More Control Flow Tools"

msgstr "Altri Strumenti di Controllo del Flusso"

#: tutorial/controlflow.rst:7

msgid ""

"As well as the :keyword:`while` statement just introduced, Python uses a few "

"more that we will encounter in this chapter."

msgstr ""

"Oltre all'istruzione :keyword:`while` appena introdotta, Python ne utilizza "

"altre che incontreremo in questo capitolo."

#: tutorial/controlflow.rst:14

msgid ":keyword:`!if` Statements"

msgstr "Istruzioni :keyword:`!if`"

#: tutorial/controlflow.rst:16

msgid ""

"Perhaps the most well-known statement type is the :keyword:`if` statement. "

"For example::"

msgstr ""

"Forse il tipo di istruzione più conosciuto è l'istruzione :keyword:`if`. Ad "

"esempio::"

#: tutorial/controlflow.rst:33

msgid ""

"There can be zero or more :keyword:`elif` parts, and the :keyword:`else` "

"part is optional. The keyword ':keyword:`!elif`' is short for 'else if', "

"and is useful to avoid excessive indentation. An :keyword:`!if` ... :"

"keyword:`!elif` ... :keyword:`!elif` ... sequence is a substitute for the "

"``switch`` or ``case`` statements found in other languages."

msgstr ""

"Possiamo avere zero o più parti :keyword:`elif`, e la parte :keyword:`else` "

"è facoltativa. La parola chiave ':keyword:`!elif`' è l'abbreviazione di "

"'else if', ed è utile per evitare un'eccessiva indentazione. Una sequenza :"

"keyword:`!if` ... :keyword:`!elif` ... :keyword:`!elif` ... è un sostituto "

"per le istruzioni ``switch`` o ``case`` trovate in altri linguaggi."

#: tutorial/controlflow.rst:39

msgid ""

"If you're comparing the same value to several constants, or checking for "

"specific types or attributes, you may also find the :keyword:`!match` "

"statement useful. For more details see :ref:`tut-match`."

msgstr ""

"Se stai confrontando lo stesso valore con diverse costanti, o controllando "

"tipi o attributi specifici, potresti trovare utile l'istruzione :keyword:`!"

"match`. Per maggiori dettagli, consulta :ref:`tut-match`."

#: tutorial/controlflow.rst:46

msgid ":keyword:`!for` Statements"

msgstr "Istruzioni :keyword:`!for`"

#: tutorial/controlflow.rst:51

msgid ""

"The :keyword:`for` statement in Python differs a bit from what you may be "

"used to in C or Pascal. Rather than always iterating over an arithmetic "

"progression of numbers (like in Pascal), or giving the user the ability to "

"define both the iteration step and halting condition (as C), Python's :"

"keyword:`!for` statement iterates over the items of any sequence (a list or "

"a string), in the order that they appear in the sequence. For example (no "

"pun intended):"

msgstr ""

"L'istruzione :keyword:`for` in Python differisce leggermente da ciò a cui "

"potresti essere abitualmente abituato in C o Pascal. Piuttosto che iterare "

"sempre su una progressione aritmetica di numeri (come in Pascal), o dare "

"all'utente la possibilità di definire sia il passo di iterazione che la "

"condizione di arresto (come in C), l'istruzione :keyword:`!for` di Python "

"itera sugli elementi di qualsiasi sequenza (una lista o una stringa), "

"nell'ordine in cui appaiono nella sequenza. Ad esempio:"

#: tutorial/controlflow.rst:72

msgid ""

"Code that modifies a collection while iterating over that same collection "

"can be tricky to get right. Instead, it is usually more straight-forward to "

"loop over a copy of the collection or to create a new collection::"

msgstr ""

"Il codice che modifica una collezione durante l'iterazione sulla stessa può "

"essere difficile da scrivere correttamente. Invece, è generalmente più "

"semplice iterare su una copia della collezione o crearne una nuova:"

#: tutorial/controlflow.rst:94

msgid "The :func:`range` Function"

msgstr "La Funzione :func:`range`"

#: tutorial/controlflow.rst:96

msgid ""

"If you do need to iterate over a sequence of numbers, the built-in function :"

"func:`range` comes in handy. It generates arithmetic progressions::"

msgstr ""

"Se hai bisogno di iterare su una sequenza di numeri, la funzione integrata :"

"func:`range` è utile. Genera progressioni aritmetiche::"

#: tutorial/controlflow.rst:108

msgid ""

"The given end point is never part of the generated sequence; ``range(10)`` "

"generates 10 values, the legal indices for items of a sequence of length "

"10. It is possible to let the range start at another number, or to specify "

"a different increment (even negative; sometimes this is called the 'step')::"

msgstr ""

"Il valore finale fornito non fa parte della sequenza generata; ``range(10)`` "

"genera 10 valori, gli indici legali per gli elementi di una sequenza di "

"lunghezza 10. È possibile far partire l'intervallo da un altro numero, o "

"specificare un incremento diverso (anche negativo; talvolta questo è "

"chiamato 'passo')::"

#: tutorial/controlflow.rst:122

msgid ""

"To iterate over the indices of a sequence, you can combine :func:`range` "

"and :func:`len` as follows::"

msgstr ""

"Per iterare sugli indici di una sequenza, puoi combinare :func:`range` e :"

"func:`len` nel seguente modo::"

#: tutorial/controlflow.rst:135

msgid ""

"In most such cases, however, it is convenient to use the :func:`enumerate` "

"function, see :ref:`tut-loopidioms`."

msgstr ""

"Nella maggior parte di questi casi, però, è conveniente utilizzare la "

"funzione :func:`enumerate`, vedi :ref:`tut-loopidioms`."

#: tutorial/controlflow.rst:138

msgid "A strange thing happens if you just print a range::"

msgstr "Attenzione: succede una cosa strana se provi a stampare un range::"

#: tutorial/controlflow.rst:143

msgid ""

"In many ways the object returned by :func:`range` behaves as if it is a "

"list, but in fact it isn't. It is an object which returns the successive "

"items of the desired sequence when you iterate over it, but it doesn't "

"really make the list, thus saving space."

msgstr ""

"In molti casi, l'oggetto restituito da :func:`range` si comporta come se "

"fosse una lista, ma in realtà non lo è. È un oggetto che restituisce gli "

"elementi successivi della sequenza desiderata quando ci si itera sopra, ma "

"non crea effettivamente la lista, risparmiando così spazio."

#: tutorial/controlflow.rst:148

msgid ""

"We say such an object is :term:`iterable`, that is, suitable as a target for "

"functions and constructs that expect something from which they can obtain "

"successive items until the supply is exhausted. We have seen that the :"

"keyword:`for` statement is such a construct, while an example of a function "

"that takes an iterable is :func:`sum`::"

msgstr ""

"Diciamo che un tale oggetto è un :term:`iterable`, cioè adatto per funzioni "

"e costrutti che si aspettano qualcosa da cui possono ottenere elementi fino "

"a quando il contenitore è vuoto. Abbiamo visto che l'istruzione :keyword:"

"`for` è un tale costrutto, mentre un esempio di una funzione che prende come "

"argomento un oggetto iterabile è :func:`sum`::"

#: tutorial/controlflow.rst:157

msgid ""

"Later we will see more functions that return iterables and take iterables as "

"arguments. In chapter :ref:`tut-structures`, we will discuss in more detail "

"about :func:`list`."

msgstr ""

"In seguito vedremo altre funzioni che restituiscono oggetti iterabili e "

"prendono oggetti iterabili come argomenti. Nel capitolo :ref:`tut-"

"structures`, discuteremo in modo più dettagliato riguardo a :func:`list`."

#: tutorial/controlflow.rst:164

msgid ""

":keyword:`!break` and :keyword:`!continue` Statements, and :keyword:`!else` "

"Clauses on Loops"

msgstr ""

"Istruzioni :keyword:`!break` e :keyword:`!continue`, e clausole :keyword:`!"

"else` nei cicli"

#: tutorial/controlflow.rst:166

msgid ""

"The :keyword:`break` statement breaks out of the innermost enclosing :"

"keyword:`for` or :keyword:`while` loop."

msgstr ""

"L'istruzione :keyword:`break` esce dal ciclo :keyword:`for` o :keyword:"

"`while` più interno."

#: tutorial/controlflow.rst:169

msgid ""

"A :keyword:`!for` or :keyword:`!while` loop can include an :keyword:`!else` "

"clause."

msgstr ""

"Un ciclo :keyword:`!for` o :keyword:`!while` può includere una clausola :"

"keyword:`!else`."

#: tutorial/controlflow.rst:171

msgid ""

"In a :keyword:`for` loop, the :keyword:`!else` clause is executed after the "

"loop reaches its final iteration."

msgstr ""

"In un ciclo :keyword:`for`, la clausola :keyword:`!else` viene eseguita dopo "

"che il ciclo ha raggiunto la sua iterazione finale."

#: tutorial/controlflow.rst:174

msgid ""

"In a :keyword:`while` loop, it's executed after the loop's condition becomes "

"false."

msgstr ""

"In un ciclo :keyword:`while`, viene eseguita dopo che la condizione del "

"ciclo diventa falsa."

#: tutorial/controlflow.rst:176

msgid ""

"In either kind of loop, the :keyword:`!else` clause is **not** executed if "

"the loop was terminated by a :keyword:`break`."

msgstr ""

"In entrambi i tipi di ciclo, la clausola :keyword:`!else` **non** viene "

"eseguita se il ciclo è stato terminato da un :keyword:`break`."

#: tutorial/controlflow.rst:179

msgid ""

"This is exemplified in the following :keyword:`!for` loop, which searches "

"for prime numbers::"

msgstr ""

"Questo è esemplificato nel seguente ciclo :keyword:`!for`, che cerca numeri "

"primi::"

#: tutorial/controlflow.rst:200

msgid ""

"(Yes, this is the correct code. Look closely: the ``else`` clause belongs "

"to the :keyword:`for` loop, **not** the :keyword:`if` statement.)"

msgstr ""

"(Sì, questo codice è corretto. Guarda attentamente: la clausola ``else`` "

"appartiene al ciclo :keyword:`for`, **non** all'istruzione :keyword:`if`.)"

#: tutorial/controlflow.rst:203

msgid ""

"When used with a loop, the ``else`` clause has more in common with the "

"``else`` clause of a :keyword:`try` statement than it does with that of :"

"keyword:`if` statements: a :keyword:`try` statement's ``else`` clause runs "

"when no exception occurs, and a loop's ``else`` clause runs when no "

"``break`` occurs. For more on the :keyword:`!try` statement and exceptions, "

"see :ref:`tut-handling`."

msgstr ""

"Quando viene utilizzata con un ciclo, la clausola ``else`` ha più in comune "

"con la clausola ``else`` di un'istruzione :keyword:`try` rispetto a quella "

"delle istruzioni :keyword:`if`: la clausola ``else`` di un'istruzione :"

"keyword:`try` viene eseguita quando non si verifica alcuna eccezione, e la "

"clausola ``else`` di un ciclo viene eseguita quando non si verifica alcun "

"``break``. Per ulteriori informazioni sull'istruzione :keyword:`!try` e "

"sulle eccezioni, consulta :ref:`tut-handling`."

#: tutorial/controlflow.rst:210

msgid ""

"The :keyword:`continue` statement, also borrowed from C, continues with the "

"next iteration of the loop::"

msgstr ""

"L'istruzione :keyword:`continue`, presa in prestito dal C, continua con la "

"prossima iterazione del ciclo::"

#: tutorial/controlflow.rst:231

msgid ":keyword:`!pass` Statements"

msgstr "Istruzioni :keyword:`!pass`"

#: tutorial/controlflow.rst:233

msgid ""

"The :keyword:`pass` statement does nothing. It can be used when a statement "

"is required syntactically but the program requires no action. For example::"

msgstr ""

"L'istruzione :keyword:`pass` non fa nulla. Può essere utilizzata quando è "

"richiesta un'istruzione sintatticamente, ma il programma non richiede alcuna "

"azione. Per esempio::"

#: tutorial/controlflow.rst:240

msgid "This is commonly used for creating minimal classes::"

msgstr "Questo è comunemente usato per creare classi minime::"

#: tutorial/controlflow.rst:246

msgid ""

"Another place :keyword:`pass` can be used is as a place-holder for a "

"function or conditional body when you are working on new code, allowing you "

"to keep thinking at a more abstract level. The :keyword:`!pass` is silently "

"ignored::"

msgstr ""

"Un altro posto in cui :keyword:`pass` può essere usato è come segnaposto per "

"il corpo di una funzione o condizionale quando si sta lavorando su nuovo "

"codice, permettendo di continuare a pensare a un livello più astratto. "

"L'istruzione :keyword:`!pass` viene ignorata silenziosamente::"

#: tutorial/controlflow.rst:258

msgid ":keyword:`!match` Statements"

msgstr "Istruzioni :keyword:`!match`"

#: tutorial/controlflow.rst:260

msgid ""

"A :keyword:`match` statement takes an expression and compares its value to "

"successive patterns given as one or more case blocks. This is superficially "

"similar to a switch statement in C, Java or JavaScript (and many other "

"languages), but it's more similar to pattern matching in languages like Rust "

"or Haskell. Only the first pattern that matches gets executed and it can "

"also extract components (sequence elements or object attributes) from the "

"value into variables."

msgstr ""

"Un'istruzione :keyword:`match` prende un'espressione e confronta il suo "

"valore con schemi successivi forniti come uno o più blocchi case. Questo è "

"superficialmente simile a un'istruzione switch in C, Java o JavaScript (e "

"molti altri linguaggi), ma è più simile al pattern matching in linguaggi "

"come Rust o Haskell. Solo il primo schema che corrisponde viene eseguito e "

"può anche estrarre componenti (elementi di sequenze o attributi di oggetti) "

"dal valore in variabili."

#: tutorial/controlflow.rst:268

msgid ""

"The simplest form compares a subject value against one or more literals::"

msgstr "La forma più semplice confronta un valore con uno o più letterali::"

#: tutorial/controlflow.rst:281

msgid ""

"Note the last block: the \"variable name\" ``_`` acts as a *wildcard* and "

"never fails to match. If no case matches, none of the branches is executed."

msgstr ""

"Nota l'ultimo blocco: il \"nome della variabile\" ``_`` funge da *wildcard* "

"e non fallisce mai. Se nessun case corrisponde, nessuno dei rami viene "

"eseguito."

#: tutorial/controlflow.rst:284

msgid ""

"You can combine several literals in a single pattern using ``|`` (\"or\")::"

msgstr ""

"Puoi combinare diversi letterali in un singolo schema usando ``|`` (\"or\")::"

#: tutorial/controlflow.rst:289

msgid ""

"Patterns can look like unpacking assignments, and can be used to bind "

"variables::"

msgstr ""

"Gli schemi possono sembrare assegnazioni di decomposizione e possono essere "

"utilizzati per associare variabili::"

#: tutorial/controlflow.rst:305

msgid ""

"Study that one carefully! The first pattern has two literals, and can be "

"thought of as an extension of the literal pattern shown above. But the next "

"two patterns combine a literal and a variable, and the variable *binds* a "

"value from the subject (``point``). The fourth pattern captures two values, "

"which makes it conceptually similar to the unpacking assignment ``(x, y) = "

"point``."

msgstr ""

"Studialo attentamente! Il primo schema ha due letterali, e può essere "

"pensato come un'estensione dello schema letterale mostrato sopra. Ma i "

"successivi due schemi combinano un letterale e una variabile, e la variabile "

"*associa* un valore dal soggetto (``point``). Il quarto schema cattura due "

"valori, che lo rende concettualmente simile all'assegnazione con *unpacking* "

"``(x, y) = point``."

#: tutorial/controlflow.rst:312

msgid ""

"If you are using classes to structure your data you can use the class name "

"followed by an argument list resembling a constructor, but with the ability "

"to capture attributes into variables::"

msgstr ""

"Se stai utilizzando classi per strutturare i tuoi dati, puoi usare il nome "

"della classe seguito da un elenco di argomenti che assomiglia a un "

"costruttore, ma con la capacità di catturare attributi in variabili::"

#: tutorial/controlflow.rst:334

msgid ""

"You can use positional parameters with some builtin classes that provide an "

"ordering for their attributes (e.g. dataclasses). You can also define a "

"specific position for attributes in patterns by setting the "

"``__match_args__`` special attribute in your classes. If it's set to (\"x\", "

"\"y\"), the following patterns are all equivalent (and all bind the ``y`` "

"attribute to the ``var`` variable)::"

msgstr ""

"Puoi utilizzare parametri posizionali con alcune classi integrate che "

"forniscono un ordinamento per i loro attributi (ad esempio le dataclassi). "

"Puoi anche definire una posizione specifica per gli attributi negli schemi "

"impostando l'attributo speciale ``__match_args__`` nelle tue classi. Se è "

"impostato su (\"x\", \"y\"), gli schemi seguenti sono tutti equivalenti (e "

"tutti associano l'attributo ``y`` alla variabile ``var``)::"

#: tutorial/controlflow.rst:345

msgid ""

"A recommended way to read patterns is to look at them as an extended form of "

"what you would put on the left of an assignment, to understand which "

"variables would be set to what. Only the standalone names (like ``var`` "

"above) are assigned to by a match statement. Dotted names (like ``foo."

"bar``), attribute names (the ``x=`` and ``y=`` above) or class names "

"(recognized by the \"(...)\" next to them like ``Point`` above) are never "

"assigned to."

msgstr ""

"Un modo consigliato per leggere gli schemi è considerarli come una forma "

"estesa di quello che metteresti a sinistra di un'assegnazione, per capire "

"quali variabili verrebbero impostate su cosa. Solo i nomi autonomi (come "

"``var`` qui sopra) vengono assegnati da un'istruzione di match. I nomi "

"puntati (come ``foo.bar``), i nomi degli attributi (il ``x=`` e ``y=`` qui "

"sopra) o i nomi delle classi (riconosciuti dalle \"(...)\" accanto a loro "

"come ``Point`` qui sopra) non vengono mai assegnati."

#: tutorial/controlflow.rst:352

msgid ""

"Patterns can be arbitrarily nested. For example, if we have a short list of "

"Points, with ``__match_args__`` added, we could match it like this::"

msgstr ""

"Gli schemi possono essere arbitrariamente nidificati. Ad esempio, se abbiamo "

"una breve lista di Punti, con ``__match_args__`` aggiunto, potremmo "

"abbinarla così::"

#: tutorial/controlflow.rst:373

msgid ""

"We can add an ``if`` clause to a pattern, known as a \"guard\". If the "

"guard is false, ``match`` goes on to try the next case block. Note that "

"value capture happens before the guard is evaluated::"

msgstr ""

"Possiamo aggiungere una clausola ``if`` a uno schema, nota come \"guardia\". "

"Se la guardia è falsa, ``match`` passa a provare il blocco case successivo. "

"Nota che la cattura del valore avviene prima che la guardia venga valutata::"

#: tutorial/controlflow.rst:383

msgid "Several other key features of this statement:"

msgstr "Altre caratteristiche chiave di questa istruzione:"

#: tutorial/controlflow.rst:385

msgid ""

"Like unpacking assignments, tuple and list patterns have exactly the same "

"meaning and actually match arbitrary sequences. An important exception is "

"that they don't match iterators or strings."

msgstr ""

"Come le assegnazioni di decomposizione, gli schemi di tuple e liste hanno "

"esattamente lo stesso significato e corrispondono effettivamente a sequenze "

"arbitrarie. Un'importante eccezione è che non corrispondano a iteratori o "

"stringhe."

#: tutorial/controlflow.rst:389

msgid ""

"Sequence patterns support extended unpacking: ``[x, y, *rest]`` and ``(x, y, "

"*rest)`` work similar to unpacking assignments. The name after ``*`` may "

"also be ``_``, so ``(x, y, *_)`` matches a sequence of at least two items "

"without binding the remaining items."

msgstr ""

"Le sequenze di schemi supportano l'unpacking esteso: ``[x, y, *rest]`` e "

"``(x, y, *rest)`` funzionano in modo simile alle assegnazioni di "

"decomposizione. Il nome dopo ``*`` può anche essere ``_``, quindi ``(x, y, "

"*_)`` corrisponde a una sequenza di almeno due elementi senza la necessità "

"di associare gli elementi rimanenti."

#: tutorial/controlflow.rst:394

msgid ""

"Mapping patterns: ``{\"bandwidth\": b, \"latency\": l}`` captures the "

"``\"bandwidth\"`` and ``\"latency\"`` values from a dictionary. Unlike "

"sequence patterns, extra keys are ignored. An unpacking like ``**rest`` is "

"also supported. (But ``**_`` would be redundant, so it is not allowed.)"

msgstr ""

"Schemi di mapping: ``{\"bandwidth\": b, \"latency\": l}`` cattura i valori "

"``\"bandwidth\"`` e ``\"latency\"`` da un dizionario. A differenza degli "

"schemi di sequenza, le chiavi aggiuntive vengono ignorate. È supportato "

"anche un unpacking come ``**rest``. (Ma ``**_`` sarebbe ridondante, quindi "

"non è possibile utilizzarlo.)"

#: tutorial/controlflow.rst:399

msgid "Subpatterns may be captured using the ``as`` keyword::"

msgstr ""

"I sotto-schemi possono essere catturati utilizzando la parola chiave ``as``::"

#: tutorial/controlflow.rst:403

msgid ""

"will capture the second element of the input as ``p2`` (as long as the input "

"is a sequence of two points)"

msgstr ""

"acquisirà il secondo elemento dell'input come ``p2`` (a patto che l'input "

"sia una sequenza di due punti)"

#: tutorial/controlflow.rst:406

msgid ""

"Most literals are compared by equality, however the singletons ``True``, "

"``False`` and ``None`` are compared by identity."

msgstr ""

"La maggior parte dei letterali sono confrontati per uguaglianza, tuttavia i "

"*singleton* ``True``, ``False`` e ``None`` sono confrontati per identità."

#: tutorial/controlflow.rst:409

msgid ""

"Patterns may use named constants. These must be dotted names to prevent "

"them from being interpreted as capture variable::"

msgstr ""

"Gli schemi possono utilizzare costanti nominate. Queste devono essere nomi "

"puntati per impedire che vengano interpretati come variabili di cattura::"

#: tutorial/controlflow.rst:428

msgid ""

"For a more detailed explanation and additional examples, you can look into :"

"pep:`636` which is written in a tutorial format."

msgstr ""

"Per una spiegazione più dettagliata e ulteriori esempi, puoi consultare :pep:"

"`636` che è scritta in un formato simile a un tutorial."

#: tutorial/controlflow.rst:434

msgid "Defining Functions"

msgstr "Definizione di Funzioni"

#: tutorial/controlflow.rst:436

msgid ""

"We can create a function that writes the Fibonacci series to an arbitrary "

"boundary::"

msgstr ""

"Possiamo creare una funzione che scrive la serie di Fibonacci fino a un "

"limite arbitrario::"

#: tutorial/controlflow.rst:456

msgid ""

"The keyword :keyword:`def` introduces a function *definition*. It must be "

"followed by the function name and the parenthesized list of formal "

"parameters. The statements that form the body of the function start at the "

"next line, and must be indented."

msgstr ""

"La parola chiave :keyword:`def` introduce una *definizione* di funzione. "

"Deve essere seguita dal nome della funzione e dall'elenco tra parentesi dei "

"parametri formali. Le istruzioni che formano il corpo della funzione "

"iniziano alla riga successiva, e devono essere indentate."

#: tutorial/controlflow.rst:461

msgid ""

"The first statement of the function body can optionally be a string literal; "

"this string literal is the function's documentation string, or :dfn:"

"`docstring`. (More about docstrings can be found in the section :ref:`tut-"

"docstrings`.) There are tools which use docstrings to automatically produce "

"online or printed documentation, or to let the user interactively browse "

"through code; it's good practice to include docstrings in code that you "

"write, so make a habit of it."

msgstr ""

"La prima istruzione del corpo della funzione può opzionalmente essere una "

"stringa letterale; questa stringa letterale è la stringa di documentazione "

"della funzione, o :dfn:`docstring`. (Maggiori informazioni sulle docstring "

"possono essere trovate nella sezione :ref:`tut-docstrings`.) Ci sono "

"strumenti che utilizzano le docstring per produrre automaticamente "

"documentazione online o stampata, o per consentire all'utente di navigare "

"interattivamente attraverso il codice; è una buona pratica includere le "

"docstring nel codice che scrivi, quindi prendilo come abitudine."

#: tutorial/controlflow.rst:468

msgid ""

"The *execution* of a function introduces a new symbol table used for the "

"local variables of the function. More precisely, all variable assignments "

"in a function store the value in the local symbol table; whereas variable "

"references first look in the local symbol table, then in the local symbol "

"tables of enclosing functions, then in the global symbol table, and finally "

"in the table of built-in names. Thus, global variables and variables of "

"enclosing functions cannot be directly assigned a value within a function "

"(unless, for global variables, named in a :keyword:`global` statement, or, "

"for variables of enclosing functions, named in a :keyword:`nonlocal` "

"statement), although they may be referenced."

msgstr ""

"L'*esecuzione* di una funzione introduce una nuova tabella dei simboli "

"utilizzata per le variabili locali della funzione. Più precisamente, tutte "

"le assegnazioni di variabili in una funzione memorizzano il valore nella "

"tabella dei simboli locali; mentre i riferimenti alle variabili cercano "

"prima nella tabella dei simboli locali, poi nelle tabelle dei simboli locali "

"delle funzioni circostanti, poi nella tabella dei simboli globali, e infine "

"nella tabella dei nomi incorporati. Pertanto, le variabili globali e le "

"variabili delle funzioni circostanti non possono essere direttamente "

"assegnate un valore all'interno di una funzione (a meno che, per le "

"variabili globali, siano nominate in un'istruzione :keyword:`global`, o, per "

"le variabili delle funzioni circostanti, siano nominate in un'istruzione :"

"keyword:`nonlocal`), anche se possono essere referenziate."

#: tutorial/controlflow.rst:479

msgid ""

"The actual parameters (arguments) to a function call are introduced in the "

"local symbol table of the called function when it is called; thus, arguments "

"are passed using *call by value* (where the *value* is always an object "

"*reference*, not the value of the object). [#]_ When a function calls "

"another function, or calls itself recursively, a new local symbol table is "

"created for that call."

msgstr ""

"I parametri effettivi (argomenti) di una chiamata di funzione vengono "

"introdotti nella tabella dei simboli locali della funzione chiamata quando "

"viene chiamata; quindi, gli argomenti sono passati utilizzando il *passaggio "

"per valore* (dove il *valore* è sempre un *riferimento* all'oggetto, non il "

"valore dell'oggetto). [#]_ Quando una funzione chiama un'altra funzione, o "

"si chiama ricorsivamente, viene creata una nuova tabella dei simboli locali "

"per quella chiamata."

#: tutorial/controlflow.rst:486

msgid ""

"A function definition associates the function name with the function object "

"in the current symbol table. The interpreter recognizes the object pointed "

"to by that name as a user-defined function. Other names can also point to "

"that same function object and can also be used to access the function::"

msgstr ""

"Una definizione di funzione associa il nome della funzione all'oggetto "

"funzione nella tabella dei simboli corrente. L'interprete riconosce "

"l'oggetto puntato da quel nome come una funzione definita dall'utente. Altri "

"nomi possono anche puntare a quello stesso oggetto funzione e possono anche "

"essere utilizzati per accedere alla funzione::"

#: tutorial/controlflow.rst:497

msgid ""

"Coming from other languages, you might object that ``fib`` is not a function "

"but a procedure since it doesn't return a value. In fact, even functions "

"without a :keyword:`return` statement do return a value, albeit a rather "

"boring one. This value is called ``None`` (it's a built-in name). Writing "

"the value ``None`` is normally suppressed by the interpreter if it would be "

"the only value written. You can see it if you really want to using :func:"

"`print`::"

msgstr ""

"Provenendo da altri linguaggi, potresti obiettare che ``fib`` non è una "

"funzione ma una procedura poiché non restituisce un valore. Infatti, anche "

"le funzioni senza un'istruzione :keyword:`return` restituiscono un valore, "

"sebbene piuttosto noioso. Questo valore si chiama ``None`` (è un nome "

"riservato del linguaggio). Scrivere il valore ``None`` è normalmente "

"soppresso dall'interprete se sarebbe l'unico valore scritto. Puoi vederlo se "

"lo desideri davvero utilizzando :func:`print`::"

#: tutorial/controlflow.rst:508

msgid ""

"It is simple to write a function that returns a list of the numbers of the "

"Fibonacci series, instead of printing it::"

msgstr ""

"È semplice scrivere una funzione che restituisce una lista dei numeri della "

"serie di Fibonacci, invece di stamparla::"

#: tutorial/controlflow.rst:524

msgid "This example, as usual, demonstrates some new Python features:"

msgstr ""

"Questo esempio, come al solito, dimostra alcune nuove funzionalità di Python:"

#: tutorial/controlflow.rst:526

msgid ""

"The :keyword:`return` statement returns with a value from a function. :"

"keyword:`!return` without an expression argument returns ``None``. Falling "

"off the end of a function also returns ``None``."

msgstr ""

"L'istruzione :keyword:`return` restituisce un valore da una funzione. :"

"keyword:`!return` senza un argomento espressione restituisce ``None``. Anche "

"uscire dalla fine di una funzione restituisce ``None``."

#: tutorial/controlflow.rst:530

msgid ""

"The statement ``result.append(a)`` calls a *method* of the list object "

"``result``. A method is a function that 'belongs' to an object and is named "

"``obj.methodname``, where ``obj`` is some object (this may be an "

"expression), and ``methodname`` is the name of a method that is defined by "

"the object's type. Different types define different methods. Methods of "

"different types may have the same name without causing ambiguity. (It is "

"possible to define your own object types and methods, using *classes*, see :"

"ref:`tut-classes`) The method :meth:`!append` shown in the example is "

"defined for list objects; it adds a new element at the end of the list. In "

"this example it is equivalent to ``result = result + [a]``, but more "

"efficient."

msgstr ""

"L'istruzione ``result.append(a)`` chiama un *metodo* dell'oggetto lista "

"``result``. Un metodo è una funzione che 'appartiene' a un oggetto e si "

"chiama ``obj.methodname``, dove ``obj`` è un qualche oggetto (questo può "

"essere un'espressione), e ``methodname`` è il nome di un metodo definito dal "

"tipo dell'oggetto. Diversi tipi definiscono metodi diversi. Metodi di tipi "

"diversi possono avere lo stesso nome senza causare ambiguità. (È possibile "

"definire i propri tipi di oggetto e metodi, utilizzando *classi*, vedi :ref:"

"`tut-classes`) Il metodo :meth:`!append` mostrato nell'esempio è definito "

"per gli oggetti lista; aggiunge un nuovo elemento alla fine della lista. In "

"questo esempio è equivalente a ``result = result + [a]``, ma più efficiente."

#: tutorial/controlflow.rst:545

msgid "More on Defining Functions"

msgstr "Ulteriori informazioni sulla Definizione di Funzioni"

#: tutorial/controlflow.rst:547

msgid ""

"It is also possible to define functions with a variable number of arguments. "

"There are three forms, which can be combined."

msgstr ""

"È anche possibile definire funzioni con un numero variabile di argomenti. "

"Esistono tre forme, che possono essere combinate."

#: tutorial/controlflow.rst:554

msgid "Default Argument Values"

msgstr "Valori predefiniti degli argomenti"

#: tutorial/controlflow.rst:556

msgid ""

"The most useful form is to specify a default value for one or more "

"arguments. This creates a function that can be called with fewer arguments "

"than it is defined to allow. For example::"

msgstr ""

"La forma più utile è specificare un valore predefinito per uno o più "

"argomenti. Questo crea una funzione che può essere chiamata con meno "

"argomenti di quelli che è definita per consentire. Ad esempio::"

#: tutorial/controlflow.rst:572

msgid "This function can be called in several ways:"

msgstr "Questa funzione può essere chiamata in diversi modi:"

#: tutorial/controlflow.rst:574

msgid ""

"giving only the mandatory argument: ``ask_ok('Do you really want to quit?')``"

msgstr ""

"dando solo l'argomento obbligatorio: ``ask_ok('Vuoi davvero uscire?')``"

#: tutorial/controlflow.rst:576

msgid ""

"giving one of the optional arguments: ``ask_ok('OK to overwrite the file?', "

"2)``"

msgstr ""

"dando uno degli argomenti opzionali: ``ask_ok('OK sovrascrivere il file?', "

"2)``"

#: tutorial/controlflow.rst:578

msgid ""

"or even giving all arguments: ``ask_ok('OK to overwrite the file?', 2, 'Come "

"on, only yes or no!')``"

msgstr ""

"o addirittura dando tutti gli argomenti: ``ask_ok('OK sovrascrivere il "

"file?', 2, 'Dai su, solo sì o no!')``"

#: tutorial/controlflow.rst:581

msgid ""

"This example also introduces the :keyword:`in` keyword. This tests whether "

"or not a sequence contains a certain value."

msgstr ""

"Questo esempio introduce anche la parola chiave :keyword:`in`. Questo testa "

"se una sequenza contiene o meno un certo valore."

#: tutorial/controlflow.rst:584

msgid ""

"The default values are evaluated at the point of function definition in the "

"*defining* scope, so that ::"

msgstr ""

"I valori predefiniti vengono valutati nel punto di definizione della "

"funzione nello *scope* di definizione, in modo che ::"

#: tutorial/controlflow.rst:595

msgid "will print ``5``."

msgstr "stamperà ``5``."

#: tutorial/controlflow.rst:597

msgid ""

"**Important warning:** The default value is evaluated only once. This makes "

"a difference when the default is a mutable object such as a list, "

"dictionary, or instances of most classes. For example, the following "

"function accumulates the arguments passed to it on subsequent calls::"

msgstr ""

"**Avvertenza importante:** Il valore predefinito viene valutato solo una "

"volta. Questo fa la differenza quando il valore predefinito è un oggetto "

"mutabile come una lista, un dizionario, o istanze della maggior parte delle "

"classi. Ad esempio, la seguente funzione accumula gli argomenti passati ad "

"essa nelle chiamate successive::"

#: tutorial/controlflow.rst:610

msgid "This will print ::"

msgstr "Questo stamperà ::"

#: tutorial/controlflow.rst:616

msgid ""

"If you don't want the default to be shared between subsequent calls, you can "

"write the function like this instead::"

msgstr ""

"Se non vuoi che il valore predefinito sia condiviso tra le chiamate "

"successive, puoi scrivere la funzione in questo modo::"

#: tutorial/controlflow.rst:629

msgid "Keyword Arguments"

msgstr "Argomenti chiave-valore"

#: tutorial/controlflow.rst:631

msgid ""

"Functions can also be called using :term:`keyword arguments <keyword "

"argument>` of the form ``kwarg=value``. For instance, the following "

"function::"

msgstr ""

"Le funzioni possono anche essere chiamate utilizzando :term:`argomenti "

"chiave-valore <keyword argument>` della forma ``kwarg=value``. Ad esempio, "

"la seguente funzione::"

#: tutorial/controlflow.rst:640

msgid ""

"accepts one required argument (``voltage``) and three optional arguments "

"(``state``, ``action``, and ``type``). This function can be called in any "

"of the following ways::"

msgstr ""

"accetta un argomento obbligatorio (``voltage``) e tre argomenti opzionali "

"(``state``, ``action``, e ``type``). Questa funzione può essere chiamata in "

"uno dei seguenti modi::"

#: tutorial/controlflow.rst:651

msgid "but all the following calls would be invalid::"

msgstr "ma tutte le chiamate seguenti non sarebbero valide::"

#: tutorial/controlflow.rst:658

msgid ""

"In a function call, keyword arguments must follow positional arguments. All "

"the keyword arguments passed must match one of the arguments accepted by the "

"function (e.g. ``actor`` is not a valid argument for the ``parrot`` "

"function), and their order is not important. This also includes non-"

"optional arguments (e.g. ``parrot(voltage=1000)`` is valid too). No argument "

"may receive a value more than once. Here's an example that fails due to this "

"restriction::"

msgstr ""

"In una chiamata di funzione, gli argomenti chiave-valore devono seguire gli "

"argomenti posizionali. Tutti gli argomenti chiave passati devono "

"corrispondere a uno degli argomenti accettati dalla funzione (ad esempio, "

"``actor`` non è un argomento valido per la funzione ``parrot``), e il loro "

"ordine non è importante. Questo include anche gli argomenti non opzionali "

"(ad esempio, ``parrot(voltage=1000)`` è valido). Nessun argomento può "

"ricevere un valore più di una volta. Ecco un esempio che fallisce a causa di "

"questa restrizione::"

#: tutorial/controlflow.rst:674

msgid ""

"When a final formal parameter of the form ``**name`` is present, it receives "

"a dictionary (see :ref:`typesmapping`) containing all keyword arguments "

"except for those corresponding to a formal parameter. This may be combined "

"with a formal parameter of the form ``*name`` (described in the next "

"subsection) which receives a :ref:`tuple <tut-tuples>` containing the "

"positional arguments beyond the formal parameter list. (``*name`` must "

"occur before ``**name``.) For example, if we define a function like this::"

msgstr ""

"Quando è presente un parametro formale finale della forma ``**name``, riceve "

"un dizionario (vedi :ref:`typesmapping`) contenente tutti gli argomenti "

"chiave tranne quelli corrispondenti a un parametro formale. Questo può "

"essere combinato con un parametro formale della forma ``*name`` (descritto "

"nella prossima sottosezione) che riceve una :ref:`tupla <tut-tuples>` "

"contenente gli argomenti posizionali oltre all'elenco dei parametri formali. "

"(``*name`` deve occorrere prima di ``**name``.) Ad esempio, se definiamo una "

"funzione in questo modo::"

#: tutorial/controlflow.rst:691

msgid "It could be called like this::"

msgstr "Potrebbe essere chiamato in questo modo::"

#: tutorial/controlflow.rst:699

msgid "and of course it would print:"

msgstr "e naturalmente stamperà:"

#: tutorial/controlflow.rst:712

msgid ""

"Note that the order in which the keyword arguments are printed is guaranteed "

"to match the order in which they were provided in the function call."

msgstr ""

"Nota che l'ordine in cui gli argomenti chiave-valore vengono stampati è "

"garantito corrispondere all'ordine in cui sono stati forniti nella chiamata "

"della funzione."

#: tutorial/controlflow.rst:716

msgid "Special parameters"

msgstr "Parametri speciali"

#: tutorial/controlflow.rst:718

msgid ""

"By default, arguments may be passed to a Python function either by position "

"or explicitly by keyword. For readability and performance, it makes sense to "

"restrict the way arguments can be passed so that a developer need only look "

"at the function definition to determine if items are passed by position, by "

"position or keyword, or by keyword."

msgstr ""

"Per impostazione predefinita, gli argomenti possono essere passati a una "

"funzione Python sia per posizione che esplicitamente per chiave. Per "

"leggibilità e prestazioni, ha senso limitare il modo in cui gli argomenti "

"possono essere passati in modo che uno sviluppatore debba solo guardare la "

"definizione della funzione per determinare se gli elementi sono passati per "

"posizione, per posizione o per chiave, o per chiave."

#: tutorial/controlflow.rst:724

msgid "A function definition may look like:"

msgstr "Ecco come potrebbe essere la definizione di una funzione:"

#: tutorial/controlflow.rst:735

msgid ""

"where ``/`` and ``*`` are optional. If used, these symbols indicate the kind "

"of parameter by how the arguments may be passed to the function: positional-"

"only, positional-or-keyword, and keyword-only. Keyword parameters are also "

"referred to as named parameters."

msgstr ""

"dove ``/`` e ``*`` sono opzionali. Se utilizzati, questi simboli indicano il "

"tipo di parametro in base a come gli argomenti possono essere passati alla "

"funzione: solo per posizione, per posizione o per chiave, e solo per chiave. "

"I parametri chiave-valore sono anche chiamati parametri nominali."

#: tutorial/controlflow.rst:742

msgid "Positional-or-Keyword Arguments"

msgstr "Argomenti Posizionali o per Chiave"

#: tutorial/controlflow.rst:744

msgid ""

"If ``/`` and ``*`` are not present in the function definition, arguments may "

"be passed to a function by position or by keyword."

msgstr ""

"Se ``/`` e ``*`` non sono presenti nella definizione della funzione, gli "

"argomenti possono essere passati a una funzione per posizione o per chiave."

#: tutorial/controlflow.rst:749

msgid "Positional-Only Parameters"

msgstr "Parametri Solo per Posizione"

#: tutorial/controlflow.rst:751

msgid ""

"Looking at this in a bit more detail, it is possible to mark certain "

"parameters as *positional-only*. If *positional-only*, the parameters' order "

"matters, and the parameters cannot be passed by keyword. Positional-only "

"parameters are placed before a ``/`` (forward-slash). The ``/`` is used to "

"logically separate the positional-only parameters from the rest of the "

"parameters. If there is no ``/`` in the function definition, there are no "

"positional-only parameters."

msgstr ""

"Guardando questo in modo più dettagliato, è possibile contrassegnare certi "

"parametri come *solo per posizione*. Se lo sono, l'ordine dei parametri è "

"importante, e i parametri non possono essere passati per chiave. I parametri "

"solo per posizione sono posizionati prima di un ``/`` (barra obliqua). Il ``/"

"`` è utilizzato per separare logicamente i parametri posizionali dal resto "

"dei parametri. Se non c'è un ``/`` nella definizione della funzione, non ci "

"sono parametri posizionali."

#: tutorial/controlflow.rst:759

msgid ""

"Parameters following the ``/`` may be *positional-or-keyword* or *keyword-"

"only*."

msgstr ""

"I parametri che seguono il ``/`` possono essere *posizionali o per chiave* o "

"*solo per chiave*."

#: tutorial/controlflow.rst:763

msgid "Keyword-Only Arguments"

msgstr "Argomenti Solo per Chiave"

#: tutorial/controlflow.rst:765

msgid ""

"To mark parameters as *keyword-only*, indicating the parameters must be "

"passed by keyword argument, place an ``*`` in the arguments list just before "

"the first *keyword-only* parameter."

msgstr ""

"Per contrassegnare i parametri come *solo per chiave*, indicando che i "

"parametri devono essere passati per argomento chiave, posiziona un ``*`` "

"nell'elenco degli argomenti subito prima del primo parametro *solo per "

"chiave*."

#: tutorial/controlflow.rst:771

msgid "Function Examples"

msgstr "Esempi di Funzioni"

#: tutorial/controlflow.rst:773

msgid ""

"Consider the following example function definitions paying close attention "

"to the markers ``/`` and ``*``::"

msgstr ""

"Considera le seguenti definizioni di funzioni di esempio prestando "

"particolare attenzione ai marcatori ``/`` e ``*``::"

#: tutorial/controlflow.rst:789

msgid ""

"The first function definition, ``standard_arg``, the most familiar form, "

"places no restrictions on the calling convention and arguments may be passed "

"by position or keyword::"

msgstr ""

"Nella prima definizione di funzione, ``standard_arg``, la forma più "

"familiare, non pone restrizioni sulla convenzione di chiamata e gli "

"argomenti possono essere passati per posizione o per chiave::"

#: tutorial/controlflow.rst:799

msgid ""

"The second function ``pos_only_arg`` is restricted to only use positional "

"parameters as there is a ``/`` in the function definition::"

msgstr ""

"La seconda funzione ``pos_only_arg`` è limitata a utilizzare solo parametri "

"posizionali poiché c'è un ``/`` nella definizione della funzione::"

#: tutorial/controlflow.rst:810

msgid ""

"The third function ``kwd_only_args`` only allows keyword arguments as "

"indicated by a ``*`` in the function definition::"

msgstr ""

"La terza funzione ``kwd_only_args`` consente solo argomenti chiave-valore "

"come indicato da un ``*`` nella definizione della funzione::"

#: tutorial/controlflow.rst:821

msgid ""

"And the last uses all three calling conventions in the same function "

"definition::"

msgstr ""

"E l'ultimo utilizza tutte e tre le convenzioni di chiamata nella stessa "

"definizione di funzione::"

#: tutorial/controlflow.rst:841

msgid ""

"Finally, consider this function definition which has a potential collision "

"between the positional argument ``name`` and ``**kwds`` which has ``name`` "

"as a key::"

msgstr ""

"Infine, considera questa definizione di funzione che ha un potenziale "

"conflitto tra l'argomento posizionale ``name`` e ``**kwds`` che ha ``name`` "

"come chiave::"

#: tutorial/controlflow.rst:846