mysqldb - ¿Cómo me conecto a una base de datos MySQL en Python?
mysqldb python 3 (21)
¿Cómo me conecto a una base de datos MySQL usando un programa python?
Deje de usar MySQLDb si quiere evitar instalar encabezados mysql solo para acceder a mysql desde python.
Utilice pymysql . Hace todo lo que hace MySQLDb, pero se implementó únicamente en Python sin NINGUNAS dependencias externas . Esto hace que el proceso de instalación en todos los sistemas operativos sea consistente y fácil. pymysql es un reemplazo para MySQLDb y IMHO, no hay razón para usar MySQLDb para nada ... ¡NUNCA! - PTSD from installing MySQLDb on Mac OSX and *Nix systems , pero eso es solo yo.
Instalación
pip install pymysql
Eso es todo ... estás listo para jugar.
Ejemplo de uso de pymysql Github repo
import pymysql.cursors
import pymysql
# Connect to the database
connection = pymysql.connect(host=''localhost'',
user=''user'',
password=''passwd'',
db=''db'',
charset=''utf8mb4'',
cursorclass=pymysql.cursors.DictCursor)
try:
with connection.cursor() as cursor:
# Create a new record
sql = "INSERT INTO `users` (`email`, `password`) VALUES (%s, %s)"
cursor.execute(sql, (''[email protected]'', ''very-secret''))
# connection is not autocommit by default. So you must commit to save
# your changes.
connection.commit()
with connection.cursor() as cursor:
# Read a single record
sql = "SELECT `id`, `password` FROM `users` WHERE `email`=%s"
cursor.execute(sql, (''[email protected]'',))
result = cursor.fetchone()
print(result)
finally:
connection.close()
TAMBIÉN - Reemplace MySQLdb en el código existente de forma rápida y transparente
Si tiene un código existente que usa MySQLdb, puede reemplazarlo fácilmente con pymysql usando este simple proceso:
# import MySQLdb << Remove this line and replace with:
import pymysql
pymysql.install_as_MySQLdb()
Todas las referencias posteriores a MySQLdb usarán pymysql de forma transparente.
SqlAlchemy
SQLAlchemy es el kit de herramientas SQL de Python y el Mapeador relacional de objetos que ofrece a los desarrolladores de aplicaciones el máximo poder y flexibilidad de SQL. SQLAlchemy proporciona un conjunto completo de patrones de persistencia conocidos a nivel empresarial, diseñados para un acceso a bases de datos eficiente y de alto rendimiento, adaptados a un lenguaje de dominio simple y Pythonic.
Instalación
pip install sqlalchemy
Consulta RAW
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, scoped_session
engine = create_engine("mysql://<user_name>:<password>@<host_name>/<db_name>")
session_obj = sessionmaker(bind=engine)
session = scoped_session(session_obj)
# insert into database
session.execute("insert into person values(2, ''random_name'')")
session.flush()
session.commit()
Forma ORM
from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, scoped_session
Base = declarative_base()
engine = create_engine("mysql://<user_name>:<password>@<host_name>/<db_name>")
session_obj = sessionmaker(bind=engine)
session = scoped_session(session_obj)
# Bind the engine to the metadata of the Base class so that the
# declaratives can be accessed through a DBSession instance
Base.metadata.bind = engine
class Person(Base):
__tablename__ = ''person''
# Here we define columns for the table person
# Notice that each column is also a normal Python instance attribute.
id = Column(Integer, primary_key=True)
name = Column(String(250), nullable=False)
# insert into database
person_obj = Person(id=12, name="name")
session.add(person_obj)
session.flush()
session.commit()
Conectando a MYSQL con Python en 3 pasos
1 - Ajuste
Debe instalar un controlador MySQL antes de hacer nada. A diferencia de PHP, solo el controlador SQLite se instala de forma predeterminada con Python. El paquete más utilizado para hacerlo es MySQLdb pero es difícil de instalar con easy_install.
Para usuarios de Windows, puede obtener un exe de MySQLdb .
Para Linux, este es un paquete informal (python-mysqldb). (Puede usar sudo apt-get install python-mysqldb (para distribuciones basadas en debian), yum install MySQL-python (para rpm)) o dnf install python-mysql (para la distribución de fedora moderna) en la línea de comandos para descargar.)
Para Mac, puedes instalar MySQLdb usando Macport .
2 - Uso
Después de instalar, reinicie. Esto no es obligatorio, pero me impedirá responder 3 o 4 preguntas más en esta publicación si algo sale mal. Así que por favor reinicie.
Entonces es como usar cualquier otro paquete:
#!/usr/bin/python
import MySQLdb
db = MySQLdb.connect(host="localhost", # your host, usually localhost
user="john", # your username
passwd="megajonhy", # your password
db="jonhydb") # name of the data base
# you must create a Cursor object. It will let
# you execute all the queries you need
cur = db.cursor()
# Use all the SQL you like
cur.execute("SELECT * FROM YOUR_TABLE_NAME")
# print all the first cell of all the rows
for row in cur.fetchall():
print row[0]
db.close()
Por supuesto, hay miles de posibilidades y opciones; Este es un ejemplo muy básico. Tendrás que mirar la documentación. Un buen punto de partida .
3 - Uso más avanzado
Una vez que sepa cómo funciona, puede usar un ORM para evitar escribir SQL manualmente y manipular sus tablas como si fueran objetos de Python. El ORM más famoso en la comunidad de Python es SQLAlchemy .
Te aconsejo encarecidamente que lo uses: tu vida será mucho más fácil.
Recientemente descubrí otra joya en el mundo de Python: peewee . Es un ORM muy simple, realmente fácil y rápido de configurar y usar. Hace mi día para proyectos pequeños o aplicaciones independientes, donde usar herramientas grandes como SQLAlchemy o Django es excesivo:
import peewee
from peewee import *
db = MySQLDatabase(''jonhydb'', user=''john'', passwd=''megajonhy'')
class Book(peewee.Model):
author = peewee.CharField()
title = peewee.TextField()
class Meta:
database = db
Book.create_table()
book = Book(author="me", title=''Peewee is cool'')
book.save()
for book in Book.filter(author="me"):
print book.title
Este ejemplo funciona fuera de la caja. No se requiere nada más que tener peewee ( pip install peewee ).
A pesar de todas las respuestas anteriores, en caso de que no desee conectarse a una base de datos específica por adelantado, por ejemplo, si desea crear la base de datos aún (!), Puede usar connection.select_db(database) , como se muestra a continuación.
import pymysql.cursors
connection = pymysql.connect(host=''localhost'',
user=''mahdi'',
password=''mahdi'',
charset=''utf8mb4'',
cursorclass=pymysql.cursors.DictCursor)
cursor = connection.cursor()
cursor.execute("CREATE DATABASE IF NOT EXISTS "+database)
connection.select_db(database)
sql_create = "CREATE TABLE IF NOT EXISTS "+tablename+(timestamp DATETIME NOT NULL PRIMARY KEY)"
cursor.execute(sql_create)
connection.commit()
cursor.close()
Aquí hay una forma de hacerlo:
#!/usr/bin/python
import MySQLdb
# Connect
db = MySQLdb.connect(host="localhost",
user="appuser",
passwd="",
db="onco")
cursor = db.cursor()
# Execute SQL select statement
cursor.execute("SELECT * FROM location")
# Commit your changes if writing
# In this case, we are only reading data
# db.commit()
# Get the number of rows in the resultset
numrows = cursor.rowcount
# Get and display one row at a time
for x in range(0, numrows):
row = cursor.fetchone()
print row[0], "-->", row[1]
# Close the connection
db.close()
Como un controlador de db, también hay oursql . Algunas de las razones enumeradas en ese enlace, que dicen por qué es mejor nuestro sql:
- Oursql tiene una parametrización real, enviando el SQL y los datos a MySQL por separado.
- oursql permite que los datos de texto o binarios se transmitan a la base de datos y se extraigan de la base de datos, en lugar de requerir que todo se almacene en el búfer en el cliente.
- Oursql puede tanto insertar filas perezosamente como recuperar filas perezosamente.
- Oursql tiene compatibilidad con Unicode de forma predeterminada.
- oursql admite Python 2.4 a 2.7 sin advertencias de desaprobación en 2.6+ (ver PEP 218) y sin fallar completamente en 2.7 (ver PEP 328).
- Oursql se ejecuta de forma nativa en Python 3.x.
Entonces, ¿cómo conectarse a mysql con oursql?
Muy similar a mysqldb:
import oursql
db_connection = oursql.connect(host=''127.0.0.1'',user=''foo'',passwd=''foobar'',db=''db_name'')
cur=db_connection.cursor()
cur.execute("SELECT * FROM `tbl_name`")
for row in cur.fetchall():
print row[0]
El tutorial en la documentación es bastante decente.
Y, por supuesto, para ORM SQLAlchemy es una buena opción, como ya se mencionó en las otras respuestas.
Intenta usar MySQLdb
Hay una página de cómo hacerlo aquí: http://www.kitebird.com/articles/pydbapi.html
Desde la página:
# server_version.py - retrieve and display database server version
import MySQLdb
conn = MySQLdb.connect (host = "localhost",
user = "testuser",
passwd = "testpass",
db = "test")
cursor = conn.cursor ()
cursor.execute ("SELECT VERSION()")
row = cursor.fetchone ()
print "server version:", row[0]
cursor.close ()
conn.close ()
La mejor manera de conectarse a MySQL desde Python es Usar MySQL Connector / Python porque es el controlador oficial de Oracle para MySQL para trabajar con Python y funciona tanto con Python 3 como con Python 2.
siga los pasos mencionados a continuación para conectar MySQL
instale el conector usando pip
pip install mysql-connector-python
o puede descargar el instalador desde https://dev.mysql.com/downloads/connector/python/
Use el método
connect()de mysql connector python para conectarse a MySQL. Pase el argumento requerido paraconnect(). Ej. Host, nombre de usuario, contraseña y nombre de base de datos.Cree el objeto del
cursorpartir del objeto de conexión devuelto por el métodoconnect()para ejecutar consultas SQL.Cierre la conexión después de que su trabajo se complete.
Ejemplo :
import mysql.connector
from mysql.connector import Error
try:
conn = mysql.connector.connect(host=''hostname'',
database=''db'',
user=''root'',
password=''passcode'')
if conn.is_connected():
cursor = conn.cursor()
cursor.execute("select database();")
record = cursor.fetchall()
print ("Your connected to - ", record)
except Error as e :
print ("Print your error msg", e)
finally:
#closing database connection.
if(conn.is_connected()):
cursor.close()
conn.close()
Referencia: https://pynative.com/python-mysql-database-connection/
API importante de MySQL Connector Python
Para operaciones DML: use
cursor.execute()ycursor.executemany()para ejecutar la consulta. y después de esto, useconnection.commit()para conservar sus cambios en la base de datos.Para recuperar datos: use
cursor.execute()para ejecutar query ycursor.fetchall(),cursor.fetchone(),cursor.fetchmany(SIZE)para recuperar datos
Oracle (MySQL) ahora es compatible con un conector de Python puro. Eso significa que no hay que instalar binarios: es solo una biblioteca de Python. Se llama "Conector / Python".
Para escribir aplicaciones de base de datos en Python, hay cinco pasos a seguir:
Importe la interfaz SQL con el siguiente comando:
>>> import MySQLdb
Establezca una conexión con la base de datos con el siguiente comando:
conn = MySQLdb.connect (host = ''localhost'', user = ''root'', passwd = '''') ... donde host es el nombre de su máquina host, seguido del nombre de usuario y la contraseña. En el caso de la raíz, no es necesario proporcionar una contraseña.
Crea un cursor para la conexión con el siguiente comando:
>>>cursor = conn.cursor()
Ejecute cualquier consulta SQL usando este cursor como se muestra a continuación; aquí, los resultados en términos de muestran un número de filas afectadas por esta consulta:
cursor.execute (''Crear base de datos biblioteca'') // Indica cuántas filas afectadas
>>> cursor.execute(''use Library'')
>>>table=''create table books(book_accno char(30) primary key, book_name
char(50),no_of_copies int(5),price int(5))''
>>> cursor.execute(table)
Finalmente, obtenga el conjunto de resultados e itere sobre este conjunto de resultados. En este paso, el usuario puede obtener los conjuntos de resultados como se muestra a continuación:
>>> cursor.execute(''select * from books'')
>>> cursor.fetchall()
((''Py9098'', ''Programming With Python'', 100L, 50L), (''Py9099'', ''Programming With Python'', 100L, 50L))
Para python 3.3
CyMySQL https://github.com/nakagami/CyMySQL
Tengo pip instalado en mi Windows 7, solo instale cymysql
(no necesitas cython) rápido y sin dolor
Primero, instale el conector python-mysql desde https://dev.mysql.com/downloads/connector/python/
en la consola de Python ingrese:
pip install mysql-connector-python-rf
import mysql.connector
Puedes conectar tu código python a mysql de esta manera.
import MySQLdb
db = MySQLdb.connect(host="localhost",
user="appuser",
passwd="",
db="onco")
cursor = db.cursor()
Sólo una modificación en la respuesta anterior. Simplemente ejecute este comando para instalar mysql para python
sudo yum install MySQL-python
sudo apt-get install MySQL-python
¡recuerda! Es sensible a mayúsculas y minúsculas.
Si no necesita MySQLdb, pero aceptaría cualquier biblioteca, le recomendaría mucho, MySQL Connector / Python de MySQL: http://dev.mysql.com/downloads/connector/python/ .
Es un paquete (alrededor de 110 k), puro Python, por lo que es independiente del sistema y es muy sencillo de instalar. Simplemente descargue, haga doble clic, confirme el acuerdo de licencia y listo. No hay necesidad de Xcode, MacPorts, compilación, reinicio ...
Entonces te conectas como
import mysql.connector
cnx = mysql.connector.connect(user=''scott'', password=''tiger'',
host=''127.0.0.1'',
database=''employees'')
try:
cursor = cnx.cursor()
cursor.execute("""
select 3 from your_table
""")
result = cursor.fetchall()
print result
finally:
cnx.close()
También eche un vistazo a Storm . Es una herramienta de asignación de SQL simple que le permite editar y crear fácilmente entradas de SQL sin escribir las consultas.
Aquí hay un ejemplo simple:
from storm.locals import *
# User will be the mapped object; you have to create the table before mapping it
class User(object):
__storm_table__ = "user" # table name
ID = Int(primary=True) #field ID
name= Unicode() # field name
database = create_database("mysql://root:password@localhost:3306/databaseName")
store = Store(database)
user = User()
user.name = u"Mark"
print str(user.ID) # None
store.add(user)
store.flush() # ID is AUTO_INCREMENT
print str(user.ID) # 1 (ID)
store.commit() # commit all changes to the database
Para buscar y objetar uso:
michael = store.find(User, User.name == u"Michael").one()
print str(user.ID) # 10
Encontrar con clave primaria:
print store.get(User, 1).name #Mark
Para más información ver el tutorial .
mysqlclient es el mejor ya que otros solo brindan soporte para versiones específicas de python
pip install mysqlclient
código de ejemplo
import mysql.connector
import _mysql
db=_mysql.connect("127.0.0.1","root","umer","sys")
#db=_mysql.connect(host,user,password,db)
# Example of how to insert new values:
db.query("""INSERT INTO table1 VALUES (''01'', ''myname'')""")
db.store_result()
db.query("SELECT * FROM new1.table1 ;")
#new1 is scheme table1 is table mysql
res= db.store_result()
for i in range(res.num_rows()):
print(result.fetch_row())
para Python3.6 encontré dos controladores: pymysql y mysqlclient. Probé el rendimiento entre ellos y obtuve el resultado: mysqlclient es más rápido.
a continuación se encuentra mi proceso de prueba (necesito instalar las activaciones de perfil lib de python para analizar el tiempo transcurrido:
raw sql: select * from FOO;
Ejecutar inmediatamente en el terminal mysql: 46410 rows in set (0.10 sec)
pymysql (2.4s):
from profilehooks import profile
import pymysql.cursors
import pymysql
connection = pymysql.connect(host=''localhost'', user=''root'', db=''foo'')
c = connection.cursor()
@profile(immediate=True)
def read_by_pymysql():
c.execute("select * from FOO;")
res = c.fetchall()
read_by_pymysql()
mysqlclient (0.4s)
from profilehooks import profile
import MySQLdb
connection = MySQLdb.connect(host=''localhost'', user=''root'', db=''foo'')
c = connection.cursor()
@profile(immediate=True)
def read_by_mysqlclient():
c.execute("select * from FOO;")
res = c.fetchall()
read_by_mysqlclient()
Aquí está el perfil mysqlclient:
Entonces, parece que mysqlclient es mucho más rápido que pymysql
primero instala el controlador
pip install MySQL-python
Entonces un código básico es el siguiente:
#!/usr/bin/python
import MySQLdb
try:
db = MySQLdb.connect(host="localhost", # db server, can be a remote one
db="mydb" # database
user="mydb", # username
passwd="mydb123", # password for this username
)
# Create a Cursor object
cur = db.cursor()
# Create a query string. It can contain variables
query_string = "SELECT * FROM MY_TABLE"
# Execute the query
cur.execute(query_string)
# Get all the rows present the database
for each_row in cur.fetchall():
print each_row
# Close the connection
db.close()
except Exception, e:
print ''Error '', e
MySQLdb es la forma más sencilla. Tienes la oportunidad de ejecutar consultas SQL a través de una conexión. Período.
Mi forma preferida, que también es pythonic, es usar el poderoso SQLAlchemy lugar. Aquí hay un tutorial relacionado con la consulta , y aquí hay un tutorial sobre las capacidades ORM de SQLALchemy.
Primero instale el controlador (Ubuntu)
sudo apt-get install python-pip
sudo pip install -u pip
sudo apt-get install python-dev libmysqlclient-dev
sudo apt-get install MySQL-python
Códigos de conexión de base de datos MySQL
import MySQLdb
conn = MySQLdb.connect (host = "localhost",user = "root",passwd = "pass",db = "dbname")
cursor = conn.cursor ()
cursor.execute ("SELECT VERSION()")
row = cursor.fetchone ()
print "server version:", row[0]
cursor.close ()
conn.close ()