Google tiene una biblioteca de Python de código abierto que crea objetos DataTable para el consumo mediante visualizaciones. Esta biblioteca se puede usar para crear un DataTable en Python y obtener el resultado en cualquiera de estos tres formatos:
- Cadena JSON : Si alojas la página que aloja la visualización que usa tus datos, puedes generar una cadena JSON para pasar a un constructor
DataTabley propagarla. - Respuesta JSON : Si no alojas la página que aloja la visualización y solo deseas actuar como una fuente de datos para visualizaciones externas, puedes crear una string de respuesta JSON completa que se pueda mostrar como respuesta a una solicitud de datos.
- Cadena de JavaScript: Puedes mostrar la tabla de datos como una cadena que consta de varias líneas de código JavaScript que creará y propagará un objeto
google.visualization.DataTablecon los datos de tu tabla de Python. Luego, puedes ejecutar este JavaScript en un motor para generar y propagar el objetogoogle.visualization.DataTable. Por lo general, se usa solo para depuración.
En este documento, se supone que conoces la programación básica en Python y que ya leíste la documentación introductoria sobre visualización para crear una visualización y usar una visualización.
Contenido
Cómo usar la biblioteca
A continuación, se presentan los pasos básicos con más detalle:
1. Crea
un objeto gviz_api.DataTable
Importa la biblioteca gviz_api.py desde el vínculo anterior y crea una instancia de la clase gviz_api.DataTable. La clase toma dos parámetros: un esquema de tabla, que describirá el formato de los datos en la tabla, y datos opcionales con los que se completará. Puedes agregar datos más adelante, si lo deseas, o reemplazarlos por completo por completo, pero no quitar filas individuales ni borrar el esquema de la tabla.
2. Describe el esquema de tu tabla
El esquema de la tabla se especifica con el parámetro table_description que se pasa al constructor. No podrás cambiarlo más adelante. El esquema describe todas las columnas de la tabla: el tipo de datos de cada columna, el ID y una etiqueta opcional.
Cada columna se describe mediante una tupla: (ID [,data_type [,label [,custom_properties]]].
- ID: Es un ID de string que se usa para identificar la columna. Pueden incluir espacios. El ID de cada columna debe ser único.
- data_type: [opcional] un descriptor de cadena del tipo de datos de Python de los datos en esa columna. Puedes encontrar una lista de los tipos de datos admitidos en el método SingleValueToJS(). Algunos ejemplos son “cadena” y “booleano”. Si no se especifica, el valor predeterminado es "string".
- etiqueta: Un nombre fácil de usar para la columna, que se puede mostrar como parte de la visualización. Si no se especifica, se usa el valor del ID.
- custom_properties: un diccionario {String:String} de propiedades de columnas personalizadas.
El esquema de la tabla es una colección de tuplas de descriptor de columna. Cada miembro de la lista, clave de diccionario o valor del diccionario debe ser otra colección o una tupla de descriptor. Puedes usar cualquier combinación de diccionarios o listas, pero cada clave, valor o miembro debe evaluarse como una tupla de descriptor. A continuación, se incluyen algunos ejemplos:
- Lista de columnas: [('a', 'number'), ('b', 'string')]
- Dictionary of lists: {('a', 'number'): [('b', 'number'), ('c', 'string')]}
- Dictionary of dictionaries: {('a', 'number'): {'b': 'number', 'c': 'string'}}
- Y así sucesivamente, con cualquier nivel de anidación.
3. Propagar tus datos
Para agregar datos a la tabla, crea una estructura de elementos de datos exactamente con la misma estructura que el esquema de la tabla. Por ejemplo, si tu esquema es una lista, los datos deben ser una lista:
- schema: [("color", "string"), ("shape", "string")]
- datos: [["blue", "square"], ["red", "círculo"]]
Si el esquema es un diccionario, los datos deben ser un diccionario:
- schema: {("rowname", "string"): [("color", "string"), ("shape", "string")] }
- datos: {"row1": ["blue", "square"], "row2": ["red", "círculo"]}
Una fila de la tabla es una sección de los datos y el esquema correspondientes. Por ejemplo, así es como se aplica un esquema de una lista de dos columnas a dos filas de datos.
Schema:[(color),(shape)]
/ \
Data: [["blue", "square"], ["red", "circle"]]
Table:
Color Shape
blue square
red circle
Ten en cuenta que las claves del diccionario aquí se evalúan como datos de columna. Puedes encontrar ejemplos más complejos en la documentación del método AppendData() en el código. El propósito de permitir un anidamiento tan complejo es permitirte usar una estructura de datos de Python adecuada para tus necesidades.
4. Genera tus datos
El formato de salida más común es JSON, por lo que es probable que uses la función ToJsonResponse() para crear los datos que se mostrarán. Sin embargo, si analizas la solicitud de entrada y admites diferentes formatos de salida, puedes llamar a cualquiera de los otros métodos de salida para mostrar otros formatos, incluidos los valores separados por comas, los valores separados por tabulaciones y JavaScript. Por lo general, JavaScript solo se usa para la depuración. Consulta Cómo implementar una fuente de datos para aprender a procesar una solicitud y obtener el formato de respuesta preferido.
Ejemplo de uso
Aquí hay algunos ejemplos que muestran cómo usar los distintos formatos de salida.
Ejemplo de ToJSon y 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()
Ejemplo de ToJSonResponse
Un cliente remoto usa JSonResponse en una solicitud de datos.
#!/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")