Introduction to Python/it: Difference between revisions

From FreeCAD Documentation
(Created page with "I numeri Int e Float possono essere mescolati tra di loro senza problemi:")
No edit summary
 
(366 intermediate revisions by 4 users not shown)
Line 1: Line 1:
<languages/>
Questo è una breve guida realizzata per chi si avvicina per la prima volta a Python.


{{Docnav
[http://it.wikipedia.org/wiki/Python Python] è un [http://it.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n linguaggio di programmazione] multipiattaforma open-source.
|[[Scripts/it|Script]]
|[[Python_scripting_tutorial/it|Guida agli script Python]]
}}


{{TOCright}}
Python dispone di numerose funzionalità che lo rendono molto diverso dagli altri comuni linguaggi di programmazione, ed è facilmente accessibile ai nuovi utenti:


<span id="Introduction"></span>
* È stato progettato appositamente per essere letto facilmente dalle persone, quindi è molto facile da imparare e da capire.
==Introduzione==
* È 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.


Quello che segue è un breve tutorial per chi non conosce [https://it.wikipedia.org/wiki/Python Python]. Python è un [https://it.wikipedia.org/wiki/Linguaggio_di_programmazione Linguaggio di programmazione] open source e multipiattaforma . Ha diverse caratteristiche, che lo rendono diverso dagli altri linguaggi di programmazione, ed è facilmente accessibile ai nuovi utenti:
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.


*È stato progettato per essere leggibile dagli esseri umani, rendendolo relativamente facile da imparare e da capire.
=== L'interprete ===
*Viene interpretato, questo significa che i programmi non devono essere compilati prima di poter essere eseguiti. Il codice Python può essere eseguito immediatamente, anche riga per riga, se si desidera.
*Può essere incorporato in altri programmi come linguaggio di scripting. FreeCAD ha un interprete Python incorporato. Si può scrivere codice Python per manipolare parti di FreeCAD. Questa funzionalità è molto potente e comporta che puoi costruire i tuoi strumenti personalizzati.
*È estensibile, si può facilmente inserire nuovi moduli nella tua installazione di Python ed estenderne la funzionalità. Ad esempio, ci sono moduli che consentono a Python di leggere e scrivere immagini, di comunicare con Twitter, di pianificare attività che devono essere eseguite dal tuo sistema operativo, ecc.


Quella che segue è un'introduzione molto semplice e non un tutorial completo. Ma si spera che fornisca un buon punto di partenza per un'ulteriore esplorazione di FreeCAD e dei suoi meccanismi. Si consiglia vivamente di inserire i seguenti frammenti di codice in un interprete Python.
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.


<span id="The_interpreter"></span>
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 parte inferiore:
==L'interprete==


Di solito, per scrivere programmi per computer, basta aprire un editor di testo (o l'ambiente di programmazione preferito che di base è un editor di testo con alcuni strumenti aggiuntivi), scrivere il programma, quindi compilarlo ed eseguirlo. Spesso 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.
[[Image:Screenshot_pythoninterpreter.jpg]]


In Python l'intero processo può essere eseguito in modo trasparente all'interno dell'interprete Python. L'interprete è una finestra Python con un prompt dei comandi, in cui puoi semplicemente digitare il codice Python. Se hai installato Python sul tuo computer (scaricalo dal [https://www.python.org/ sito Web Python] se sei su Windows o Mac, installalo dal repository del tuo pacchetto se sei su GNU/Linux), avrai un interprete Python nel tuo menu di avvio. Ma, come già accennato, FreeCAD ha anche un interprete Python integrato: la [[Python_console/it|Console Python]].
Se non è visibile, cliccare su Visualizza → Viste → Console Python.


[[Image:FreeCAD_Python_console.png]]
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:
{{Caption|La console di FreeCAD Python}}
<syntaxhighlight>
print "hello"
</syntaxhighlight>
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:
<syntaxhighlight>
print hello
</syntaxhighlight>
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.


Se non la vedi, clicca su {{MenuCommand|Visualizza → Pannelli → Console Python}}. La console Python può essere ridimensionata e anche sganciata.
L'interprete Python possiede anche un sistema di aiuto incorporato. Provare a digitare:
<syntaxhighlight>
help
</syntaxhighlight>
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:
<syntaxhighlight>
help("print")
</syntaxhighlight>
Si ottiene una lunga e completa descrizione di tutto quello che può fare il comando print.


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:
Ora che si ha il controllo totale dell'interprete, si può cominciare con le cose significative.


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


{{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:
Naturalmente, stampare "ciao" non è molto interessante. Più interessante è stampare cose che non si conoscono prima, o lasciare che Python le trovi per noi. Quì entra in gioco il concetto di variabile. Una variabile è semplicemente un valore che viene memorizzato con un nome specifico. Ad esempio, digitare questo:
<syntaxhighlight>
a = "hello"
print a
</syntaxhighlight>
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 delle semplici regole, tipo non usare spazi o segni di punteggiatura. Ad esempio, si potrebbe tranquillamente scrivere:
<syntaxhighlight>
hello = "my own version of hello"
print hello
</syntaxhighlight>
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":
<syntaxhighlight>
print = "hello"
</syntaxhighlight>
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:
<syntaxhighlight>
myVariable = "hello"
print myVariable
myVariable = "good bye"
print myVariable
</syntaxhighlight>
Il valore di myVariable è stato cambiato. Le variabili possono anche essere copiate:
<syntaxhighlight>
var1 = "hello"
var2 = var1
print var2
</syntaxhighlight>
Notare che è utile 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.


{{Code|code=
===Numeri===
print(hello)
}}


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.
È 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.


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:
Per controllare in qualsiasi momento di quale tipo sono i dati contenuti in una variabile si utilizza la speciale parola chiave di Python type():
<syntaxhighlight>
myVar = "hello"
type(myVar)
</syntaxhighlight>
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):
<syntaxhighlight>
firstNumber = 10
secondNumber = 20
print firstNumber + secondNumber
type(firstNumber)
</syntaxhighlight>
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:
<syntaxhighlight>
firstNumber = "10"
secondNumber = "20"
print firstNumber + secondNumber
</syntaxhighlight>
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:
<syntaxhighlight>
var1 = 13
var2 = 15.65
print "var1 is of type ", type(var1)
print "var2 is of type ", type(var2)
</syntaxhighlight>
I numeri Int e Float possono essere mescolati tra di loro senza problemi:
<syntaxhighlight>
total = var1 + var2
print total
print type(total)
</syntaxhighlight>
Of course the total has decimals, right? Then Python automatically decided that the result is a float. In several cases such as this one, Python automatically decides what type to give to something. In other cases it doesn't. For example:
<syntaxhighlight>
varA = "hello 123"
varB = 456
print varA + varB
</syntaxhighlight>
This will give us an error, varA is a string and varB is an int, and Python doesn't know what to do. But we can force Python to convert between types:
<syntaxhighlight>
varA = "hello"
varB = 123
print varA + str(varB)
</syntaxhighlight>
Now both are strings, the operation works! Note that we "stringified" varB at the time of printing, but we didn't change varB itself. If we wanted to turn varB permanently into a string, we would need to do this:
<syntaxhighlight>
varB = str(varB)
</syntaxhighlight>
We can also use int() and float() to convert to int and float if we want:
<syntaxhighlight>
varA = "123"
print int(varA)
print float(varA)
</syntaxhighlight>
'''Note on Python commands'''


{{Code|code=
You must have noticed that in this section we used the print command in several ways. We printed variables, sums, several things separated by commas, and even the result of other Python command such as type(). Maybe you also saw that doing those two commands:
help("print")
<syntaxhighlight>
}}
type(varA)
print type(varA)
</syntaxhighlight>
have exactly the same result. That is because we are in the interpreter, and everything is automatically printed on screen. When we'll write more complex programs that run outside the interpreter, they won't print automatically everything on screen, so we'll need to use the print command. But from now on, let's stop using it here, it'll go faster. So we can simply write:
<syntaxhighlight>
myVar = "hello friends"
myVar
</syntaxhighlight>
You must also have seen that most of the Python commands (or keywords) we already know have parenthesis used to tell them on what contents the command must work: type(), int(), str(), etc. Only exception is the print command, which in fact is not an exception, it also works normally like this: print("hello"), but, since it is used often, the Python programmers made a simplified version.


Si ottiene una lunga e completa descrizione di tutto quello che può fare il comando {{incode|print()}}.
==Lists==


Ora che si è capito cos'è l'interprete Python, possiamo continuare con le cose più serie.
Another interesting data type is lists. A list is simply a list of other data. The same way as we define a text string by using " ", we define lists by using [ ]:
{{Top}}
<syntaxhighlight>
<span id="Variables"></span>
myList = [1,2,3]
==Variabili==
type(myList)
myOtherList = ["Bart", "Frank", "Bob"]
myMixedList = ["hello", 345, 34.567]
</syntaxhighlight>
You see that it can contain any type of data. Lists are very useful because you can group variables together. You can then do all kind of things within that groups, for example counting them:
<syntaxhighlight>
len(myOtherList)
</syntaxhighlight>
or retrieving one item of a list:
<syntaxhighlight>
myName = myOtherList[0]
myFriendsName = myOtherList[1]
</syntaxhighlight>
You see that while the len() command returns the total number of items in a list, their "position" in the list begins with 0. The first item in a list is always at position 0, so in our myOtherList, "Bob" will be at position 2. We can do much more stuff with lists such as you can read [http://www.diveintopython.net/native_data_types/lists.html here], such as sorting contents, removing or adding elements.


Molto spesso nella programmazione è necessario memorizzare un valore sotto un nome. È qui che entrano in gioco le variabili. Ad esempio, digita questo:
A funny and interesting thing for you: a text string is very similar to a list of characters! Try doing this:
<syntaxhighlight>
myvar = "hello"
len(myvar)
myvar[2]
</syntaxhighlight>
Usually all you can do with lists can also be done with strings. In fact both lists and strings are sequences.


{{Code|code=
Outside strings, ints, floats and lists, there are more built-in data types, such as [http://www.diveintopython.net/native_data_types/index.html#d0e5174 dictionnaries], or you can even create your own data types with [http://www.freenetpages.co.uk/hp/alan.gauld/tutclass.htm classes].
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:
==Indentation==


{{Code|code=
One big cool use of lists is also browsing through them and do something with each item. For example look at this:
hello = "my own version of hello"
<syntaxhighlight>
print(hello)
alldaltons = ["Joe", "William", "Jack", "Averell"]
}}
for dalton in alldaltons:
print dalton + " Dalton"
</syntaxhighlight>
We iterated (programming jargon again!) through our list with the "for ... in ..." command and did something with each of the items. Note the special syntax: the for command terminates with : which indicates that what will comes after will be a block of one of more commands. Immediately after you enter the command line ending with :, the command prompt will change to ... which means Python knows that a :-ended line has happened and that what will come next will be part of it.


Ora {{incode|hello}} non è più un indefinito. Le variabili possono essere modificate in qualsiasi momento, per questo si chiamano variabili, il loro contenuto può variare. Per esempio:
How will Python know how many of the next lines will be to be executed inside the for...in operation? For that, Python uses indentation. That is, your next lines won't begin immediately. You will begin them with a blank space, or several blank spaces, or a tab, or several tabs. Other programming languages use other methods, like putting everythin inside parenthesis, etc.
As long as you write your next lines with the '''same''' indentation, they will be considered part of the for-in block. If you begin one line with 2 spaces and the next one with 4, there will be an error.
When you finished, just write another line without indentation, or simply press Enter to come back from the for-in block


{{Code|code=
Indentation is cool because if you make big ones (for example use tabs instead of spaces because it's larger), when you write a big program you'll have a clear view of what is executed inside what. We'll see that many other commands than for-in can have indented blocks of code too.
myVariable = "hello"
print(myVariable)
myVariable = "good bye"
print(myVariable)
}}


Il valore di {{incode|myVariable}} è stato cambiato. Le variabili possono anche essere copiate:
For-in commands can be used for many things that must be done more than once. It can for example be combined with the range() command:

<syntaxhighlight>
{{Code|code=
serie = range(1,11)
var1 = "hello"
total = 0
var2 = var1
print "sum"
print(var2)
for number in serie:
}}
print number

È consigliabile assegnare nomi significativi alle variabili. Dopo un po' ci si ricorderà più cosa rappresenta la variabile denominata {{incode|a}}. Ma se l'hai chiamata, ad esempio, {{incode|myWelcomeMessage}}, ricorderai facilmente il suo scopo. Inoltre, il tuo codice sarà un passo avanti verso l'autodocumentazione.

Il Maiuscolo o minuscolo è molto importante, {{incode|myVariable}} non è lo stesso di {{incode|myvariable}}. Se si dovesse inserire {{incode|print(myvariable)}}, verrebbe restituito un errore come nome non definito.
{{Top}}
<span id="Numbers"></span>
==Numeri==

Ovviamente i programmi Python possono gestire tutti i tipi di dati, non solo le stringhe di testo. Una cosa è importante, Python deve sapere con che tipo di dati ha a che fare. Abbiamo visto nel nostro esempio print hello, che il comando {{incode|print()}} ha riconosciuto la nostra stringa {{incode|"hello"}}. Utilizzando i caratteri {{incode|" "}}, abbiamo specificato che quella che segue è una stringa di testo.

Possiamo sempre controllare il tipo di dati di una variabile con il comando {{incode|type()}}:

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

Questo significa che il contenuto di {{incode|myVar}} è un {{incode|'str'}}, che è l'abbreviazione di string. Esistono anche altri tipi di dati di base come numeri interi e a virgola mobile:

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

Python sa che 10 e 20 sono numeri interi, quindi sono archiviati come {{incode|'int'}} e Python può fare con loro tutto ciò che può fare con i numeri interi. Osserva i risultati di questo codice:

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

Qui abbiamo costretto Python a considerare che le nostre due variabili non sono numeri ma parti di testo. Python può unire due parti di testo insieme, anche se in tal caso, ovviamente, non eseguirà alcuna operazione aritmetica. Ma si stava parlando di numeri interi. Ci sono anche i numeri a virgola mobile. La differenza è che i numeri a virgola mobile possono avere una parte decimale, mentre i numeri interi no:

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

Numeri interi e a virgola mobile possono essere mescolati insieme senza problemi:

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

Poiché {{incode|var2}} è un numero a virgola mobile, Python decide automaticamente, che anche il risultato deve essere un numero a virgola mobile. Ma ci sono casi in cui Python non sa quale tipo adottare. Per esempio:

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

Quel codice provoca un errore, {{incode|varA}} è una stringa e {{incode|varB}} è un numero intero e Python non sa cosa fare. Tuttavia, possiamo forzare Python a convertire tra tipi:

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

Ora che entrambe le variabili sono stringhe l'operazione funziona. Nota che abbiamo "stringificato" {{incode|varB}} al momento della stampa, ma non abbiamo modificato {{incode|varB}} stesso. Se volessimo trasformare {{incode|varB}} in modo permanente in una stringa, dovremmo farlo in questo modo:

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

Possiamo anche usare {{incode|int()}} e {{incode|float()}} per convertire tra numeri interi e numeri a virgola mobile se vogliamo:

{{Code|code=
varA = "123"
print(int(varA))
print(float(varA))
}}

Avrai notato che abbiamo usato il comando {{incode|print()}} in diversi modi. Abbiamo stampato variabili, somme, diverse cose separate da virgole e persino il risultato di un altro comando Python. Forse hai anche notato che questi due comandi:

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

hanno lo stesso risultato. Questo perché siamo nell'interprete e tutto viene stampato automaticamente. Quando scriviamo programmi più complessi, che vengono eseguiti al di fuori dell'interprete, non verranno stampati automaticamente, quindi dovremo usare il comando {{incode|print()}}. Tenendo questo presente, smetteremo di usarlo. D'ora in poi scriveremo semplicemente:

{{Code|code=
myVar = "hello friends"
myVar
}}
{{Top}}
<span id="Lists"></span>
==Liste==

Un altro tipo di dati utile è la lista. Una lista è una raccolta di altri dati. Per definire una lista utilizziamo {{incode|[ ]}}:

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

Come puoi notare una lista può contenere qualsiasi tipo di dato. Puoi fare molte cose con una lista. Ad esempio, contare i suoi elementi:

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

o recuperare un elemento:

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

Mentre il comando {{incode|len()}} restituisce il numero totale di elementi in una lista, il primo elemento in una lista è sempre nella posizione {{incode|0}}, quindi nella nostra {{incode|myOtherList}} {{incode|"Bob"}} sarà nella posizione {{incode|2}}. Possiamo fare molto di più con le liste, come l'ordinamento degli elementi e la rimozione o l'aggiunta di elementi.

È interessante notare che una stringa di testo è molto simile a un elenco di caratteri in Python. Prova a fare questo:

{{Code|code=
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, numeri interi, numeri a virgola mobile e liste, ci sono altri tipi di dati incorporati, come i dizionari, e puoi persino creare i tuoi tipi di dati con le classi.
{{Top}}
<span id="Indentation"></span>
==Indentazione==

Un uso importante delle liste è la possibilità di "attraversarle" e fare qualcosa con ogni loro elemento. Ad esempio, si noti quanto segue:

{{Code|code=
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 {{incode|for in}} e con ognuno dei suoi elementi viene eseguito qualcosa.

Notare la speciale sintassi. Il comando {{incode|for}} termina con un {{incode|:}} 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 {{incode|:}}, il prompt dei comandi cambia in {{incode|...}} il che significa che Python sa che c'è dell'altro in arrivo..

Come fa Python a sapere quante delle prossime righe devono essere eseguite all'interno dell'operazione {{incode|for in}}? Per sapere questo, Python si basa sull'indentazione. Le righe successive devono iniziare con uno spazio vuoto, o più spazi vuoti, o una tabulazione, o più tabulazioni. E finché l'indentazione rimane la stessa, le righe saranno considerate parte del blocco {{incode|for in}}. Se si inizia una riga con 2 spazi e la successiva con 4, darà un errore. Quando si finisce, scrivere un'altra riga senza indentazione o premere {{KEY|Enter}} per uscire dal blocco {{incode|for in}}.

L'indentazione è molto utile anche per la leggibilità del programma. Se si usano rientri lunghi (ad esempio le tabulazioni invece degli spazi) quando si scrive un programma di grandi dimensioni, si avrà una visione chiara di ciò che viene eseguito all'interno dei blocchi. Vedremo che anche altri comandi utilizzano blocchi di codice indentati.

Il comando {{incode|for in}} può essere utilizzato per molte cose che devono essere eseguite più di una volta. Può, ad esempio, essere combinato con il comando {{incode|range()}}:

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

Or more complex things like this:
Se è stato eseguito l'esempio di codice in un interprete copiando e incollando, si noterà che il blocco di testo precedente genera un errore. Si copi invece fino alla fine del blocco rientrato, cioè alla fine della riga {{incode|total <nowiki>=</nowiki> total + number}} e poi si incolli nell'interprete. Quindi nell'interprete si prema {{KEY|Enter}} fino a quando il prompt dei tre punti scompare e il codice viene eseguito. Infine, si copino le ultime due righe seguite da un altro {{KEY|Enter}}. Dovrebbe apparire la risposta finale.
<syntaxhighlight>

alldaltons = ["Joe", "William", "Jack", "Averell"]
Se si digita nell'interprete {{incode|help(range)}} si otterrà:
for n in range(4):

print alldaltons[n], " is Dalton number ", n
{{Code|code=
</syntaxhighlight>
range(...)
You see that the range() command also has that strange particularity that it begins with 0 (if you don't specify the starting number) and that its last number will be one less than the ending number you specify. That is, of course, so it works well with other Python commands. For example:
range(stop) -> list of integers
<syntaxhighlight>
range(start, stop[, step]) -> list of integers
alldaltons = ["Joe", "William", "Jack", "Averell"]
}}
total = len(alldaltons)

for n in range(total):
Qui le parentesi quadre denotano un parametro opzionale. Tuttavia, tutti dovrebbero essere interi. Di seguito forzeremo il parametro step a essere un intero usando {{incode|int()}}:
print alldaltons[n]

</syntaxhighlight>
{{Code|code=
Another interesting use of indented blocks is with the if command. If executes a code block only if a certain condition is met, for example:
number = 1000
<syntaxhighlight>
for i in range(0, 180 * number, int(0.5 * number)):
alldaltons = ["Joe", "William", "Jack", "Averell"]
print(float(i) / number)
if "Joe" in alldaltons:
}}
print "We found that Dalton!!!"

</syntaxhighlight>
Un altro esempio con {{incode|range()}}:
Of course this will always print the first sentence, but try replacing the second line by:

<syntaxhighlight>
{{Code|code=
if "Lucky" in alldaltons:
alldaltons = ["Joe", "William", "Jack", "Averell"]
</syntaxhighlight>
for n in range(4):
Then nothing is printed. We can also specify an else: statement:
print(alldaltons[n], " is Dalton number ", n)
<syntaxhighlight>
}}
alldaltons = ["Joe", "William", "Jack", "Averell"]

if "Lucky" in alldaltons:
Il comando {{incode|range()}} ha la strana particolarità di iniziare con {{incode|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 sistema funziona bene con gli altri comandi di Python. Ad esempio:
print "We found that Dalton!!!"

else:
{{Code|code=
print "Such Dalton doesn't exist!"
alldaltons = ["Joe", "William", "Jack", "Averell"]
</syntaxhighlight>
total = len(alldaltons)
==Functions==
for n in range(total):
print(alldaltons[n])
}}

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

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

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

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

Qui non viene stampato nulla. Possiamo anche specificare un'istruzione {{incode|else}}:

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

I [https://docs.python.org/3/reference/lexical_analysis.html#identifiers comandi standard di Python] non sono molti e ne conosciamo già alcuni di loro. Ma i comandi possono anche essere creati. In effetti, la maggior parte dei moduli aggiuntivi, che si possono inserire nella propria installazione di Python, fanno esattamente questo e aggiungono dei comandi, che si possono utilizzare. In Python un comando personalizzato si chiama funzione e si crea in questo modo:

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

printsqm(45)
}}

Il comando {{incode|def()}} definisce una nuova funzione, le si assegna un nome e tra parentesi si definiscono gli argomenti, che la funzione utilizzerà. Gli argomenti sono dati, che verranno passati alla funzione. Ad esempio, si osservi il comando {{incode|len()}}. Se si scrive semplicemente {{incode|len()}}, Python dirà che ha bisogno di un argomento. Il che è ovvio: vuoi conoscere la lunghezza di qualcosa. Se si scrive {{incode|len(myList)}} allora {{incode|myList}} è l'argomento, che si passa alla funzione {{incode|len()}}. E la funzione {{incode|len()}} è definita in modo tale da sapere cosa fare con questo argomento. Abbiamo fatto la stessa cosa con la nostra funzione {{incode|printsqm}}.

Il nome {{incode|myValue}} può essere un qualsiasi oggetto e verrà utilizzato solo all'interno della funzione. È solo un nome, che dai all'argomento, in modo da poterci fare qualcosa. Definendo gli argomenti si deve anche dire alla funzione quanti aspettarsene. Ad esempio, se facendo quanto segue:

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


si otterrà un errore. La nostra funzione è stata programmata per ricevere un solo argomento, ma ne ha ricevuti due, {{incode|45}} e {{incode|34}}. Proviamo un altro esempio:
The [http://docs.python.org/reference/lexical_analysis.html#identifiers standard Python commands] are not many. In current version of Python there are about 30, and we already know several of them. But imagine if we could invent our own commands? Well, we can, and it's extremely easy. In fact, most the additional modules that you can plug into your Python installation do just that, they add commands that you can use. A custom command in Python is called a function and is made like this:
<syntaxhighlight>
def printsqm(myValue):
print str(myValue)+" square meters"
printsqm(45)
</syntaxhighlight>
Extremely simple: the def() command defines a new function. You give it a name, and inside the parenthesis you define arguments that we'll use in our function. Arguments are data that will be passed to the function. For example, look at the len() command. If you just write len() alone, Python will tell you it needs an argument. That is, you want len() of something, right? Then, for example, you'll write len(myList) and you'll get the length of myList. Well, myList is an argument that you pass to the len() function. The len() function is defined in such a way that it knows what to do with what is passed to it. Same as we did here.


{{Code|code=
The "myValue" name can be anything, and it will be used only inside the function. It is just a name you give to the argument so you can do something with it, but it also serves so the function knows how many arguments to expect. For example, if you do this:
def sum(val1, val2):
<syntaxhighlight>
printsqm(45,34)
</syntaxhighlight>
There will be an error. Our function was programmed to receive just one argument, but it received two, 45 and 34. We could instead do something like this:
<syntaxhighlight>
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)
</syntaxhighlight>
We made a function that receives two arguments, sums them, and returns that value. Returning something is very useful, because we can do something with the result, such as store it in the myTotal variable. Of course, since we are in the interpreter and everything is printed, doing:
<syntaxhighlight>
sum(45,34)
</syntaxhighlight>
will print the result on the screen, but outside the interpreter, since there is no more print command inside the function, nothing would appear on the screen. You would need to do:
<syntaxhighlight>
print sum(45,34)
</syntaxhighlight>
to have something printed. Read more about functions [http://www.diveintopython.net/getting_to_know_python/declaring_functions.html here].


Qui abbiamo creato una funzione che riceve due argomenti, li somma e restituisce quel valore. Restituire qualcosa è molto utile, perché possiamo fare qualcosa con il risultato, come memorizzarlo nella variabile {{incode|myTotal}}.
==Modules==
{{Top}}
<span id="Modules"></span>
==Moduli==


Now that we have a good idea of how Python works, we'll need one last thing: How to work with files and modules.
Ora che si ha una buona idea di come funziona Python, c'è bisogno di sapere un'altra cosa: come lavorare con file e moduli.


Fino ad ora, abbiamo scritto le istruzioni Python riga per riga nell'interprete. Questo metodo ovviamente non è adatto per programmi più grandi. Normalmente il codice per i programmi Python è memorizzato in file con estensione {{FileName|.py}}. Che sono solo semplici file di testo e qualsiasi editor di testo (Linux gedit, emacs, vi o persino Blocco note di Windows) può essere utilizzato per crearli e modificarli.
Until now, we wrote Python instructions line by line in the interpreter, right? What if we could write several lines together, and have them executed all at once? It would certainly be handier for doing more complex things. And we could save our work too. Well, that too, is extremely easy. Simply open a text editor (such as the windows notepad), and write all your Python lines, the same way as you write them in the interpreter, with indentations, etc. Then, save that file somewhere, preferably with a .py extension. That's it, you have a complete Python program. Of course, there are much better editors than notepad, but it is just to show you that a Python program is nothing else than a text file.


Esistono diversi modi per eseguire un programma Python. In Windows, fai semplicemente clic con il pulsante destro del mouse, aprilo con Python ed eseguilo. Ma puoi anche eseguirlo dall'interprete Python stesso. Per questo, l'interprete deve sapere dove si trova il tuo programma. In FreeCAD il modo più semplice è posizionare il programma in una cartella, che l'interprete Python di FreeCAD conosce per impostazione predefinita, come la cartella utente {{FileName|Mod}} di FreeCAD:
To make Python execute that program, there are hundreds of ways. In windows, simply right-click your file, open it with Python, and execute it. But you can also execute it from the Python interpreter itself. For this, the interpreter must know where your .py program is. In FreeCAD, the easiest way is to place your program in a place that FreeCAD's Python interpreter knows by default, such as FreeCAD's bin folder, or any of the Mod folders. Suppose we write a file like this:
* Su Linux è solitamente {{FileName|/home/<username>/.local/share/FreeCAD/Mod/}} ({{VersionPlus/it|0.20}}) o {{FileName|/home/<username>/. FreeCAD/Mod/}} ({{VersionMinus/it|0.19}}).
<syntaxhighlight>
* Su Windows è {{FileName|%APPDATA%\FreeCAD\Mod\}}, che di solito è {{FileName|C:\Users\<username>\Appdata\Roaming\FreeCAD\Mod\}}.
* Su macOS è solitamente {{FileName|/Users/<username>/Library/Application Support/FreeCAD/Mod/}}.
Aggiungiamo una sottocartella chiamata {{FileName|scripts}} e quindi scriviamo un file come questo:

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


print "test.py succesfully loaded"
print("myTest.py succesfully loaded")
}}
</syntaxhighlight>


Salviamo il file come {{FileName|myTest.py}} nella cartella {{FileName|scripts}} e nella finestra dell'interprete si scriva:
and we save it as test.py in our FreeCAD/bin directory. Now, let's start FreeCAD, and in the interpreter window, write:
<syntaxhighlight>
import test
</syntaxhighlight>
without the .py extension. This will simply execute the contents of the file, line by line, just as if we had written it in the interpreter. The sum function will be created, and the message will be printed. There is one big difference: the import command is made not only to execute programs written in files, like ours, but also to load the functions inside, so they become available in the interpreter. Files containing functions, like ours, are called modules.


{{Code|code=
Normally when we write a sum() function in the interpreter, we execute it simply like that:
import myTest
<syntaxhighlight>
}}
sum(14,45)
</syntaxhighlight>
Like we did earlier. When we import a module containing our sum() function, the syntax is a bit different. We do:
<syntaxhighlight>
test.sum(14,45)
</syntaxhighlight>
That is, the module is imported as a "container", and all its functions are inside. This is extremely useful, because we can import a lot of modules, and keep everything well organized. So, basically, everywhere you see something.somethingElse, with a dot in between, that means somethingElse is inside something.


senza l'estensione {{FileName|.py}}. Questo eseguirà il contenuto del file, riga per riga, proprio come se lo avessimo scritto nell'interprete. Verrà creata la funzione di somma e il messaggio verrà stampato. I file contenenti funzioni, come la nostra, sono chiamati moduli.
We can also throw out the test part, and import our sum() function directly into the main interpreter space, like this:
<syntaxhighlight>
from test import *
sum(12,54)
</syntaxhighlight>
Basically all modules behave like that. You import a module, then you can use its functions like that: module.function(argument). Almost all modules do that: they define functions, new data types and classes that you can use in the interpreter or in your own Python modules, because nothing prevents you to import modules inside your module!


Quando scriviamo una funzione {{incode|sum()}} nell'interprete, la eseguiamo in questo modo:
One last extremely useful thing. How do we know what modules we have, what functions are inside and how to use them (that is, what kind of arguments they need)? We saw already that Python has a help() function. Doing:
<syntaxhighlight>
help()
modules
</syntaxhighlight>
Will give us a list of all available modules. We can now type q to get out of the interactive help, and import any of them. We can even browse their content with the dir() command
<syntaxhighlight>
import math
dir(math)
</syntaxhighlight>
We'll see all the functions contained in the math module, as well as strange stuff named __doc__, __file__, __name__. The __doc__ is extremely useful, it is a documentation text. Every function of (well-made) modules has a __doc__ that explains how to use it. For example, we see that there is a sin function in side the math module. Want to know how to use it?
<syntaxhighlight>
print math.sin.__doc__
</syntaxhighlight>
And finally one last little goodie: When we work on programming a new module, we often want to test it. So once we wrote a little piece of module, in a python interpreter, we do something like this, to test our new code:
<syntaxhighlight>
import myModule
myModule.myTestFunction()
</syntaxhighlight>
But what if we see that myTestFunction() doesn't work correctly? We go back to our editor and modifiy it. Then, instead of closing and reopening the python interpreter, we can simply update the module like this:
<syntaxhighlight>
reload(myModule)
</syntaxhighlight>
==Starting with FreeCAD==


{{Code|code=
Well, I think you must know have a good idea of how Python works, and you can start exploring what FreeCAD has to offer. FreeCAD's Python functions are all well organized in different modules. Some of them are already loaded (imported) when you start FreeCAD. So, just do
sum(14, 45)
<syntaxhighlight>
}}
dir()
</syntaxhighlight>
and read on to [[FreeCAD Scripting Basics]]...


Ma quando importiamo un modulo contenente una funzione {{incode|sum()}} la sintassi è leggermente diversa:
Of course, we saw here only a very small part of the Python world. There are many important concepts that we didn't mention here. There are three very important Python reference documents on the net:
* the [http://docs.python.org/3/tutorial/index.html official Python tutorial with way more information than this one]
* the [http://docs.python.org/reference/ official Python reference]
* the [http://www.diveintopython.net Dive into Python] wikibook/ book.
Be sure to bookmark them!


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


Cioè, il modulo viene importato come un "contenitore" e tutte le sue funzioni sono all'interno di quel contenitore. Questo è molto utile, perché possiamo importare molti moduli e mantenere tutto ben organizzato. Fondamentalmente quando vedi {{incode|something.somethingElse}}, con un punto in mezzo, significa che {{incode|somethingElse}} è all'interno di {{incode|something}}.
{{docnav|Macros|Python scripting tutorial}}


Possiamo anche importare la nostra funzione sum() direttamente nello spazio dell'interprete principale:
[[Category:Poweruser Documentation]]


{{Code|code=
{{clear}}
from myTest import *
<languages/>
sum(12, 54)
}}

Quasi tutti i moduli lo fanno: definiscono funzioni, nuovi tipi di dati e classi, che puoi usare nell'interprete o nei tuoi moduli Python, perché nulla impedisce di importare altri moduli all'interno del tuo modulo!

Come facciamo a sapere quali moduli abbiamo, quali funzioni ci sono all'interno e come usarli (ovvero, di che tipo di argomenti hanno bisogno)? Abbiamo già visto che Python ha una funzione {{incode|help()}}. Facendo:

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

ci restituirà un elenco di tutti i moduli disponibili. Possiamo importarne uno qualsiasi e sfogliarne il contenuto con il comando {{incode|dir()}}:

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

Vedremo tutte le funzioni contenute nel modulo {{incode|math}}, oltre a cose strane denominate {{incode|__doc__}}, {{incode|__file__}}, {{incode|__name__}}. Ogni funzione in un modulo ben fatto ha un {{incode|__doc__}} che spiega come usarla. Ad esempio, vediamo che c'è una funzione {{incode|sin()}} all'interno del modulo matematico. Vuoi sapere come usarlo?
{{Code|code=
print(math.sin.__doc__)
}}

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

E infine un ultimo consiglio: quando si lavora su del codice nuovo o esistente, è meglio non utilizzare l'estensione del file macro di FreeCAD, {{FileName|.FCMacro}}, ma utilizzare invece l'estensione standard {{FileName|.py}}. Questo perché Python non riconosce l'estensione {{FileName|.FCMacro}}. Se usi {{FileName|.py}} il tuo codice può essere facilmente caricato con {{incode|import}}, come abbiamo già visto, e anche ricaricato con {{incode|importlib.reload()}}:

{{Code|code=
import importlib
importlib.reload(myTest)
}}

C'è comunque un'alternativa:

{{Code|code=
exec(open("C:/PathToMyMacro/myMacro.FCMacro").read())
}}
{{Top}}
<span id="Starting_with_FreeCAD"></span>
==Iniziare con FreeCAD==

Spero che ora tu ti sia fatto una buona idea di come funziona Python e che tu possa iniziare a esplorare ciò che FreeCAD ha da offrire. Le funzioni Python di FreeCAD sono tutte ben organizzate in diversi moduli. Alcuni di essi sono già caricati (importati) all'avvio di FreeCAD. Prova:

{{Code|code=
dir()
}}
{{Top}}
<span id="Notes"></span>
==Note==

* FreeCAD è stato originariamente progettato per funzionare con Python 2. Poiché Python 2 ha raggiunto la fine del suo ciclo di vita nel 2020, lo sviluppo futuro di FreeCAD sarà effettuato esclusivamente con Python 3 e la compatibilità con le versioni precedenti non sarà supportata.
* Molte più informazioni su Python possono essere trovate nel [https://docs.python.org/3/tutorial/index.html tutorial ufficiale di Python] e nel [https://docs.python.org/3/reference/ manuale di riferimento ufficiale di Python].
{{Top}}

{{Docnav
|[[Scripts/it|Script]]
|[[Python_scripting_tutorial/it|Guida agli script Python]]
}}

{{Powerdocnavi{{#translation:}}}}
[[Category:Developer Documentation{{#translation:}}]]
[[Category:Python Code{{#translation:}}]]

Latest revision as of 20:23, 17 February 2023

Introduzione

Quello che segue è un breve tutorial per chi non conosce Python. Python è un Linguaggio di programmazione open source e multipiattaforma . Ha diverse caratteristiche, che lo rendono diverso dagli altri linguaggi di programmazione, ed è facilmente accessibile ai nuovi utenti:

  • È stato progettato per essere leggibile dagli esseri umani, rendendolo relativamente facile da imparare e da capire.
  • Viene interpretato, questo significa che i programmi non devono essere compilati prima di poter essere eseguiti. Il codice Python può essere eseguito immediatamente, anche riga per riga, se si desidera.
  • Può essere incorporato in altri programmi come linguaggio di scripting. FreeCAD ha un interprete Python incorporato. Si può scrivere codice Python per manipolare parti di FreeCAD. Questa funzionalità è molto potente e comporta che puoi costruire i tuoi strumenti personalizzati.
  • È estensibile, si può facilmente inserire nuovi moduli nella tua installazione di Python ed estenderne la funzionalità. Ad esempio, ci sono moduli che consentono a Python di leggere e scrivere immagini, di comunicare con Twitter, di pianificare attività che devono essere eseguite dal tuo sistema operativo, ecc.

Quella che segue è un'introduzione molto semplice e non un tutorial completo. Ma si spera che fornisca un buon punto di partenza per un'ulteriore esplorazione di FreeCAD e dei suoi meccanismi. Si consiglia vivamente di inserire i seguenti frammenti di codice in un interprete Python.

L'interprete

Di solito, per scrivere programmi per computer, basta aprire un editor di testo (o l'ambiente di programmazione preferito che di base è un editor di testo con alcuni strumenti aggiuntivi), scrivere il programma, quindi compilarlo ed eseguirlo. Spesso 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 dell'interprete Python. L'interprete è una finestra Python con un prompt dei comandi, in cui puoi semplicemente digitare il codice Python. Se hai installato Python sul tuo computer (scaricalo dal sito Web Python se sei su Windows o Mac, installalo dal repository del tuo pacchetto se sei su GNU/Linux), avrai un interprete Python nel tuo menu di avvio. Ma, come già accennato, FreeCAD ha anche un interprete Python integrato: la Console Python.

La console di FreeCAD Python

Se non la vedi, clicca su Visualizza → 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 è capito cos'è l'interprete Python, possiamo continuare con le cose più serie.

Inizio

Variabili

Molto spesso nella programmazione è necessario memorizzare un valore sotto un nome. È qui che entrano in gioco le variabili. Ad esempio, digita 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)

Ora hello non è più un indefinito. Le variabili possono essere modificate in qualsiasi momento, per questo si chiamano variabili, il loro contenuto può variare. Per esempio:

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)

È consigliabile assegnare nomi significativi alle variabili. Dopo un po' ci si ricorderà più cosa rappresenta la variabile denominata a. Ma se l'hai chiamata, ad esempio, myWelcomeMessage, ricorderai facilmente il suo scopo. Inoltre, il tuo codice sarà un passo avanti verso l'autodocumentazione.

Il Maiuscolo o minuscolo è molto importante, myVariable non è lo stesso di myvariable. Se si dovesse inserire print(myvariable), verrebbe restituito un errore come nome non definito.

Inizio

Numeri

Ovviamente i programmi Python possono gestire tutti i tipi di dati, non solo le stringhe di testo. Una cosa è importante, Python deve sapere con che tipo di dati ha a che fare. Abbiamo visto nel nostro esempio print hello, che il comando print() ha riconosciuto la nostra stringa "hello". Utilizzando i caratteri " ", abbiamo specificato che quella che segue è una stringa di testo.

Possiamo sempre controllare il tipo di dati di una variabile con il comando type():

myVar = "hello"
type(myVar)

Questo significa che il contenuto di myVar è un 'str', che è l'abbreviazione di string. Esistono anche altri tipi di dati di base come numeri interi e a virgola mobile:

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

Python sa che 10 e 20 sono numeri interi, quindi sono archiviati come 'int' e Python può fare con loro tutto ciò che può fare con i numeri interi. Osserva i risultati di questo codice:

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

Qui abbiamo costretto Python a considerare che le nostre due variabili non sono numeri ma parti di testo. Python può unire due parti di testo insieme, anche se in tal caso, ovviamente, non eseguirà alcuna operazione aritmetica. Ma si stava parlando di numeri interi. Ci sono anche i numeri a virgola mobile. La differenza è che i numeri a virgola mobile possono avere una parte decimale, mentre i numeri interi no:

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

Numeri interi e a virgola mobile possono essere mescolati insieme senza problemi:

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

Poiché var2 è un numero a virgola mobile, Python decide automaticamente, che anche il risultato deve essere un numero a virgola mobile. Ma ci sono casi in cui Python non sa quale tipo adottare. Per esempio:

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

Quel codice provoca un errore, varA è una stringa e varB è un numero intero e Python non sa cosa fare. Tuttavia, possiamo forzare Python a convertire tra tipi:

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

Ora che entrambe le variabili sono stringhe l'operazione funziona. Nota che abbiamo "stringificato" varB al momento della stampa, ma non abbiamo modificato varB stesso. Se volessimo trasformare varB in modo permanente in una stringa, dovremmo farlo in questo modo:

varB = str(varB)

Possiamo anche usare int() e float() per convertire tra numeri interi e numeri a virgola mobile se vogliamo:

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

Avrai notato che abbiamo usato il comando print() in diversi modi. Abbiamo stampato variabili, somme, diverse cose separate da virgole e persino il risultato di un altro comando Python. Forse hai anche notato che questi due comandi:

type(varA)
print(type(varA))

hanno lo stesso risultato. Questo perché siamo nell'interprete e tutto viene stampato automaticamente. Quando scriviamo programmi più complessi, che vengono eseguiti al di fuori dell'interprete, non verranno stampati automaticamente, quindi dovremo usare il comando print(). Tenendo questo presente, smetteremo di usarlo. D'ora in poi scriveremo semplicemente:

myVar = "hello friends"
myVar

Inizio

Liste

Un altro tipo di dati utile è la lista. Una lista è una raccolta di altri dati. Per definire una lista utilizziamo [ ]:

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

Come puoi notare una lista può contenere qualsiasi tipo di dato. Puoi fare molte cose con una lista. Ad esempio, contare i suoi elementi:

len(myOtherList)

o recuperare un elemento:

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

Mentre il comando len() restituisce il numero totale di elementi in una lista, il primo elemento in una lista è sempre nella posizione 0, quindi nella nostra myOtherList "Bob" sarà nella posizione 2. Possiamo fare molto di più con le liste, come l'ordinamento degli elementi e la rimozione o l'aggiunta di elementi.

È interessante notare che una stringa di testo è molto simile a un elenco di caratteri in Python. Prova 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, numeri interi, numeri a virgola mobile e liste, ci sono altri tipi di dati incorporati, come i dizionari, e puoi persino creare i tuoi tipi di dati con le classi.

Inizio

Indentazione

Un uso importante delle liste è la possibilità di "attraversarle" e fare qualcosa con ogni loro elemento. Ad esempio, si noti quanto segue:

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 sa che c'è dell'altro in arrivo..

Come fa Python a sapere quante delle prossime righe devono essere eseguite all'interno dell'operazione for in? Per sapere questo, Python si basa sull'indentazione. Le righe successive devono iniziare con uno spazio vuoto, o più spazi vuoti, o una tabulazione, o più tabulazioni. E finché l'indentazione rimane la stessa, le righe saranno considerate parte del blocco for in. Se si inizia una riga con 2 spazi e la successiva con 4, darà un errore. Quando si finisce, scrivere un'altra riga senza indentazione o premere Enter per uscire dal blocco for in.

L'indentazione è molto utile anche per la leggibilità del programma. Se si usano rientri lunghi (ad esempio le tabulazioni invece degli spazi) quando si scrive un programma di grandi dimensioni, si avrà una visione chiara di ciò che viene eseguito all'interno dei blocchi. Vedremo che anche altri comandi utilizzano blocchi di codice indentati.

Il comando for in può essere utilizzato per molte cose che devono essere eseguite più di una volta. Può, ad esempio, 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)

Se è stato eseguito l'esempio di codice in un interprete copiando e incollando, si noterà che il blocco di testo precedente genera un errore. Si copi invece fino alla fine del blocco rientrato, cioè alla fine della riga total = total + number e poi si incolli nell'interprete. Quindi nell'interprete si prema Enter fino a quando il prompt dei tre punti scompare e il codice viene eseguito. Infine, si copino le ultime due righe seguite da un altro Enter. Dovrebbe apparire la risposta finale.

Se si digita nell'interprete help(range) si otterrà:

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

Qui le parentesi quadre denotano un parametro opzionale. Tuttavia, tutti dovrebbero essere interi. Di seguito forzeremo il parametro step a essere un intero usando int():

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

Un altro esempio con range():

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

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 sistema 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. Questo comando 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 si provi a sostituire la seconda riga con:

if "Lucky" in alldaltons:

Qui non viene stampato nulla. Possiamo anche specificare un'istruzione 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 e ne conosciamo già alcuni di loro. Ma i comandi possono anche essere creati. In effetti, la maggior parte dei moduli aggiuntivi, che si possono inserire nella propria installazione di Python, fanno esattamente questo e aggiungono dei comandi, che si possono utilizzare. In Python un comando personalizzato si chiama funzione e si crea in questo modo:

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

printsqm(45)

Il comando def() definisce una nuova funzione, le si assegna un nome e tra parentesi si definiscono gli argomenti, che la funzione utilizzerà. Gli argomenti sono dati, che verranno passati alla funzione. Ad esempio, si osservi il comando len(). Se si scrive semplicemente len(), Python dirà che ha bisogno di un argomento. Il che è ovvio: vuoi conoscere la lunghezza di qualcosa. Se si scrive len(myList) allora myList è l'argomento, che si passa alla funzione len(). E la funzione len() è definita in modo tale da sapere cosa fare con questo argomento. Abbiamo fatto la stessa cosa con la nostra funzione printsqm.

Il nome myValue può essere un qualsiasi oggetto e verrà utilizzato solo all'interno della funzione. È solo un nome, che dai all'argomento, in modo da poterci fare qualcosa. Definendo gli argomenti si deve anche dire alla funzione quanti aspettarsene. Ad esempio, se facendo quanto segue:

printsqm(45, 34)

si otterrà un errore. La nostra funzione è stata programmata per ricevere un solo argomento, ma ne ha ricevuti due, 45 e 34. Proviamo un altro esempio:

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

myTotal = sum(45, 34)

Qui abbiamo creato una funzione che riceve due argomenti, li somma e restituisce quel valore. Restituire qualcosa è molto utile, perché possiamo fare qualcosa con il risultato, come memorizzarlo nella variabile myTotal.

Inizio

Moduli

Ora che si ha una buona idea di come funziona Python, c'è bisogno di sapere un'altra cosa: come lavorare con file e moduli.

Fino ad ora, abbiamo scritto le istruzioni Python riga per riga nell'interprete. Questo metodo ovviamente non è adatto per programmi più grandi. Normalmente il codice per i programmi Python è memorizzato in file con estensione .py. Che sono solo semplici file di testo e qualsiasi editor di testo (Linux gedit, emacs, vi o persino Blocco note di Windows) può essere utilizzato per crearli e modificarli.

Esistono diversi modi per eseguire un programma Python. In Windows, fai semplicemente clic con il pulsante destro del mouse, aprilo con Python ed eseguilo. Ma puoi anche eseguirlo dall'interprete Python stesso. Per questo, l'interprete deve sapere dove si trova il tuo programma. In FreeCAD il modo più semplice è posizionare il programma in una cartella, che l'interprete Python di FreeCAD conosce per impostazione predefinita, come la cartella utente Mod di FreeCAD:

  • Su Linux è solitamente /home/<username>/.local/share/FreeCAD/Mod/ (versione 0.20 e superiori) o /home/<username>/. FreeCAD/Mod/ (versione 0.19 e precedenti).
  • Su Windows è %APPDATA%\FreeCAD\Mod\, che di solito è C:\Users\<username>\Appdata\Roaming\FreeCAD\Mod\.
  • Su macOS è solitamente /Users/<username>/Library/Application Support/FreeCAD/Mod/.

Aggiungiamo una sottocartella chiamata scripts e quindi scriviamo un file come questo:

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

print("myTest.py succesfully loaded")

Salviamo il file come myTest.py nella cartella scripts e nella finestra dell'interprete si scriva:

import myTest

senza l'estensione .py. Questo eseguirà il contenuto del file, riga per riga, proprio come se lo avessimo scritto nell'interprete. Verrà creata la funzione di somma e il messaggio verrà stampato. I file contenenti funzioni, come la nostra, sono chiamati moduli.

Quando scriviamo una funzione sum() nell'interprete, la eseguiamo in questo modo:

sum(14, 45)

Ma quando importiamo un modulo contenente una funzione sum() la sintassi è leggermente diversa:

myTest.sum(14, 45)

Cioè, il modulo viene importato come un "contenitore" e tutte le sue funzioni sono all'interno di quel contenitore. Questo è molto utile, perché possiamo importare molti moduli e mantenere tutto ben organizzato. Fondamentalmente quando vedi something.somethingElse, con un punto in mezzo, significa che somethingElse è all'interno di something.

Possiamo anche importare la nostra funzione sum() direttamente nello spazio dell'interprete principale:

from myTest import *
sum(12, 54)

Quasi tutti i moduli lo fanno: definiscono funzioni, nuovi tipi di dati e classi, che puoi usare nell'interprete o nei tuoi moduli Python, perché nulla impedisce di importare altri moduli all'interno del tuo modulo!

Come facciamo a sapere quali moduli abbiamo, quali funzioni ci sono all'interno e come usarli (ovvero, di che tipo di argomenti hanno bisogno)? Abbiamo già visto che Python ha una funzione help(). Facendo:

help("modules")

ci restituirà un elenco di tutti i moduli disponibili. Possiamo importarne uno qualsiasi e sfogliarne il contenuto con il comando dir():

import math
dir(math)

Vedremo tutte le funzioni contenute nel modulo math, oltre a cose strane denominate __doc__, __file__, __name__. Ogni funzione in un modulo ben fatto ha un __doc__ che spiega come usarla. Ad esempio, vediamo che c'è una funzione sin() all'interno del modulo matematico. Vuoi sapere come usarlo?

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 consiglio: quando si lavora su del codice nuovo o esistente, è meglio non utilizzare l'estensione del file macro di FreeCAD, .FCMacro, ma utilizzare invece l'estensione standard .py. Questo perché Python non riconosce l'estensione .FCMacro. Se usi .py il tuo codice può essere facilmente caricato con import, come abbiamo già visto, e anche ricaricato con importlib.reload():

import importlib
importlib.reload(myTest)

C'è comunque un'alternativa:

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

Inizio

Iniziare con FreeCAD

Spero che ora tu ti sia fatto una buona idea di come funziona Python e che tu possa iniziare a esplorare ciò che FreeCAD ha da offrire. Le funzioni Python di FreeCAD sono tutte ben organizzate in diversi moduli. Alcuni di essi sono già caricati (importati) all'avvio di FreeCAD. Prova:

dir()

Inizio

Note

  • FreeCAD è stato originariamente progettato per funzionare con Python 2. Poiché Python 2 ha raggiunto la fine del suo ciclo di vita nel 2020, lo sviluppo futuro di FreeCAD sarà effettuato esclusivamente con Python 3 e la compatibilità con le versioni precedenti non sarà supportata.
  • Molte più informazioni su Python possono essere trovate nel tutorial ufficiale di Python e nel manuale di riferimento ufficiale di Python.

Inizio