Share
Tenk deg at du har et stort sett med data med millioner av rader, og du står overfor oppgaven med å utvinne informasjon fra dataene. Hvordan gir du mening om et stort sett med data? Det enkle svaret på dette spørsmålet er at vi gjør det via datavisualisering, men hva er det, nøyaktig?
Datavisualisering er den grafiske representasjonen av data for å finne ut hva som er skjult inne i informasjonen. I denne tredelte serien lager vi en visualiseringsapp for å hente informasjon og gi mening om et stort sett med data.
Å spørre store biter av data uten riktig maskinvare kan resultere i ytelsesproblemer. Google gir en løsning på dette problemet i form av BigQuery. Sikkerhetskopiert av Googles infrastruktur, gjør det mulig å spørre store biter av data. Vi bruker et datasett fra Google BigQuery for vårt visualiseringsprogram.
I denne opplæringen tar jeg deg gjennom prosessen med å lage et visualiseringsprogram ved hjelp av Python, Google BigQuery og D3.js JavaScript-biblioteket. Vi bruker Google App Engine (eller GAE) for å være vert for programmet vårt. Denne opplæringen antar at du har grunnleggende kunnskap om Python og JavaScript. For å lage grafer bruker vi D3.js.
Legg også merke til at koden fra ovenstående veiledning er tilgjengelig på GitHub, og en demo er vert på AppSpot.
La oss starte med å sette opp utviklingsmiljøet vårt. Last ned Google App Engine Python SDK og pakk den ut. Vi bruker webapp2-rammen for Python.
Fra Googles dokumentasjon:
Et webapp2-program har to deler:
1) en eller flere RequestHandler-klasser som behandler forespørsler og bygger svar
2) en WSGIApplication-forekomst som ringer innkommende forespørsler til behandlere basert på nettadressen.
De nevnte punktene blir tydeligere når vi lager vår forespørselhandlerklasse. Opprett en katalog som heter PythonD3jsMashup som vil bli vår prosjektkatalog. Naviger til prosjektkatalogen og opprett en fil som heter app.py. Dette blir vår applikasjonsmodul. La oss lage en forespørselhandlerklasse for å behandle forespørselen og bygge et svar, og en WSGIApplication-instans for å rute forespørsler.
Her er hvordan app.py bør se:
Accentsconagua
importer webapp2 klasse ShowHome (webapp2.RequestHandler): def get (selv): ## Kode for å gjengi hjemmesiden ## Her er WSGI-applikasjonseksemplet som ruter forespørsler application = webapp2.WSGIApplication ([('/', ShowHome) , debug = True)Når en / forespørsel oppstår, blir den sendt til showhome klasse som gjør hjemmesiden. La oss skrive Python-koden for å vise vår hjemmeside. Først oppretter du en ny mappe som heter maler i PythonD3jsMashup mappe. Inne i det, opprett en HTML-side som heter index.html.
Den skal inneholde følgende kode:
Datavisualisering App
- Hjem
- Kildekode
- Handle om
Datavisualisering App
Python & D3.js Mashup app
Klikk her
© Firma 2014
For å kunne lage maler må vi importere malbiblioteket. Etter å ha gjort det, bruker vi det til å gjengi index.html side som vist nedenfor:
importer webapp2 fra google.appengine.ext.webapp importmal klasse VisHome (webapp2.RequestHandler): def get (selv): temp_data = temp_path = 'Maler / index.html' self.response.out.write (template.render (temp_path, temp_data)) application = webapp2.WSGIApplication ([('/', ShowHome),] debug = True)Deretter navigerer du til prosjektkatalogen PythonD3jsMashup og lag en fil som heter app.yaml. Denne filen vil fungere som en konfigurasjonsfil for vår søknad. Det skal se slik ut:
søknad: appid versjon: 1 runtime: python27 api_version: 1 threadsafe: true handlers: - url: /.* script: app.application
Som du kan se, har vi definert en rekke ting i app.yaml. De fleste parametrene er selvforklarende. De handlers Direktivet dikterer at hver URL-forespørsel som samsvarer /.* håndteres av applikasjonsobjektet i app modul.
For å kjøre programmet lokalt, naviger til GAE SDK og kjør følgende kommando:
./dev_appserver.py
Pek nettleseren din til http: // localhost: 8080 og du bør se denne siden:
Deretter distribuerer vi vår app på Google App Engine. For å distribuere appen må du først logge deg på GAE-konsollen:
Fra dashbordet klikker du på Lag applikasjon knapp.
Deretter ser du en skjerm som ligner på den som vises nedenfor. Skriv en Applikasjonsidentifikator og Søknadstittel for appen og klikk Lag applikasjon.
Når søknaden er registrert, vil du bli møtt med en vellykket melding:
Legg merke til den røde sirklede teksten som vil bli brukt som applikasjonsidentifikator senere.
Klikk på dashbord link. Fra venstremenyen i Dashboard, under Administrasjon fanen, klikk på Applikasjon innstillinger. Du ser følgende skjermbilde:
Legg merke til Tjenerkonto navn. Vi trenger dette i Google-utviklerkonsollen.
Deretter endrer du applikasjon navn til pythond3jsmashup i app.yaml.
søknad: pythond3jsmashup versjon: 1 runtime: python27 api_version: 1 threadsafe: true handlers: - url: /.* script: app.application
Nå for å distribuere appen til GAE, naviger til GAE Python SDK og skriv inn følgende kommando:
./appcfg.py oppdatere PythonD3jsMashup /
Når du er distribuert, kan du prøve å bla AppSpot-nettadressen.
For å komme i gang med Google BigQuery, logg deg inn på Google API-konsollen. Du bør se et dashbord som viser alle tilgjengelige prosjekter i Google-kontoen din. Klikk på prosjektnavnet PythonD3jsMashup.
Legg merke til Prosjektnummer, som vi skal bruke mens du kobler til med Google BigQuery.
Fra venstre side menyen, klikk på APIer og auth fane. Fra de oppførte produktene klikker du på APIer. Nå bør du se en liste over tilgjengelige APIer:
BigQuery API er slått av. Klikk på AV status for å slå den PÅ.
Klikk på prosjektnavnet pythond3jsmashup på menyen til venstre og klikk tillatelser. Klikk Legg til medlem og legg til Tjenerkonto navn (som vi nevnte tidligere) med "Kan redigere" tillatelser som vist nedenfor:
Inntil nå har vi opprettet vår enkle app og distribuert den på GAE med BigQuery API aktivert. Deretter kobler vi til et av de fritt tilgjengelige datasettene på BigQuery.
La oss begynne med å opprette en ny side som heter Maler / chart.html hvor vi skal vise visualiseringen. Lag en metode for å rute Klikk her lenke på vår hjemmeside til chart.html.
Slik ser det ut:
klasse ShowChartPage (webapp2.RequestHandler): def get (selv): temp_data = temp_path = 'Maler / chart.html' self.response.out.write (template.render (temp_path, temp_data))
Endre også forespørselsbehandleren for å rute forespørselen / kart til ShowChartPage som vist under:
søknad = webapp2.WSGIApplication ([('/ chart', ShowChartPage), ('/', ShowHome),] debug = True)Deretter endrer du href attributten til Klikk her lenke som vist:
Klikk her
Prøv nå å kjøre appen og klikke på Klikk her, og du bør omdirigeres til chart.html.
Deretter prøver vi å godkjenne vår app med Google BigQuery og hente noen data. For godkjenning krever vi Google API Python-klienten. nedlasting google-api-python-client-gae-1.2.zip og trekk den ut i prosjektmappen.
Inkluder følgende biblioteker i app.py.
importer httplib2 fra apiclient.discovery import bygge fra oauth2client.appengine import AppAssertionCredentials
Først, for å spørre et datasett fra BigQuery, må vi bygge en BigQuery-tjeneste som vist:
url = 'https://www.googleapis.com/auth/bigquery' credentials = AppAssertionCredentials (scope = url) httpss = credentials.authorize (httplib2.Http ()) bigquery_service = bygge ('bigquery', 'v2', http = httpss)For det andre må vi lage en spørring som vi skal utføre mot BigQuery datasettet. Vi bruker Shakespeare datasettet. Her er spørringen som vi vil utføre mot datasettet:
queryData = 'query': 'VELG ord fra [publiseringsdata: samples.shakespeare] LIMIT 1000'
For å spørre dataene oppretter vi en jobb fra bigquery_service:
tableData = bigquery_service.jobs ()
Og deretter spørre fra den opprettede jobben:
respons = tableData.query (projectId = PROJECT_NUMBER, body = queryData) .execute ()
Erstatte PROJECT_NUMBER med prosjektnummeret vi hadde nevnt tidligere. Så, her er den endrede app.py:
importer httplib2 importer webapp2 fra google.appengine.ext.webapp import mal fra apiclient.discovery import bygge fra oauth2client.appengine import AppAssertionCredentials url = 'https://www.googleapis.com/auth/bigquery' PROJECT_NUMBER = 'xxxxxxxxxxxxx' credentials = AppAssertionCredentials (scope = url) httpss = credentials.authorize (httplib2.Http ()) bigquery_service = bygge ('bigquery', 'v2', http = httpss) klasse ShowChartPage (webapp2.RequestHandler): def get (selv): temp_data = temp_path = 'Maler / chart.html' queryData = 'query': 'VELG ord FRA [publicdata: samples.shakespeare] LIMIT 1000' tableData = bigquery_service.jobs () respons = tableData.query (projectId = PROJECT_NUMBER, body = queryData) .execute () self.response.out.write (response) # self.response.out.write (template.render (temp_path, temp_data)) klasse ShowHome (webapp2.RequestHandler): def get template_data = template_path = 'Maler / index.html' self.response.out.write (template.render (template_path, template_data)) a pplication = webapp2.WSGIApplication ([('/ chart', ShowChartPage), ('/', ShowHome),] debug = True)Svaret fra spørringen vil bli skrevet ut på chart.html. Lagre all kode og last opp den endrede koden til GAE ved hjelp av appcfg.py oppdatering PythonD3jsMashup /.
Nå hvis du peker nettleseren din til http://pythond3jsmashup.appspot.com/chart vil du se svaret fra json returnert fra å spørre datasettet.
I denne opplæringen opprettet vi et Python-program og distribuerte det på Google App Engine. Vi koblet vår søknad med Google BigQuery og hentet data fra det fritt tilgjengelige datasettet.
Deretter prøver vi å analysere dataene hentet fra Google BigQuery og visualisere det ved hjelp av JavaScript-biblioteket D3.js. I mellomtiden, vennligst ikke nøl med å legge igjen noen spørsmål eller kommentarer i feedet under.
