¿Cómo me conecto a una base de datos MySQL usando un programa python?
pymysql
porque es Python libre de acuerdo con esta comparación .
¿Cómo me conecto a una base de datos MySQL usando un programa python?
pymysql
porque es Python libre de acuerdo con esta comparación .
Respuestas:
1 - Configuración
Debe instalar un controlador MySQL antes de hacer algo. A diferencia de PHP, solo el controlador SQLite se instala de manera predeterminada con Python. El paquete más utilizado para hacerlo es MySQLdb, pero es difícil instalarlo usando easy_install. Tenga en cuenta que MySQLdb solo es compatible con Python 2.
Para el usuario de Windows, puede obtener un exe de MySQLdb .
Para Linux, este es un paquete informal (python-mysqldb). (Puede utilizar sudo apt-get install python-mysqldb
(para distribuciones basadas en Debian), yum install MySQL-python
(para distribuciones basadas en rpm) o dnf install python-mysql
(para distribuciones modernas de Fedora) en la línea de comandos para descargar).
Para Mac, puede instalar MySQLdb usando Macport .
2 - Uso
Después de la instalación, reinicie. Esto no es obligatorio, pero me impedirá responder 3 o 4 preguntas más en esta publicación si algo sale mal. Entonces, 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, es posible que desee utilizar un ORM para evitar escribir SQL manualmente y manipular sus tablas como si fueran objetos de Python. El ORM más famoso de la comunidad Python es SQLAlchemy .
Le recomiendo encarecidamente que lo use: su vida será mucho más fácil.
Recientemente descubrí otra joya en el mundo de Python: peewee . Es un ORM muy ligero, realmente fácil y rápido de configurar y usar. Me hace el 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 pip install peewee
se requiere nada más que tener pipí ( ).
pip install MySQL-python
Aquí hay una forma de hacerlo, utilizando MySQLdb , que solo es compatible con Python 2:
#!/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()
No module named MySQLdb
. ¿Cómo puedo usar mysql con python en hosting compartido? Alguna alternativa?
Oracle (MySQL) ahora admite un conector Python puro. Eso significa que no hay binarios para instalar: es solo una biblioteca de Python. Se llama "Conector / Python".
Si no necesita MySQLdb, pero aceptaría cualquier biblioteca, le recomendaría muchísimo MySQL Connector / Python de MySQL: http://dev.mysql.com/downloads/connector/python/ .
Es un paquete (alrededor de 110k), Python puro, por lo que es independiente del sistema y fácil de instalar. Simplemente descargue, haga doble clic, confirme el acuerdo de licencia y listo. No hay necesidad de Xcode, MacPorts, compilar, reiniciar ...
Luego 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()
rpm -i mysql-connector-python-1.1.5-1.el6.noarch.rpm
error: Failed dependencies:
rpmlib(FileDigests) <= 4.6.0-1 is needed by mysql-connector-python-1.1.5-1.el6.noarch
rpmlib(PayloadIsXz) <= 5.2-1 is needed by mysql-connector-python-1.1.5-1.el6.noarch
pip install mysql-connector-python
También funcionará. No veo donde dice que ya no es compatible con PyPi. Excelente si no tiene acceso a los compiladores gcc / C en su sistema y, por lo tanto, no puede instalarlo mysqldb
.
pip search mysql-connector
para encontrar el nombre del paquete. respuesta desde aquí: stackoverflow.com/a/22829966/2048266
Deje de usar MySQLDb si desea evitar la instalación de encabezados mysql solo para acceder a mysql desde python.
Usa pymysql . Hace todo lo que hace MySQLDb, pero se implementó únicamente en Python sin dependencias externas . Esto hace que el proceso de instalación en todos los sistemas operativos sea consistente y fácil. pymysql
es una caída en el reemplazo de MySQLDb y en mi humilde opinión, no hay razón para usar MySQLDb para nada ... ¡NUNCA! - PTSD from installing MySQLDb on Mac OSX and *Nix systems
, pero solo soy yo.
Instalación
pip install pymysql
Eso es todo ... ya estás listo para jugar.
Ejemplo de uso del repositorio pymysql Github
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, ('webmaster@python.org', '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, ('webmaster@python.org',))
result = cursor.fetchone()
print(result)
finally:
connection.close()
TAMBIÉN - Reemplace MySQLdb en código existente de forma rápida y transparente
Si tiene un código existente que usa MySQLdb, puede reemplazarlo fácilmente con pymysql mediante este sencillo proceso:
# import MySQLdb << Remove this line and replace with:
import pymysql
pymysql.install_as_MySQLdb()
Todas las referencias posteriores a MySQLdb utilizarán pymysql de forma transparente.
Intenta usar MySQLdb . MySQLdb solo es compatible con Python 2.
Hay una página de instrucciones aquí: http://www.kitebird.com/articles/pydbapi.html
De 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 ()
localhost
)?
Como controlador de base de datos, también existe ourql . Algunas de las razones enumeradas en ese enlace, que dicen por qué ourql es mejor:
- ourql tiene una parametrización real, enviando el SQL y los datos a MySQL completamente por separado.
- ourql permite que el texto o los datos binarios se transmitan a la base de datos y se transmitan fuera de la base de datos, en lugar de requerir que todo se guarde en el cliente.
- ourql puede insertar filas perezosamente y buscar filas perezosamente.
- ourql tiene soporte Unicode activado por defecto.
- OurSQL soporta 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).
- ourql se ejecuta de forma nativa en python 3.x.
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.
Ejecute este comando en su terminal para instalar el conector mysql:
pip install mysql-connector-python
Y ejecute esto en su editor de Python para conectarse a MySQL:
import mysql.connector
mydb = mysql.connector.connect(
host="localhost",
user="yusername",
passwd="password",
database="database_name"
)
Muestras para ejecutar Comandos MySQL (en su editor python):
mycursor = mydb.cursor()
mycursor.execute("CREATE TABLE customers (name VARCHAR(255), address VARCHAR(255))")
mycursor.execute("SHOW TABLES")
mycursor.execute("INSERT INTO customers (name, address) VALUES ('John', 'Highway 21')")
mydb.commit() # Use this command after insert or update
Para más comandos: https://www.w3schools.com/python/python_mysql_getstarted.asp
mysql-connector
solo con. stackoverflow.com/questions/59405740/…
mydb.commit()
después de insertar valores en la tabla
SQLAlchemy es el kit de herramientas Python SQL y Object Relational Mapper que brinda a los desarrolladores de aplicaciones toda la potencia y flexibilidad de SQL. SQLAlchemy proporciona un conjunto completo de patrones de persistencia de nivel empresarial bien conocidos, diseñados para un acceso eficiente y de alto rendimiento a la base de datos, adaptado a un lenguaje de dominio simple y pitónico.
pip install sqlalchemy
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()
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()
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 (!), Puede usarla connection.select_db(database)
, como se demuestra 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()
MySQLdb es la forma más sencilla. Puede ejecutar consultas SQL a través de una conexión. Período.
Mi forma preferida, que también es pitónica, es usar la poderosa SQLAlchemy en su lugar. Aquí hay un tutorial relacionado con consultas , y aquí hay un tutorial sobre las capacidades ORM de SQLALchemy.
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 está mi proceso de prueba (necesito instalar python lib profilehooks para analizar el tiempo transcurrido :
sql sin procesar: select * from FOO;
Ejecutar inmediatamente en la 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 de mysqlclient:
Entonces, parece que mysqlclient es mucho más rápido que pymysql
Aunque algunos de ustedes pueden marcar esto como un duplicado y molestarse porque estoy copiando la respuesta de otra persona, REALMENTE me gustaría resaltar un aspecto de la respuesta del Sr. Napik. Como me perdí esto, causé el tiempo de inactividad del sitio web a nivel nacional (9 minutos). Si solo alguien compartiera esta información, ¡podría haberlo evitado!
Aquí está su código:
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()
Lo importante aquí es la cláusula Try and Finalmente . Esto permite que las conexiones a SIEMPRE se cierren, independientemente de lo que suceda en la porción de cursor / sqlstatement del código. Muchas conexiones activas hacen que DBLoadNoCPU se dispare y podría bloquear un servidor db.
¡Espero que esta advertencia ayude a salvar servidores y, en última instancia, trabajos! :RE
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 connect()
método del conector python de mysql para conectarse a MySQL. Pase el argumento requerido al connect()
método. es decir, host, nombre de usuario, contraseña y nombre de la base de datos.
Cree un cursor
objeto a partir del objeto de conexión devuelto por el connect()
método para ejecutar consultas SQL.
cierre la conexión después de que termine su trabajo.
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 ("You're 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()
y cursor.executemany()
para ejecutar la consulta. y después de este uso connection.commit()
para persistir sus cambios a DB
Para obtener los datos - Uso cursor.execute()
de ejecutar la consulta y cursor.fetchall()
, cursor.fetchone()
, cursor.fetchmany(SIZE)
para obtener los datos
Solo 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.
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())
mysql.connector
y _mysql
dar a ambos un error de importación (aunque la segunda opción debería funcionar de acuerdo con la documentación). import MySQLdb
funciona, y luegoMySQLdb.connect...
También eche un vistazo a Storm . Es una herramienta de mapeo SQL simple que le permite editar y crear fácilmente entradas 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 usar objetos:
michael = store.find(User, User.name == u"Michael").one()
print str(user.ID) # 10
Buscar con clave principal:
print store.get(User, 1).name #Mark
Para más información ver el tutorial .
Esta es la conexión Mysql DB
from flask import Flask, render_template, request
from flask_mysqldb import MySQL
app = Flask(__name__)
app.config['MYSQL_HOST'] = 'localhost'
app.config['MYSQL_USER'] = 'root'
app.config['MYSQL_PASSWORD'] = 'root'
app.config['MYSQL_DB'] = 'MyDB'
mysql = MySQL(app)
@app.route('/', methods=['GET', 'POST'])
def index():
if request.method == "POST":
details = request.form
cur = mysql.connection.cursor()
cur.execute ("_Your query_")
mysql.connection.commit()
cur.close()
return 'success'
return render_template('index.html')
if __name__ == '__main__':
app.run()
primero instale el controlador
pip install MySQL-python
Entonces un código básico es así:
#!/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
Puede conectar su código de Python a MySQL de esta manera.
import MySQLdb
db = MySQLdb.connect(host="localhost",
user="appuser",
passwd="",
db="onco")
cursor = db.cursor()
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 ()
Para python 3.3
CyMySQL https://github.com/nakagami/CyMySQL
Tengo pip instalado en mi Windows 7, solo pip install cymysql
(no necesitas cython) rápido e indoloro
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