En este artículo, vamos a almacenar datos de Google Sheets en una base de datos usando Python. El primer paso es habilitar la API y crear las credenciales, así que comencemos.
Habilitación de las API y creación de las credenciales
- Vaya a Marketplace en Cloud Console.
- Haga clic en HABILITAR APIS Y SERVICIOS
- Luego busque la API de Google Drive y habilítela
- Luego vaya a la pestaña Credenciales en la barra de navegación izquierda en la pantalla.
- Luego haga clic en Crear credenciales y luego seleccione Clave de cuenta de servicio
- Luego cree una nueva cuenta de servicio dándole un nombre y establezca el Rol en Editor en el subcampo Proyectos y mantenga el tipo de clave como JSON y haga clic en el botón Crear. Mantenga el JSON descargado de forma segura.
- Después de realizar todos estos pasos, su página debería verse así.
- Vuelva a ir a Dashboard y siga los mismos pasos. Esta vez busque Hojas de cálculo de Google y habilite la API.
Después de habilitar la API, creemos el formulario de Google.
Creando el formulario de Google:
- Crear un formulario de Google. Aquí, mantuvimos un formulario simple con solo dos campos.
- Haga que el formulario de Google acepte respuestas en Hojas de cálculo de Google.
- Luego busque el archivo JSON descargado para el campo client_email y copie ese correo electrónico.
- Abra la hoja de cálculo recién creada y haga clic en la opción de compartir y escriba el correo electrónico del cliente allí.
Después de dar acceso al correo electrónico del cliente, debería verse así. El correo electrónico superior será su correo electrónico personal y el inferior será el correo electrónico del cliente.
Formulario de Google:
Así que hemos terminado con la configuración. Ahora, vayamos al código. Antes de comenzar, entendamos el flujo.
- Crearemos una base de datos y una tabla según los esquemas de entrada del formulario.
- Realice una conexión con las hojas a través de la API y obtenga todas las filas.
- Ejecute la consulta de inserción para insertar los datos de la fila de las hojas en la base de datos.
Acercarse:
- Primero, inicializamos las credenciales de la cuenta de servicio JSON.
- Luego usamos este objeto de credenciales para acceder a la hoja que generamos desde el formulario de Google.
- Una vez que tenemos acceso a las hojas, simplemente extraemos todas las filas a la vez para reducir la cantidad de llamadas a la API.
- Ahora, primero hacemos nuestra conexión a la base de datos. Aquí, usamos la base de datos sqlite para simplificar. Puede usar cualquier tipo de base de datos, todo lo que necesita hacer es pasar la string de conexión.
- Una vez establecida la conexión, creamos la tabla (si no existe)
- Una vez que la tabla está lista, pasamos las filas recuperadas a la tabla. Simplemente iteramos sobre todas las filas obtenidas y luego pasamos cada valor de columna en la fila a la base de datos.
Código:
Python3
# imports
import sqlite3
from sqlite3 import Error
import gspread
from oauth2client.service_account import ServiceAccountCredentials
def get_from_sheet():
# name of the sheet
# you should replace with the name
# of your sheet
sheet_name = "Details (Responses)"
config = { Your_API
# should contain the service account
# key JSON as dict here
}
# use credentials to create a client to
# interact with the Google Drive API
scope = [
"https://spreadsheets.google.com/feeds",
"https://www.googleapis.com/auth/drive",
]
# credential object for authenticating
creds_obj = ServiceAccountCredentials.from_json_keyfile_dict(config, scope)
# initializing gspread client with the
# credentials object
client = gspread.authorize(creds_obj)
# Find a workbook by name and open the
# first sheet Make sure you use the
# right name here.
sheet = client.open(sheet_name).sheet1
# returns all the data in the entire sheet
return sheet.get_all_values()
class SQLite:
# change this to your sqlite file path
# if you keep then, then it will create
# a sqlite database in your current working
# directory
DB_NAME = "db.sqlite"
def __init__(self):
self.conn = self.create_connection()
self._get_or_create_table()
@classmethod
def create_connection(cls):
"""
create a database connection to the SQLite database specified by db_name
:return: Connection object or None
"""
conn = None
try:
# connects or creates a sqlite3 file
conn = sqlite3.connect(cls.DB_NAME)
return conn
except Error as e:
print(e)
# returns the connection object
return conn
def _get_or_create_table(self):
"""Creates the table if it does not exists"""
# sql query to create a details table
create_table_sql = """CREATE TABLE IF NOT EXISTS details (
timestamp varchar(20) PRIMARY KEY,
name varchar(30) NOT NULL,
year varchar(3) NOT NULL
)"""
try:
# initializing the query cursor
c = self.conn.cursor()
# executes the create table query
c.execute(create_table_sql)
except Error as e:
# prints the exception if any errors
# occurs during runtime
print(e)
def add_data_to_table(self, rows: list):
"""Inserts the data from sheets to the table"""
# initializing sql cursor
c = self.conn.cursor()
# excluding the first row because it
# contains the headers
insert_table_sql = """INSERT INTO details (timestamp, name, year)
VALUES (?, ?, ?);"""
for row in rows[1:]:
# inserts the data into the table
# NOTE: the data needs to be in the order
# which the values are provided into the
# sql statement
c.execute(insert_table_sql, tuple(row))
# committing all the changes to the database
self.conn.commit()
# closing the connection to the database
c.close()
if __name__ == '__main__':
# fetches data from the sheets
data = get_from_sheet()
sqlite_util = SQLite()
sqlite_util.add_data_to_table(data)
Producción:
Como puede ver, ahora tenemos con éxito los datos en nuestra base de datos.
Publicación traducida automáticamente
Artículo escrito por debdutgoswami y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA