Coupler.io Blog

Cómo conectar Python a Google Sheets

  • Zakhar Yung

    • Python está diseñado con funciones que permiten el análisis y la visualización de datos. Por eso suele ser el lenguaje de facto para aplicaciones de ciencia de datos y aprendizaje automático. Puedes integrar tus datos con bibliotecas de análisis de datos, como NumPy o Pandas, o bibliotecas de visualización de datos, como Matplotlib o Seaborn. 

    Y, por supuesto, es posible leer y escribir en Google Sheets utilizando Python.

    ¿Cuáles son las formas de cargar datos de Python en Google Sheets?

    Estas son las formas de cargar datos en Google Sheets utilizando Python:

    Necesitas Python para crear una conexión entre una aplicación de origen y Google Sheets y automatizar la carga de datos. 

    Al mismo tiempo, puedes hacerlo sin codificación en absoluto con Coupler.io. Es una solución de automatización de informes que proporciona más de 50 fuentes de datos preestablecidas. Además, te permite extraer datos de API externas a Google Sheets sin codificar.

    Automatiza la importación de datos a Google Sheets sin codificar

    Todo lo que tienes que hacer es seleccionar tu aplicación de origen en el siguiente formulario y hacer clic en Continuar.

    Se te pedirá que crees una cuenta gratuita en Coupler.io. Puedes registrarte con tu cuenta de Google sin necesidad de tarjeta de crédito. 

    Una vez iniciada la sesión, especifica los datos que deseas extraer de tu fuente y transfórmalos. Sí, puedes renombrar y ocultar columnas, cambiar tipos de datos, filtrar datos e incluso añadir campos personalizados directamente en la interfaz de usuario. 

    Por no hablar de la combinación de datos: puedes añadir varias fuentes y combinar los datos procedentes de ellas.

    Después de eso, selecciona la hoja de cálculo donde deseas cargar los datos y eso es todo. Oh no, ¡también puedes programar la actualización de datos, por ejemplo cada día o cada 15 minutos, con unos pocos clics!Más información sobre las integraciones de Google Sheets disponibles en Coupler.io.

    Conectar Python a Google Sheets

    En este post, utilizaremos el cliente Python Google API para interactuar con Google Sheets. 

    Para leer y escribir datos en Google Sheets en Python, tendremos que crear una cuenta de servicio.

    Una cuenta de servicio es un tipo especial de cuenta que utiliza una aplicación o una instancia de máquina virtual (VM), no una persona. Las aplicaciones utilizan cuentas de servicio para realizar llamadas a API autorizadas, con autorización como la propia cuenta de servicio o como usuarios de Google Workspace o Cloud Identity a través de la delegación en todo el dominio.

    – Google Cloud Docs

    Crear una cuenta de servicio

    Cómo habilitar el acceso de Python a Google Sheets

    Con las credenciales de la consola de desarrollador, puedes habilitar el acceso de Python a Google Sheets.

    Requisito previo:

    Este tutorial requiere que tengas Python 3 y Pip3 instalados en tu ordenador local. Para instalar Python, puedes seguir esta excelente guía en el blog Real Python.

    Crea un nuevo directorio de proyecto, utilizando el terminal de tu sistema o una aplicación de línea de comandos, con el comando mkdir python-to-google-sheets. Navega al nuevo directorio del proyecto utilizando cd python-to-google-sheets.

    Crea un entorno virtual Python para el proyecto utilizando el módulo venv.

    venv es un módulo incorporado de Python que crea entornos Python aislados para cada uno de tus proyectos Python.

    Cada entorno virtual tiene su propio binario Python (que coincide con la versión del binario que se utilizó para crear este entorno) y puede tener su propio conjunto independiente de paquetes Python instalados. Los dos comandos siguientes crearán y activarán un nuevo entorno virtual en una carpeta llamada env.

    python -m venv env
fuente env/bin/activate

    A continuación, instala las bibliotecas de cliente de Google. Crea un archivo requirement.txt y añádele las siguientes dependencias.

    google-api-python-client==1.7.9
google-auth-httplib2==0.0.3
google-auth-oauthlib==0.4.0

    Ejecuta pip install -r requirements.txt para instalar los paquetes.

    Crea un archivo auth.py y añade el siguiente código al archivo.

    # auth.py

from __future__ import función_impresión
from googleapiclient.discovery import build 
from google.oauth2 import cuenta_de_servicio


SCOPES = [
'https://www.googleapis.com/auth/spreadsheets',
'https://www.googleapis.com/auth/drive'
]

credenciales = cuenta_de_servicio.credenciales.from_archivo_de_cuenta_de_servicio('credenciales.json', ámbitos=SCOPES)

spreadsheet_service = build('hojas', 'v4', credenciales=credenciales)
drive_service = build('drive', 'v3', credentials=credentials)

    El código anterior gestionará toda la autenticación en Google Sheets y Google Drive. Mientras que la API de hojas será útil para crear y manipular hojas de cálculo, la API de Google Drive es necesaria para compartir el archivo de hoja de cálculo con otras cuentas de Google.

    Cómo utilizar Python con Google Sheets

    Python a Google Sheets – crear una hoja de cálculo 

    Para crear una nueva hoja de cálculo, utiliza el método create() de la API de Google Sheets, como se muestra en el siguiente ejemplo de código. Creará una hoja de cálculo en blanco con el título especificado python-google-sheets-demo.

    # sheets.py

from __future__ import función_impresión
from auth import spreadsheet_service
from auth import drive_service

def crear():
    hoja_detalles = {
    'propiedades': {
        'title': 'Python-google-sheets-demo'
        }
    }
    hoja = spreadsheet_service.spreadsheets().create(body=detalles_hoja_de_datos,
                                    fields='spreadsheetId').execute()
    sheetId = sheet.get('spreadsheetId')
    print('ID de hoja de cálculo: {0}'.format(sheetId))
    permiso1 = {
    'tipo': 'usuario',
    "rol": 'escritor',
    'emailAddress': 'SU CORREO ELECTRÓNICO'
    }
    drive_service.permissions().create(fileId=sheetId, body=permission1).execute()
    devolver sheetId

crear()

    Acabas de crear tu primer archivo de Google Sheets con Python utilizando una cuenta de servicio y lo has compartido con tu cuenta de Google.

    La cuenta de servicio es diferente de tu propia cuenta de Google, por lo que cuando una hoja de cálculo es creada por la cuenta de servicio, el archivo se crea en Google Drive de la cuenta de servicio y no puedes verlo en tu propio Google Drive. Se ha utilizado la API de permisos de Drive para conceder acceso a tu cuenta de Google o a cualquier otra cuenta con la que quieras ver la hoja.

    Cómo escribir en Google Sheets con Python

    Has creado una nueva hoja de cálculo, pero aún no contiene ningún dato. La API de Google Sheets proporciona la colección spreadsheets.values para permitir la lectura y escritura simple de valores. Para escribir datos en una hoja, habrá que recuperarlos de una fuente, base de datos, hoja de cálculo existente, etc. Para el propósito de este post, leerás datos de una hoja de cálculo existente: Datos de muestra para modelar el presupuesto de Google Spreadsheet y luego los escribirás en la hoja de cálculo python-google-sheets-demo, que creamos en el paso anterior.

    Cómo publicar una serie de datos en Google Sheets con Python

    La colección spreadsheets.values tiene un método get() para leer un único rango y un método update() para actualizar un único rango. El método get() acepta el ID de la hoja de cálculo y un rango (Notación A1) mientras que el método update() acepta argumentos adicionales requeridos body y valueInputOption:

    Enviar datos de Python a un script de Google Sheets

    from __future__ import función_impresión
from auth import spreadsheet_service
from auth import drive_service

def crear():
    hoja_detalles = {
    'propiedades': {
        'title': 'Python-google-sheets-demo'
        }
    }
    hoja = spreadsheet_service.spreadsheets().create(body=spreadsheet_details,
                                    fields='spreadsheetId').execute()
    sheetId = sheet.get('spreadsheetId')
    print('ID de hoja de cálculo: {0}'.format(sheetId))
    permiso1 = {
    'tipo': 'usuario',
    'rol': 'escritor',
    'dirección de correo electrónico': 'godwinekuma@gmail.com'
    }
    drive_service.permissions().create(fileId=sheetId, body=permission1).execute()
    return sheetId

def leer_rango():
    range_name = 'Hoja1!A1:H1'
    spreadsheet_id = '1JCEHwIa4ZzwAiKGmAnWGfbjeVCH_tWZF6MkIU0zICwM'
    resultado = spreadsheet_service.spreadsheets().values().get(
    spreadsheetId=spreadsheet_id, range=range_name).execute()
    filas = result.get('valores', [])
    print('{0} filas recuperadas.'.format(len(filas)))
    print('{0} filas recuperadas.'.format(filas))
    devolver filas

def scribir_rango():
    spreadsheet_id = crear()
    range_name = 'Hoja1!A1:H1'
    valores = read_range()
    value_input_option = 'USER_ENTERED'
    cuerpo = {
        'valores': valores
    }
    resultado = spreadsheet_service.spreadsheets().values().update(
        spreadsheetId=id_hoja_de_calculo, range=nombre_rango,
        valueInputOption=value_input_option, body=body).execute()
    print('{0} celdas actualizadas.'.format(result.get('celdasactualizadas')))

escribir_rango()

    Este código lee la primera fila (Hoja1!A1:H1) de la hoja de cálculo de ejemplo y la escribe en la hoja de cálculo python-google-sheets-demo.

    Exportar múltiples rangos a Google Sheets con Python

    Anteriormente, sólo actualizaste la primera fila de la hoja de demostración. Para rellenar las otras celdas, el código siguiente leerá múltiples rangos discontinuos de la hoja de cálculo de gastos de ejemplo utilizando el método spreadsheets.values.batchGet y luego escribirá esos rangos en la hoja de demostración.

    from __future__ import función_impresión
from auth import spreadsheet_service
from auth import drive_service

spreadsheet_id = ''
def crear():
    hoja_detalles = {
    'propiedades': {
        'title': 'Python-google-sheets-demo'
        }
    }
    hoja = spreadsheet_service.spreadsheets().create(body=spreadsheet_details,
                                    fields='spreadsheetId').execute()
    global spreadsheet_id
    spreadsheet_id = sheet.get('spreadsheetId')
    print('ID de hoja de cálculo: {0}'.format(spreadsheet_id))
    permiso1 = {
    'tipo': 'usuario',
    'rol': 'escritor',
    'dirección de correo electrónico': 'godwinekuma@gmail.com'
    }
    drive_service.permissions().create(fileId=spreadsheet_id, body=permission1).execute()
    return hoja_de_datos
def leer_rango():
    range_name = 'Hoja1!A1:H1'
    sheetId = '1JCEHwIa4ZzwAiKGmAnWGfbjeVCH_tWZF6MkIU0zICwM'
    resultado = spreadsheet_service.spreadsheets().values().get(
    hoja_de_datos=hoja_de_datos, rango=nombre_rango).execute()
    filas = result.get('valores', [])
    print('{0} filas recuperadas.'.format(len(filas)))
    print('{0} filas recuperadas.'.format(filas))
    devolver filas
def escribir_rango():
    crear()
    range_name = 'Hoja1!A1:H1'
    valores = read_range()
    value_input_option = 'USER_ENTERED'
    cuerpo = {
        'valores': valores
    }
    resultado = spreadsheet_service.spreadsheets().values().update(
        spreadsheetId=id_hoja_de_calculo, range=nombre_rango,
        valueInputOption=value_input_option, body=body).execute()
    print('{0} celdas actualizadas.'.format(result.get('celdasactualizadas')))
def leer_rangos():
    escribir_rango()
    sheetId = '1JCEHwIa4ZzwAiKGmAnWGfbjeVCH_tWZF6MkIU0zICwM'
    range_names = ['Hoja1!A2:H21', 'Hoja1!A42:H62']
    resultado = spreadsheet_service.spreadsheets().values().batchGet(
     spreadsheetId=sheetId, ranges=nombres_rangos).execute()
    rangos = result.get('rangosValor', [])
    print('{0} rangos recuperados.'.format(len(rangos)))
    rangos de devolución

def escribir_rangos():
    valores = read_ranges()
     datos = [
        {
            'rango': 'Hoja1!A2:H21',
            'valores': valores[0]['valores']
        },
       {
            'rango': 'Hoja1!A22:H42',
            'valores': valores[1]['valores']
        }
    ]
    cuerpo = {
        'valueInputOption': 'USER_ENTERED',
        'datos': datos
    }
    resultado = spreadsheet_service.spreadsheets().values().batchUpdate(
        spreadsheetId=spreadsheet_id, body=body).execute()
    print('{0} celdas actualizadas.'.format(result.get('totalCeldasActualizadas')))
escribir_rangos()

    Añadir una lista a Google Sheets con Python

    También puedes añadir datos después de una tabla de datos en una hoja utilizando el método spreadsheets.values.append. No es necesario especificar un rango, ya que los datos se añadirán a la hoja a partir de la primera fila vacía después de la fila con datos.

    def append():
    values = read_ranges()
    datos = [
         valores[0]['valores'], valores[1]['valores']
    ]
    cuerpo = {
        'valueInputOption': 'USER_ENTERED',
        'datos': datos
    }
    resultado = spreadsheet_service.spreadsheets().values().append(
        spreadsheetId=spreadsheet_id, body=body).execute()
    print('{0} celdas actualizadas.'.format(result.get('totalCeldasActualizadas')))
añadir()

    Script Python para exportar Excel a Google Sheets

    ¿Ya tienes una hoja de Excel cuyos datos quieres enviar a Google Sheets? Eso también es posible con Python. Aquí está la hoja de Excel de ejemplo que tenemos:

    Puedes leer algunos de los datos allí y añadirlos al documento existente de Google Sheets.

    Primero, añade pandas==1.2.3 y openpyxl==3.0.7 como nuevas dependencias en tu requirement.txt y vuelve a ejecutar pip install -r requirements.txt para instalar los paquetes.

    Ahora añade el siguiente código en el archivo sheets.py.

    def export_excel_to_sheets():
    spreadsheet_id = '1JCEHwIa4ZzwAiKGmAnWGfbjeVCH_tWZF6MkIU0zICwM'
    excel_data_df = pandas.read_excel('sample-excel.xlsx', sheet_name='Hoja1', skiprows = range(1, 62), engine='openpyxl')
    excel_data_df['Fecha'] = excel_data_df['Fecha'].astype(str)
    excel_data_df['Sin nombre: 0'] = ''



    cuerpo = {
        'valores': excel_data_df.valores.tolist()
    }
    
  
    spreadsheet_service.spreadsheets().values().append(
        spreadsheetId=spreadsheet_id, body=body, valueInputOption='USER_ENTERED', range='Hoja1').execute()
    print('{0} celdas añadidas.'.format(resultado \
                                       .get('updates') \
                                       .get('updatedCells')))


export_excel_to_sheets()

    Esto extraerá los datos de la hoja Excel a partir de la fila 63 y, a continuación, los añadirá al archivo de Google Sheets.

    Sin embargo, puedes hacer lo mismo con Coupler.io mucho más fácilmente. Solo tienes que hacer clic en Proceder en el siguiente formulario y especificar qué datos extraer de Excel y dónde cargarlos en Google Sheets.

    Enviar Pandas dataframe a Google Sheets

    Exportar un dataframe de Pandas a Google Sheets es tan fácil como convertir los datos en una lista y luego anexarlos a una hoja. El siguiente código envía un dataframe de Pandas a Google Sheets.

    def export_pandas_df_to_sheets():
    spreadsheet_id = '1iKZHRN4MnbyUeeSO5EWvTLmSeIOzXfwx1s0PSVw27lc'
    
    df = pd.DataFrame(
        [[21, 72, 67],
        [23, 78, 69],
        [32, 74, 56],
        [52, 54, 76]],
        columns=['a', 'b', 'c'])



    cuerpo = {
        'valores': df.valores.tolist()
    }
    
  
    resultado = spreadsheet_service.spreadsheets().values().append(
        spreadsheetId=spreadsheet_id, body=body, valueInputOption='USER_ENTERED', range='Hoja1').execute()
    print('{0} celdas añadidas.'.format(resultado \
                                       .get('updates') \
                                       .get('updatedCells')))

    ¿A qué velocidad puede Python cargar datos en Google Sheets?

    Con la automatización, ¡tus datos pueden estar en Google Sheets en cuestión de 2-5 segundos! Por supuesto, tendrás que pasar tiempo escribiendo el código inicial, pero después de eso, todo estará en piloto automático.

    ¿Necesitas Python para automatizar la exportación de datos a Google Sheets?

    En el mundo empresarial actual, la velocidad desempeña un papel fundamental para tener éxito. La velocidad implica la automatización de todo, incluida la introducción de datos en una hoja de cálculo. Cuando automatizas tareas repetitivas, como leer y escribir en Google Sheets, puedes alcanzar la eficiencia funcional y operativa.

    Puedes confiar en Python para automatizar los flujos de datos desde tu fuente a Google Sheets. Sin embargo, no es un trabajo fácil de hacer ya que necesitas aprender APIs, escribir un script, etc. Por supuesto, esto requerirá conocimientos de codificación.

    Si no eres lo suficientemente experto en tecnología como para usar Python o simplemente quieres automatizar las tareas de enrutamiento más rápido, echa un vistazo a Coupler.io. Te permite importar datos a Google Sheets desde múltiples fuentes, como Pipedrive, Jira, BigQuery, Airtable y muchas más. Además, puedes utilizar Coupler.io para extraer datos a través de REST API, así como de archivos CSV y Excel publicados en línea, en Google Sheets.

    Lo mejor es que puedes programar la importación de datos cuando quieras.

    Automatiza la exportación de datos con Coupler.io

    Empieza gratis

    Salir de la versión móvil