पायथन 3.3 के लिए

CyMySQL https://github.com/nakagami/CyMySQL

मेरे पास विंडोज 7 पर स्थापित पाइप है, बस पाइप स्थापित cymysql

(आपको साइथन की आवश्यकता नहीं है) त्वरित और दर्द रहित

उपर्युक्त उत्तर में बस एक संशोधन। पाइथन के लिए mysql स्थापित करने के लिए बस इस कमांड को चलाएं

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

याद है! यह मामला संवेदनशील है।

SQLAlchemy

SQLAlchemy पायथन एसक्यूएल टूलकिट और ऑब्जेक्ट रिलेशनल मैपर है जो एप्लिकेशन डेवलपर्स को पूर्ण शक्ति और एसक्यूएल की लचीलापन देता है। SQLAlchemy एक सरल और पायथनिक डोमेन भाषा में अनुकूलित, कुशल और उच्च प्रदर्शन डेटाबेस पहुंच के लिए डिज़ाइन किए गए प्रसिद्ध उद्यम-स्तर दृढ़ता पैटर्न का एक पूर्ण सूट प्रदान करता है।

स्थापना

pip install sqlalchemy

रॉ क्वेरी के साथ उपयोग करें

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, scoped_session

engine = create_engine("mysql://<user_name>:<password>@<host_name>/smsmagic")
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>/smsmagic")
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()

तूफान पर भी एक नज़र डालें। यह एक साधारण एसक्यूएल मैपिंग टूल है जो आपको प्रश्नों को लिखने के बिना आसानी से एसक्यूएल प्रविष्टियों को संपादित और बनाने की अनुमति देता है।

ये रहा एक सरल उदाहरण:

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:[email protected]: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

उपयोग खोजने और ऑब्जेक्ट करने के लिए:

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

प्राथमिक कुंजी के साथ खोजें:

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

अधिक जानकारी के लिए tutorial देखें।

उपरोक्त सभी उत्तरों के बावजूद, यदि आप किसी विशिष्ट डेटाबेस से पहले से कनेक्ट नहीं करना चाहते हैं, उदाहरण के लिए, यदि आप अभी भी डेटाबेस बनाना चाहते हैं (!), तो आप connection.select_db(database) उपयोग कर सकते हैं, जैसा कि निम्न में दिखाया गया है।

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 का उपयोग करना बंद करें यदि आप mysql शीर्षकों को केवल पायथन से mysql तक पहुंचने से बचाना चाहते हैं।

pymysql प्रयोग करें। यह MySQLDb की सभी चीजें करता है, लेकिन इसे पूरी तरह से पायथन में लागू नहीं किया गया था, जिसमें कोई बाहरी निर्भरता नहीं थी । यह सभी ऑपरेटिंग सिस्टम पर इंस्टॉलेशन प्रक्रिया को लगातार और आसान बनाता है। pymysql MySQLDb और IMHO के प्रतिस्थापन में एक बूंद है, किसी भी चीज़ के लिए कभी भी MySQLDb का उपयोग करने का कोई कारण नहीं है ... कभी! - PTSD from installing MySQLDb on Mac OSX and *Nix systems , लेकिन यह सिर्फ मुझे है।

स्थापना

pip install pymysql

यही वह है ... आप खेलने के लिए तैयार हैं।

उदाहरण के उपयोग pymysql गीथूब रेपो से

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

यह भी - मौजूदा कोड में MySQLdb को जल्दी और पारदर्शी रूप से बदलें

यदि आपके पास मौजूदा कोड है जो MySQLdb का उपयोग करता है, तो आप इस सरल प्रक्रिया का उपयोग करके इसे आसानी से pymysql से प्रतिस्थापित कर सकते हैं:

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

MySQLdb के बाद के सभी संदर्भ पारदर्शी रूप से pymysql का उपयोग करेंगे।

ऐसा करने का एक तरीका यहां दिया गया है:

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

यहां संदर्भ

यदि आपको MySQLdb की आवश्यकता नहीं है, लेकिन किसी भी लाइब्रेरी को स्वीकार करेगा, तो मैं बहुत कुछ MySQL कनेक्टर / पायथन को MySQL से अनुशंसा करता हूं: http://dev.mysql.com/downloads/connector/python/ ।

यह एक पैकेज (लगभग 110k), शुद्ध पायथन है, इसलिए यह सिस्टम स्वतंत्र है, और स्थापित करने के लिए मृत सरल है। आप बस डाउनलोड करें, डबल-क्लिक करें, लाइसेंस समझौते की पुष्टि करें और जाएं। एक्सकोड, मैकपॉर्ट्स, संकलन, पुनरारंभ करने की कोई आवश्यकता नहीं है ...

फिर आप इस तरह से जुड़ते हैं:

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

पहले ड्राइवर स्थापित करें

pip install MySQL-python   

फिर एक मूल कोड इस तरह जाता है:

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

एक डीबी चालक के रूप में, हमारे oursql भी है। उस लिंक पर सूचीबद्ध कुछ कारणों से, जो कहते हैं कि हमारा एसक्यूएल बेहतर क्यों है:

• oursql में वास्तविक पैरामीटरेशन है, जो SQL और डेटा को MySQL को पूरी तरह अलग से भेज रहा है।
• oursql क्लाइंट में बफर किए जाने वाले सबकुछ की आवश्यकता के बजाय डेटाबेस में टेक्स्ट या बाइनरी डेटा को स्ट्रीम करने और डेटाबेस से बाहर स्ट्रीम करने की अनुमति देता है।
• oursql दोनों पंक्तियों को आलसी ढंग से सम्मिलित कर सकते हैं और पंक्तियों को आलसी रूप से ला सकते हैं।
• oursql में डिफ़ॉल्ट रूप से यूनिकोड समर्थन है।
• oursql 2.6+ पर किसी भी बहिष्करण चेतावनियों के बिना पाइथन 2.4 से 2.7 का समर्थन करता है (पीईपी 218 देखें) और पूरी तरह से 2.7 पर असफल होने के बिना (पीईपी 328 देखें)।
• oursql पायथन 3.x पर मूल रूप से चलाता है।

तो mysql के साथ mysql से कैसे कनेक्ट करें?

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]

दस्तावेज़ीकरण में ट्यूटोरियल बहुत सभ्य है।

और निश्चित रूप से ओआरएम स्क्लाक्लेमी के लिए एक अच्छा विकल्प है, जैसा कि पहले से ही अन्य उत्तरों में उल्लिखित है।

mysqlclient सर्वोत्तम है क्योंकि अन्य केवल पाइथन के विशिष्ट संस्करणों को समर्थन प्रदान करते हैं

 pip install mysqlclient

उदाहरण कोड

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

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

MySQLdb सीधा तरीका है। आप कनेक्शन पर SQL क्वेरी निष्पादित करने के लिए मिलता है। अवधि।

मेरा पसंदीदा तरीका, जो कि पाइथोनिक भी है, इसके बजाय शक्तिशाली SQLAlchemy उपयोग करना है। यहां एक क्वेरी से संबंधित ट्यूटोरियल है, और यहां SQLALchemy की ORM क्षमताओं पर एक ट्यूटोरियल है।