Immagina di avere un grande insieme di dati con milioni di righe e ti trovi di fronte al compito di estrarre informazioni dai dati. Come hai senso di un grande insieme di dati? La semplice risposta a questa domanda è che lo facciamo tramite la visualizzazione dei dati, ma che cos'è esattamente?

La visualizzazione dei dati è la rappresentazione grafica dei dati per capire cosa si nasconde all'interno delle informazioni. In questa serie in tre parti, creeremo un'app di visualizzazione per estrarre informazioni e dare un senso a un ampio insieme di dati.

La ricerca di blocchi di dati di grandi dimensioni senza l'hardware corretto può causare problemi di prestazioni. Google fornisce una soluzione a questo problema sotto forma di BigQuery. Supportato dall'infrastruttura di Google, consente di eseguire query su blocchi di dati di grandi dimensioni. Utilizzeremo un set di dati da Google BigQuery per la nostra applicazione di visualizzazione.

In questa esercitazione ti illustrerò il processo di creazione di un'applicazione di visualizzazione utilizzando Python, Google BigQuery e la libreria JavaScript D3.js. Utilizzeremo Google App Engine (o GAE) per ospitare la nostra applicazione. Questo tutorial presume che tu abbia una conoscenza di base di Python e JavaScript. Per la creazione di grafici, utilizzeremo D3.js.

Nota anche che il codice dell'esercitazione precedente è disponibile su GitHub e una demo è ospitata su AppSpot.

Guida introduttiva con Google App Engine 

Passaggio 1: download e utilizzo di GAE Python SDK 

Iniziamo impostando il nostro ambiente di sviluppo. Scarica l'SDK Python per Google App Engine ed estrailo. Useremo il framework webapp2 per Python. 

Dalla documentazione di Google:

Un'applicazione webapp2 ha due parti: 

1) una o più classi RequestHandler che elaborano richieste e costruiscono risposte 

2) un'istanza di applicazione WSGIA che indirizza le richieste in entrata ai gestori in base all'URL.

I suddetti punti diventeranno più chiari quando creiamo la nostra classe di gestore richieste. Crea una directory chiamata PythonD3jsMashup quale sarà la nostra directory di progetto. Passare alla directory del progetto e creare un file chiamato app.py. Questo sarà il nostro modulo di applicazione. Creiamo una classe del gestore richieste per elaborare la richiesta e generare una risposta e un'istanza di applicazione WSGIA per instradare le richieste. 

 Ecco come app.py dovrebbe guardare:

import webapp2 class ShowHome (webapp2.RequestHandler): def get (self): ## Codice per il rendering della home page ## Ecco l'istanza dell'applicazione WSGI che instrada le richieste application = webapp2.WSGIApplication ([('/', ShowHome),] , debug = True)

Quando un / richiesta si verifica, è instradata al Showhome classe che rende la home page. Scriviamo il codice Python per visualizzare la nostra homepage. Per prima cosa, crea una nuova cartella chiamata Modelli nel PythonD3jsMashup cartella. Al suo interno, creare una pagina HTML chiamata index.html. 

Dovrebbe contenere il seguente codice:

         
 
 
App Visualizzazione dati
 
 
Casa 
 
Codice sorgente 
 
Di 
 
 
  
 
App Visualizzazione dati
 
App Python e D3.js Mashup
 
Clicca qui 
 
  
 
© Azienda 2014
 
 
   

Per eseguire il rendering dei modelli, è necessario importare la libreria dei modelli. Dopo averlo fatto, lo useremo per rendere il index.html pagina come mostrato di seguito:

import webapp2 da google.appengine.ext.webapp classe template di importazione ShowHome (webapp2.RequestHandler): def get (self): temp_data =  temp_path = 'Modelli / index.html' self.response.out.write (template.render (temp_path, temp_data)) application = webapp2.WSGIApplication ([('/', ShowHome),], debug = True)

Quindi, vai alla directory del progetto PythonD3jsMashup e creare un file chiamato app.yaml. Questo file fungerà da file di configurazione per la nostra applicazione. Dovrebbe sembrare come questo:

applicazione: versione appid: 1 runtime: python27 api_version: 1 threadsafe: veri gestori: - url: /.* script: app.application

Come puoi vedere, abbiamo definito una serie di cose nel app.yaml. La maggior parte dei parametri è auto-esplicativa. Il gestori direttiva impone che ogni richiesta di URL che corrisponde /.* essere gestito dall'oggetto dell'applicazione nel App modulo.

Per eseguire l'applicazione localmente, accedere a GAE SDK ed esegui il seguente comando:

./dev_appserver.py 

Indirizza il tuo browser a http: // localhost: 8080 e dovresti vedere questa pagina:

Distribuzione di un'app su AppSpot 

Successivamente, implementeremo la nostra app sul Google App Engine. Per distribuire l'app, accedi prima alla console GAE:

Dal cruscotto clicca sul Crea applicazione pulsante.

Successivamente, vedrai una schermata simile a quella mostrata sotto. Digitare un Identificatore dell'applicazione e Titolo dell'applicazione per l'app e fare clic Crea applicazione.

Una volta che l'applicazione è stata registrata correttamente, verrai accolto con un messaggio di successo:

Prendi nota del testo cerchiato rosso che verrà utilizzato come identificativo dell'applicazione più tardi.

Clicca sul cruscotto collegamento. Dal menu a sinistra in Dashboard, sotto il Amministrazione scheda, fare clic su Impostazioni dell'applicazione. Vedrai la seguente schermata:

Prendi nota di Nome account di servizio. Ne avremo bisogno nella console degli sviluppatori di Google.

Quindi, modificare il applicazione nome a pythond3jsmashup nel app.yaml.

applicazione: pythond3jsmashup versione: 1 runtime: python27 api_version: 1 threadsafe: veri gestori: - url: /.* script: app.application

Ora per distribuire l'app su GAE, accedere a GAE Python SDK e digitare il seguente comando:

./appcfg.py update PythonD3jsMashup /

Una volta implementato, prova a sfogliare l'URL di AppSpot.

Introduzione a Google BigQuery

Per iniziare con Google BigQuery, accedi alla console dell'API di Google. Dovresti vedere una dashboard che elenca tutti i progetti disponibili nel tuo account Google. Clicca sul nome del progetto PythonD3jsMashup.

Prendi nota di Progetto numero, che utilizzeremo durante la connessione con Google BigQuery.

Dal menu di sinistra, fare clic su API e autenticazione scheda. Dagli elementi elencati fai clic su API. Ora dovresti vedere un elenco di API disponibili:

API BigQuery è spento. Clicca sul OFF stato per girarlo SOPRA.

Clicca sul nome del progetto pythond3jsmashup sul lato sinistro del menu e fare clic permessi. Clic Aggiungi membro e aggiungi il Nome account di servizio (che abbiamo annotato in precedenza) con le autorizzazioni "Can edit" come mostrato di seguito:

Raccolta di dati da Google BigQuery

Fino ad ora, abbiamo creato la nostra semplice app e l'abbiamo implementata su GAE con l'API di BigQuery abilitata. Successivamente, ci collegheremo a uno dei set di dati liberamente disponibili su BigQuery. 

Iniziamo creando una nuova pagina chiamata  Modelli / chart.html dove mostreremo la visualizzazione. Creare un metodo per instradare il Clicca qui link sulla nostra home page a chart.html. 

Ecco come appare:

class ShowChartPage (webapp2.RequestHandler): def get (self): temp_data =  temp_path = 'Modelli / chart.html' self.response.out.write (template.render (temp_path, temp_data))

Modificare anche il gestore richieste per instradare la richiesta /grafico a ShowChartPage come mostrato di seguito:

application = webapp2.WSGIApplication ([('/ chart', ShowChartPage), ('/', ShowHome),], debug = True)

Quindi, modificare il href attributo del Clicca qui collegamento come mostrato:

Clicca qui

Ora prova a eseguire l'app e fai clic Clicca qui, e dovresti essere reindirizzato a chart.html.

Successivamente, proveremo ad autenticare la nostra app con Google BigQuery e a recuperare alcuni dati. Per l'autenticazione, avremo bisogno del client Python API di Google. Scaricare google-api-python-client-gae-1.2.zip ed estrailo nella cartella del progetto.

Includere le seguenti librerie in app.py.

importare httplib2 da apiclient.discovery import build da oauth2client.appengine import AppAssertionCredentials

Per prima cosa, per interrogare un set di dati da BigQuery dobbiamo creare un servizio BigQuery come mostrato: 

url = 'https://www.googleapis.com/auth/bigquery' credenziali = AppAssertionCredentials (scope = url) httpss = credentials.authorize (httplib2.Http ()) bigquery_service = build ('bigquery', 'v2', http = httpss)

In secondo luogo, dobbiamo creare una query che eseguiremo contro il set di dati BigQuery. Useremo il set di dati di Shakespeare. Ecco la query che eseguiremo contro il set di dati:

queryData = 'query': 'SELECT word FROM [publicdata: samples.shakespeare] LIMIT 1000'

Per interrogare i dati creeremo un lavoro dal bigquery_service:

tableData = bigquery_service.jobs ()

E quindi eseguire una query dal lavoro creato:

response = tableData.query (projectId = PROJECT_NUMBER, body = queryData) .execute ()

Sostituire PROGETTO NUMERO con il numero del progetto che avevamo annotato prima. Quindi, ecco la modifica app.py:

importare httplib2 import webapp2 da google.appengine.ext.webapp import template da apiclient.discovery import build da oauth2client.appengine import AppAssertionCredentials url = 'https://www.googleapis.com/auth/bigquery' PROJECT_NUMBER = 'xxxxxxxxxxxxx' credenziali = AppAssertionCredentials (scope = url) httpss = credentials.authorize (httplib2.Http ()) bigquery_service = build ('bigquery', 'v2', http = httpss) classe ShowChartPage (webapp2.RequestHandler): def get (self): temp_data =  temp_path = 'Templates / chart.html' queryData = 'query': 'SELECT parola FROM [publicdata: samples.shakespeare] LIMIT 1000' tableData = bigquery_service.jobs () response = tableData.query (projectId = PROJECT_NUMBER, body = queryData) .execute () self.response.out.write (response) # self.response.out.write (template.render (temp_path, temp_data)) classe ShowHome (webapp2.RequestHandler): def get (self): template_data =  template_path = 'Templates / index.html' self.response.out.write (template.render (template_path, template_data)) a pplication = webapp2.WSGIApplication ([('/ chart', ShowChartPage), ('/', ShowHome),], debug = True)

La risposta dalla query verrebbe stampata chart.html. Salva tutto il codice e carica il codice modificato su GAE usando appcfg.py update PythonD3jsMashup /.

Ora se punti il ​​tuo browser su http://pythond3jsmashup.appspot.com/chart vedrai la risposta json restituita dall'interrogazione del set di dati.

Conclusione

In questo tutorial, abbiamo creato un'applicazione Python e l'abbiamo distribuita su Google App Engine. Abbiamo collegato la nostra applicazione con Google BigQuery e recuperato i dati dal set di dati liberamente disponibile. 

Successivamente, cercheremo di analizzare i dati recuperati da Google BigQuery e visualizzarli utilizzando la libreria JavaScript D3.js. Nel frattempo, non esitare a lasciare qualsiasi domanda o commento nel feed qui sotto.