¿Has ingerido tu conocimiento hoy?
Ser capaz de escribir SQL es importante, y poder consultar una base de datos de manera eficiente se considera una de las habilidades más básicas para un analista/científico de datos.
gran aplicación de datos
La Escuela de Aplicación de Datos fue calificada como el Top Data Camp en América del Norte en 2016. Es la organización de servicios de consultoría de ciencia de datos integral más profesional, ¡su experto en consultoría laboral de ciencia de datos!
4336 contenido original
sin publico
SQL no solo es importante, sino que se usa con mucha frecuencia. Según la Encuesta de desarrolladores de Stackoverflow de 2021, SQL es uno de los cinco lenguajes de programación más utilizados. Entonces, deberíamos invertir más tiempo para aprender SQL.
Ilustraciones de personajes por Storyset
Pero hay una pregunta: ¿cómo practicar consultas de bases de datos sin una base de datos?
En el artículo de hoy, abordemos este problema básico y aprendamos cómo crear su propia base de datos MySQL desde cero. Con la ayuda de Python y algunas bibliotecas externas, crearemos un script simple que automáticamente crea y completa nuestra tabla con datos generados aleatoriamente.
Sin embargo, antes de discutir los detalles de implementación, primero debemos discutir algunos requisitos previos.
Nota: por supuesto, hay otras formas de obtener una base de datos SQL para practicar (como la descarga directa) , pero el uso de Python y algunas bibliotecas externas puede brindarnos oportunidades de práctica adicionales y valiosas.
requisitos previos
Comencemos con lo básico primero.
Primero, debe instalar MySQL Workbench y conectarse al servicio, luego puede comenzar a construir la base de datos:
CREATE DATABASE IF NOT EXISTS your_database_name;Ahora, solo necesitamos instalar las bibliotecas de python necesarias y la configuración básica está lista. La biblioteca que usaremos se muestra a continuación y se puede instalar fácilmente a través de la terminal.
-
1. NumPy: instalación de pip numpy
-
2. Sqlalchemy: pip install sqlalchemy
-
3. Falsificador: pip install falsificador
Crear guión
Después de completar la configuración básica, podemos comenzar a escribir scripts de Python.
Comience por crear una clase con un código repetitivo que nos brinde un modelo que nos guíe a través del resto de la implementación.
import numpy as np
import sqlalchemy
from faker import Faker
from sqlalchemy import Table, Column, Integer, String, MetaData, Date,
class SQLData:
def __init__(self, server:str, db:str, uid:str, pwd:str) -> None:
self.__fake = Faker()
self.__server = server
self.__db = db
self.__uid = uid
self.__pwd = pwd
self.__tables = dict()
def connect(self) -> None:
pass
def drop_all_tables(self) -> None:
pass
def create_tables(self) -> None:
pass
def populate_tables(self) -> None:
passTodavía no hemos utilizado una sintaxis particularmente avanzada. Básicamente, simplemente creamos una clase, almacenamos las credenciales de la base de datos para su uso posterior, importamos la biblioteca y definimos algunos métodos.
establecer conexión
Lo primero que queremos hacer es crear una conexión de base de datos.
Afortunadamente, podemos utilizar la biblioteca sqlalchemy de Python para hacer la mayor parte del trabajo.
class SQLData:
#...
def connect(self) -> None:
self.__engine = sqlalchemy.create_engine(
f"mysql+pymysql://{self.__uid}:{self.__pwd}@{self.__server}/{self.__db}"
)
self.__conn = self.__engine.connect()
self.__meta = MetaData(bind=self.__engine)Este método puede crear y almacenar 3 objetos como propiedades de instancia.
Primero, creamos una conexión que sirve como punto de partida para la aplicación sqlalchemy, describiendo cómo hablar con un tipo específico de combinación de base de datos/DBAPI.
En nuestro caso, especificamos una base de datos MySQL y pasamos nuestras credenciales.
A continuación, crea una conexión que nos permitirá ejecutar sentencias SQL y un objeto de metadatos (un contenedor) que reúna las diferentes funciones de la base de datos y nos permita asociar y acceder a las tablas de la base de datos.
crear una tabla
Ahora, necesitamos crear las tablas de la base de datos.
class SQLData:
#...
def create_tables(self) -> None:
self.__tables['jobs'] = Table (
'jobs', self.__meta,
Column('job_id', Integer, primary_key=True, autoincrement=True, nullable=False),
Column('description', String(255))
)
self.__tables['companies'] = Table(
'companies', self.__meta,
Column('company_id', Integer, primary_key=True, autoincrement=True, nullable=False),
Column('name', String(255), nullable=False),
Column('phrase', String(255)),
Column('address', String(255)),
Column('country', String(255)),
Column('est_date', Date)
)
self.__tables['persons'] = Table(
'persons', self.__meta,
Column('person_id', Integer, primary_key=True, autoincrement=True, nullable=False),
Column('job_id', Integer, ForeignKey('jobs.job_id'), nullable=False),
Column('company_id', Integer, ForeignKey('companies.company_id'), nullable=False),
Column('last_name', String(255), nullable=False),
Column('first_name', String(255)),
Column('date_of_birth', Date),
Column('address', String(255)),
Column('country', String(255)),
Column('zipcode', String(10)),
Column('salary', Integer)
)
self.__meta.create_all()Creamos 3 tablas y las almacenamos en un diccionario para referencia posterior.
Crear tablas en sqlalchemy también es muy simple. Simplemente instanciamos una nueva tabla, proporcionamos el nombre de la tabla, el objeto de metadatos y especificamos las diferentes columnas.
En este ejemplo, creamos una tabla de trabajo, una tabla de empresa y una tabla de persona. La tabla de personas también vincula otras tablas a través de claves externas, lo que hace que la base de datos sea más interesante para practicar uniones SQL.
Después de definir todas las tablas, simplemente llamamos al método create_all() del objeto MetaData.
generar algunos datos aleatorios
Aunque creamos las tablas de la base de datos, todavía no hay datos disponibles. Entonces necesitamos generar algunos datos aleatorios e insertarlos en la tabla.
class SQLData:
#...
def populate_tables(self) -> None:
jobs_ins = list()
companies_ins = list()
persons_ins = list()
for _ in range(100):
record = dict()
record['description'] = self.__fake.job()
jobs_ins.append(record)
for _ in range(100):
record = dict()
record['name'] = self.__fake.company()
record['phrase'] = self.__fake.catch_phrase()
record['address'] = self.__fake.street_address()
record['country'] = self.__fake.country()
record['est_date'] = self.__fake.date_of_birth()
companies_ins.append(record)
for _ in range(500):
record = dict()
record['job_id'] = np.random.randint(1, 100)
record['company_id'] = np.random.randint(1, 100)
record['last_name'] = self.__fake.last_name()
record['first_name'] = self.__fake.first_name()
record['date_of_birth'] = self.__fake.date_of_birth()
record['address'] = self.__fake.street_address()
record['country'] = self.__fake.country()
record['zipcode'] = self.__fake.zipcode()
record['salary'] = np.random.randint(60000, 150000)
persons_ins.append(record)
self.__conn.execute(self.__tables['jobs'].insert(), jobs_ins)
self.__conn.execute(self.__tables['companies'].insert(), companies_ins)
self.__conn.execute(self.__tables['persons'].insert(), persons_ins)Ahora, podemos utilizar la biblioteca Faker para generar datos aleatorios.
Simplemente usamos los datos generados aleatoriamente en un bucle for para crear un nuevo registro representado por un diccionario. Luego, el registro único se agrega a una lista que se puede usar en declaraciones de inserción (múltiples) .
A continuación, llame al método execute() desde el objeto de conexión, pasando la lista de diccionarios como argumento.
¡Eso es todo! Hemos implementado con éxito la clase: solo cree una instancia de la clase y llame a las funciones relevantes para crear la base de datos.
if __name__ == '__main__':
sql = SQLData('localhost','yourdatabase','root','yourpassword')
sql.connect()
sql.create_tables()
sql.populate_tables()intenta hacer una consulta
Lo único que queda es: debemos verificar que nuestra base de datos esté en funcionamiento y que, de hecho, contenga algunos datos.
Comience con una consulta básica:
SELECT *
FROM jobs
LIMIT 10;
Resultados de la consulta básica [Imagen del autor]
Parece que nuestro script tuvo éxito y tenemos una base de datos con datos reales.
Ahora, intente una declaración SQL más compleja:
SELECT
p.first_name,
p.last_name,
p.salary,
j.description
FROM
persons AS p
JOIN
jobs AS j ON
p.job_id = j.job_id
WHERE
p.salary > 130000
ORDER BY
p.salary DESC;
Este resultado parece plausible: podemos decir que nuestra base de datos funciona correctamente.
En conclusión
En este artículo, aprendimos a utilizar Python y algunas bibliotecas externas para crear nuestra propia base de datos de práctica con datos generados aleatoriamente.
Si bien es fácil descargar una base de datos existente para comenzar a practicar SQL, crear su propia base de datos desde cero en Python brinda oportunidades de aprendizaje adicionales. Dado que SQL y Python suelen estar estrechamente vinculados, estas oportunidades de aprendizaje pueden ser particularmente útiles.
final
Este es el final de este intercambio ~ ¡Espero que pueda ser de alguna ayuda para usted! ! Si te gusta, recuerda darle al editor un seguimiento de tres líneas ♀️
El apoyo de la familia es la mayor motivación para que el editor actualice
