# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2019, Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

msgid ""

msgstr ""

"Project-Id-Version: Python 3.7\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2024-05-30 08:10+0200\n"

"PO-Revision-Date: 2024-05-30 09:19+0200\n"

"Last-Translator: Alessandro Cucci <alessandro.cucci@gmail.com>\n"

"Language-Team: \n"

"Language: it_IT\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

"X-Generator: Poedit 2.2.1\n"

#: tutorial/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

msgid ""

"There is no possible call that will make it return ``True`` as the keyword "

"``'name'`` will always bind to the first parameter. For example::"

msgstr ""

"Non esiste una chiamata possibile che lo farà restituire ``True`` poiché la chiave "

"``'name'`` si legherà sempre al primo parametro. Ad esempio::"

#: tutorial/controlflow.rst:855

msgid ""

"But using ``/`` (positional only arguments), it is possible since it allows "

"``name`` as a positional argument and ``'name'`` as a key in the keyword "

"arguments::"

msgstr ""

"Ma utilizzando ``/`` (argomenti solo per posizione), è possibile poiché consente "

"``name`` come argomento posizionale e ``'name'`` come chiave negli argomenti chiave-valore::"

#: tutorial/controlflow.rst:863

msgid ""

"In other words, the names of positional-only parameters can be used in "

"``**kwds`` without ambiguity."

msgstr ""

"In altre parole, i nomi dei parametri solo per posizione possono essere utilizzati in "

"``**kwds`` senza ambiguità."