Introduzione a Python

From FreeCAD Documentation
Jump to: navigation, search
This page is a translated version of the page Introduction to Python and the translation is 96% complete.

Outdated translations are marked like this.
Other languages:
čeština • ‎Deutsch • ‎English • ‎español • ‎français • ‎Bahasa Indonesia • ‎italiano • ‎日本語 • ‎한국어 • ‎polski • ‎português • ‎português do Brasil • ‎română • ‎русский • ‎svenska • ‎Türkçe • ‎中文(中国大陆)‎
Arrow-left.svg Macro Pagina precedente:
Pagina successiva: Guida agli script Python Arrow-right.svg
(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 print() è preferita rispetto alla vecchia print.

Questo è una breve guida realizzata per chi si avvicina per la prima volta a Python. Python è un 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:

  • È 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:

Screenshot pythoninterpreter.jpg

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:

print "hello"

per Python print è 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:

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.

L'interprete Python possiede anche un sistema di aiuto incorporato. Provare a digitare:

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:

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.

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":

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:

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.

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)

Note sui comandi Python

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

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

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.

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 would type into the interpreter help(range) you would 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 range parameters to be an integer using int()

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

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!"

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.

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

sum(45,34)
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:

sum(45,34)

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:

print sum(45,34)

Per ulteriori informazioni sulle funzioni leggere qui.

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 myModule
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:

reload(myModule)

Questo perché Python non conosce l'estensione FCMacro.

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

f = open("myModule","r")
d = f.read()
exec d

oppure

execfile "myModule"

Per Python 3.xxx sostituire questo codice con:

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

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.

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

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()

e continuate a leggere in Script base in FreeCAD.

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:

Accertarsi di averli nel segnalibri!


Arrow-left.svg Macro Pagina precedente:
Pagina successiva: Guida agli script Python Arrow-right.svg