Google dispose d'une bibliothèque Python Open Source qui crée des objets DataTable à utiliser par les visualisations. Cette bibliothèque peut être utilisée pour créer un fichier 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, mais souhaitez simplement agir en tant que source de données pour les visualisations externes, vous pouvez créer une chaîne de réponse JSON complète qui peut être renvoyée en réponse à une requête de données.
- Chaîne JavaScript : vous pouvez générer le tableau de données sous la forme d'une 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. Cette option n'est généralement utilisée que pour le débogage.
Dans ce document, nous partons du principe que vous maîtrisez la programmation Python de base, et que vous avez lu la documentation de présentation pour créer une visualisation et utiliser une visualisation.
Sommaire
Utiliser la bibliothèque
Voici les étapes de base, plus en détail:
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 à renseigner dans la table. Vous pouvez ajouter des données ultérieurement, si vous le souhaitez, 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 la 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 : ID de chaîne permettant d'identifier la colonne. Peut inclure des espaces. L'ID de chaque colonne doit être unique.
- data_type : [facultatif] un descripteur de chaîne du type de données Python des données de cette colonne. Vous trouverez la 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 "chaîne".
- 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 : dictionnaire {String:String} des propriétés de la colonne personnalisée.
Le schéma de la table est une collection de tuples de descripteurs de colonne. Chaque membre de la liste, clé du dictionnaire ou valeur du dictionnaire doit être un autre tuple de collection ou de descripteur. Vous pouvez utiliser n'importe quelle combinaison de dictionnaires ou de listes, mais chaque clé, valeur ou membre doit finir par être évalué par un tuple descripteur. Voici quelques exemples :
- Liste des colonnes: [('a', 'number'), ('b', 'string')
- Dictionnaire de listes: {('a', 'number'): [('b', 'number'), ('c', 'string')]}
- Dictionnaire des dictionnaires: {('a', 'number'): {'b': 'number', 'c': 'string'}}
- Et ainsi de suite, avec n'importe quel niveau d'imbrication.
3. Insérer les données
Pour ajouter des données à la table, créez une structure d'éléments de données dans 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: [("color", "string"), ("shape", "string")
- données: [["blue", "square"], ["red", "circle"]
Si le schéma est un dictionnaire, les données doivent être un dictionnaire:
- schema: {("rowname", "string"): [("color", "string"), ("shape", "string")]
- données: {"row1": ["blue", "square"], "row2": ["red", "circle"]}
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 du dictionnaire permettent ici d'évaluer les données des colonnes. Vous trouverez des exemples plus complexes dans la documentation de la méthode AppendData() dans le code. L'objectif de cette imbrication 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 allez donc probablement utiliser la fonction ToJsonResponse() pour créer les données à renvoyer. Toutefois, si vous analysez la requête d'entrée et prenez en charge 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 une virgule, les valeurs séparées par une tabulation et JavaScript. En général, JavaScript n'est utilisé que pour le débogage. Consultez la page Mettre en œuvre une source de données pour découvrir comment traiter une requête afin d'obtenir le format de réponse préféré.
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 ToJSonResponse
JSonResponse est utilisé par un client distant dans une requête 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")