Como eu me conecto a um banco de dados MySQL usando um programa python?

Conectando-se ao MYSQL com Python 2 em três etapas

1 - Configuração

Você deve instalar um driver MySQL antes de fazer qualquer coisa. Ao contrário do PHP, apenas o driver SQLite é instalado por padrão com o Python. O pacote mais usado para fazer isso é o MySQLdb, mas é difícil instalá-lo usando o easy_install. Observe que o MySQLdb suporta apenas Python 2.

Para usuários do Windows, você pode obter um exe do MySQLdb .

Para Linux, este é um pacote casual (python-mysqldb). (Você pode usar sudo apt-get install python-mysqldb(para distros baseados no debian), yum install MySQL-python(para rpm) ou dnf install python-mysql(para a distribuição moderna do fedora) na linha de comando para fazer o download.)

No Mac, você pode instalar o MySQLdb usando o Macport .

2 - Uso

Após a instalação, reinicie. Isso não é obrigatório, mas me impedirá de responder 3 ou 4 outras perguntas neste post, se algo der errado. Então, por favor, reinicie.

Então é como usar qualquer outro pacote:

#!/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()

Claro, existem milhares de possibilidades e opções; este é um exemplo muito básico. Você terá que olhar para a documentação. Um bom ponto de partida .

3 - Uso mais avançado

Depois de saber como ele funciona, convém usar um ORM para evitar a gravação manual do SQL e manipular suas tabelas como se fossem objetos Python. O ORM mais famoso da comunidade Python é o SQLAlchemy .

Eu recomendo fortemente que você a use: sua vida será muito mais fácil.

Eu descobri recentemente outra jóia no mundo Python: peewee . É um ORM muito simples, muito fácil e rápido de configurar e usar. Faz o meu dia para pequenos projetos ou aplicativos independentes, onde o uso de grandes ferramentas como SQLAlchemy ou Django é um exagero:

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 exemplo funciona imediatamente. Nada além de ter peewee ( pip install peewee) é necessário.

Aqui está uma maneira de fazer isso, usando o MySQLdb , que suporta apenas o 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()

Referência aqui

O Oracle (MySQL) agora suporta um conector Python puro. Isso significa que não há binários para instalar: é apenas uma biblioteca Python. Chama-se "Connector / Python".

http://dev.mysql.com/downloads/connector/python/

Se você não precisa do MySQLdb, mas aceita qualquer biblioteca, eu recomendaria muito, muito, o MySQL Connector / Python do MySQL: http://dev.mysql.com/downloads/connector/python/ .

É um pacote (cerca de 110k), puro Python, por isso é independente do sistema e simples de instalar. Você acabou de baixar, clicar duas vezes, confirmar o contrato de licença e partir. Não há necessidade de Xcode, MacPorts, compilar, reiniciar…

Então você se conecta 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()

Pare de usar o MySQLDb se você deseja evitar a instalação de cabeçalhos mysql apenas para acessar o mysql a partir do python.

Use pymysql . Ele faz tudo o que o MySQLDb faz, mas foi implementado puramente em Python sem dependências externas . Isso torna o processo de instalação em todos os sistemas operacionais consistente e fácil. pymysqlé uma queda no substituto do MySQLDb e IMHO, não há razão para usar o MySQLDb para nada ... NUNCA! - PTSD from installing MySQLDb on Mac OSX and *Nix systems, mas sou só eu.

Instalação

pip install pymysql

É isso aí ... você está pronto para jogar.

Exemplo de uso do repositório 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()

TAMBÉM - Substitua o MySQLdb no código existente de forma rápida e transparente

Se você possui um código existente que usa o MySQLdb, pode substituí-lo facilmente pelo pymysql usando este processo simples:

# import MySQLdb << Remove this line and replace with:
import pymysql
pymysql.install_as_MySQLdb()

Todas as referências subseqüentes ao MySQLdb usarão o pymysql de forma transparente.

Tente usar o MySQLdb . O MySQLdb suporta apenas Python 2.

Há uma página de instruções aqui: http://www.kitebird.com/articles/pydbapi.html

Na 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 ()

Como um driver de banco de dados, também existe o ourql . Algumas das razões listadas nesse link, que dizem por que o ourql é melhor:

• oursql possui parametrização real, enviando o SQL e os dados para o MySQL completamente separadamente.
• oursql permite que dados de texto ou binários sejam transmitidos para o banco de dados e transmitidos para fora do banco de dados, em vez de exigir que tudo seja armazenado em buffer no cliente.
• o oursql pode inserir linhas preguiçosamente e buscar linhas preguiçosamente.
• o ourql possui suporte unicode ativado por padrão.
• O oursql suporta python 2.4 a 2.7 sem nenhum aviso de reprovação no 2.6+ (consulte o PEP 218) e sem falhar completamente no 2.7 (consulte o PEP 328).
• oursql roda nativamente no python 3.x.

Então, como conectar-se ao mysql com o ourql?

Muito semelhante ao 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]

O tutorial na documentação é bastante decente.

E, claro, para ORM SQLAlchemy é uma boa escolha, como já mencionado nas outras respostas.

Execute este comando no seu terminal para instalar o conector mysql:

pip install mysql-connector-python

E execute isso no seu editor python para conectar-se ao MySQL:

import mysql.connector

mydb = mysql.connector.connect(
      host="localhost",
      user="yusername",
      passwd="password",
      database="database_name"
)

Exemplos para executar comandos do MySQL (no seu python edior):

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 mais comandos: https://www.w3schools.com/python/python_mysql_getstarted.asp

SqlAlchemy

SQLAlchemy é o kit de ferramentas Python SQL e o Object Relational Mapper que fornece aos desenvolvedores de aplicativos todo o poder e flexibilidade do SQL. O SQLAlchemy fornece um conjunto completo de padrões de persistência de nível empresarial conhecidos, projetados para acesso eficiente e de alto desempenho ao banco de dados, adaptado a uma linguagem de domínio simples e Python.

Instalação

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()

Maneira 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()

Apesar de todas as respostas acima, caso você não deseje se conectar a um banco de dados específico antecipadamente, por exemplo, se desejar criar o banco de dados ainda (!), Você pode usá-lo connection.select_db(database), conforme demonstrado a seguir.

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()

O MySQLdb é o caminho direto. Você pode executar consultas SQL através de uma conexão. Período.

Minha maneira preferida, que também é pitônica, é usar o poderoso SQLAlchemy . Aqui está um tutorial relacionado à consulta e um tutorial sobre os recursos ORM do SQLALchemy.

para Python3.6 eu encontrei dois drivers: pymysql e mysqlclient. Testei o desempenho entre eles e obtive o resultado: o mysqlclient é mais rápido.

abaixo está o meu processo de teste (preciso instalar o python lib profilehooks para analisar o tempo decorrido ：

sql bruto: select * from FOO;

execute imediatamente no 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()

aqui está o perfil do 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()

aqui está o perfil do mysqlclient:

Então, parece que o mysqlclient é muito mais rápido que o pymysql

Embora alguns de vocês possam marcar isso como duplicado e ficarem chateados por eu estar copiando a resposta de outra pessoa, eu REALMENTE gostaria de destacar um aspecto da resposta do Sr. Napik. Por ter perdido isso, causei inatividade em sites de âmbito nacional (9min). Se apenas alguém compartilhasse essa informação, eu poderia ter evitado!

Aqui está o código dele:

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()

O importante aqui é a cláusula Try and Finalmente . Isso permite que as conexões SEMPRE sejam fechadas, independentemente do que acontece na parte do cursor / sqlstatement do código. Muitas conexões ativas fazem o DBLoadNoCPU disparar e podem travar um servidor db.

Espero que este aviso ajude a salvar servidores e, finalmente, empregos! : D

A melhor maneira de conectar-se ao MySQL a partir do python é Usar o MySQL Connector / Python, porque é o driver oficial do Oracle para o MySQL para trabalhar com o Python e funciona com o Python 3 e o Python 2.

siga as etapas mencionadas abaixo para conectar o MySQL

1. instalar o conector usando pip

   pip install mysql-connector-python

ou você pode baixar o instalador em https://dev.mysql.com/downloads/connector/python/

2. Use o connect()método do conector mysql python para conectar-se ao MySQL.pass o argumento necessário ao connect()método. ou seja, host, nome de usuário, senha e nome do banco de dados.

3. Crie um cursorobjeto a partir do objeto de conexão retornado pelo connect()método para executar consultas SQL.

4. feche a conexão após a conclusão do seu trabalho.

Exemplo :

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()

Referência - https://pynative.com/python-mysql-database-connection/

API importante do MySQL Connector Python

• Para operações DML - use cursor.execute()e cursor.executemany()para executar a consulta. e após esse uso, connection.commit()para manter suas alterações no banco de dados

• Para buscar dados - Use cursor.execute()para executar a consulta e cursor.fetchall(), cursor.fetchone(), cursor.fetchmany(SIZE)para buscar dados

Apenas uma modificação na resposta acima. Simplesmente execute este comando para instalar o mysql for python

sudo yum install MySQL-python
sudo apt-get install MySQL-python

lembrar! É sensível a maiúsculas e minúsculas.

O mysqlclient é o melhor, pois outros apenas fornecem suporte para versões específicas do python

 pip install mysqlclient

código de exemplo

    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())

consulte https://github.com/PyMySQL/mysqlclient-python

Também dê uma olhada no Storm . É uma ferramenta simples de mapeamento de SQL que permite editar e criar facilmente entradas de SQL sem escrever as consultas.

Aqui está um exemplo simples:

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 encontrar e usar objetos:

michael = store.find(User, User.name == u"Michael").one()
print str(user.ID) # 10

Encontre com chave primária:

print store.get(User, 1).name #Mark

Para mais informações, consulte o tutorial .

Esta é a conexão do banco de dados Mysql

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()

primeiro instale o driver

pip install MySQL-python   

Então, um código básico é assim:

#!/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 

você pode conectar seu código python ao mysql dessa maneira.

import MySQLdb
db = MySQLdb.connect(host="localhost",
                 user="appuser",
                 passwd="",
                 db="onco")

cursor = db.cursor()

Primeiro instale o driver (Ubuntu)

• O sudo apt-get instala o python-pip

• instalação do sudo pip -U pip

• sudo apt-get install python-dev libmysqlclient-dev

• sudo apt-get instala MySQL-python

Códigos de conexão do banco de dados 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

Eu tenho o pip instalado no meu windows 7, apenas o pip instala o cymysql

(você não precisa de cython) rápido e indolor

Primeiro, instale o conector python-mysql em https://dev.mysql.com/downloads/connector/python/

no console Python, digite:

pip install mysql-connector-python-rf
import mysql.connector