Google ha reso open source una libreria Python che crea oggetti DataTable per il consumo da parte delle visualizzazioni. Questa libreria può essere utilizzata per creare
una classe DataTable in Python e generarla in uno di questi tre formati:
- Stringa JSON: se ospiti la pagina che ospita la visualizzazione che utilizza i tuoi dati, puoi generare una stringa JSON da passare in un costruttore
DataTableper completarla. - Risposta JSON: se non ospiti la pagina che ospita la visualizzazione e vuoi agire da origine dati per le visualizzazioni esterne, puoi creare una stringa di risposta JSON completa che può essere restituita in risposta a una richiesta di dati.
- Stringa JavaScript: puoi generare una tabella di dati come stringa composta da diverse righe di codice JavaScript che creano e popolano un oggetto
google.visualization.DataTablecon i dati della tabella Python. Puoi quindi eseguire questo JavaScript in un motore per generare e completare l'oggettogoogle.visualization.DataTable. In genere viene utilizzata solo per il debug.
Questo documento presuppone che tu abbia una conoscenza di base della programmazione di Python e che tu abbia letto la documentazione di visualizzazione introduttiva per creare una visualizzazione e utilizzare una visualizzazione.
Contenuti
Come utilizzare la Raccolta
Di seguito sono riportati i passaggi di base in maggiore dettaglio:
1. Crea un oggetto gviz_api.DataTable
Importa la libreria gviz_api.py dal link precedente e crea un'istanza della classe gviz_api.DataTable. La classe accetta due parametri: uno schema di tabella, che descrive il formato dei dati nella tabella, e dati facoltativi per completare la tabella. Puoi aggiungere dati in un secondo momento, se preferisci, o sovrascrivere completamente i dati, ma non rimuovere singole righe oppure cancellare lo schema della tabella.
2. Descrivi lo schema della tabella
Lo schema della tabella è specificato dal parametro table_description passato nel costruttore. Non potrai modificarlo in un secondo momento. Lo schema descrive tutte le colonne nella tabella: il tipo di dati di ogni colonna, l'ID ed un'etichetta facoltativa.
Ogni colonna è descritta da una tupla: (ID [,data_type [,label[,custom_properties]]]).
- ID: un ID stringa utilizzato per identificare la colonna. Può includere spazi. L'ID di ogni colonna deve essere univoco.
- data_type: [facoltativo] un descrittore di stringa del tipo di dati Python dei dati in quella colonna. Puoi trovare un elenco dei tipi di dati supportati nel metodo SingleValueToJS(). Alcuni esempi sono "string" e "boolean". Se non specificato, il valore predefinito è "string".
- label: un nome facile da usare per la colonna, che potrebbe essere visualizzato come parte della visualizzazione. Se non specificato, viene utilizzato il valore ID.
- custom_properties: un dizionario {String:String} di proprietà di colonna personalizzata.
Lo schema della tabella è una raccolta di tuple descrittore della colonna. Ogni membro dell'elenco, chiave del dizionario o valore del dizionario deve essere un'altra raccolta o una tupla descrittiva. Puoi utilizzare qualsiasi combinazione di dizionari o elenchi, ma ogni chiave, valore o membro deve effettuare la valutazione con una tupla del descrittore. Ecco alcuni esempi.
- Elenco delle colonne: [('a', 'number'), ('b', 'string')]
- Dizionario degli elenchi: {('a', 'number'): [('b', 'number'), ('c', 'string')]}
- Dizionario dei dizionari: {('a', 'number'): {'b': 'number', 'c': 'string'}}
- E così via, con qualsiasi livello di nidificazione.
3. Completa i tuoi dati
Per aggiungere dati alla tabella, crea una struttura degli elementi dati nella stessa struttura dello schema della tabella. Ad esempio, se lo schema è un elenco, i dati devono essere un elenco:
- schema: [("colore", "stringa"), ("forma", "stringa")]
- data: [["blue", "square"], ["red", "Circle"]]
Se lo schema è un dizionario, i dati devono essere un dizionario:
- schema: {("nomeriga", "stringa"): [("colore", "stringa"; ("forma", "stringa")] }
- data: {"row1": ["blu", "quadrato"], "riga2": ["rosso", "cerchio"]}
Una riga della tabella è una sezione di dati e schema corrispondenti. Ad esempio, ecco come viene applicato uno schema di un elenco di due colonne a due righe di dati.
Schema:[(color),(shape)]
/ \
Data: [["blue", "square"], ["red", "circle"]]
Table:
Color Shape
blue square
red circle
Tieni presente che le chiavi del dizionario qui valutano i dati delle colonne. Puoi trovare esempi più complessi nella documentazione del metodo AppendData() nel codice. L'obiettivo di consentire una nidificazione così complessa è consentirti di utilizzare una struttura di dati Python adeguata alle tue esigenze.
4. Output dei dati
Il formato di output più comune è JSON, quindi probabilmente utilizzerai la funzione ToJsonResponse()
per creare i dati da restituire. Se, però, stai analizzando la richiesta di input e supportando formati di output diversi, puoi chiamare uno qualsiasi degli altri metodi di output per restituire altri formati, inclusi valori separati da virgole, valori separati da tabulazioni e JavaScript. JavaScript viene generalmente utilizzato solo per il debug. Consulta la pagina relativa all'implementazione di un'origine dati per scoprire come elaborare una richiesta per ottenere il formato di risposta preferito.
Esempio di utilizzo
Ecco alcuni esempi che mostrano come utilizzare i vari formati di output.
Esempio di ToJSon e ToJS
#!/usr/bin/python
import gviz_api
page_template = """
<html>
<script src="https://www.gstatic.com/charts/loader.js"></script>
<script>
google.charts.load('current', {packages:['table']});
google.charts.setOnLoadCallback(drawTable);
function drawTable() {
%(jscode)s
var jscode_table = new google.visualization.Table(document.getElementById('table_div_jscode'));
jscode_table.draw(jscode_data, {showRowNumber: true});
var json_table = new google.visualization.Table(document.getElementById('table_div_json'));
var json_data = new google.visualization.DataTable(%(json)s, 0.6);
json_table.draw(json_data, {showRowNumber: true});
}
</script>
<body>
<H1>Table created using ToJSCode</H1>
<div id="table_div_jscode"></div>
<H1>Table created using ToJSon</H1>
<div id="table_div_json"></div>
</body>
</html>
"""
def main():
# Creating the data
description = {"name": ("string", "Name"),
"salary": ("number", "Salary"),
"full_time": ("boolean", "Full Time Employee")}
data = [{"name": "Mike", "salary": (10000, "$10,000"), "full_time": True},
{"name": "Jim", "salary": (800, "$800"), "full_time": False},
{"name": "Alice", "salary": (12500, "$12,500"), "full_time": True},
{"name": "Bob", "salary": (7000, "$7,000"), "full_time": True}]
# Loading it into gviz_api.DataTable
data_table = gviz_api.DataTable(description)
data_table.LoadData(data)
# Create a JavaScript code string.
jscode = data_table.ToJSCode("jscode_data",
columns_order=("name", "salary", "full_time"),
order_by="salary")
# Create a JSON string.
json = data_table.ToJSon(columns_order=("name", "salary", "full_time"),
order_by="salary")
# Put the JS code and JSON string into the template.
print "Content-type: text/html"
print
print page_template % vars()
if __name__ == '__main__':
main()
Esempio ToJSonResponse
JSonResponse viene utilizzato da un client remoto in una richiesta di dati.
#!/usr/bin/python
import gviz_api
description = {"name": ("string", "Name"),
"salary": ("number", "Salary"),
"full_time": ("boolean", "Full Time Employee")}
data = [{"name": "Mike", "salary": (10000, "$10,000"), "full_time": True},
{"name": "Jim", "salary": (800, "$800"), "full_time": False},
{"name": "Alice", "salary": (12500, "$12,500"), "full_time": True},
{"name": "Bob", "salary": (7000, "$7,000"), "full_time": True}]
data_table = gviz_api.DataTable(description)
data_table.LoadData(data)
print "Content-type: text/plain"
print
print data_table.ToJSonResponse(columns_order=("name", "salary", "full_time"),
order_by="salary")