# OT Python3

**URL:** <https://it.discourse.mcneel.com/t/ot-python3/1854>\
**Category:** Scripting e Programmazione\
**Created:** [13 Luglio 2018, 1:17am UTC](https://it.discourse.mcneel.com/t/ot-python3/1854 "2018-07-13T01:17:21Z")\
**Posts on this page:** 20\
**Page:** 1

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [13 Luglio 2018, 1:17am UTC](https://it.discourse.mcneel.com/t/ot-python3/1854/1 "2018-07-13T01:17:21Z")

</div>

```python
es 1:
def persona(anni):
    if anni < 18:

es 2:
if persona.anni < 18:

```

nell’esempio 1 la sintassi funziona sia nella versione 2.7 che 3.1  
mi chiedevo se in qualche versione di Python il secondo esempio sia valido?

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [13 Luglio 2018, 4:55am UTC](https://it.discourse.mcneel.com/t/ot-python3/1854/2 "2018-07-13T04:55:10Z")

</div>

Ciao Salvio

( Vedo che la formattazione funziona. 🙂 )

> [@0904](#):
>
> in qualche versione di Python il secondo esempio sia valido

Per quanto ne so (premessa necessaria !), e’ valido se **persona** e’ un’istanza di una classe, in ogni versione di Python.

Poi l’attributo **anni** lo puoi creare e settare dentro o fuori dalla classe,  
ho provato con alcuni esempi:

```python

class tizio:
  pass

persona = tizio()
setattr( persona, 'anni', 99 )
print( persona.anni )

########

class caio:

  def __init__ ( self ):
    self.anni = 0

persona = caio()
persona.anni = 99
print( persona.anni )

########

class sempronio:

  def __init__ ( self, anni ):
    self.anni = anni

persona = sempronio( 99 )
print( persona.anni )

```

Ad esempio, con le classi di RhinoCommon usiamo regolarmente la notazione col punto del tuo esempio 2.

Ciao !

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [13 Luglio 2018, 1:20pm UTC](https://it.discourse.mcneel.com/t/ot-python3/1854/3 "2018-07-13T13:20:53Z")

</div>

ciao Emilio

> [@emilio](#):
>
> ( Vedo che la formattazione funziona. 🙂 )

grazie della dritta, adesso la formattazione è 👌

per quanto riguarda la domanda adesso sono più confuso di prima nel senso, mi è capitato questo esempio:

```python
if persona.anni < 18:
    print("Accesso negato")
    accesso = False
elif persona.anni > 99:
    print("Non è il caso...")
    accesso = False
else:
    accesso = True
    if persona.is_uomo():
        print("Benvenuto")
    else:
        print("Benvenuta")
return accesso

```

come da esempio sopra, il codice non funziona e quindi, senza sapere la soluzione sono andato a tentativi.

in primis ho iniziato con un “def” per poi aggiungere “class”:

```python
class Prova:
    pass
persona=Prova()
def persona(anni,is_uomo):
    if persona.anni < 18:
        print("Accesso negato")
        accesso = False
    elif persona.anni > 99:
        print("Non è il caso...")
        accesso = False
    else:
        accesso = True
        if persona.is_uomo():
            print("Benvenuto")
        else:
            print("Benvenuta")
    return accesso
    print(persona(50,True))

```

il codice non dava errori ma non restituiva nulla.

quindi dopo vari tentativi ho trovato questa soluzione ma ho dovuto modificare il codice originario:

```python
def persona(anni,is_uomo):
    if anni < 18:
        print("Accesso negato")
        accesso = False
    elif anni > 99:
        print("Non è il caso...")
        accesso = False
    else:
        accesso = True
    if is_uomo:
        print("Benvenuto")
    else:
        print("Benvenuta")
    return accesso
print(persona(50,True))

```

ho dovuto togliere (persona.) davanti ad anni e is\_uomo poi rientrare (if persona.is\_uomo) e così funziona

mentre considerando i tuoi suggerimenti e combinando un pò il tutto:

```python
class Prova:
    def __init__ (self,anni,is_uomo):
        self.anni = anni
        self.is_uomo = is_uomo
        
persona = Prova(50,True)

if persona.anni < 18:
    print("Accesso negato")
    accesso = False
elif persona.anni > 99:
    print("Non è il caso...")
    accesso = False
else:
    accesso = True
    if persona.is_uomo:
        print("Benvenuto")
    else:
        print("Benvenuta")
#return accesso

print(accesso)
print(persona.anni)
print(persona.is_uomo)

```

sono arrivato a questo codice che funziona usando (persona.anni) ma mi da errore con (return accesso)

lo sò ho fatto un macello (come al solito)

fatto sta che alla fine il risultato identico all’esempio non l’ho ottenuto ☹

> [@emilio](#):
>
> con le classi di RhinoCommon usiamo regolarmente la notazione col punto del tuo esempio 2.

> [@0904](#):
>
> es 2: if persona.anni \< 18:

tu mi hai confermato che viene usata la sintassi del mio esempio 2. dov’è che sbaglio?

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [13 Luglio 2018, 1:26pm UTC](https://it.discourse.mcneel.com/t/ot-python3/1854/4 "2018-07-13T13:26:21Z")

</div>

Salvio, mi sembra di ricordare l’esempio che citi nel libro di Beri.  
Puoi mica dirmi dove si trova nel libro, cosi’ questa sera ci do’ un’occhiata, anche per curiosita’ … 😉

Grazie

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [13 Luglio 2018, 1:29pm UTC](https://it.discourse.mcneel.com/t/ot-python3/1854/5 "2018-07-13T13:29:56Z")

</div>

certo, si trova sia alla pagina 19

ma anche all’inizio del 5 capitolo

grazie Emilio, gentile come sempre 😄

> [@emilio](#):
>
> cosi’ questa sera ci do’ un’occhiata, anche per curiosita’ … 😉

mi sa che fai bene, di sicuro ci sarà qualcosa nella sua spiegazione che mi è sfuggito ahahahah

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [13 Luglio 2018, 1:32pm UTC](https://it.discourse.mcneel.com/t/ot-python3/1854/6 "2018-07-13T13:32:26Z")

</div>

Grazie Salvio.  
Indagheremo … 🕶

… sai mai che imparo qualcosa …😕

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [13 Luglio 2018, 1:36pm UTC](https://it.discourse.mcneel.com/t/ot-python3/1854/7 "2018-07-13T13:36:19Z")

</div>

> [@emilio](#):
>
> … sai mai che imparo qualcosa …

di sicuro da me si può imparare “cosa non fare” ahahahah

parafrasando “Edison - 10.000 medoti che non funzionano”

potrei pubblicare un libro “come non scrivere i codici” 😃

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [13 Luglio 2018, 8:47pm UTC](https://it.discourse.mcneel.com/t/ot-python3/1854/8 "2018-07-13T20:47:10Z")

</div>

> [@0904](#):
>
> sono arrivato a questo codice che funziona usando (persona.anni) ma mi da errore con (return accesso)
> 
> lo sò ho fatto un macello (come al solito)

Quale macello ?  
A me sembra tutto a posto, bravo ! 🙂

**return** da’ errore perche’ non sei in una funzione.  
Se tu inserisci le istruzioni in una funzione, vedi che poi **return** funziona. 🙂

> [@0904](#):
>
> fatto sta che alla fine il risultato identico all’esempio non l’ho ottenuto

Mah … ho guardato il libro.  
Secondo me il caro Beri stava solo mostrando che aspetto ha il codice Python, con la sua bella indentazione.

( Non mi sembra che il libro parli di un risultato ottenuto con quelle istruzioni … )

A parte il solito proselitismo, quelle istruzioni servono solo a far vedere come va organizzato il codice Python, cioe’ tramite indentazione.

Certo, trattandosi di un libro per principianti, forse si poteva avvisare che il codice mostrato non puo’ essere eseguito cosi’ com’e’ …  
O forse, come dici tu, si tratta di un esercizio camuffato … 😄

… Esercizio che tu hai risolto felicemente … 🙂

Ciao !

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [13 Luglio 2018, 10:15pm UTC](https://it.discourse.mcneel.com/t/ot-python3/1854/9 "2018-07-13T22:15:18Z")

</div>

grazie Emilio sia per l’interessamento che per la pazienza 🙂

ps dopo una pausa presa oggi pomeriggio adesso ho riaccesso il pc ed ho letto la tua risposta  
in effetti si lo avevo capito che il codice che aveva scritto non poteva funzionare cosi com’era  
per questo anche senza esperienza avevo azzardato a cercare di trovare una possibile soluzione  
alla fine mi ero fermato credendo di aver combinato tutti gli algoritmi possibili ma non era così.

infatti mentre leggevo quello che mi hai scritto mi si è illuminata la lampadina  
e la soluzione era più semplice di quanto pensassi, in pratica:  
se una mia soluzione funzionava con (persona.anni) e l’altra funzionava con (return accesso)  
combinando insieme le due soluzioni si avrà il risultato finale 😉

soluzione:

```python
class Prova:
    def __init__ (self,anni,is_uomo):
        self.anni = anni
        self.is_uomo = is_uomo
        persona = Prova
def persona(anni,is_uomo):
    if anni < 18:
        print("Accesso negato")
        accesso = False
    elif anni > 99:
        print("Non è il caso...")
        accesso = False
    else:
        accesso = True
        if is_uomo:
            print("Benvenuto")
        else:
            print("Benvenuta")
    return accesso
print(persona(50,True))

```

in questo modo funziona tutto. come credo era l’intenzione di Beri (o spero non si allontani troppo)  
ok alla prossima e grazie ancora 👍

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [18 Luglio 2018, 12:35am UTC](https://it.discourse.mcneel.com/t/ot-python3/1854/10 "2018-07-18T00:35:32Z")

</div>

gli occhi sono facili ad essere ingannati:

la soluzione che ho proposto non funziona essendo che ho sbagliato ad incollare il codice della seconda Definizione infatti sia “anni” che “is\_uomo” devono essere preceduti da “persona.”

l’euforia mi ha annebbiato la mente cavolo 😒

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [21 Luglio 2018, 8:32pm UTC](https://it.discourse.mcneel.com/t/ot-python3/1854/11 "2018-07-21T20:32:48Z")

</div>

```python
class Class1:
  pass
persona = Class1()
setattr( persona, 'anni', 50 )
setattr( persona, 'is_uomo', True )
def def1():
    if persona.anni < 18:
        print( "Accesso negato" )
        accesso = False
    elif persona.anni > 99:
        print( "Non è il caso..." )
        accesso = False
    else:
        accesso = True
        if persona.is_uomo:
            print( "Benvenuto" )
        else:
            print( "Benvenuta" )
    return accesso
print( def1() )

```

questa volta credo che è la sintassi giusta  
infatti mi funziona sia il “return accesso”  
che “persona.anni” e “persona.is\_uomo”

> [@emilio](#):
>
> ```python
> class tizio:
> pass
> 
> persona = tizio()
> setattr( persona, 'anni', 99 )
> print( persona.anni )
> 
> ```

quindi @emilio in definitiva la tua prima opzione si collega bene al resto del codice  
garzie ancora, anche per la formattazione è una bomba 😉

ps peccato che nel libro a quanto pare non spiega la differenza tra i vari metodi

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [21 Luglio 2018, 9:03pm UTC](https://it.discourse.mcneel.com/t/ot-python3/1854/12 "2018-07-21T21:03:38Z")

</div>

Ciao Salvio,

Bravo !  
Sei riuscito a replicare le istruzioni che ti incuriosivano … 🙂  
Devo ammettere che sei testardo … 😄

> [@0904](#):
>
> peccato che nel libro a quanto pare non spiega la differenza tra i vari metodi

Scusa, cosa intendi ?  
Di quali metodi parli ?

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [21 Luglio 2018, 11:49pm UTC](https://it.discourse.mcneel.com/t/ot-python3/1854/13 "2018-07-21T23:49:25Z")

</div>

Grazie Emilio, i tuoi elogi li apprezzo molto.

> [@emilio](#):
>
> Devo ammettere che sei testardo … 😄

ahahahah

beh in effetti la qualità che mi ha sempre permesso di superarmi è proprio la tenacia  
io provo a passare avanti, ma se non risolvo gli intoppi non mi sento soddisfatto

> [@emilio](#):
>
> Di quali metodi parli ?

ho scritto metodo nel senso tra le 3 scelte che mi hai consigliato (metodo 1 - 2 - 3)

nel cap8 pag106 del libro c’è un esempio della funzione “setattr”  
sarà una mia mancanza ma senza il tuo esempio non avrei risolto

in pratica come faccio a sapere quando usare “init” o “setattr”  
o altre funzioni per avere un risultato se non conosco le differenze?

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [22 Luglio 2018, 8:25am UTC](https://it.discourse.mcneel.com/t/ot-python3/1854/14 "2018-07-22T08:25:59Z")

</div>

> [@0904](#):
>
> in pratica come faccio a sapere quando usare “init” o “setattr”

Eh … bella domanda … 😄

Qui parilamo di programmazione a oggetti … che e’ una moda che risale (ho cercato su Wikipedia …😄 ) alla nascita del C++ nel 1985.  
Da allora in poi e’ stato un … diluvio di oggettti 😉 …  
Certo, questo paradigma di programmazione ( lo chiamano cosi’ … ) puo’ essere utile in quanto facilita l’organizzazione di dati e procedure, nonche’ il loro riutilizzo.  
( Ad esempio Rhino e’ scritto in C++ )  
Pero’, come gli altri paradigmi precedenti (o successivi, suppongo …) si porta appresso anche una certa ‘filosofia’ su cosa “e’ megilo” o “e’ peggio”.  
( Certi programmatori in quanto a guerre di religione non hanno niente da invidiare all’inquisizione … 😉 )  
Filosofia che in pratica da’ forma al linguaggio di programmazione stesso, stabilendo quali caratteristiche ha o non ha, e di conseguenza come puo’ essere utilizzato (da te, in questo caso … 🙂 )  
Se l’argomento (la progrmmazione ad oggetti) ti interessa, credo che se cerchi sul Web troverai molto materiale da leggere,  
Ai fini pratici, bisogna cercare di capire cosa ti consente di fare il linguaggio, e come …  
Nel tutorial per Python di Van Rossum c’e’ un capito su classi ed oggetti.  
Ho provato a cercare la traduzione in itailano, ma … incredibilmente non l’ho trovata …probabilomente sono io che non so cercare.  
Intanto ti mando il link al testo originale:

> **[9. Classes](https://docs.python.org/2.0/tut/node11.html)**
>
> 9. Classes

Tornando agli esempi di cui parlavamo, posso solo dirti come il vedo io, che non sono certo la fonte miglore per questo tipo di infiormazioni… la programmazione ad oggetti non mi ha mai convinto gran che, diciamo che non ci ho mai capito gran che …😄

Dicevamo:  
se usi \_\_init\_\_() , quello che scrivi dentro \_\_init\_\_() vale per tutti gli oggetti della classe,  
cioe’ se tu definisci l’attributo ‘anni’ dentro \_\_init\_\_(), ogni oggetto di quella classe che tu costruirai in seguito avra’ il suo bell’attributo ‘anni’ gia’ pronto per l’uso. 🙂  
Se invece usi setattr() sull’oggetto ‘persona’ ad esempio, solo quell’oggetto avra’ quell’attributo.  
Gil altri oggetti della stessa classe ne saranno privi.

Almeno questo e’ quello che credo di capire io, ma ti consigilo vivamente di provare in pratica, perche’ posso facilmente aver detto grosse cavolate …

Una volta capito come funziona la cosa … sta a te decidere come fare, oppure ti scegil un filosofo (di programmazione) e segui i suoi precetti …😄

Ciao !

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [22 Luglio 2018, 11:13am UTC](https://it.discourse.mcneel.com/t/ot-python3/1854/15 "2018-07-22T11:13:42Z")

</div>

Ciao Emilio,

> [@emilio](#):
>
> la programmazione ad oggetti non mi ha mai convinto gran che, diciamo che non ci ho mai capito gran che …😄

grazie per la risposta anche se non è tanto incoraggiante leggere la citazione sopra 🙂  
cercando una consolazione come dice il detto: “mal comune mezzo gaudio” ahahahah

grazie anche per il link l’ho memorizzato nei preferiti  
ps nel caso ti potrebbe interessare allego un link in italiano  
[https://www.python.it/doc/Howtothink/Howtothink-html-it/chap14.htm](https://www.python.it/doc/Howtothink/Howtothink-html-it/chap14.htm)  
dove avevo letto qualcosa sulle classi senza capirci gran chè

il tuo link invece mi ha chiarito una situazione che non avevo ancora compreso

```python
>>> class Complex:
... def __init__ (self, realpart, imagpart):
... self.r = realpart
... self.i = imagpart
... 
>>> x = Complex(3.0,-4.5)
>>> x.r, x.i
(3.0, -4.5)

```

dove self.r equivale a realpart mentre in tutti gli altri esempi che ho visionato riportano lo stesso nome  
tipo come nel libro: (self.proteine = proteine) cosa che secondo me fa confondere chi è alle prime armi.

mentre in quest’altro link (simile a quello che hai postato ma senza le classi)

> **[Tutorial per principianti in Python](https://www.python.it/doc/Easytut/easytut-it/easytut-it.html)**
>
> Tutorial per principianti in Python

nel capitolo “Debugging” lo scrittore scrive questa frase:  
Una volta ho impiegato un’intera settimana per correggere un bug dovuto allo scambio di una x con una y.

che dire stringiamo i denti e tiriamo avanti, tanto se ci piacevano le cose semplici non eravamo qui 😉

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [22 Luglio 2018, 4:17pm UTC](https://it.discourse.mcneel.com/t/ot-python3/1854/16 "2018-07-22T16:17:30Z")

</div>

> [@0904](#):
>
> ps nel caso ti potrebbe interessare allego un link in italiano

Grazie ! … E’ quello che non trovavo io … 😀

> [@0904](#):
>
> (self.proteine = proteine) cosa che secondo me fa confondere chi è alle prime armi.

Vero !  
Occhio che la stessa cosa spesso si fa anche per i parametri delle funzioni, tipo:

```python
def somma( a, b ):
  return a + b

a = 22
b = 33
print( somma( a, b ) )
# o anche:
print( somma( a = a, b = b ) )

```

> [@0904](#):
>
> Una volta ho impiegato un’intera settimana per correggere un bug dovuto allo scambio di una x con una y.

Beh … speriamo che non ci capiti con uno script che ci serve per un lavoro urgente … 🤣

> [@0904](#):
>
> se ci piacevano le cose semplici non eravamo qui

Hehe … al contrario, io mi faccio gli script proprio per semplificare le cose … 😉

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [22 Luglio 2018, 8:25pm UTC](https://it.discourse.mcneel.com/t/ot-python3/1854/17 "2018-07-22T20:25:15Z")

</div>

mi sto meravigliando di come Python permetta che si possa creare questa confusione  
mette dei vincoli sull’indentazione tiene conto delle Maiuscole e poi ti fa usare lo stesso nome nei parametri

```python
def somma( a, b ):
  return c + d

c = 22
d = 33

print( somma( c, d ) )
# o anche:
print( somma( a = c, b = d ) )

```

Emilio ho fatto alcune prove e in questo modo funziona, spero sia la conversione giusta?

chissà @lucio_zadra quante risate si sta facendo leggendo i miei post ahah  
disse che era interessato a Python, speravo che si aggregava anche lui 🙂

EDIT:

continuando con il discorso stavo facendo delle prove:

```python
def saluto(par1):
    print('ciao', par1) #x
nome=['tizio','caio','sempronio']
for x in nome:
    saluto(x)

```

```python
def saluto(par1):
    print('ciao', x) #par1
nome=['tizio','caio','sempronio']
for x in nome:
    saluto(x)

```

i due codici funzionano entrambi con l’identico risultato  
ma come sintassi quale dei due è quella corretta?

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [23 Luglio 2018, 5:01am UTC](https://it.discourse.mcneel.com/t/ot-python3/1854/18 "2018-07-23T05:01:56Z")

</div>

> [@0904](#):
>
> mi sto meravigliando di come Python permetta che si possa creare questa confusione

Mah … su queste cose ognuno ha la sua idea.  
Chi preferisce un linguaggio ‘sbirro’ che decide lui cosa puoi o non puoi fare.  
Chi preferisce un linguaggio ‘strumento’, che puoi usare come ti pare e piace.  
Io propendo per la seconda …  
Come dicevo, diffido delle filosofie di programmazione gia’ cotte e servite … 😉  
( Inoltre non sono una multinazionale con grossi problemi di manutenzione del software … 😄 )

In questo caso, a me sembra utile poter usare lo stesso nome (ma e’ solo il mio parere).  
A volte lo faccio, ad esempio quando uso una funzione non per eseguire un’operazione generica (tipo una funzione di libreria), ma per dividere una funzione troppo lunga (secondo me) in 2 o 3 parti.  
In questo caso mi sembra comodo conservare lo stesso nome della variabile.

E comunque quando mi sembra il nome piu’ appropriato per il parametro.

Facciamo una prova … virtuale …  
Scrivi una funzione (tipo libreria) che poi userai in centinaia di script.  
Non ti sembra scomodo ogni volta che usi la funzione doverti preoccupare del nome del parametro da passarle ?  
E se tu per caso hai una variabile con lo stesso nome, come fai ?  
Cambi nome alla variabile, cosi’ magari ‘cozzi’ con un altro parametro in un’altra funzione …  
Oppure devi usare una variabile ausiliaria solo per poter usare la tua funziona di libreria …  
O altre cose piuttosto stupide, tipo sommare zero a un numero …  
A me sembrerebbe demenziale … 😄

Un linguaggio di solito non deve servire solo per fare test di 4 o 5 istruzioni, ma deve permetterti di scrivere anche cose piu’ grandi senza troppi problemi.  
Poi, certo, ci sono linguaggi adatti soprattutto per brevi script, ma Python non mi risulta che abbia questi limiti.  
Anzi, spesso e’ apprezzato proprio perche’ permette di scrivere agevolmente cose piuttosto complesse. 🙂

> [@0904](#):
>
> i due codici funzionano entrambi con l’identico risultato  
> ma come sintassi quale dei due è quella corretta?

Se non fossero corrette entrambe, non funzionerebbero … 🕶 … 😄

Sulla prima niente da dire, passi un parametro e lo usi.

La seconda la scriverei cosi’

```python
def saluto():
    print('ciao', x)
nome=['tizio','caio','sempronio']
for x in nome:
    saluto()

```

il parametro **par1** e’ inutile, non lo usi.  
Invece usi la **x** come variabile globale, cioe’ definita fuori dalla funzione.

Comunque non c’e’ niente di male a scriverla come hai fatto tu, se funziona, e’ OK. 🙂

Python ti permette di usare parametri di funzione o variabili globali.  
Scegli tu, caso per caso, cosa preferisci. 🙂

---

<div class="post-metadata">

**Author:** ![0904](https://avatars.discourse-cdn.com/v4/letter/0/b3f665/32.png) [@0904](https://it.discourse.mcneel.com/u/0904)\
**Post date:** [23 Luglio 2018, 9:31am UTC](https://it.discourse.mcneel.com/t/ot-python3/1854/19 "2018-07-23T09:31:15Z")

</div>

infatti Emilio chiedo e faccio domande proprio per capire il perchè si è scelto di impostare la sintassi di Python in un modo o in un’altro, perchè come giustamente hai detto io che scrivo poche righe di codice è un conto ovviamente non conosco tutte le possibili situazini che si possono incontrare facendo una “programmazione” nel vero senso della parola, ovviamente il discorso li cambia e non di poco.

grazie come sempre adesso mi è più chiara la situazione 👍

---

<div class="post-metadata">

**Author:** ![emilio](https://sea3.discourse-cdn.com/mcneel/user_avatar/it.discourse.mcneel.com/emilio/32/16095_2.png) [@emilio](https://it.discourse.mcneel.com/u/emilio)\
**Post date:** [23 Luglio 2018, 9:42am UTC](https://it.discourse.mcneel.com/t/ot-python3/1854/20 "2018-07-23T09:42:31Z")

</div>

> [@0904](#):
>
> per capire il perchè si è scelto di impostare la sintassi di Python in un modo o in un’altro

Purtroppo io posso solo dirti come la vedo io da povero scriptomane …  
I motivi veri andrebbero chiesti a Van Rossum. 🙂

Comunque anche senza conoscere bene le motivazioni, possiamo divertirci a scriptare sfruttando quello che c’e’ … 😀

… Praticamente e’ quello che capita anche con Rhino (almeno per me …). 😄

[Pagina seguente](https://it.discourse.mcneel.com/t/ot-python3/1854.md?page=2)