Google propose une bibliothèque Python Open Source qui crée des objets DataTable qui peuvent être consommés par les visualisations. Cette bibliothèque peut être utilisée pour créer un DataTable en Python et le générer dans l'un des trois formats suivants:
- Chaîne JSON : si vous hébergez la page qui héberge la visualisation qui utilise vos données, vous pouvez générer une chaîne JSON à transmettre à un constructeur
DataTablepour la remplir. - Réponse JSON : si vous n'hébergez pas la page qui héberge la visualisation et que vous souhaitez simplement servir de source de données pour les visualisations externes, vous pouvez créer une chaîne de réponse JSON complète pouvant être renvoyée en réponse à une requête de données.
- Chaîne JavaScript : vous pouvez afficher la table de données sous forme de chaîne composée de plusieurs lignes de code JavaScript qui créeront et renseigneront un objet
google.visualization.DataTableavec les données de votre table Python. Vous pouvez ensuite exécuter ce code JavaScript dans un moteur pour générer et renseigner l'objetgoogle.visualization.DataTable. Il n'est généralement utilisé que pour le débogage.
Ce document part du principe que vous maîtrisez les bases de la programmation Python et que vous avez lu la documentation d'introduction à la visualisation pour créer une visualisation et utiliser une visualisation.
Sommaire
Comment utiliser la bibliothèque
Voici la procédure de base plus détaillée:
1. Créer un objet gviz_api.DataTable
Importez la bibliothèque gviz_api.py à partir du lien ci-dessus et instanciez la classe gviz_api.DataTable. La classe utilise deux paramètres : un schéma de table, qui décrit le format des données de la table, et des données facultatives qui serviront à remplir la table. Si vous le souhaitez, vous pouvez ajouter des données ultérieurement ou les écraser complètement, mais pas supprimer des lignes individuelles ni effacer le schéma de la table.
2. Décrire le schéma de votre table
Le schéma de la table est spécifié par le paramètre table_description transmis au constructeur. Ce paramètre n'est pas modifiable par la suite. Le schéma décrit toutes les colonnes de la table: le type de données de chaque colonne, l'ID et une étiquette facultative.
Chaque colonne est décrite par un tuple: (ID [,data_type [,label [,custom_properties]]]).
- ID : un ID de chaîne permettant d'identifier la colonne. Peut inclure des espaces. L'ID de chaque colonne doit être unique.
- data_type : [facultatif] descripteur de chaîne du type de données Python des données de cette colonne. Vous trouverez une liste des types de données acceptés dans la méthode SingleValueToJS(). Exemples : "string" et "boolean". Si aucune valeur n'est spécifiée, la valeur par défaut est "string".
- label : nom convivial de la colonne, qui peut être affiché dans la visualisation. Si elle n'est pas spécifiée, la valeur de l'ID est utilisée.
- custom_properties : un dictionnaire {String:String} de propriétés de colonnes personnalisées.
Le schéma de la table est un ensemble de tuples de descripteurs de colonne. Chaque membre de la liste, clé de dictionnaire ou valeur de dictionnaire doit être une autre collection ou un tuple de descripteur. Vous pouvez utiliser n'importe quelle combinaison de dictionnaires ou de listes, mais chaque clé, valeur ou membre doit à terme s'évaluer sur un tuple de descripteur. Voici quelques exemples.
- Liste de colonnes: [('a', 'number'), ('b', 'string')]
- Dictionary of lists: {('a', 'number'): [('b', 'number'), ('c', 'string')]}
- Dictionary of dictionaries: {('a', 'number'): {'b': 'number', 'c': 'string'}}
- Et ainsi de suite, quel que soit le niveau d'imbrication.
3. Insérer des données
Pour ajouter des données à la table, créez une structure des éléments de données ayant exactement la même structure que le schéma de la table. Ainsi, si votre schéma est une liste, les données doivent être une liste:
- schema: [("couleur", "chaîne"), ("forme", "chaîne")]
- données: [["blue", "square"], ["red", "circle"]]
Si le schéma est un dictionnaire, les données doivent être un dictionnaire:
- schema: {("nom de ligne", "chaîne"): [("couleur", "chaîne"), ("forme", "chaîne")] }
- data: {"row1": ["bleu", "carré"], "ligne2": ["rouge", "cercle"]}
Une ligne du tableau est une section des données et du schéma correspondants. Par exemple, voici comment le schéma d'une liste de deux colonnes est appliqué à deux lignes de données.
Schema:[(color),(shape)]
/ \
Data: [["blue", "square"], ["red", "circle"]]
Table:
Color Shape
blue square
red circle
Notez que les clés de dictionnaire sont ici évaluées en fonction des données de colonne. Vous trouverez des exemples plus complexes dans la documentation sur la méthode AppendData() du code. Autoriser une imbrication aussi complexe est de vous permettre d'utiliser une structure de données Python adaptée à vos besoins.
4. Générer vos données
Le format de sortie le plus courant est JSON. Vous utiliserez donc probablement la fonction ToJsonResponse() pour créer les données à renvoyer. Toutefois, si vous analysez la requête d'entrée et que vous acceptez différents formats de sortie, vous pouvez appeler l'une des autres méthodes de sortie pour renvoyer d'autres formats, y compris les valeurs séparées par des virgules, les valeurs séparées par des tabulations et JavaScript. JavaScript n'est généralement utilisé que pour le débogage. Pour savoir comment traiter une requête afin d'obtenir le format de réponse préféré, consultez la page Implémenter une source de données.
Exemple d'utilisation
Voici quelques exemples montrant comment utiliser les différents formats de sortie.
Exemple ToJSon et 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()
Exemple de réponse ToJSonResponse
JSonResponse est utilisé par un client distant dans une demande de données.
#!/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")