Cómo podemos ejecutar la consulta mysql en Python
Antes del inicio, tenemos que instalar el conector MySQL en nuestro entorno de sistema local.
Hay dos métodos para instalar:
Método 1:
Podemos descargar directamente e instalar el conector MySQL desde su sitio web oficial de acuerdo con nuestra compatibilidad y versión del sistema operativo.
Método_2:
La forma fácil es usar el método PIP.
PIP Instale MySQL-Connector-PythonSi estamos utilizando alguna versión en particular, entonces tenemos que asignar el nombre de la versión como se da a continuación:
PIP install MySQL-Connector-Python ==Creación de conexión:
Ahora, en el primer paso después de la instalación exitosa de MySQL a nuestro sistema local, intentamos crear una conexión. Si la conexión es exitosa, entonces podemos pasar al siguiente paso.
#python EastAblish_connection.py#Importa la biblioteca
importar mysql.conector
# Creación de conexión
Conn = mySQL.conector.conectar(
host = "localhost",
user = "Sammy",
contraseña = "contraseña"
)
# imprime la conexión
Imprimir (Conn)
Producción:
Línea 4:
Importamos la clase de conector de mysql.
Línea 7 a 11:
Accedemos al método de conexión a través de la clase de conector, que ya importamos a nuestro programa. Ahora, estamos pasando nuestros parámetros de conexión al método de conexión. El nombre de usuario y la contraseña serán diferentes según su proceso de instalación.
Línea 13:
Por fin, simplemente imprimimos la conexión y se muestra en la conexión de salida realizada al MySQL, y devuelve un objeto con su dirección de memoria.
Crear una base de datos:
Ahora, creamos una base de datos con la ayuda de Python.
#python create_a_database.py#Importa la biblioteca
importar mysql.conector
# Creación de conexión
Conn = mySQL.conector.conectar(
host = "localhost",
user = "Sammy",
contraseña = "contraseña"
)
#Imprima la conexión
Imprimir (Conn)
# Importar el cursor desde la conexión (Conn)
Micursor = Conn.cursor()
#Print el micursor
Imprimir (micrursor)
micursor.ejecutar ("Crear base de datos dBtest")
Producción:
CMYSQLCURSOR: (Nada ejecutado todavía)
Línea 16:
Importamos el método cursor desde el objeto de conexión establecida (Conn).
Línea 18:
Ahora, solo imprimimos este micursor que creamos en la línea 16, y la salida muestra que CMYSQLCURSOR: (nada ejecutado todavía).
Línea 20:
Estamos ejecutando una consulta para crear una base de datos, pero no devuelve nada. Entonces, si imprimimos (Micursor.Ejecutar ("Crear base de datos dbtest")), no obtendremos ninguno como tipo de retorno.
Si verificamos nuestra base de datos MySQL, podemos ver que nuestra nueva base de datos (DBTEST) se crea con éxito.
➜ ~ mysql -u sammy -pIntroducir la contraseña:
Bienvenido al monitor MySQL. Los comandos terminan con; o \ g.
Tu ID de conexión mysql es 17
Versión del servidor: 8.0.26-0ubuntu0.20.04.2 (Ubuntu)
Copyright (c) 2000, 2021, Oracle y/o sus afiliados.
Oracle es una marca registrada de Oracle Corporation y/o su
afiliados. Otros nombres pueden ser marcas registradas de sus respectivos
propietarios.
Escriba 'ayuda;' o '\ h' por ayuda. Escriba '\ c' para borrar la instrucción de entrada actual.
MySQL> Mostrar bases de datos;
+--------------------+
| Base de datos |
+--------------------+
| dBtest |
| Information_schema |
| mysql |
| Performance_schema |
| SYS |
+--------------------+
5 filas en el set (0.00 seg)
mysql>
Conexión a la base de datos:
Ahora, estamos tratando de conectarnos con nuestra recién creada base de datos (DBTest) con Python. El código para esto se da a continuación:
#python conn_to_database.py#Importa la biblioteca
importar mysql.conector
# Crear conexión a la base de datos
Conn = mySQL.conector.conectar(
host = "localhost",
user = "Sammy",
contraseña = "contraseña",
base de datos = "dbtest"
)
# imprime la conexión
Imprimir (Conn)
Línea 11:
Agregamos un nombre de parámetro más a la base de datos. Ahora, nuestro código Python intentará conectarse con esta base de datos MySQL (DBTEST) solamente.
Crea una tabla:
- Creemos una nueva mesa (película) en la base de datos recién creada (DBTest).
- Las tres columnas que vamos a usar son ID, nombre y año. La identificación y el año serán int (entero), y el nombre será tipo varchar. También definiremos una columna (ID) como clave principal.
- El nombre de la columna almacenará el número máximo de caracteres 30, ya que definimos Varchar (30).
#Importa la biblioteca
importar mysql.conector
# Crear conexión a la base de datos
Conn = mySQL.conector.conectar(
host = "localhost",
user = "Sammy",
contraseña = "contraseña",
base de datos = "dbtest"
)
# Creamos un objeto micursor usando la conexión.cursor()
Micursor = Conn.cursor()
micursor.Ejecutar ("Drop Table If Existe Movie")
# Escribimos una consulta para crear una mesa
QUERY = "Crear película de tabla (ID int primario, nombre Varchar (30), año int)"
# Ejecutamos la consulta aquí
micursor.ejecutar la solicitud)
# Después de realizar el proceso, cerramos la conexión
conn.cerca()
Línea 14:
Creamos un objeto del cursor.
Línea 15:
También estamos ejecutando una consulta aquí con el método de ejecución que si el nombre de la tabla (película) ya existe en la base de datos MySQL, eliminará esa tabla. De lo contrario, recibiremos el error que ya existe.
Línea 18 a 21:
Creamos una consulta para crear una tabla y ejecutar esa consulta en la línea número 21 con la función de ejecución.
Línea 24:
Por fin, cerramos nuestra conexión.
A continuación se muestra la salida MySQL, donde confirmamos que nuestra tabla se crea con éxito dentro de la base de datos MySQL.
MySQL> Mostrar bases de datos;+--------------------+
| Base de datos |
+--------------------+
| dBtest |
| Information_schema |
| mysql |
| Performance_schema |
| SYS |
+--------------------+
5 filas en el set (0.00 seg)
mysql> usar dbtest;
Lectura de la información de la tabla para completar los nombres de la tabla y la columna
Puede desactivar esta función para obtener una inicio más rápida con -a
Base de datos cambiada
MySQL> Mostrar tablas;
+------------------+
| Tablas_in_dbtest |
+------------------+
| Película |
+------------------+
1 fila en el set (0.00 seg)
mysql> seleccionar * de la película;
Conjunto vacío (0.00 seg)
mysql> seleccionar * de la película;
Error 1146 (42S02): tabla 'dbtest.Película 'no existe
MySQL> Desc Película;
+-------+-------------+------+-----+---------+-------+
| Campo | Tipo | NULL | Clave | Predeterminado | Extra |
+-------+-------------+------+-----+---------+-------+
| ID | int | No | PRI | NULL | |
| nombre | Varchar (30) | SÍ | | NULL | |
| año | int | SÍ | | NULL | |
+-------+-------------+------+-----+---------+-------+
3 filas en el set (0.00 seg)
mysql>
Agregue un registro a la tabla:
Ahora, vamos a insertar un registro en la tabla. El código de Python para eso se da a continuación.
#Python Record_insertion.py#Importa la biblioteca
importar mysql.conector
# Crear conexión a la base de datos
Conn = mySQL.conector.conectar(
host = "localhost",
user = "Sammy",
contraseña = "contraseña",
base de datos = "dbtest"
)
Micursor = Conn.cursor()
# Ejecutar la consulta con su valor registrado
Query = 'Insertar en la película (ID, nombre, año) \
Valores (1, "Bruce Todopoderoso", 2003) '
micursor.ejecutar la solicitud)
# cometimos (guardamos) los registros en la tabla
conn.comprometerse()
Línea 17:
Creamos una consulta para insertar un disco en la película de la mesa.
Línea 19:
Ejecutamos esa consulta.
Línea 22:
Por fin cometimos el récord.
Producción:
La siguiente salida muestra que hemos grabado con éxito insertado en la película de la tabla.
mysql> seleccionar * de la película;+----+----------------+------+
| ID | nombre | año |
+----+----------------+------+
| 1 | Bruce Todopoderoso | 2003 |
+----+----------------+------+
1 fila en el set (0.00 seg)
mysql>
Inserción de registros múltiples:
También podemos agregar múltiples registros a la vez en la tabla. Entonces, en este programa, vamos a ver ese método. Para ingresar los registros múltiples, tenemos que usar el método ExecutEMany () en lugar del método Execute ().
#python insert_record_multiple.py#Importa la biblioteca
importar mysql.conector
# Crear conexión a la base de datos
Conn = mySQL.conector.conectar(
host = "localhost",
user = "Sammy",
contraseña = "contraseña",
base de datos = "dbtest"
)
Micursor = Conn.cursor()
# Ejecutar la consulta con su valor registrado
Query = 'Insertar en la película (ID, nombre, año) Valores ( %s, %s, %s)'
Val = [(2, "Kung Fu Panda", 2014),
(4, "Frozen", 2014),
(5, "Frozen2", 2020),
(6, "Iron Man", 2013)
]
micursor.Executemany (consulta, val)
# cometimos (guardamos) los registros en la tabla
conn.comprometerse()
Imprimir (micrursor.RowCount, "Registro (s) insertado.")
Línea 17:
Creamos nuestra consulta para los datos de inserción.
Línea 18:
Creamos una lista de valores que queremos insertar en la tabla.
Línea 25:
Utilizamos el método ExeckEmany () para ingresar los múltiples registros.
Producción:
mysql> seleccionar * de la película;+----+----------------+------+
| ID | nombre | año |
+----+----------------+------+
| 1 | Bruce Todopoderoso | 2003 |
| 2 | Kung Fu Panda | 2014 |
| 3 | Kung Fu Panda | 2014 |
| 4 | Congelado | 2014 |
| 5 | Frozen2 | 2020 |
| 6 | Iron Man | 2013 |
+----+----------------+------+
6 filas en el set (0.00 seg)
Seleccione el registro de la tabla:
En este programa, agregaremos otra consulta seleccionar para obtener los registros de la tabla.
#python select_query.py#Importa la biblioteca
importar mysql.conector
# Crear conexión a la base de datos
Conn = mySQL.conector.conectar(
host = "localhost",
user = "Sammy",
contraseña = "contraseña",
base de datos = "dbtest"
)
Micursor = Conn.cursor()
# Ejecutar la consulta y obtener todos los registros
consulta = 'Seleccionar * de la película'
micursor.ejecutar la solicitud)
resultado = micrursor.Fetchall ()
# Imprimimos nuestro resultado
Imprimir (resultado)
# Ahora, hacemos iteración en cada registro e imprimimos
Para el registro en el resultado:
Imprimir (registro)
Línea 17 a 19:
Creamos una consulta seleccionada y ejecutamos esa consulta. El método fetchall () se usa para obtener todos los registros de esa tabla en particular.
Línea 22:
Imprimimos el resultado y encontramos que todos los registros son tupla y dentro de una lista. La siguiente salida está mostrando la lista.
Línea 25 a 26:
Iteramos la lista e imprimimos cada registro de tupla.
Producción:
[(1, 'Bruce Allophouty', 2003), (2, 'Kung Fu Panda', 2014), (3, 'Kung Fu Panda', 2014), (4, 'Frozen', 2014), (5, ' Frozen2 ', 2020), (6,' Iron Man ', 2013)](1, 'Bruce Todopoderoso', 2003)
(2, 'Kung Fu Panda', 2014)
(3, 'Kung Fu Panda', 2014)
(4, 'Frozen', 2014)
(5, 'Frozen2', 2020)
(6, 'Iron Man', 2013)
Conclusión:
En este artículo, hemos visto cómo crear una conexión con MySQL usando Python. También estudiamos los diferentes métodos de inserción de datos, como las inserciones de registros de datos simples o múltiples en la tabla. También hemos visto cómo podemos ejecutar la consulta a través de Python. Tenemos que crear una consulta y luego pasar esa consulta al método Execute () para la ejecución y almacenar que resulte a alguna variable.
El código de este artículo está disponible en el enlace GitHub:
https: // github.com/shekharpandey89/mysql-query-connection