Introduction to Python/it: Difference between revisions

From FreeCAD Documentation
No edit summary
(Updating to match new version of source page)
(28 intermediate revisions by 3 users not shown)
Line 1: Line 1:
<languages/>
<languages/>

<div class="mw-translate-fuzzy">
{{docnav/it|[[Macros/it|Macro]]|[[Python scripting tutorial/it|Guida agli script Python]]}}
{{docnav/it|[[Macros/it|Macro]]|[[Python scripting tutorial/it|Guida agli script Python]]}}
</div>


{{TOCright}}
{{VeryImportantMessage|(Novembre 2018) FreeCAD è stato originariamente progettato per funzionare con Python 2. Molte funzioni funzionano con Python 3, ma altre no. È in corso un lavoro per fare in modo che FreeCAD supporti pienamente Python 3.
Qui le informazioni descrivono Python 2, ma la maggior parte del codice dovrebbe funzionare allo stesso modo con Python 3. In particolare, la funzione {{incode|print()}} è preferita rispetto alla vecchia {{incode|print}}.}}


==Introduzione==
Questo è una breve guida realizzata per chi si avvicina per la prima volta a Python.
[http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python] è un [http://en.wikipedia.org/wiki/Programming_language linguaggio di programmazione] multi-piattaforma open-source.
Python dispone di numerose funzionalità che lo rendono molto diverso dagli altri comuni linguaggi di programmazione, ed è facilmente accessibile ai nuovi utenti:


Questo è un breve tutorial per quelli nuovi di [https://it.wikipedia.org/wiki/Python Python]. Python è un [https://it.wikipedia.org/wiki/Linguaggio_di_programmazione Linguaggio di programmazione] sorgente-aperto e multipiattaforma . Ha diverse caratteristiche che lo rendono diverso dagli altri linguaggi di programmazione, e molto accessibile ai nuovi utenti:

<div class="mw-translate-fuzzy">
* È stato progettato appositamente per essere letto facilmente dalle persone, quindi è molto facile da imparare e da capire.
* È stato progettato appositamente per essere letto facilmente dalle persone, quindi è molto facile da imparare e da capire.
* È interpretato, ciò significa che, a differenza dei linguaggi compilati come il C, non è necessario compilare il programma prima di poterlo eseguire. Quando si desidera, il codice che si scrive può essere eseguito immediatamente, riga dopo riga. Siccome si procede gradualmente, passo dopo passo, è facile impararlo e trovare gli eventuali errori nel codice.
* È interpretato, ciò significa che, a differenza dei linguaggi compilati come il C, non è necessario compilare il programma prima di poterlo eseguire. Quando si desidera, il codice che si scrive può essere eseguito immediatamente, riga dopo riga. Siccome si procede gradualmente, passo dopo passo, è facile impararlo e trovare gli eventuali errori nel codice.
* Può essere incorporato in altri programmi per essere usato come linguaggio di script. FreeCAD ha un interprete Python integrato, così, in FreeCAD, è possibile scrivere dei codici Python che manipolano parti di FreeCAD, ad esempio per creare la geometria. Questo è estremamente performante, perché invece di premere semplicemente un pulsante denominato "Crea sfera", che un programmatore ha messo a disposizione, si ha la libertà di creare facilmente dei propri strumenti per produrre una particolare geometria desiderata.
* Può essere incorporato in altri programmi per essere usato come linguaggio di script. FreeCAD ha un interprete Python integrato, così, in FreeCAD, è possibile scrivere dei codici Python che manipolano parti di FreeCAD, ad esempio per creare la geometria. Questo è estremamente performante, perché invece di premere semplicemente un pulsante denominato "Crea sfera", che un programmatore ha messo a disposizione, si ha la libertà di creare facilmente dei propri strumenti per produrre una particolare geometria desiderata.
* È estensibile. Si possono inserire facilmente dei nuovi moduli nella propria installazione di Python ed estenderne le funzionalità. Ad esempio, esistono moduli Python che permettono di leggere e scrivere le immagini jpg, di comunicare con Twitter, di programmare le operazioni del proprio sistema operativo, ecc.
* È estensibile. Si possono inserire facilmente dei nuovi moduli nella propria installazione di Python ed estenderne le funzionalità. Ad esempio, esistono moduli Python che permettono di leggere e scrivere le immagini jpg, di comunicare con Twitter, di programmare le operazioni del proprio sistema operativo, ecc.
</div>


<div class="mw-translate-fuzzy">
Ora, mettiamoci al lavoro! Ricordare che ciò che verrà dopo è solamente una semplice introduzione e non un tutorial completo. Ma la speranza è che dopo si avranno basi sufficienti per esplorare più in profondità i meccanismi di FreeCAD.
Ora, mettiamoci al lavoro! Ricordare che ciò che verrà dopo è solamente una semplice introduzione e non un tutorial completo. Ma la speranza è che dopo si avranno basi sufficienti per esplorare più in profondità i meccanismi di FreeCAD.
</div>


== L'interprete ==
== L'interprete ==


<div class="mw-translate-fuzzy">
Di solito, per scrivere programmi per computer, basta aprire un editor di testo (o l'ambiente di programmazione preferito che, in genere, è un editor di testo con strumenti aggiuntivi), scrivere il programma, quindi compilarlo ed eseguirlo. Il più delle volte si fanno degli errori di scrittura, per cui il programma non funziona, e si ottiene un messaggio di errore che dà informazioni su cosa è andato storto. Quindi si ritorna all'editor di testo, si correggono gli errori, si esegue di nuovo, e così via fino a quando il programma funziona bene.
Di solito, per scrivere programmi per computer, basta aprire un editor di testo (o l'ambiente di programmazione preferito che, in genere, è un editor di testo con strumenti aggiuntivi), scrivere il programma, quindi compilarlo ed eseguirlo. Il più delle volte si fanno degli errori di scrittura, per cui il programma non funziona, e si ottiene un messaggio di errore che dà informazioni su cosa è andato storto. Quindi si ritorna all'editor di testo, si correggono gli errori, si esegue di nuovo, e così via fino a quando il programma funziona bene.
</div>


<div class="mw-translate-fuzzy">
In Python, l'intero processo, può essere eseguito in modo trasparente all'interno del suo interprete. L'interprete Python è una finestra con un prompt dei comandi, dove si può digitare direttamente il codice Python. Se si installa Python sul ​​proprio computer (scaricarlo dal [http://www.python.org sito web di Python] se lavorate su Windows o Mac, installarlo dal repository dei pacchetti se utilizzate GNU/Linux), si avrà un interprete Python nel menu di avvio. FreeCAD dispone di un proprio interprete Python visualizzato nella sua finestra inferiore:
In Python, l'intero processo, può essere eseguito in modo trasparente all'interno del suo interprete. L'interprete Python è una finestra con un prompt dei comandi, dove si può digitare direttamente il codice Python. Se si installa Python sul ​​proprio computer (scaricarlo dal [http://www.python.org sito web di Python] se lavorate su Windows o Mac, installarlo dal repository dei pacchetti se utilizzate GNU/Linux), si avrà un interprete Python nel menu di avvio. FreeCAD dispone di un proprio interprete Python visualizzato nella sua finestra inferiore:
</div>

[[Image:FreeCAD_Python_console.png]]
{{Caption|La console di FreeCAD Python}}


Se non la vedi, clicca su {{MenuCommand|Vista → Pannelli → Console Python}}. La console Python può essere ridimensionata e anche sganciata.
[[Image:Screenshot_pythoninterpreter.jpg]]


L'interprete mostra la versione di Python, poi un simbolo {{incode|>>>}} che è il prompt dei comandi. Scrivere codice nell'interprete è semplice: una linea è un'istruzione. Quando premete {{KEY|Invio}}, la vostra linea di codice verrà eseguita (dopo essere stata istantaneamente e invisibilmente compilata). Per esempio, provate a scrivere questo:
Se non è visibile, cliccare su Visualizza → Viste → Console Python.


L'interprete mostra la versione di Python, quindi il simbolo >>>, che è il suo prompt dei comandi, cioè, dove si deve inserire il codice Python. Scrivere il codice nell'interprete è semplice: ogni riga è una istruzione. Quando si preme Invio, la riga di codice viene eseguita (dopo essere stata istantaneamente e invisibilmente compilata). Ad esempio, provare a scrivere questo:
{{Code|code=
{{Code|code=
print "hello"
print("hello")
}}
}}

per Python <code>print</code> è una speciale parola chiave che, ovviamente, serve per stampare qualcosa sullo schermo. Quando si preme Invio, l'operazione viene eseguita, e viene stampato il messaggio "ciao". Se si commette un errore, provare, per esempio, a scrivere:
{{incode|print()}} è un comando Python che, ovviamente, stampa qualcosa sullo schermo. Quando si preme {{KEY|Invio}}, l'operazione viene eseguita e viene stampato il messaggio {{incode|"hello"}}. Se si commette un errore, per esempio scriviamo:

{{Code|code=
{{Code|code=
print hello
print(hello)
}}
}}
Python dice che non conosce ciao. I caratteri " " specificano che il contenuto è una stringa. In gergo tecnico, una stringa è semplicemente un pezzo di testo. Senza i segni ", la parola ciao viene vista come una specificazione del comando di stampa, cioè come una speciale parola chiave di Python, e non come un testo. Il fatto importante è che l'errore viene immediatamente notificato. Premendo la freccia verso l'alto (o, nell'interprete di FreeCAD, CTRL + freccia su), si può tornare all'ultimo comando scritto e correggerlo.


Python ve lo dirà immediatamente. In questo caso Python non sa cosa sia {{incode|hello}}. I caratteri {{incode|" "}} specificano che il contenuto è una stringa, gergo di programmazione per un pezzo di testo. Senza questi il comando {{incode|print()}} non riconosce {{incode|hello}}. Premendo la freccia su si può tornare indietro all'ultima linea di codice e correggerla.
L'interprete Python possiede anche un sistema di aiuto incorporato. Provare a digitare:

{{Code|code=
L'interprete Python ha anche un sistema di aiuto integrato. Diciamo che non capiamo cosa è andato storto con {{incode|print(hello)}} e vogliamo informazioni specifiche sul comando:
help

}}
oppure, ad esempio, se non si riesce a capire cosa è andato storto con il precedente comando print ciao, e si desiderano delle informazioni specifiche sul comando "print" digitare:
{{Code|code=
{{Code|code=
help("print")
help("print")
}}
}}

<div class="mw-translate-fuzzy">
Si ottiene una lunga e completa descrizione di tutto quello che può fare il comando print.
Si ottiene una lunga e completa descrizione di tutto quello che può fare il comando print.
</div>


<div class="mw-translate-fuzzy">
Ora che si ha il controllo totale dell'interprete, si può cominciare con le cose significative.
Ora che si ha il controllo totale dell'interprete, si può cominciare con le cose significative.
</div>

{{Top}}
==Variabili==
==Variabili==


<div class="mw-translate-fuzzy">
Naturalmente, stampare "ciao" non è molto interessante. Più interessante è stampare cose che non si conoscono prima, o lasciare che Python le trovi per noi. Qui entra in gioco il concetto di variabile. Una variabile è semplicemente un valore che viene memorizzato con un nome specifico. Ad esempio, digitare questo:
Naturalmente, stampare "ciao" non è molto interessante. Più interessante è stampare cose che non si conoscono prima, o lasciare che Python le trovi per noi. Qui entra in gioco il concetto di variabile. Una variabile è semplicemente un valore che viene memorizzato con un nome specifico. Ad esempio, digitare questo:
</div>

{{Code|code=
{{Code|code=
a = "hello"
a = "hello"
print a
print(a)
}}
}}

<div class="mw-translate-fuzzy">
Sicuramente si capisce quello che succede, la stringa "ciao" viene "salvata" sotto il nome "a". Ora, "a" non è più un nome sconosciuto! Si può usare ovunque, per esempio nel comando print. È possibile utilizzare qualsiasi nome che si desideri, basta rispettare alcune semplici regole, tipo non usare spazi o segni di punteggiatura. Ad esempio, si potrebbe tranquillamente scrivere:
Sicuramente si capisce quello che succede, la stringa "ciao" viene "salvata" sotto il nome "a". Ora, "a" non è più un nome sconosciuto! Si può usare ovunque, per esempio nel comando print. È possibile utilizzare qualsiasi nome che si desideri, basta rispettare alcune semplici regole, tipo non usare spazi o segni di punteggiatura. Ad esempio, si potrebbe tranquillamente scrivere:
</div>

{{Code|code=
{{Code|code=
hello = "my own version of hello"
hello = "my own version of hello"
print hello
print(hello)
}}
}}

<div class="mw-translate-fuzzy">
Visto? ciao ora non è più una parola indefinita. E se, per sfortuna, si sceglie un nome che in Python esiste già? Supponiamo di voler conservare una stringa con il nome "print":
Visto? ciao ora non è più una parola indefinita. E se, per sfortuna, si sceglie un nome che in Python esiste già? Supponiamo di voler conservare una stringa con il nome "print":
</div>
{{Code|code=

print = "hello"
}}
Python è molto intelligente e ci dice che questo non è possibile. Possiede alcune parole chiave "riservate" che non possono essere modificate. Invece le nostre variabili possono essere modificate in qualsiasi momento, il che è esattamente il motivo per cui sono chiamate variabili, ovvero il contenuto può variare. Ad esempio:
{{Code|code=
{{Code|code=
myVariable = "hello"
myVariable = "hello"
print myVariable
print(myVariable)
myVariable = "good bye"
myVariable = "good bye"
print myVariable
print(myVariable)
}}
}}

<div class="mw-translate-fuzzy">
Il valore di myVariable è stato cambiato. Le variabili possono anche essere copiate:
Il valore di myVariable è stato cambiato. Le variabili possono anche essere copiate:
</div>

{{Code|code=
{{Code|code=
var1 = "hello"
var1 = "hello"
var2 = var1
var2 = var1
print var2
print(var2)
}}
}}

<div class="mw-translate-fuzzy">
Notare che è importante dare alle variabili dei nomi descrittivi. Quando si scrivono programmi lunghi, dopo un po' probabilmente non si ricorda più cosa rappresenta la variabile denominata "a". Se invece viene chiamata, ad esempio, MioMessaggioDiBenvenuto, quando la si vede, si capisce facilmente a cosa serve. In più è un passo avanti verso l'autodocumentazione del proprio codice.
Notare che è importante dare alle variabili dei nomi descrittivi. Quando si scrivono programmi lunghi, dopo un po' probabilmente non si ricorda più cosa rappresenta la variabile denominata "a". Se invece viene chiamata, ad esempio, MioMessaggioDiBenvenuto, quando la si vede, si capisce facilmente a cosa serve. In più è un passo avanti verso l'autodocumentazione del proprio codice.
</div>


<div class="mw-translate-fuzzy">
La differenza tra maiuscole e minuscole è molto importante. myVariable non è uguale a myvariable, la differenza è tra '''v''' maiuscola e minuscola. Se si inserisce "print myvariable", viene restituito un errore non definito.
La differenza tra maiuscole e minuscole è molto importante. myVariable non è uguale a myvariable, la differenza è tra '''v''' maiuscola e minuscola. Se si inserisce "print myvariable", viene restituito un errore non definito.
</div>

{{Top}}
==Numeri==
==Numeri==


<div class="mw-translate-fuzzy">
È noto che la programmazione serve per trattare ogni tipo di dati, non solo le stringhe di testo, ma soprattutto i numeri. È molto importante che Python sappia che tipo di dati deve trattare. Nell'esempio precedente, con print ciao, si è visto che il comando print ha riconosciuto la nostra stringa "ciao". Questo perché utilizzando il segno ", abbiamo specificato al comando print che ciò che seguiva era una stringa di testo.
È noto che la programmazione serve per trattare ogni tipo di dati, non solo le stringhe di testo, ma soprattutto i numeri. È molto importante che Python sappia che tipo di dati deve trattare. Nell'esempio precedente, con print ciao, si è visto che il comando print ha riconosciuto la nostra stringa "ciao". Questo perché utilizzando il segno ", abbiamo specificato al comando print che ciò che seguiva era una stringa di testo.
</div>


<div class="mw-translate-fuzzy">
Per controllare in qualsiasi momento di quale tipo sono i dati contenuti in una variabile si utilizza la speciale parola chiave di Python type():
Per controllare in qualsiasi momento di quale tipo sono i dati contenuti in una variabile si utilizza la speciale parola chiave di Python type():
</div>

{{Code|code=
{{Code|code=
myVar = "hello"
myVar = "hello"
type(myVar)
type(myVar)
}}
}}

<div class="mw-translate-fuzzy">
In questo caso ci dice che il contenuto di myVar è 'str', ovvero una stringa in gergo Python. Ci sono anche altri tipi di dati, ad esempio i numeri interi (integer) e i numeri in virgola mobile (float numbers):
In questo caso ci dice che il contenuto di myVar è 'str', ovvero una stringa in gergo Python. Ci sono anche altri tipi di dati, ad esempio i numeri interi (integer) e i numeri in virgola mobile (float numbers):
</div>

{{Code|code=
{{Code|code=
firstNumber = 10
firstNumber = 10
secondNumber = 20
secondNumber = 20
print firstNumber + secondNumber
print(firstNumber + secondNumber)
type(firstNumber)
type(firstNumber)
}}
}}

<div class="mw-translate-fuzzy">
Questo è già molto più interessante, vero? Ora si dispone di una potente calcolatrice! Notare bene come funziona. Python capisce che 10 e 20 sono numeri interi, quindi vengono memorizzati come "int", e con essi Python può fare tutte le operazioni consentite con numeri interi. Osservare i risultati di questo codice:
Questo è già molto più interessante, vero? Ora si dispone di una potente calcolatrice! Notare bene come funziona. Python capisce che 10 e 20 sono numeri interi, quindi vengono memorizzati come "int", e con essi Python può fare tutte le operazioni consentite con numeri interi. Osservare i risultati di questo codice:
</div>

{{Code|code=
{{Code|code=
firstNumber = "10"
firstNumber = "10"
secondNumber = "20"
secondNumber = "20"
print firstNumber + secondNumber
print(firstNumber + secondNumber)
}}
}}

<div class="mw-translate-fuzzy">
Visto? Python è stato indotto a considerare le due variabili non più come numeri, ma come semplici parti di testo. Python può unire insieme due parti di testo, ma con esse non cerca di produrre una somma. Torniamo ai numeri. Oltre ai numeri interi (int) ci sono anche i numeri in virgola mobile (float). I numeri interi non hanno una parte decimale, mentre i numeri float possono avere una parte decimale:
Visto? Python è stato indotto a considerare le due variabili non più come numeri, ma come semplici parti di testo. Python può unire insieme due parti di testo, ma con esse non cerca di produrre una somma. Torniamo ai numeri. Oltre ai numeri interi (int) ci sono anche i numeri in virgola mobile (float). I numeri interi non hanno una parte decimale, mentre i numeri float possono avere una parte decimale:
</div>

{{Code|code=
{{Code|code=
var1 = 13
var1 = 13
var2 = 15.65
var2 = 15.65
print "var1 is of type ", type(var1)
print("var1 is of type ", type(var1))
print "var2 is of type ", type(var2)
print("var2 is of type ", type(var2))
}}
}}

<div class="mw-translate-fuzzy">
I numeri Int e Float possono essere mescolati tra di loro senza problemi:
I numeri Int e Float possono essere mescolati tra di loro senza problemi:
</div>

{{Code|code=
{{Code|code=
total = var1 + var2
total = var1 + var2
print total
print(total)
print type(total)
print(type(total))
}}
}}

<div class="mw-translate-fuzzy">
Naturalmente il totale ha dei decimali, vero? Quindi Python ha deciso automaticamente che il risultato è un float. In molti casi, come in questo, Python decide automaticamente il tipo da usare. In altri casi no. Ad esempio con:
Naturalmente il totale ha dei decimali, vero? Quindi Python ha deciso automaticamente che il risultato è un float. In molti casi, come in questo, Python decide automaticamente il tipo da usare. In altri casi no. Ad esempio con:
</div>

{{Code|code=
{{Code|code=
varA = "hello 123"
varA = "hello 123"
varB = 456
varB = 456
print varA + varB
print(varA + varB)
}}
}}

<div class="mw-translate-fuzzy">
Si produce un errore, varA è una stringa e varB è un int, quindi Python non sa cosa fare. Ma possiamo indurre Python a convertire i tipi:
Si produce un errore, varA è una stringa e varB è un int, quindi Python non sa cosa fare. Ma possiamo indurre Python a convertire i tipi:
</div>

{{Code|code=
{{Code|code=
varA = "hello"
varA = "hello"
varB = 123
varB = 123
print varA + str(varB)
print(varA + str(varB))
}}
}}

<div class="mw-translate-fuzzy">
Ora entrambi sono stringhe, e l'operazione funziona! Notare che, con questi comandi, varB è convertita in "stringa" solo al momento della stampa, però varB originale non viene modificata. Per trasformare varB permanentemente in una stringa, si deve fare:
Ora entrambi sono stringhe, e l'operazione funziona! Notare che, con questi comandi, varB è convertita in "stringa" solo al momento della stampa, però varB originale non viene modificata. Per trasformare varB permanentemente in una stringa, si deve fare:
</div>

{{Code|code=
{{Code|code=
varB = str(varB)
varB = str(varB)
}}
}}

<div class="mw-translate-fuzzy">
Inoltre è possibile usare int() e float() per convertire in int e in float:
Inoltre è possibile usare int() e float() per convertire in int e in float:
</div>

{{Code|code=
{{Code|code=
varA = "123"
varA = "123"
print int(varA)
print(int(varA))
print float(varA)
print(float(varA))
}}
}}
'''Note sui comandi Python'''


<div class="mw-translate-fuzzy">
Sicuramente avete notato che in questa sezione il comando di stampa (print) è stato utilizzato in diversi modi. Abbiamo stampato variabili, somme, parti separati da virgole, e anche il risultato di altri comandi Python, ad esempio type(). Forse avete anche notato che questi due comandi,
Sicuramente avete notato che in questa sezione il comando di stampa (print) è stato utilizzato in diversi modi. Abbiamo stampato variabili, somme, parti separati da virgole, e anche il risultato di altri comandi Python, ad esempio type(). Forse avete anche notato che questi due comandi,
</div>

{{Code|code=
{{Code|code=
type(varA)
type(varA)
print type(varA)
print(type(varA))
}}
}}

<div class="mw-translate-fuzzy">
producono esattamente lo stesso risultato. Questo succede perché siamo nell'interprete, dove ogni cosa viene sempre automaticamente stampata sullo schermo. Per velocizzare, d'ora in avanti si può fare a meno di usarlo e quindi scrivere semplicemente:
producono esattamente lo stesso risultato. Questo succede perché siamo nell'interprete, dove ogni cosa viene sempre automaticamente stampata sullo schermo. Per velocizzare, d'ora in avanti si può fare a meno di usarlo e quindi scrivere semplicemente:
</div>

{{Code|code=
{{Code|code=
myVar = "hello friends"
myVar = "hello friends"
myVar
myVar
}}
}}
{{Top}}
Inoltre avrete notato che con la maggior parte dei comandi (o parole chiave) di Python si usano le parentesi per dire loro su quale contenuto devono operare: type(), int(), str(), ecc. Unica eccezione è il comando print, ma in realtà non si tratta di un'eccezione, anche lui funziona normalmente in questo modo:

print ("ciao")

però, siccome viene utilizzato frequentemente, i programmatori di Python ne hanno creato una versione semplificata.

==Liste==
==Liste==


<div class="mw-translate-fuzzy">
Un altro tipo di dati interessante è una list (lista). Una lista è semplicemente un elenco di altri dati. In modo analogo a come si definisce una stringa di testo usando " ", una lista si definisce usando []:
Un altro tipo di dati interessante è una list (lista). Una lista è semplicemente un elenco di altri dati. In modo analogo a come si definisce una stringa di testo usando " ", una lista si definisce usando []:
</div>

{{Code|code=
{{Code|code=
myList = [1,2,3]
myList = [1, 2, 3]
type(myList)
type(myList)
myOtherList = ["Bart", "Frank", "Bob"]
myOtherList = ["Bart", "Frank", "Bob"]
myMixedList = ["hello", 345, 34.567]
myMixedList = ["hello", 345, 34.567]
}}
}}

<div class="mw-translate-fuzzy">
Come si vede, una lista può contenere dati di qualsiasi tipo. Le liste sono molto utili perché permettono di raggruppare le variabili. Con il gruppo, successivamente, è possibile fare diverse cose, ad esempio contare i suoi componenti:
Come si vede, una lista può contenere dati di qualsiasi tipo. Le liste sono molto utili perché permettono di raggruppare le variabili. Con il gruppo, successivamente, è possibile fare diverse cose, ad esempio contare i suoi componenti:
</div>

{{Code|code=
{{Code|code=
len(myOtherList)
len(myOtherList)
}}
}}

<div class="mw-translate-fuzzy">
o recuperare un elemento da una lista:
o recuperare un elemento da una lista:
</div>

{{Code|code=
{{Code|code=
myName = myOtherList[0]
myName = myOtherList[0]
myFriendsName = myOtherList[1]
myFriendsName = myOtherList[1]
}}
}}

<div class="mw-translate-fuzzy">
Come si vede, mentre il comando len() restituisce il numero totale di elementi in una lista, la loro "posizione" nella lista inizia con 0. Il primo elemento in una lista si trova sempre in posizione 0, quindi nella lista myOtherList, "Bob" è nella posizione 2. Con le liste è possibile eseguire molte altre operazioni, descritte in modo più completo [http://diveintopython.org/native_data_types/lists.html qui], ad esempio, ordinare i suoi contenuti, rimuovere o aggiungere elementi.
Come si vede, mentre il comando len() restituisce il numero totale di elementi in una lista, la loro "posizione" nella lista inizia con 0. Il primo elemento in una lista si trova sempre in posizione 0, quindi nella lista myOtherList, "Bob" è nella posizione 2. Con le liste è possibile eseguire molte altre operazioni, descritte in modo più completo [http://diveintopython.org/native_data_types/lists.html qui], ad esempio, ordinare i suoi contenuti, rimuovere o aggiungere elementi.
</div>


<div class="mw-translate-fuzzy">
Una cosa curiosa: una stringa di testo è molto simile a una lista di caratteri! Provate a fare questo:
Una cosa curiosa: una stringa di testo è molto simile a una lista di caratteri! Provate a fare questo:
</div>

{{Code|code=
{{Code|code=
myvar = "hello"
myvar = "hello"
Line 182: Line 270:
myvar[2]
myvar[2]
}}
}}

<div class="mw-translate-fuzzy">
In genere, tutto quello che si può fare con le liste si può fare anche con le stringhe. In effetti le liste e le stringhe sono entrambe delle sequenze.
In genere, tutto quello che si può fare con le liste si può fare anche con le stringhe. In effetti le liste e le stringhe sono entrambe delle sequenze.
</div>


<div class="mw-translate-fuzzy">
Oltre a stringhe, int, float e liste, in Python sono disponibili molti altri tipi di dati built-in (incorporati), quali ad esempio i [http://www.diveintopython.net/native_data_types/index.html#d0e5174 dictionaries] (collezione di oggetti), oppure si possono creare dei propri tipi di dati utilizzando le [http://www.freenetpages.co.uk/hp/alan.gauld/tutclass.htm classi].
Oltre a stringhe, int, float e liste, in Python sono disponibili molti altri tipi di dati built-in (incorporati), quali ad esempio i [http://www.diveintopython.net/native_data_types/index.html#d0e5174 dictionaries] (collezione di oggetti), oppure si possono creare dei propri tipi di dati utilizzando le [http://www.freenetpages.co.uk/hp/alan.gauld/tutclass.htm classi].
</div>
{{Top}}
==Indentazione==


<div class="mw-translate-fuzzy">
===Indentazione===

Un tipico uso della lista consiste nel navigare al suo interno e di operare con i suoi elementi. Per esempio osservare questo:
Un tipico uso della lista consiste nel navigare al suo interno e di operare con i suoi elementi. Per esempio osservare questo:
</div>

{{Code|code=
{{Code|code=
alldaltons = ["Joe", "William", "Jack", "Averell"]
alldaltons = ["Joe", "William", "Jack", "Averell"]
for dalton in alldaltons:
for dalton in alldaltons:
print dalton + " Dalton"
print(dalton + " Dalton")
}}
}}

<div class="mw-translate-fuzzy">
In questo esempio, la lista viene iterata (nuovo gergo di programmazione!) con il comando "for ... in ..." e con ognuno dei suoi elementi viene eseguito qualcosa.
In questo esempio, la lista viene iterata (nuovo gergo di programmazione!) con il comando "for ... in ..." e con ognuno dei suoi elementi viene eseguito qualcosa.


Notare la speciale sintassi. Il comando "for" termina con un ":" questo indica a Python che ciò che segue è un blocco di uno o più comandi. Subito dopo che viene inserita la riga con il comando che termina con :, il prompt dei comandi cambia in ... il che significa che Python ha riconosciuto un comando terminato con un (:) e quello che segue è parte del comando stesso.
Notare la speciale sintassi. Il comando "for" termina con un ":" questo indica a Python che ciò che segue è un blocco di uno o più comandi. Subito dopo che viene inserita la riga con il comando che termina con :, il prompt dei comandi cambia in ... il che significa che Python ha riconosciuto un comando terminato con un (:) e quello che segue è parte del comando stesso.
</div>


<div class="mw-translate-fuzzy">
Come fa Python a sapere quante delle prossime righe sono da eseguire all'interno dell'operazione for ... in ? Per sapere questo, Python utilizza l'indentazione. Cioè, le righe successive non iniziano immediatamente, ma iniziano con uno o più spazi vuoti, oppure con uno o più spazi di tabulazione. Altri linguaggi di programmazione utilizzano vari metodi, tipo inserire tutto dentro parentesi, ecc. Finché le righe successive sono scritte con la '''stessa indentazione''', esse sono considerate come parte del blocco for-in. Quando si inizia una riga con 2 spazi vuoti e quella successiva con 4, si produce un errore. Per terminare e uscire dal blocco for-in, basta scrivere una nuova riga senza rientro, o semplicemente premere Invio.
Come fa Python a sapere quante delle prossime righe sono da eseguire all'interno dell'operazione for ... in ? Per sapere questo, Python utilizza l'indentazione. Cioè, le righe successive non iniziano immediatamente, ma iniziano con uno o più spazi vuoti, oppure con uno o più spazi di tabulazione. Altri linguaggi di programmazione utilizzano vari metodi, tipo inserire tutto dentro parentesi, ecc. Finché le righe successive sono scritte con la '''stessa indentazione''', esse sono considerate come parte del blocco for-in. Quando si inizia una riga con 2 spazi vuoti e quella successiva con 4, si produce un errore. Per terminare e uscire dal blocco for-in, basta scrivere una nuova riga senza rientro, o semplicemente premere Invio.
</div>


<div class="mw-translate-fuzzy">
L'indentazione è molto utile perché conferisce leggibilità al promma. Se è ampia (usando, ad esempio, tab che crea più spazi invece di un solo), quando si scrive un programma lungo si ha una visione chiara di ciò che viene eseguito all'interno di ogni blocco. Vedremo che anche molti altri comandi diversi da for-in richiedono blocchi indentati.
L'indentazione è molto utile perché conferisce leggibilità al promma. Se è ampia (usando, ad esempio, tab che crea più spazi invece di un solo), quando si scrive un programma lungo si ha una visione chiara di ciò che viene eseguito all'interno di ogni blocco. Vedremo che anche molti altri comandi diversi da for-in richiedono blocchi indentati.
</div>


<div class="mw-translate-fuzzy">
Il comando for-in può essere utilizzato per varie operazioni che devono essere eseguite più volte. Ad esempio, può essere combinato con il comando range():
Il comando for-in può essere utilizzato per varie operazioni che devono essere eseguite più volte. Ad esempio, può essere combinato con il comando range():
</div>

{{Code|code=
{{Code|code=
serie = range(1,11)
serie = range(1, 11)
total = 0
total = 0
print "sum"
print("sum")
for number in serie:
for number in serie:
print number
print(number)
total = total + number
total = total + number
print "----"
print("----")
print total
print(total)
}}
}}

<div class="mw-translate-fuzzy">
<div class="mw-translate-fuzzy">
Per usare i decimali in un loop range.
Per usare i decimali in un loop range.
</div>
</div>


If you would type into the interpreter '''help(range)''' you would see:
If you type into the interpreter {{incode|help(range)}} you will see:

{{Code|code=
{{Code|code=
range(...)
range(...)
Line 223: Line 331:
range(start, stop[, step]) -> list of integers
range(start, stop[, step]) -> list of integers
}}
}}

Here the square brackets denote an optional parameter. However all are expected to be integers. Below we will force the range parameters to be an integer using int()
Here the square brackets denote an optional parameter. However all are expected to be integers. Below we will force the step parameter to be an integer using {{incode|int()}}:

{{Code|code=
{{Code|code=
number = 1000
decimales = 1000 # for 3 decimales
for i in range(0, 180 * number, int(0.5 * number)):
#decimales = 10000 # for 4 decimales ...
print(float(i) / number)
for i in range(int(0 * decimales),int(180 * decimales),int(0.5 * decimales)):
print float(i) / decimales
}}
}}

<div class="mw-translate-fuzzy">
O per operazioni più complesse tipo questa:
O per operazioni più complesse tipo questa:
</div>

{{Code|code=
{{Code|code=
alldaltons = ["Joe", "William", "Jack", "Averell"]
alldaltons = ["Joe", "William", "Jack", "Averell"]
for n in range(4):
for n in range(4):
print alldaltons[n], " is Dalton number ", n
print(alldaltons[n], " is Dalton number ", n)
}}
}}

<div class="mw-translate-fuzzy">
Come si vede, anche il comando range() ha la strana particolarità di iniziare con 0 (quando non si specifica il numero di partenza) e che il suo ultimo numero è uno in meno del numero finale specificato. Ciò, naturalmente, perché questo modo funziona bene con gli altri comandi di Python. Ad esempio:
Come si vede, anche il comando range() ha la strana particolarità di iniziare con 0 (quando non si specifica il numero di partenza) e che il suo ultimo numero è uno in meno del numero finale specificato. Ciò, naturalmente, perché questo modo funziona bene con gli altri comandi di Python. Ad esempio:
</div>

{{Code|code=
{{Code|code=
alldaltons = ["Joe", "William", "Jack", "Averell"]
alldaltons = ["Joe", "William", "Jack", "Averell"]
total = len(alldaltons)
total = len(alldaltons)
for n in range(total):
for n in range(total):
print alldaltons[n]
print(alldaltons[n])
}}
}}

<div class="mw-translate-fuzzy">
Un altro uso interessante dei blocchi indentati si ha con il comando if. Il comando if esegue un blocco di codice solo se una certa condizione è soddisfatta, ad esempio:
Un altro uso interessante dei blocchi indentati si ha con il comando if. Il comando if esegue un blocco di codice solo se una certa condizione è soddisfatta, ad esempio:
</div>

{{Code|code=
{{Code|code=
alldaltons = ["Joe", "William", "Jack", "Averell"]
alldaltons = ["Joe", "William", "Jack", "Averell"]
if "Joe" in alldaltons:
if "Joe" in alldaltons:
print "We found that Dalton!!!"
print("We found that Dalton!!!")
}}
}}

<div class="mw-translate-fuzzy">
Naturalmente, questo esempio stampa sempre la prima frase, ma provare a sostituire la seconda riga con:
Naturalmente, questo esempio stampa sempre la prima frase, ma provare a sostituire la seconda riga con:
</div>

{{Code|code=
{{Code|code=
if "Lucky" in alldaltons:
if "Lucky" in alldaltons:
}}
}}

<div class="mw-translate-fuzzy">
Ora non viene più stampato nulla. Si può anche specificare una dichiarazione: else:
Ora non viene più stampato nulla. Si può anche specificare una dichiarazione: else:
</div>

{{Code|code=
{{Code|code=
alldaltons = ["Joe", "William", "Jack", "Averell"]
alldaltons = ["Joe", "William", "Jack", "Averell"]
if "Lucky" in alldaltons:
if "Lucky" in alldaltons:
print "We found that Dalton!!!"
print("We found that Dalton!!!")
else:
else:
print "Such Dalton doesn't exist!"
print("Such Dalton doesn't exist!")
}}
}}
{{Top}}
==Funzioni==


<div class="mw-translate-fuzzy">
===Funzioni===

I [http://docs.python.org/reference/lexical_analysis.html#identifiers comandi standard di Python] non sono molti. Nella versione corrente di Python ce ne sono circa 30, e ne conosciamo già alcuni di loro. Ma immaginate se potessimo inventare dei nostri propri comandi? Beh, possiamo, ed è estremamente facile. In effetti, la maggior parte dei moduli aggiuntivi che si possono aggiungere nella propria installazione di Python fanno esattamente questo, essi aggiungono dei comandi utilizzabili. In Python un comando personalizzato si chiama funzione e si crea in questo modo:
I [http://docs.python.org/reference/lexical_analysis.html#identifiers comandi standard di Python] non sono molti. Nella versione corrente di Python ce ne sono circa 30, e ne conosciamo già alcuni di loro. Ma immaginate se potessimo inventare dei nostri propri comandi? Beh, possiamo, ed è estremamente facile. In effetti, la maggior parte dei moduli aggiuntivi che si possono aggiungere nella propria installazione di Python fanno esattamente questo, essi aggiungono dei comandi utilizzabili. In Python un comando personalizzato si chiama funzione e si crea in questo modo:
</div>

{{Code|code=
{{Code|code=
def printsqm(myValue):
def printsqm(myValue):
print str(myValue)+" square meters"
print(str(myValue) + " square meters")

printsqm(45)
printsqm(45)
}}
}}

<div class="mw-translate-fuzzy">
<div class="mw-translate-fuzzy">
Estremamente semplice: il comando def() definisce una nuova funzione. Si può dargli un nome, e dentro la parentesi si definiscono gli argomenti che useremo nella nostra funzione. Gli argomenti sono i dati che verranno passati alla funzione.
Estremamente semplice: il comando def() definisce una nuova funzione. Si può dargli un nome, e dentro la parentesi si definiscono gli argomenti che useremo nella nostra funzione. Gli argomenti sono i dati che verranno passati alla funzione.
Line 277: Line 410:
</div>
</div>


<div class="mw-translate-fuzzy">
Estremamente semplice: il comando def() definisce una nuova funzione. Si può dargli un nome, e dentro la parentesi si definiscono gli argomenti che useremo nella nostra funzione. Gli argomenti sono i dati che verranno passati alla funzione.

Ad esempio, osservare il comando len(). Se si scrive semplicemente len() da solo, Python vi dice che ha bisogno di un argomento. Cioè, si vuole len() di qualcosa. Quindi, ad esempio, bisogna scrivere len(myList) per ottenere la lunghezza di myList. Bene, myList è un argomento che viene passato alla funzione len(). La funzione len() è definita in modo da sapere come utilizzare ciò che gli viene passato. Esattamente come si è appena fatto qui.

Il nome "myValue" può contenere qualsiasi oggetto, e viene utilizzato solo all'interno della funzione. È solo un nome assegnato all'argomento in modo da poter operare con esso, però serve anche a fare in modo che la funzione sappia quanti argomenti aspettarsi. Se, ad esempio, si esegue:
Il nome "myValue" può contenere qualsiasi oggetto, e viene utilizzato solo all'interno della funzione. È solo un nome assegnato all'argomento in modo da poter operare con esso, però serve anche a fare in modo che la funzione sappia quanti argomenti aspettarsi. Se, ad esempio, si esegue:
</div>

{{Code|code=
{{Code|code=
printsqm(45,34)
printsqm(45, 34)
}}
}}

<div class="mw-translate-fuzzy">
Si ottiene un errore. La funzione è stata programmata per ricevere un solo argomento, ma ne ha ricevuto due, 45 e 34. In sostituzione, si può eseguire qualcosa di simile a:
Si ottiene un errore. La funzione è stata programmata per ricevere un solo argomento, ma ne ha ricevuto due, 45 e 34. In sostituzione, si può eseguire qualcosa di simile a:
</div>

{{Code|code=
{{Code|code=
def sum(val1,val2):
def sum(val1, val2):
total = val1 + val2
total = val1 + val2
return total
return total


sum(45,34)
myTotal = sum(45, 34)
myTotal = sum(45,34)
}}
}}

<div class="mw-translate-fuzzy">
Dove si crea una funzione che riceve due argomenti, li somma, e restituisce il valore. Ottenere qualcosa è molto utile, perché permette di utilizzare il risultato ottenuto e, ad esempio, memorizzarlo nella variabile myTotal. Naturalmente, visto che siamo nell'interprete e tutto quello che facciamo viene stampato, digitando:
Dove si crea una funzione che riceve due argomenti, li somma, e restituisce il valore. Ottenere qualcosa è molto utile, perché permette di utilizzare il risultato ottenuto e, ad esempio, memorizzarlo nella variabile myTotal. Naturalmente, visto che siamo nell'interprete e tutto quello che facciamo viene stampato, digitando:
</div>
{{Code|code=
{{Top}}
sum(45,34)
==Moduli==
}}
il risultato viene stampato sullo schermo, ma al di fuori dell'interprete, e, siccome non vi è alcun comando di stampa all'interno della funzione, sullo schermo non appare nulla. Per ottenere la stampa, si deve digitare:
{{Code|code=
print sum(45,34)
}}
Per ulteriori informazioni sulle funzioni leggere [http://www.diveintopython.net/getting_to_know_python/declaring_functions.html| qui].

===Moduli===


<div class="mw-translate-fuzzy">
Ora che si ha un'idea di come funziona Python, serve una ultima cosa: Come lavorare con i file e i moduli.
Ora che si ha un'idea di come funziona Python, serve una ultima cosa: Come lavorare con i file e i moduli.
</div>


<div class="mw-translate-fuzzy">
Fino ad ora, abbiamo scritto le istruzioni nell'interprete di Python riga per riga, vero?
Fino ad ora, abbiamo scritto le istruzioni nell'interprete di Python riga per riga, vero?


Line 313: Line 446:


È sufficiente aprire un editor di testo (ad es. il Blocco Note di Windows, o gedit, emacs, o vi per Linux), e scrivere tutte le proprie righe di Python, nello stesso modo in cui si scrivono nell'interprete, con indentazioni, ecc. Quindi, salvare il file da qualche parte, preferibilmente con estensione .py. Tutto qui, ora si dispone di un programma Python completo. Naturalmente, ci sono editor migliori di notepad, citato solo per dimostrare che un programma Python non è altro che un file di testo.
È sufficiente aprire un editor di testo (ad es. il Blocco Note di Windows, o gedit, emacs, o vi per Linux), e scrivere tutte le proprie righe di Python, nello stesso modo in cui si scrivono nell'interprete, con indentazioni, ecc. Quindi, salvare il file da qualche parte, preferibilmente con estensione .py. Tutto qui, ora si dispone di un programma Python completo. Naturalmente, ci sono editor migliori di notepad, citato solo per dimostrare che un programma Python non è altro che un file di testo.
</div>


<div class="mw-translate-fuzzy">
<div class="mw-translate-fuzzy">
Per far eseguire questo programma da Python, ci sono centinaia di modi. In Windows, è sufficiente fare clic sul file, aprirlo con Python, ed eseguirlo. Ma si può anche eseguire con l'interprete di Python stesso. Per fare questo, l'interprete deve sapere dove si trova il programma .py. In FreeCAD, il modo più semplice è quello di inserire il programma in un luogo che l'interprete Python di FreeCAD conosce di default, quale, ad esempio, la cartella bin di FreeCAD, o una qualsiasi delle cartelle Mod. Supponiamo di scrivere questo file:
Per far eseguire questo programma da Python, ci sono centinaia di modi. In Windows, è sufficiente fare clic sul file, aprirlo con Python, ed eseguirlo. Ma si può anche eseguire con l'interprete di Python stesso. Per fare questo, l'interprete deve sapere dove si trova il programma .py. In FreeCAD, il modo più semplice è quello di inserire il programma in un luogo che l'interprete Python di FreeCAD conosce di default, quale, ad esempio, la cartella bin di FreeCAD, o una qualsiasi delle cartelle Mod. (In Linux, si ha probabilmente una directory /home/<username>/.FreeCAD/Mod, aggiungiamo una sottodirectory a quegli script richiamati dove inseriremo il file di testo.) Supponiamo di scrivere questo file:
</div>
</div>

{{Code|code=
{{Code|code=
def sum(a,b):
def sum(a,b):
return a + b
return a + b


print "myTest.py succesfully loaded"
print("myTest.py succesfully loaded")
}}
}}


<div class="mw-translate-fuzzy">
e di salvarlo con il nome MioTest.py nella nostra directory /bin di FreeCAD (o on Linux to /home/<username>/.FreeCAD/Mod/scripts). Ora, avviamo FreeCAD e nella finestra interprete scriviamo:
e di salvarlo con il nome MioTest.py nella nostra directory /bin di FreeCAD (o on Linux to /home/<username>/.FreeCAD/Mod/scripts). Ora, avviamo FreeCAD e nella finestra interprete scriviamo:
</div>

{{Code|code=
{{Code|code=
import myTest
import myTest
}}
}}

<div class="mw-translate-fuzzy">
senza l'estensione. py. Questo comando esegue semplicemente il contenuto del file, riga per riga, esattamente come quando viene scritto nell'interprete. Viene creata la funzione somma, poi viene stampato il messaggio. Però c'è una grande differenza: il comando di importazione (import) serve non solo per eseguire i programmi contenuti in un file, come il nostro, ma anche per caricare le funzioni interne, in modo da renderle disponibili nell'interprete. I file, come il nostro, contenenti funzioni sono chiamati moduli.
senza l'estensione. py. Questo comando esegue semplicemente il contenuto del file, riga per riga, esattamente come quando viene scritto nell'interprete. Viene creata la funzione somma, poi viene stampato il messaggio. Però c'è una grande differenza: il comando di importazione (import) serve non solo per eseguire i programmi contenuti in un file, come il nostro, ma anche per caricare le funzioni interne, in modo da renderle disponibili nell'interprete. I file, come il nostro, contenenti funzioni sono chiamati moduli.
</div>


<div class="mw-translate-fuzzy">
Di solito, come si è fatto in precedenza, quando si scrive la funzione sum() nell'interprete, si digita semplicemente:
Di solito, come si è fatto in precedenza, quando si scrive la funzione sum() nell'interprete, si digita semplicemente:
</div>

{{Code|code=
{{Code|code=
sum(14,45)
sum(14, 45)
}}
}}

<div class="mw-translate-fuzzy">
Invece, quando si importa un modulo contenente una funzione sum(), la sintassi è un po' diversa. Si scrive:
Invece, quando si importa un modulo contenente una funzione sum(), la sintassi è un po' diversa. Si scrive:
</div>

{{Code|code=
{{Code|code=
myTest.sum(14,45)
myTest.sum(14, 45)
}}
}}

<div class="mw-translate-fuzzy">
Cioè, il modulo viene importato come un "contenitore", e tutte le sue funzioni sono all'interno. Dato che è possibile importare più moduli, ciò è estremamente utile per tenere il tutto ben organizzato. In sostanza, quando si vede "qualcosa.qualcosaAltro", con un punto in mezzo, significa che "qualcosaAltro" è contenuto in "qualcosa".
Cioè, il modulo viene importato come un "contenitore", e tutte le sue funzioni sono all'interno. Dato che è possibile importare più moduli, ciò è estremamente utile per tenere il tutto ben organizzato. In sostanza, quando si vede "qualcosa.qualcosaAltro", con un punto in mezzo, significa che "qualcosaAltro" è contenuto in "qualcosa".
</div>


<div class="mw-translate-fuzzy">
Si può anche estrarre da test una sua parte, e importare la funzione sum() direttamente nello spazio principale dell'interprete, in questo modo:
Si può anche estrarre da test una sua parte, e importare la funzione sum() direttamente nello spazio principale dell'interprete, in questo modo:
</div>

{{Code|code=
{{Code|code=
from myTest import *
from myTest import *
sum(12,54)
sum(12, 54)
}}
}}

<div class="mw-translate-fuzzy">
In pratica tutti i moduli si comportano in questo modo. È possibile importare un modulo, e poi utilizzare le sue funzioni tramite l'istruzione: module.function (argomento). Quasi tutti i moduli eseguono le seguenti operazioni: definiscono le funzioni, i nuovi tipi di dati e le classi che è possibile utilizzare nell'interprete o nei moduli Python, perché nulla impedisce di importare altri moduli all'interno di un proprio modulo!
In pratica tutti i moduli si comportano in questo modo. È possibile importare un modulo, e poi utilizzare le sue funzioni tramite l'istruzione: module.function (argomento). Quasi tutti i moduli eseguono le seguenti operazioni: definiscono le funzioni, i nuovi tipi di dati e le classi che è possibile utilizzare nell'interprete o nei moduli Python, perché nulla impedisce di importare altri moduli all'interno di un proprio modulo!
</div>


<div class="mw-translate-fuzzy">
Un'ultima cosa estremamente utile. Come si fa per sapere quali moduli sono disponibili, quali funzioni sono al loro interno e come usarli (cioè, di che tipo di argomenti hanno bisogno)? Si è già visto che Python ha una funzione help(). Digitare:
Un'ultima cosa estremamente utile. Come si fa per sapere quali moduli sono disponibili, quali funzioni sono al loro interno e come usarli (cioè, di che tipo di argomenti hanno bisogno)? Si è già visto che Python ha una funzione help(). Digitare:
</div>

{{Code|code=
{{Code|code=
help()
help("modules")
modules
}}
}}

<div class="mw-translate-fuzzy">
Viene restituito un elenco di tutti i moduli disponibili. Digitare q per uscire dall'aiuto interattivo e importare qualsiasi di essi.
Viene restituito un elenco di tutti i moduli disponibili. Digitare q per uscire dall'aiuto interattivo e importare qualsiasi di essi.


Si può anche sfogliare il contenuto del modulo tramite il comando dir():
Si può anche sfogliare il contenuto del modulo tramite il comando dir():
</div>

{{Code|code=
{{Code|code=
import math
import math
dir(math)
dir(math)
}}
}}

<div class="mw-translate-fuzzy">
In questo caso, si vedono tutte le funzioni contenute nel modulo di matematica (il modulo math), come, ad esempio, cose con strani nomi __ doc__, __ FILE__, __ name__. L'oggetto doc__ __ è estremamente utile, è un testo di documentazione. Ogni funzione dei moduli (se fatti bene) ha un proprio __doc__ che spiega come usarla. Se, per esempio, si vuole sapere come usare la funzione sin (seno) contenuta all'interno del modulo math, basta digitare:
In questo caso, si vedono tutte le funzioni contenute nel modulo di matematica (il modulo math), come, ad esempio, cose con strani nomi __ doc__, __ FILE__, __ name__. L'oggetto doc__ __ è estremamente utile, è un testo di documentazione. Ogni funzione dei moduli (se fatti bene) ha un proprio __doc__ che spiega come usarla. Se, per esempio, si vuole sapere come usare la funzione sin (seno) contenuta all'interno del modulo math, basta digitare:
</div>
{{Code|code=
{{Code|code=
print math.sin.__doc__
print(math.sin.__doc__)
}}
}}

<div class="mw-translate-fuzzy">
<div class="mw-translate-fuzzy">
(Potrebbe non essere evidente, ma su entrambi i lati del doc ci sono due caratteri di sottolineatura.)
Infine un ultimo consiglio utile. Quando si lavora sulla programmazione di un nuovo modulo, si desidera testarlo frequentemente.
</div>
</div>


<div class="mw-translate-fuzzy">
<div class="mw-translate-fuzzy">
Allora è meglio sostituire l'estensione del file con py e diventa un modulo Python normale myModule.fcmacro => myModule.py.
E infine un ultimo piccolo omaggio: quando lavoriamo su un modulo nuovo o esistente, è meglio sostituire l'estensione del file con py come: myModule.FCMacro => myModule.py. Spesso vogliamo testarlo, quindi lo caricheremo come sopra.
</div>
</div>

{{Code|code=
{{Code|code=
import myModule
import importlib
importlib.reload(myTest)
myModule.myTestFunction()
}}
}}
Ma cosa succede se il modulo myTestFunction() non funziona correttamente? Si torna al proprio editor per modificarlo. Dopo, invece di chiudere e riaprire l'interprete python, è possibile aggiornare semplicemente il modulo in questo modo:
{{Code|code=
reload(myModule)
}}
Questo perché Python non conosce l'estensione FCMacro.


<div class="mw-translate-fuzzy">
Però, si può fare in due modi:
Però, si può fare in due modi:
1. Utilizzare una funzione exec o execfile di Python all'interno della macro.
1. Utilizzare una funzione exec o execfile di Python all'interno della macro.
</div>
{{Code|code=
f = open("myModule","r")
d = f.read()
exec d
}}
oppure
{{Code|code=
execfile "myModule"
}}


Per condividere il codice tra le macro, è possibile ad esempio accedere al modulo FreeCAD o FreeCADGui (o qualsiasi altro modulo Python) e impostare qualsiasi attributo ad esso. Questo dovrebbe sopravvivere alla esecuzione della macro.
{{Code|code=
{{Code|code=
exec(open("C:/PathToMyMacro/myMacro.FCMacro").read())
import FreeCAD
if hasattr(FreeCAD,"macro2_executed"):
...
else:
FreeCAD.macro2_executed = True # you can assign any value because we only check for the existence of the attribute
... execute macro2
}}
}}
{{Top}}
==Iniziare con FreeCAD==


<div class="mw-translate-fuzzy">
===Iniziare con FreeCAD===

Ora che si ha un'idea di come funziona Python si può iniziare ad esplorare quello che FreeCAD ha da offrire. Le funzioni Python di FreeCAD sono tutte ben organizzate in moduli diversi. Alcuni di loro vengono caricati (importati) all'avvio di FreeCAD. Quindi, basta solo, digitare:
Ora che si ha un'idea di come funziona Python si può iniziare ad esplorare quello che FreeCAD ha da offrire. Le funzioni Python di FreeCAD sono tutte ben organizzate in moduli diversi. Alcuni di loro vengono caricati (importati) all'avvio di FreeCAD. Quindi, basta solo, digitare:
</div>

{{Code|code=
{{Code|code=
dir()
dir()
}}
}}
{{Top}}
<div class="mw-translate-fuzzy">
==Notes==
e continuate a leggere in [[FreeCAD Scripting Basics/it|Script base in FreeCAD]]...
</div>

<div class="mw-translate-fuzzy">
Naturalmente, quì si è visto solo una parte molto piccola del mondo di Python. Ci sono ancora molti altri concetti importanti che non sono stati menzionati qui.

In rete sono disponibili tre documenti molto importanti che referenziano Python:
* The [http://docs.python.org/3/tutorial/index.html official Python tutorial with way more information than this one]
* La [http://docs.python.org/reference/ guida ufficiale di Python]
* Il wiki [http://www.diveintopython.org/toc/index.html Dive into Python]

Accertarsi di averli nel segnalibri!
</div>


* FreeCAD was originally designed to work with Python 2. Since Python 2 reached the end of its life in 2020, future development of FreeCAD will be done exclusively with Python 3, and backwards compatibility will not be supported.
* Much more information about Python can be found in the [https://docs.python.org/3/tutorial/index.html official Python tutorial] and the [https://docs.python.org/3/reference/ official Python reference].
{{Top}}


<div class="mw-translate-fuzzy">
<div class="mw-translate-fuzzy">
Line 428: Line 572:
</div>
</div>


{{Powerdocnavi{{#translation:}}}}
{{Userdocnavi}}
[[Category:Developer Documentation{{#translation:}}]]

[[Category:Poweruser Documentation/it]]
[[Category:Python Code{{#translation:}}]]

[[Category:Python_Code]]
{{clear}}

Revision as of 13:50, 22 October 2021

Introduzione

Questo è un breve tutorial per quelli nuovi di Python. Python è un Linguaggio di programmazione sorgente-aperto e multipiattaforma . Ha diverse caratteristiche che lo rendono diverso dagli altri linguaggi di programmazione, e molto accessibile ai nuovi utenti:

  • È stato progettato appositamente per essere letto facilmente dalle persone, quindi è molto facile da imparare e da capire.
  • È interpretato, ciò significa che, a differenza dei linguaggi compilati come il C, non è necessario compilare il programma prima di poterlo eseguire. Quando si desidera, il codice che si scrive può essere eseguito immediatamente, riga dopo riga. Siccome si procede gradualmente, passo dopo passo, è facile impararlo e trovare gli eventuali errori nel codice.
  • Può essere incorporato in altri programmi per essere usato come linguaggio di script. FreeCAD ha un interprete Python integrato, così, in FreeCAD, è possibile scrivere dei codici Python che manipolano parti di FreeCAD, ad esempio per creare la geometria. Questo è estremamente performante, perché invece di premere semplicemente un pulsante denominato "Crea sfera", che un programmatore ha messo a disposizione, si ha la libertà di creare facilmente dei propri strumenti per produrre una particolare geometria desiderata.
  • È estensibile. Si possono inserire facilmente dei nuovi moduli nella propria installazione di Python ed estenderne le funzionalità. Ad esempio, esistono moduli Python che permettono di leggere e scrivere le immagini jpg, di comunicare con Twitter, di programmare le operazioni del proprio sistema operativo, ecc.

Ora, mettiamoci al lavoro! Ricordare che ciò che verrà dopo è solamente una semplice introduzione e non un tutorial completo. Ma la speranza è che dopo si avranno basi sufficienti per esplorare più in profondità i meccanismi di FreeCAD.

L'interprete

Di solito, per scrivere programmi per computer, basta aprire un editor di testo (o l'ambiente di programmazione preferito che, in genere, è un editor di testo con strumenti aggiuntivi), scrivere il programma, quindi compilarlo ed eseguirlo. Il più delle volte si fanno degli errori di scrittura, per cui il programma non funziona, e si ottiene un messaggio di errore che dà informazioni su cosa è andato storto. Quindi si ritorna all'editor di testo, si correggono gli errori, si esegue di nuovo, e così via fino a quando il programma funziona bene.

In Python, l'intero processo, può essere eseguito in modo trasparente all'interno del suo interprete. L'interprete Python è una finestra con un prompt dei comandi, dove si può digitare direttamente il codice Python. Se si installa Python sul ​​proprio computer (scaricarlo dal sito web di Python se lavorate su Windows o Mac, installarlo dal repository dei pacchetti se utilizzate GNU/Linux), si avrà un interprete Python nel menu di avvio. FreeCAD dispone di un proprio interprete Python visualizzato nella sua finestra inferiore:

La console di FreeCAD Python

Se non la vedi, clicca su Vista → Pannelli → Console Python. La console Python può essere ridimensionata e anche sganciata.

L'interprete mostra la versione di Python, poi un simbolo >>> che è il prompt dei comandi. Scrivere codice nell'interprete è semplice: una linea è un'istruzione. Quando premete Invio, la vostra linea di codice verrà eseguita (dopo essere stata istantaneamente e invisibilmente compilata). Per esempio, provate a scrivere questo:

print("hello")

print() è un comando Python che, ovviamente, stampa qualcosa sullo schermo. Quando si preme Invio, l'operazione viene eseguita e viene stampato il messaggio "hello". Se si commette un errore, per esempio scriviamo:

print(hello)

Python ve lo dirà immediatamente. In questo caso Python non sa cosa sia hello. I caratteri " " specificano che il contenuto è una stringa, gergo di programmazione per un pezzo di testo. Senza questi il comando print() non riconosce hello. Premendo la freccia su si può tornare indietro all'ultima linea di codice e correggerla.

L'interprete Python ha anche un sistema di aiuto integrato. Diciamo che non capiamo cosa è andato storto con print(hello) e vogliamo informazioni specifiche sul comando:

help("print")

Si ottiene una lunga e completa descrizione di tutto quello che può fare il comando print.

Ora che si ha il controllo totale dell'interprete, si può cominciare con le cose significative.

Inizio

Variabili

Naturalmente, stampare "ciao" non è molto interessante. Più interessante è stampare cose che non si conoscono prima, o lasciare che Python le trovi per noi. Qui entra in gioco il concetto di variabile. Una variabile è semplicemente un valore che viene memorizzato con un nome specifico. Ad esempio, digitare questo:

a = "hello"
print(a)

Sicuramente si capisce quello che succede, la stringa "ciao" viene "salvata" sotto il nome "a". Ora, "a" non è più un nome sconosciuto! Si può usare ovunque, per esempio nel comando print. È possibile utilizzare qualsiasi nome che si desideri, basta rispettare alcune semplici regole, tipo non usare spazi o segni di punteggiatura. Ad esempio, si potrebbe tranquillamente scrivere:

hello = "my own version of hello"
print(hello)

Visto? ciao ora non è più una parola indefinita. E se, per sfortuna, si sceglie un nome che in Python esiste già? Supponiamo di voler conservare una stringa con il nome "print":

myVariable = "hello"
print(myVariable)
myVariable = "good bye"
print(myVariable)

Il valore di myVariable è stato cambiato. Le variabili possono anche essere copiate:

var1 = "hello"
var2 = var1
print(var2)

Notare che è importante dare alle variabili dei nomi descrittivi. Quando si scrivono programmi lunghi, dopo un po' probabilmente non si ricorda più cosa rappresenta la variabile denominata "a". Se invece viene chiamata, ad esempio, MioMessaggioDiBenvenuto, quando la si vede, si capisce facilmente a cosa serve. In più è un passo avanti verso l'autodocumentazione del proprio codice.

La differenza tra maiuscole e minuscole è molto importante. myVariable non è uguale a myvariable, la differenza è tra v maiuscola e minuscola. Se si inserisce "print myvariable", viene restituito un errore non definito.

Inizio

Numeri

È noto che la programmazione serve per trattare ogni tipo di dati, non solo le stringhe di testo, ma soprattutto i numeri. È molto importante che Python sappia che tipo di dati deve trattare. Nell'esempio precedente, con print ciao, si è visto che il comando print ha riconosciuto la nostra stringa "ciao". Questo perché utilizzando il segno ", abbiamo specificato al comando print che ciò che seguiva era una stringa di testo.

Per controllare in qualsiasi momento di quale tipo sono i dati contenuti in una variabile si utilizza la speciale parola chiave di Python type():

myVar = "hello"
type(myVar)

In questo caso ci dice che il contenuto di myVar è 'str', ovvero una stringa in gergo Python. Ci sono anche altri tipi di dati, ad esempio i numeri interi (integer) e i numeri in virgola mobile (float numbers):

firstNumber = 10
secondNumber = 20
print(firstNumber + secondNumber)
type(firstNumber)

Questo è già molto più interessante, vero? Ora si dispone di una potente calcolatrice! Notare bene come funziona. Python capisce che 10 e 20 sono numeri interi, quindi vengono memorizzati come "int", e con essi Python può fare tutte le operazioni consentite con numeri interi. Osservare i risultati di questo codice:

firstNumber = "10"
secondNumber = "20"
print(firstNumber + secondNumber)

Visto? Python è stato indotto a considerare le due variabili non più come numeri, ma come semplici parti di testo. Python può unire insieme due parti di testo, ma con esse non cerca di produrre una somma. Torniamo ai numeri. Oltre ai numeri interi (int) ci sono anche i numeri in virgola mobile (float). I numeri interi non hanno una parte decimale, mentre i numeri float possono avere una parte decimale:

var1 = 13
var2 = 15.65
print("var1 is of type ", type(var1))
print("var2 is of type ", type(var2))

I numeri Int e Float possono essere mescolati tra di loro senza problemi:

total = var1 + var2
print(total)
print(type(total))

Naturalmente il totale ha dei decimali, vero? Quindi Python ha deciso automaticamente che il risultato è un float. In molti casi, come in questo, Python decide automaticamente il tipo da usare. In altri casi no. Ad esempio con:

varA = "hello 123"
varB = 456
print(varA + varB)

Si produce un errore, varA è una stringa e varB è un int, quindi Python non sa cosa fare. Ma possiamo indurre Python a convertire i tipi:

varA = "hello"
varB = 123
print(varA + str(varB))

Ora entrambi sono stringhe, e l'operazione funziona! Notare che, con questi comandi, varB è convertita in "stringa" solo al momento della stampa, però varB originale non viene modificata. Per trasformare varB permanentemente in una stringa, si deve fare:

varB = str(varB)

Inoltre è possibile usare int() e float() per convertire in int e in float:

varA = "123"
print(int(varA))
print(float(varA))

Sicuramente avete notato che in questa sezione il comando di stampa (print) è stato utilizzato in diversi modi. Abbiamo stampato variabili, somme, parti separati da virgole, e anche il risultato di altri comandi Python, ad esempio type(). Forse avete anche notato che questi due comandi,

type(varA)
print(type(varA))

producono esattamente lo stesso risultato. Questo succede perché siamo nell'interprete, dove ogni cosa viene sempre automaticamente stampata sullo schermo. Per velocizzare, d'ora in avanti si può fare a meno di usarlo e quindi scrivere semplicemente:

myVar = "hello friends"
myVar

Inizio

Liste

Un altro tipo di dati interessante è una list (lista). Una lista è semplicemente un elenco di altri dati. In modo analogo a come si definisce una stringa di testo usando " ", una lista si definisce usando []:

myList = [1, 2, 3]
type(myList)
myOtherList = ["Bart", "Frank", "Bob"]
myMixedList = ["hello", 345, 34.567]

Come si vede, una lista può contenere dati di qualsiasi tipo. Le liste sono molto utili perché permettono di raggruppare le variabili. Con il gruppo, successivamente, è possibile fare diverse cose, ad esempio contare i suoi componenti:

len(myOtherList)

o recuperare un elemento da una lista:

myName = myOtherList[0]
myFriendsName = myOtherList[1]

Come si vede, mentre il comando len() restituisce il numero totale di elementi in una lista, la loro "posizione" nella lista inizia con 0. Il primo elemento in una lista si trova sempre in posizione 0, quindi nella lista myOtherList, "Bob" è nella posizione 2. Con le liste è possibile eseguire molte altre operazioni, descritte in modo più completo qui, ad esempio, ordinare i suoi contenuti, rimuovere o aggiungere elementi.

Una cosa curiosa: una stringa di testo è molto simile a una lista di caratteri! Provate a fare questo:

myvar = "hello"
len(myvar)
myvar[2]

In genere, tutto quello che si può fare con le liste si può fare anche con le stringhe. In effetti le liste e le stringhe sono entrambe delle sequenze.

Oltre a stringhe, int, float e liste, in Python sono disponibili molti altri tipi di dati built-in (incorporati), quali ad esempio i dictionaries (collezione di oggetti), oppure si possono creare dei propri tipi di dati utilizzando le classi.

Inizio

Indentazione

Un tipico uso della lista consiste nel navigare al suo interno e di operare con i suoi elementi. Per esempio osservare questo:

alldaltons = ["Joe", "William", "Jack", "Averell"]
for dalton in alldaltons:
    print(dalton + " Dalton")

In questo esempio, la lista viene iterata (nuovo gergo di programmazione!) con il comando "for ... in ..." e con ognuno dei suoi elementi viene eseguito qualcosa.

Notare la speciale sintassi. Il comando "for" termina con un ":" questo indica a Python che ciò che segue è un blocco di uno o più comandi. Subito dopo che viene inserita la riga con il comando che termina con :, il prompt dei comandi cambia in ... il che significa che Python ha riconosciuto un comando terminato con un (:) e quello che segue è parte del comando stesso.

Come fa Python a sapere quante delle prossime righe sono da eseguire all'interno dell'operazione for ... in ? Per sapere questo, Python utilizza l'indentazione. Cioè, le righe successive non iniziano immediatamente, ma iniziano con uno o più spazi vuoti, oppure con uno o più spazi di tabulazione. Altri linguaggi di programmazione utilizzano vari metodi, tipo inserire tutto dentro parentesi, ecc. Finché le righe successive sono scritte con la stessa indentazione, esse sono considerate come parte del blocco for-in. Quando si inizia una riga con 2 spazi vuoti e quella successiva con 4, si produce un errore. Per terminare e uscire dal blocco for-in, basta scrivere una nuova riga senza rientro, o semplicemente premere Invio.

L'indentazione è molto utile perché conferisce leggibilità al promma. Se è ampia (usando, ad esempio, tab che crea più spazi invece di un solo), quando si scrive un programma lungo si ha una visione chiara di ciò che viene eseguito all'interno di ogni blocco. Vedremo che anche molti altri comandi diversi da for-in richiedono blocchi indentati.

Il comando for-in può essere utilizzato per varie operazioni che devono essere eseguite più volte. Ad esempio, può essere combinato con il comando range():

serie = range(1, 11)
total = 0
print("sum")
for number in serie:
    print(number)
    total = total + number
print("----")
print(total)

Per usare i decimali in un loop range.

If you type into the interpreter help(range) you will see:

range(...)
    range(stop) -> list of integers
    range(start, stop[, step]) -> list of integers

Here the square brackets denote an optional parameter. However all are expected to be integers. Below we will force the step parameter to be an integer using int():

number = 1000
for i in range(0, 180 * number, int(0.5 * number)):
    print(float(i) / number)

O per operazioni più complesse tipo questa:

alldaltons = ["Joe", "William", "Jack", "Averell"]
for n in range(4):
    print(alldaltons[n], " is Dalton number ", n)

Come si vede, anche il comando range() ha la strana particolarità di iniziare con 0 (quando non si specifica il numero di partenza) e che il suo ultimo numero è uno in meno del numero finale specificato. Ciò, naturalmente, perché questo modo funziona bene con gli altri comandi di Python. Ad esempio:

alldaltons = ["Joe", "William", "Jack", "Averell"]
total = len(alldaltons)
for n in range(total):
    print(alldaltons[n])

Un altro uso interessante dei blocchi indentati si ha con il comando if. Il comando if esegue un blocco di codice solo se una certa condizione è soddisfatta, ad esempio:

alldaltons = ["Joe", "William", "Jack", "Averell"]
if "Joe" in alldaltons:
    print("We found that Dalton!!!")

Naturalmente, questo esempio stampa sempre la prima frase, ma provare a sostituire la seconda riga con:

if "Lucky" in alldaltons:

Ora non viene più stampato nulla. Si può anche specificare una dichiarazione: else:

alldaltons = ["Joe", "William", "Jack", "Averell"]
if "Lucky" in alldaltons:
    print("We found that Dalton!!!")
else:
    print("Such Dalton doesn't exist!")

Inizio

Funzioni

I comandi standard di Python non sono molti. Nella versione corrente di Python ce ne sono circa 30, e ne conosciamo già alcuni di loro. Ma immaginate se potessimo inventare dei nostri propri comandi? Beh, possiamo, ed è estremamente facile. In effetti, la maggior parte dei moduli aggiuntivi che si possono aggiungere nella propria installazione di Python fanno esattamente questo, essi aggiungono dei comandi utilizzabili. In Python un comando personalizzato si chiama funzione e si crea in questo modo:

def printsqm(myValue):
    print(str(myValue) + " square meters")

printsqm(45)

Estremamente semplice: il comando def() definisce una nuova funzione. Si può dargli un nome, e dentro la parentesi si definiscono gli argomenti che useremo nella nostra funzione. Gli argomenti sono i dati che verranno passati alla funzione.

Ad esempio, osservare il comando len(). Se si scrive semplicemente len() da solo, Python vi dice che ha bisogno di un argomento. Cioè, si vuole len() di qualcosa. Quindi, ad esempio, bisogna scrivere len(myList) per ottenere la lunghezza di myList. Bene, myList è un argomento che viene passato alla funzione len(). La funzione len() è definita in modo da sapere come utilizzare ciò che gli viene passato. Esattamente come si è appena fatto qui.

Il nome "myValue" può contenere qualsiasi oggetto, e viene utilizzato solo all'interno della funzione. È solo un nome assegnato all'argomento in modo da poter operare con esso, però serve anche a fare in modo che la funzione sappia quanti argomenti aspettarsi. Se, ad esempio, si esegue:

printsqm(45, 34)

Si ottiene un errore. La funzione è stata programmata per ricevere un solo argomento, ma ne ha ricevuto due, 45 e 34. In sostituzione, si può eseguire qualcosa di simile a:

def sum(val1, val2):
    total = val1 + val2
    return total

myTotal = sum(45, 34)

Dove si crea una funzione che riceve due argomenti, li somma, e restituisce il valore. Ottenere qualcosa è molto utile, perché permette di utilizzare il risultato ottenuto e, ad esempio, memorizzarlo nella variabile myTotal. Naturalmente, visto che siamo nell'interprete e tutto quello che facciamo viene stampato, digitando:

Inizio

Moduli

Ora che si ha un'idea di come funziona Python, serve una ultima cosa: Come lavorare con i file e i moduli.

Fino ad ora, abbiamo scritto le istruzioni nell'interprete di Python riga per riga, vero?

Quando si intende fare delle cose più complesse, è certamente più comodo scrivere prima diverse righe di codice, e poi eseguirle tutte insieme in una unica volta. Bene, anche questo, è estremamente facile da farsi, e inoltre permette anche salvare il proprio lavoro.

È sufficiente aprire un editor di testo (ad es. il Blocco Note di Windows, o gedit, emacs, o vi per Linux), e scrivere tutte le proprie righe di Python, nello stesso modo in cui si scrivono nell'interprete, con indentazioni, ecc. Quindi, salvare il file da qualche parte, preferibilmente con estensione .py. Tutto qui, ora si dispone di un programma Python completo. Naturalmente, ci sono editor migliori di notepad, citato solo per dimostrare che un programma Python non è altro che un file di testo.

Per far eseguire questo programma da Python, ci sono centinaia di modi. In Windows, è sufficiente fare clic sul file, aprirlo con Python, ed eseguirlo. Ma si può anche eseguire con l'interprete di Python stesso. Per fare questo, l'interprete deve sapere dove si trova il programma .py. In FreeCAD, il modo più semplice è quello di inserire il programma in un luogo che l'interprete Python di FreeCAD conosce di default, quale, ad esempio, la cartella bin di FreeCAD, o una qualsiasi delle cartelle Mod. (In Linux, si ha probabilmente una directory /home/<username>/.FreeCAD/Mod, aggiungiamo una sottodirectory a quegli script richiamati dove inseriremo il file di testo.) Supponiamo di scrivere questo file:

def sum(a,b):
    return a + b

print("myTest.py succesfully loaded")

e di salvarlo con il nome MioTest.py nella nostra directory /bin di FreeCAD (o on Linux to /home/<username>/.FreeCAD/Mod/scripts). Ora, avviamo FreeCAD e nella finestra interprete scriviamo:

import myTest

senza l'estensione. py. Questo comando esegue semplicemente il contenuto del file, riga per riga, esattamente come quando viene scritto nell'interprete. Viene creata la funzione somma, poi viene stampato il messaggio. Però c'è una grande differenza: il comando di importazione (import) serve non solo per eseguire i programmi contenuti in un file, come il nostro, ma anche per caricare le funzioni interne, in modo da renderle disponibili nell'interprete. I file, come il nostro, contenenti funzioni sono chiamati moduli.

Di solito, come si è fatto in precedenza, quando si scrive la funzione sum() nell'interprete, si digita semplicemente:

sum(14, 45)

Invece, quando si importa un modulo contenente una funzione sum(), la sintassi è un po' diversa. Si scrive:

myTest.sum(14, 45)

Cioè, il modulo viene importato come un "contenitore", e tutte le sue funzioni sono all'interno. Dato che è possibile importare più moduli, ciò è estremamente utile per tenere il tutto ben organizzato. In sostanza, quando si vede "qualcosa.qualcosaAltro", con un punto in mezzo, significa che "qualcosaAltro" è contenuto in "qualcosa".

Si può anche estrarre da test una sua parte, e importare la funzione sum() direttamente nello spazio principale dell'interprete, in questo modo:

from myTest import *
sum(12, 54)

In pratica tutti i moduli si comportano in questo modo. È possibile importare un modulo, e poi utilizzare le sue funzioni tramite l'istruzione: module.function (argomento). Quasi tutti i moduli eseguono le seguenti operazioni: definiscono le funzioni, i nuovi tipi di dati e le classi che è possibile utilizzare nell'interprete o nei moduli Python, perché nulla impedisce di importare altri moduli all'interno di un proprio modulo!

Un'ultima cosa estremamente utile. Come si fa per sapere quali moduli sono disponibili, quali funzioni sono al loro interno e come usarli (cioè, di che tipo di argomenti hanno bisogno)? Si è già visto che Python ha una funzione help(). Digitare:

help("modules")

Viene restituito un elenco di tutti i moduli disponibili. Digitare q per uscire dall'aiuto interattivo e importare qualsiasi di essi.

Si può anche sfogliare il contenuto del modulo tramite il comando dir():

import math
dir(math)

In questo caso, si vedono tutte le funzioni contenute nel modulo di matematica (il modulo math), come, ad esempio, cose con strani nomi __ doc__, __ FILE__, __ name__. L'oggetto doc__ __ è estremamente utile, è un testo di documentazione. Ogni funzione dei moduli (se fatti bene) ha un proprio __doc__ che spiega come usarla. Se, per esempio, si vuole sapere come usare la funzione sin (seno) contenuta all'interno del modulo math, basta digitare:

print(math.sin.__doc__)

(Potrebbe non essere evidente, ma su entrambi i lati del doc ci sono due caratteri di sottolineatura.)

E infine un ultimo piccolo omaggio: quando lavoriamo su un modulo nuovo o esistente, è meglio sostituire l'estensione del file con py come: myModule.FCMacro => myModule.py. Spesso vogliamo testarlo, quindi lo caricheremo come sopra.

import importlib
importlib.reload(myTest)

Però, si può fare in due modi: 1. Utilizzare una funzione exec o execfile di Python all'interno della macro.

exec(open("C:/PathToMyMacro/myMacro.FCMacro").read())

Inizio

Iniziare con FreeCAD

Ora che si ha un'idea di come funziona Python si può iniziare ad esplorare quello che FreeCAD ha da offrire. Le funzioni Python di FreeCAD sono tutte ben organizzate in moduli diversi. Alcuni di loro vengono caricati (importati) all'avvio di FreeCAD. Quindi, basta solo, digitare:

dir()

Inizio

Notes

  • FreeCAD was originally designed to work with Python 2. Since Python 2 reached the end of its life in 2020, future development of FreeCAD will be done exclusively with Python 3, and backwards compatibility will not be supported.
  • Much more information about Python can be found in the official Python tutorial and the official Python reference.

Inizio