Marzo 2016

Volume 31 Numero 3

Il presente articolo è stato tradotto automaticamente.

Python - Introduzione alla programmazione in SciPy per sviluppatori C#

Da James McCaffrey

Nessuna definizione formale di analisi scientifica dei dati il termine, ma considerata come tramite i programmi software per analizzare i dati utilizzando le tecniche statistiche classico e algoritmi di apprendimento automatico. Fino a poco tempo fa, gran parte delle analisi di analisi scientifica dei dati è stata eseguita con prodotti commerciali costosi, ma negli ultimi anni ha aumentato notevolmente l'utilizzo di alternative di origine aperto.

In base alle conversazioni con colleghi, tre approcci Apri origine più comuni per l'analisi di analisi scientifica dei dati sono il linguaggio R, il linguaggio Python combinati con la libreria SciPy ("Python scientifica") e ambienti di lingua e l'esecuzione, ad esempio SciLab e ottava integrati.

In questo articolo fornirò una breve panoramica della programmazione con SciPy così sarà possibile capire esattamente ciò che è e determinare se si desidera dedicare tempo all'apprendimento. Questo articolo si presuppone una certa esperienza con c# o un linguaggio di programmazione generico simile, ad esempio Java, ma non si supponga che conoscere Python o SciPy.

A mio parere, la parte più difficile imparare un nuovo linguaggio di programmazione o una tecnologia è iniziare, pertanto verrà descritta in dettaglio come installare il software necessario per eseguire un programma SciPy (e disinstallare). Quindi, descriverò in diversi modi per modificare ed eseguire un programma SciPy e spiegare perché preferisce utilizzando il programma di ambiente di sviluppo integrato (inattivo).

Concluderò attraverso un programma rappresentativo che utilizza SciPy per risolvere un sistema di equazioni lineare, per illustrare analogie e differenze di programmazione c#. Figura 1 viene illustrato l'output del programma demo e dà un'idea del futuro in questo articolo.

Figura 1 Output da un programma SciPy rappresentante

Installare lo Stack SciPy

Lo stack SciPy ha tre componenti: Python, NumPy e SciPy. Il linguaggio Python con funzionalità di base, ad esempio durante il ciclo strutture di controllo e un tipo di dati elenco generico, ma è interessante notare che, alcun tipo di matrice predefinite. La libreria NumPy aggiunge il supporto per le matrici e matrici, nonché alcune funzioni relativamente semplice, ad esempio matrice ricerca e ordinamento di matrice. La libreria SciPy aggiunge funzioni di livello intermedie e avanzate che funzionano con i dati archiviati in matrici e matrici.

Per eseguire un programma SciPy (tecnicamente uno script perché Python viene interpretato anziché compilato), l'installazione di Python, quindi NumPy e SciPy. Installazione non è troppo difficile, ed è possibile installare un pacchetto software che include tutti e tre i componenti. Un bundle comune è la distribuzione di Anaconda, che viene mantenuta da Continuum Analytics in continuum.io. Tuttavia, vi mostrerò come installare i componenti singolarmente.

Python è supportata in quasi tutte le versioni di Windows. Per installare Python, visitare python.org/downloads, in cui troverete la possibilità di installare una versione di Python 3. x o una versione 2. x (vedere Figura 2). Le due versioni non sono completamente compatibili, ma sono supportate sia le librerie di NumPy e SciPy. Si consiglia di installare la versione 2. x, poiché sono presenti alcune funzioni di terze parti che non sono ancora supportati nella versione 3. x.

Figura 2 installazione di Python

Quando si fa clic su un pulsante di download, si otterrà l'opzione per eseguire il programma di installazione MSI immediatamente o salvarla in modo che è possibile eseguire in un secondo momento. È possibile fare clic sul pulsante Esegui. Il programma di installazione utilizza una procedura guidata. Nella prima schermata viene chiesto se si desidera installare per tutti gli utenti o solo l'utente corrente. Il valore predefinito è per tutti gli utenti, fare clic sul pulsante Avanti.

Nella schermata successiva viene chiesto di specificare la directory di installazione radice. Il valore predefinito è C:\Python27 (invece di solito più directory C:\Program Files) e si consiglia utilizzare il percorso predefinito e fare clic su Avanti. Il seguente consente di schermata è includere o escludere varie funzionalità, ad esempio gli strumenti di documentazione e utilità come pip ("pip installa Python"). Le funzionalità di Python predefinite sono corrette, quindi fare clic sul pulsante Avanti.

Avviare l'installazione e verrà visualizzata una finestra con un indicatore blu familiare. Al termine dell'installazione, verrà visualizzata una finestra con il pulsante Fine. Fare clic sul pulsante.

Per impostazione predefinita, il processo di installazione di Python non modifica variabile di ambiente PATH del computer. È opportuno aggiungere C:\Python27 e C:\Python27\Scripts C:\Python27\Lib\idlelib la variabile PATH in modo che è possibile eseguire Python da una shell dei comandi e avviare l'editor di inattività senza dover passare ai percorsi di directory.

È necessario verificare che Python sia installato correttamente. Avviare una shell dei comandi e passare alla directory radice del sistema tramite l'immissione di un cd \ comando. A questo punto immettere python comando - versione (nota due trattini). Se Python risponde, è stato installato correttamente.

L'installazione di NumPy e SciPy

È possibile installare i pacchetti SciPy e NumPy dal codice sorgente tramite l'utilità di pip Python. L'approccio pip funziona bene con pacchetti di codice Python puro, ma NumPy e SciPy hanno hook nel codice compilato del linguaggio C, quindi installarli usando pip è piuttosto complicata.

Per fortuna, i membri della community di Python sono creati i programmi di installazione binario precompilati NumPy e SciPy. Si consiglia di utilizzare quelli vengono mantenuti nel repository SourceForge. Per installare NumPy, visitare bit.ly/1Q3mo4M, in cui verranno visualizzati i collegamenti alle varie versioni. Si consiglia di utilizzare la versione più recente che contiene la maggior parte delle attività di download.

Verrà visualizzato un elenco di collegamenti. Cercare un collegamento con un nome simile a numpy-1.10.2-win32-superpack-python2.7.exe, come illustrato nella Figura 3. Assicurarsi di avere il file eseguibile che corrisponde alla versione di Python e fare clic sul collegamento. Dopo un breve ritardo verrà visualizzata l'opzione per eseguire il programma di installazione eseguibile autoestraente immediatamente o salvarlo per installare in un secondo momento. Fare clic sul pulsante Esegui.

Figura 3 installazione NumPy

Il programma di installazione NumPy utilizza una procedura guidata. Nella prima schermata mostra solo una finestra iniziale introduttivo. Fare clic sul pulsante Avanti. Nella schermata successiva viene chiesto di specificare la directory di installazione. Il programma di installazione verrà trovati l'installazione di Python esistente e consiglia di installare NumPy nella directory C:\Python27\Lib\site-packages. Accettare il percorso e fare clic su Avanti.

Nella schermata successiva offre un'ultima possibilità di annullare l'installazione, ma non farlo. Fare clic sul pulsante Avanti. Verrà visualizzata una finestra di avanzamento durante l'installazione, se si osserva attentamente, si noterà alcuni interessanti i messaggi di registrazione. Al termine dell'installazione di NumPy, verrà visualizzato con il pulsante Fine. Fare clic su di esso. Verrà visualizzata una finestra del programma di installazione completato finale con un pulsante Chiudi. Fare clic su di esso.

Dopo aver installato NumPy, il passaggio successivo è per installare il pacchetto SciPy, che è identico a installare NumPy. Passare a bit.ly/1QbwJ0z e individuare una directory di recente, ben utilizzata. Passare alla directory e trovare un collegamento a un eseguibile con un nome simile scipy-0.16.1-win32-superpack-python2.7.exe e fare clic su di esso per avviare il programma di installazione eseguibile autoestraente.

Una caratteristica interessante dello stack SciPy è che è molto semplice disinstallare i componenti. È possibile utilizzare il pannello di controllo di Windows, programmi e funzionalità, selezionare il componente (vale a dire o NumPy, SciPy o Python,) per rimuovere e quindi fare clic sul pulsante Disinstalla e il componente verrà rapidamente e correttamente rimossi.

Modifica ed esecuzione di un programma SciPy

Se si scrivono programmi mediante un linguaggio .NET, quasi certamente utilizzare Visual Studio sono disponibili molte opzioni. Ma quando si scrive un programma Python sono disponibili molte opzioni. Si consiglia di utilizzare l'ambiente di editor e l'esecuzione inattiva.

Per impostazione predefinita nella directory C:\Python27\Lib\idelib si trova il file di avvio del programma idle.bat. Se questa directory è stato aggiunto alla variabile di ambiente PATH del sistema, è possibile avviare inattivo, aprire una shell dei comandi e digitando il comando inattivo. Verrà avviato il programma di inattività della Shell di Python come indicato nella parte superiore di Figura 4.

Figura 4 modifica ed esecuzione di un programma tramite inattivo

È possibile creare un nuovo file di codice sorgente Python facendo clic sul File | Nuovo elemento di File nella barra dei menu. Questa finestra di editor separata viene aperto un simili come illustrato nella parte inferiore della Figura 4. Digitare le sette istruzioni nella finestra dell'editor:

# test.py
import numpy as np
import scipy.misc as sm
arr = np.array([1.0, 3.0, 5.0])
print arr
n = sm.factorial(4)
print "4! = " + str(n)

Salvare quindi il programma come test.py in una directory qualunque. È ora possibile eseguire il programma facendo clic su esecuzione | Eseguire la voce di menu modulo nella finestra dell'editor o premendo il tasto di scelta rapida F5. Output del programma verrà visualizzato nella finestra della Shell di Python. Semplice!

Alcuni sviluppatori esperti di Python hanno potshots al tempo di inattività, in quanto è piuttosto semplice. Ma questo è esattamente perché mi piace. Non si ottengono qualsiasi ambiente di programmazione sofisticata di Visual Studio, ma si ottengono la colorazione della sintassi e un generatore di messaggio di errore valido quando si scrive codice errato.

Anziché utilizzare inattivo per modificare ed eseguire i programmi, è possibile utilizzare qualsiasi editor di testo, incluso il blocco note, per scrivere e salvare un programma Python. È quindi possibile eseguire il programma dalla riga di comando simile al seguente:

C:\IntroToPython> python test.py

Questo presuppone che il percorso dell'interprete python.exe nella variabile di ambiente PATH del sistema. Verrà visualizzato l'output nella shell dei comandi.

Esistono molti IDE Python. Un open source molto diffuso IDE che è concepito appositamente per l'utilizzo con SciPy è il programma di ambiente di sviluppo Python scientifica (Spyder). È possibile trovare informazioni su di esso in pythonhosted.org/spyder.

Un'alternativa interessante alla Spyder e inattivo è Apri origine Python Tools per Visual Studio (PTVS) plug-in. Come suggerisce il nome, PTVS consente di modificare ed eseguire i programmi di Python in Visual Studio. È possibile trovare informazioni su PTVS in microsoft.github.io/PTVS.

Un programma Demo SciPy

Esaminiamo il programma Python in Figura 5, o meglio ancora, digitare o scaricare il file che accompagna l'articolo in un editor di Python ed eseguire il programma. La demo non deve essere un set completo di esempi SciPy, ma è progettato per fornire risultati ottimali con le novità di programmazione SciPy.

Figura 5 rappresentante SciPy programma

# linear_systems.py
# Python 2.7
import numpy as np
import scipy.linalg as spla
def my_print(arr, cols, dec, nl):
  n = len(arr)
  fmt = "%." + str(dec) + "f" # like %.4f
  for i in xrange(n):  # alt: for x in arr
    if i > 0 and i % cols == 0:
      print ""
    print fmt % arr[i],
  if nl == True:
    print "\n"
def main():
  print "\nBegin linear system using SciPy demo \n"
  print "Goal is to solve the system: \n"
  print "3x0 + 4x1 - 8x2 = 9"
  print "2x0 - 5x1 + 6x2 = 7"
  print " x0 + 9x1 - 7x2 = 3"
  print ""
  A = np.matrix([[3.0, 4.0, -8.0],
                 [2.0, -5.0, 6.0],
                 [1.0, 9.0, -7.0]])
  b = np.array([9.0, 7.0, 3.0])      # b is an array
  b = np.reshape(b, (3,1))           # b is a col vector
  print "Matrix A is "
  print A
  print ""
  print "Array b is "
  my_print(b, b.size, 2, True)
  d = spla.det(A)
  if d == 0.0:
    print "Determinant of A is zero so no solution "
  else:
    Ai = spla.inv(A)
    print "Determinant of A is non-zero "
    print "Inverse of A is "
    print Ai
    print ""
  Aib = np.dot(Ai, b)
  print "A inverse times b is "
  print Aib
  print ""
  x = spla.solve(A, b)
  print "Using x = linalg.solve(A,b) gives x = "
  print x
  print ""
  try:
    A = np.array([[2.0, 4.0], [3.0, 6.0]])
    print "Matrix A is "
    print A
    print ""
    print "Inverse of A is "
    Ai = spla.inv(A)
    print Ai
  except Exception, e:
    print "Fatal error: " + str(e)
  print "\nEnd SciPy demo \n"
if __name__ == "__main__":
  main()

Il programma demo inizia con due righe di commento:

# linear_systems.py
# Python 2.7

Poiché le versioni 2. x e 3. x di Python non sono completamente compatibili, non è una buona idea di essere espliciti sul quale versione di Python è stato utilizzato. Successivamente, la demo carica l'intero modulo di NumPy e un modulo secondario SciPy:

import numpy as np
import scipy.linalg as spla

È possibile considerare queste istruzioni come più o meno come aggiungere un riferimento da una DLL di Microsoft .NET Framework a un programma c# e quindi riportare l'assembly nell'ambito con un'istruzione. Il modulo secondario linalg è l'acronimo di algebra lineare. SciPy è organizzato in 16 moduli secondari primari e due moduli secondari utilità. Successivamente, la demo implementa una funzione definita dall'applicazione per visualizzare una matrice:

def my_print(arr, cols, dec, nl):
  n = len(arr)
  fmt = "%." + str(dec) + "f" # like %.4f
  for i in xrange(n):  # alt: for x in arr
    if i > 0 and i % cols == 0:
      print ""
    print fmt % arr[i],
  if nl == True:
    print "\n"

Python utilizza rientro anziché i caratteri parentesi graffa per delimitare i blocchi di codice. In questo caso, usare due spazi per il rientro per risparmiare spazio; la maggior parte dei programmatori Python utilizzare quattro spazi per il rientro.

Funzione my_print ha quattro parametri: una matrice per visualizzare, il numero di colonne da visualizzare i valori, il numero di cifre decimali per ogni valore e un flag che indica se stampare una nuova riga. La funzione len restituisce le dimensioni (numero di celle) della matrice. In alternativa è possibile utilizzare la proprietà di dimensione di matrice:

n = arr.size

La funzione xrange restituisce un iteratore e la modalità standard per attraversare una matrice. Un'alternativa consiste nell'utilizzare un modello "per x in arr", che è simile all'istruzione foreach in c#.

Perché Python e c# è radici nel linguaggio C, gran parte della sintassi di Python è familiare ai programmatori di c#. Nella demo, % è il modulo (operatore), ma viene anche utilizzato per la formattazione di output valore a virgola mobile; e viene utilizzato come un operatore logico anziché & &; = = è un controllo per verificare l'uguaglianza; e True e False (in maiuscolo) sono costanti booleane.

Successivamente, la demo crea una funzione definita dall'applicazione denominata main, che inizia con alcune istruzioni print che descrivono il problema da risolvere:

def main():
  print "\nBegin linear system using SciPy demo \n"
  print "Goal is to solve the system: \n"
  print "3x0 + 4x1 - 8x2 = 9"
  print "2x0 - 5x1 + 6x2 = 7"
  print " x0 + 9x1 - 7x2 = 3"

L'obiettivo è individuare i valori per le variabili x0, x1 e x2 in modo che tutte e tre le equazioni sono soddisfatti. Il nome principale non è una parola chiave Python, pertanto potrebbe essere chiamata alcuna operazione. Non è necessario disporre di una funzione principale di qualche tipo. Per i programmi brevi (in genere inferiore a una pagina di codice), in genere essere distribuiti con una funzione principale e iniziare con le istruzioni eseguibili.

Successivamente, il programma demo imposta il problema inserendo i valori dei coefficienti in una matrice NumPy 3x3 denominata una e le costanti in una matrice NumPy denominata b:

A = np.matrix([[3.0, 4.0, -8.0],
               [2.0, -5.0, 6.0],
               [1.0, 9.0, -7.0]])
b = np.array([9.0, 7.0, 3.0])

In questo caso le funzioni matrice e la matrice accettano effettivamente gli elenchi di Python (indicati da parentesi quadre) con valori hardcoded come argomenti. È inoltre possibile creare matrici e matrici utilizzando il NumPy gli zeri (funzione) e per leggere dati da un file di testo in una matrice o una matrice utilizzando la funzione loadtxt.

Se è stata eseguita una classe algebra, si ricorderà che per risolvere un sistema di equazioni Ax = b per x, in cui è una matrice quadrata dei coefficienti e b è una matrice di colonna (vale a dire n righe ma solo di 1 colonna) delle costanti, è necessario trovare l'inversa di un e quindi l'operazione inversa moltiplicare matrix volte colonna matrice b.

A questo punto nella demo, b è una matrice con tre celle anziché una matrice di colonna 3 x 1. Per convertire b in una matrice di colonna, il programma demo utilizza la funzione di modifica della forma:

b = np.reshape(b, (3,1))

La libreria NumPy include numerose funzioni che consente di modificare le matrici e matrici. Ad esempio, la funzione Appiattisci convertirà una matrice a una matrice. A questo punto, in realtà, la funzione di moltiplicazione di matrice SciPy è arriva a dedurre previsto se moltiplicare matrix e una matrice in modo la chiamata per modificare la forma non è necessaria qui.

Successivamente, il programma demo vengono visualizzati i valori nelle matrici A e b:

print "Matrix A is "
print A
print ""
print "Array b is "
my_print(b, b.size, 2, True)

In Python 2. x, stampa è un'istruzione, anziché una funzione, come se fosse in Python 3. x, in modo parentesi sono facoltative. La funzione definita dall'applicazione my_print non restituita un valore, pertanto è equivalente a una funzione void in c# e viene chiamato come previsto. Python supporta chiamate parametro denominato in modo da avere potuto la chiamata:

my_print(arr=b, cols=3, dec=2, nl=True)

Successivamente, il programma demo rileva l'inverso della matrice r:

d = spla.det(A)
if d == 0.0:
  print "Determinant of A is zero so no solution "
else:
  Ai = spla.inv(A)
  print "Determinant of A is non-zero "
  print "Inverse of A is "
  print Ai

La funzione det SciPy restituisce il determinante della matrice quadrato. Se una matrice dei coefficienti di un sistema di equazione lineare di determinante è pari a zero, la matrice non possono essere invertita. L'istruzione if-else Python dovrebbe essere familiare. Python è una parola chiave i cosiddetti "elif" per le strutture di controllo if-else-if, ad esempio:

if n < 0:
  print "n is negative"
elif n == 0:
  print "n equals zero"
else:
  print "n is positive"

Successivamente, la demo risolve il sistema di equazioni tramite moltiplicazione di matrici mediante la funzione di punto NumPy:

Aib = np.dot(Ai, b)
print "A inverse times b is "
print Aib

La funzione di punto nome perché la moltiplicazione è una forma di ciò che viene definito il prodotto scalare.

Successivamente, il programma demo risolve direttamente il sistema di equazioni, utilizzando il NumPy risolvere funzione:

x = spla.solve(A, b)
print "Using x = linalg.solve(A,b) gives x = "
print x

Molte funzioni di SciPy e NumPy hanno parametri facoltativi con i valori predefiniti, ovvero qualche aspetto equivalente all'overload di metodo c#. Funzione di risolvere il SciPy include cinque parametri facoltativi. Il punto è che se una funzione di esempio SciPy o NumPy chiama, anche se si ritiene di che aver compreso l'esempio, è consigliabile consultare la documentazione per verificare se esistono eventuali parametri facoltativi utili.

Non esiste alcune sovrapposizioni tra le librerie di NumPy e SciPy. Ad esempio, il pacchetto NumPy ha inoltre sottomodulo linalg che dispone di una funzione di valutazione. Il NumPy risolve tuttavia funzione non dispone di alcun parametro facoltativo.

Successivamente, il programma demo illustrato un esempio di try Python-except meccanismo:

try:
  A = np.array([[2.0, 4.0], [3.0, 6.0]])
  Ai = spla.inv(A)
  print Ai
except Exception, e:
  print "Fatal error: " + str(e)

Questo modello dovrebbe essere familiare se si utilizza le istruzioni try-catch in c#. In c#, quando si concatenano le stringhe, è possibile farlo in modo implicito. In c#, ad esempio, è possibile scrivere:

int n = 99;
Console.WriteLine("The value of n is " + n);

Ma quando si concatenano le stringhe in Python, è necessario eseguire in modo esplicito con un cast utilizzando la funzione str:

n = 99
print "The value of n is " + str(n)

Il programma demo è terminata con un'istruzione di stampa e un incantation Python speciali:

print "\nEnd SciPy demo \n"
if __name__ == "__main__":
  main()

L'ultima istruzione del programma demo avrebbe potuto comportare semplicemente Main (), che verrebbe interpretato come un'istruzione di chiamare la funzione definita dall'applicazione principale, e il programma verrà eseguito correttamente. Aggiunta di se __name__ = = "__main__" modello (si noti che esistono due caratteri di sottolineatura prima e dopo il nome e il principale) determina il punto di ingresso del programma che il modulo corrente. Quando un programma Python inizia l'esecuzione, l'interprete etichette internamente il modulo iniziale come:

"__main__"

Pertanto, si supponga che si dispone di alcuni altri moduli definito dal programma con le istruzioni eseguibili e sono stati importati. Senza il controllo se l'interprete Python sarebbe vedere istruzioni eseguibili nei moduli importati ed eseguirle. Inserire in modo leggermente diverso, se il controllo se si aggiunge ai file Python definito dal programma, questi file possono essere importati da altri programmi di Python e non causino problemi.

Quindi, qual è il punto?

La reazione iniziale di questo articolo può anche riguardare, ad esempio, "Beh, questo è tutto piuttosto interessante, ma nella mia attività quotidiane effettivamente non è necessario risolvere sistemi di equazioni lineare o utilizzare le funzioni matematiche incomprensibili." Risponderei, ", che è true, ma forse uno dei motivi non utilizzare alcune delle funzionalità della libreria SciPy è che non si è conoscenza di quali tipi di problemi risolvibili."

In altre parole, a mio parere, gli sviluppatori tendono ad affrontare i problemi per le quali sono gli strumenti. Ad esempio, se si conosce Windows Communication Foundation (WCF), si sarà utilizzare WCF (e non è my Condoglianze). Se si aggiungono SciPy all'insieme di competenze personali, si potrebbe individuare che si dispone di dati che è possibile trasformare in informazioni utili.

Ripristino di emergenza. James McCaffreylavora per Microsoft Research a Redmond, Washington. Ha lavorato su numerosi prodotti Microsoft, inclusi Internet Explorer e Bing. Dr. È possibile contattarlo McCaffrey jammc@microsoft.com.

Grazie ai seguenti esperti tecnici Microsoft per la revisione di questo articolo: Dan Liebling e Olynyk Kirk