පයිතන් වැඩසටහනක් භාවිතා කර MySQL දත්ත ගබඩාවට සම්බන්ධ වන්නේ කෙසේද?

පියවර තුනකින් පයිතන් 2 සමඟ MYSQL වෙත සම්බන්ධ වීම

1 - සැකසුම

කිසිවක් කිරීමට පෙර ඔබ MySQL ධාවකයක් ස්ථාපනය කළ යුතුය. PHP මෙන් නොව, පෙරනිමියෙන් පයිතන් සමඟ ස්ථාපනය කර ඇත්තේ SQLite ධාවක පමණි. එසේ කිරීමට වැඩිපුරම භාවිතා කරන පැකේජය වන්නේ MySQLdb නමුත් පහසු_ඉන්ස්ටෝල් භාවිතයෙන් එය ස්ථාපනය කිරීම දුෂ්කර ය. MySQLdb සහය දක්වන්නේ පයිතන් 2 ට පමණක් බව කරුණාවෙන් සලකන්න.

වින්ඩෝස් පරිශීලකයා සඳහා, ඔබට MySQLdb හි exe එකක් ලබා ගත හැකිය .

ලිනක්ස් සඳහා, මෙය අනියම් පැකේජයකි (python-mysqldb). (ඔබට බාගත කිරීම සඳහා විධාන රේඛාවේ ( sudo apt-get install python-mysqldbඩෙබියන් පදනම් කරගත් ඩිස්ට්‍රෝස් සඳහා), yum install MySQL-python( ආර්පීඑම් මත පදනම් වූ) හෝ dnf install python-mysql(නවීන ෆෙඩෝරා ඩිස්ට්‍රෝ සඳහා) භාවිතා කළ හැකිය.)

මැක් සඳහා, ඔබට මැක්පෝට් භාවිතයෙන් MySQLdb ස්ථාපනය කළ හැකිය .

2 - භාවිතය

ස්ථාපනය කිරීමෙන් පසු, නැවත ආරම්භ කරන්න. මෙය අනිවාර්ය නොවේ, නමුත් යමක් වැරදුනහොත් මෙම ලිපියේ තවත් ප්‍රශ්න 3 ක් හෝ 4 කට පිළිතුරු සැපයීම වළක්වනු ඇත. එබැවින් කරුණාකර නැවත ආරම්භ කරන්න.

එවිට එය වෙනත් ඕනෑම පැකේජයක් භාවිතා කිරීම හා සමානයි:

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

ඇත්ත වශයෙන්ම, හැකියාවන් සහ විකල්ප දහස් ගණනක් ඇත; මෙය ඉතා මූලික උදාහරණයකි. ඔබට ලියකියවිලි බැලීමට සිදුවේ. හොඳ ආරම්භක ස්ථානයක් .

3 - වඩා දියුණු භාවිතය

එය ක්‍රියාත්මක වන ආකාරය ඔබ දැනගත් පසු, ඔබට SQL අතින් ලිවීම වළක්වා ගැනීමට ORM භාවිතා කිරීමට අවශ්‍ය විය හැකි අතර ඔබේ වගු පයිතන් වස්තු ලෙස හැසිරවිය හැකිය. පයිතන් ප්‍රජාවේ වඩාත් ප්‍රචලිත ORM වන්නේ SQLAlchemy ය .

එය භාවිතා කරන ලෙස මම ඔබට තරයේ අවවාද කරමි: ඔබේ ජීවිතය වඩාත් පහසු වනු ඇත.

මම මෑතකදී පයිතන් ලෝකයේ තවත් මැණිකක් සොයාගත්තා: පීවී . එය ඉතා සැහැල්ලු ORM එකක් වන අතර එය සැකසීමට පහසු සහ වේගවත් වේ. එය කුඩා ව්‍යාපෘති සඳහා හෝ තනිවම යෙදුම් සඳහා මගේ දවස බවට පත් කරයි, එහිදී SQLAlchemy හෝ Jjango වැනි විශාල මෙවලම් භාවිතා කිරීම අධික ලෙස මරණයට පත් වේ:

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

මෙම උදාහරණය කොටුවෙන් පිටත ක්‍රියාත්මක වේ. පීවී ( pip install peewee) තිබීම හැර වෙන කිසිවක් අවශ්‍ය නොවේ.

Python 2 ට පමණක් සහය දක්වන MySQLdb භාවිතා කරමින් එය කළ හැකි එක් ක්‍රමයක් මෙන්න :

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

මෙහි යොමුව

ඔරකල් (MySQL) දැන් පිරිසිදු පයිතන් සම්බන්ධකයකට සහය දක්වයි. එයින් අදහස් කරන්නේ ස්ථාපනය කිරීමට ද්විමය කිසිවක් නොමැති බවයි: එය පයිතන් පුස්තකාලයක් පමණි. එය "සම්බන්ධකය / පයිතන්" ලෙස හැඳින්වේ.

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

ඔබට MySQLdb අවශ්‍ය නැති නමුත් ඕනෑම පුස්තකාලයක් පිළිගන්නේ නම්, මම MySQL වෙතින් MySQL Connector / Python නිර්දේශ කරමි: http://dev.mysql.com/downloads/connector/python/ .

එය එක් පැකේජයක් (110k පමණ), පිරිසිදු පයිතන්, එබැවින් එය පද්ධතියෙන් ස්වාධීන වන අතර ස්ථාපනය කිරීමට සරලයි. ඔබ බාගත කරන්න, දෙවරක් ක්ලික් කරන්න, බලපත්‍ර ගිවිසුම තහවුරු කර යන්න. Xcode, MacPorts, සම්පාදනය, නැවත ආරම්භ කිරීම අවශ්‍ය නොවේ…

එවිට ඔබ මෙසේ සම්බන්ධ වේ:

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

පයිතන් වෙතින් mysql වෙත ප්‍රවේශ වීම සඳහා ඔබට mysql ශීර්ෂ ස්ථාපනය කිරීමෙන් වළක්වා ගැනීමට අවශ්‍ය නම් MySQLDb භාවිතා කිරීම නවත්වන්න.

Pymysql භාවිතා කරන්න . එය MySQLDb කරන සෑම දෙයක්ම කරයි, නමුත් එය තනිකරම ක්‍රියාත්මක වූයේ බාහිර පරායත්තයන් නොමැති පයිතන් හි ය . මෙමඟින් සියලුම මෙහෙයුම් පද්ධතිවල ස්ථාපන ක්‍රියාවලිය ස්ථාවර හා පහසු වේ. pymysqlMySQLDb සහ IMHO වෙනුවට ආදේශ කිරීම පහත වැටීමකි. කිසි විටෙකත් කිසිවක් සඳහා MySQLDb භාවිතා කිරීමට හේතුවක් නැත ... එවර! - PTSD from installing MySQLDb on Mac OSX and *Nix systems, නමුත් ඒ මම පමණයි.

ස්ථාපනය

pip install pymysql

ඒක තමයි ... ඔයා සෙල්ලම් කරන්න ලෑස්තියි.

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

ALSO - පවතින කේතයේ MySQLdb ඉක්මනින් හා විනිවිදභාවයෙන් ප්‍රතිස්ථාපනය කරන්න

ඔබට MySQLdb භාවිතා කරන කේතයක් තිබේ නම්, මෙම සරල ක්‍රියාවලිය භාවිතයෙන් ඔබට එය පහසුවෙන් pymysql සමඟ ප්‍රතිස්ථාපනය කළ හැකිය:

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

MySQLdb පිළිබඳ සියලු පසුකාලීන යොමු කිරීම් විනිවිදභාවයෙන් pymysql භාවිතා කරනු ඇත.

MySQLdb භාවිතා කිරීමට උත්සාහ කරන්න . MySQLdb සහය දක්වන්නේ පයිතන් 2 ට පමණි.

මෙහි පිටුවක් සකසන ආකාරය තිබේ: http://www.kitebird.com/articles/pydbapi.html

පිටුවෙන්:

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

Db ධාවකයක් ලෙස, අපගේ sql ද ඇත . එම සබැඳියේ ලැයිස්තුගත කර ඇති හේතු කිහිපයක්, එයින් කියවෙන්නේ අපගේ SQL වඩා හොඳ වන්නේ මන්ද යන්නයි:

• oursql හි සැබෑ පරාමිතිකරණයක් ඇත, SQL සහ දත්ත සම්පූර්ණයෙන්ම වෙන වෙනම MySQL වෙත යවයි.
• අපගේ සේවාදායකයා තුළ සෑම දෙයක්ම ආරෝපණය කිරීම අවශ්‍ය නොවී, පෙළ හෝ ද්විමය දත්ත දත්ත ගබඩාවට ප්‍රවාහනය කර දත්ත ගබඩාවෙන් පිටතට ගෙනයාමට oursql ඉඩ දෙයි.
• කම්මැලි ලෙස පේළි ඇතුළු කළ හැකි අතර කම්මැලි ලෙස පේළි ලබා ගත හැකිය.
• oursql ට පෙරනිමියෙන් යුනිකෝඩ් සහාය ඇත.
• 2.6+ හි කිසිදු අවලංගු කිරීමේ අනතුරු ඇඟවීමකින් තොරව (PEP 218 බලන්න) සහ 2.7 මත සම්පූර්ණයෙන්ම අසමත් නොවී අපගේ පයිතන් 2.4 සිට 2.7 දක්වා සහය දක්වයි (PEP 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]

මෙම ලේඛගතකිරීම දී නිබන්ධනය ලස්සන යහපත් වේ.

අනෙක් පිළිතුරු වල දැනටමත් සඳහන් කර ඇති පරිදි ORM SQLAlchemy සඳහා හොඳ තේරීමක් වේ.

MySQL සම්බන්ධකය ස්ථාපනය කිරීම සඳහා මෙම විධානය ඔබගේ පර්යන්තයේ ක්‍රියාත්මක කරන්න:

pip install mysql-connector-python

MySQL හා සම්බන්ධ වීමට මෙය ඔබේ පයිතන් සංස්කාරකයේ ධාවනය කරන්න:

import mysql.connector

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

MySQL විධාන ක්‍රියාත්මක කිරීමට නියැදි (ඔබේ පයිතන් එඩියරයේ):

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

තවත් විධාන සඳහා: https://www.w3schools.com/python/python_mysql_getstarted.asp

SqlAlchemy

SQLAlchemy යනු යෙදුම් සංවර්ධකයින්ට SQL හි පූර්ණ බලය සහ නම්‍යතාවය ලබා දෙන පයිතන් SQL මෙවලම් කට්ටලය සහ වස්තු සම්බන්ධතා සිතියමයි. සරල හා පයිතොනික් වසම් භාෂාවකට අනුවර්තනය කරන ලද කාර්යක්ෂම හා ඉහළ කාර්යසාධනයක් සහිත දත්ත සමුදායන් සඳහා නිර්මාණය කර ඇති SQLAlchemy විසින් සුප‍්‍රසිද්ධ ව්‍යවසාය මට්ටමේ අඛණ්ඩ රටාවන්ගෙන් සමන්විත වේ.

ස්ථාපනය

pip install sqlalchemy

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

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

ඉහත සියලු පිළිතුරු තිබියදීත්, ඔබට නිශ්චිත දත්ත සමුදායකට සම්බන්ධ වීමට අවශ්‍ය නැතිනම්, උදාහරණයක් ලෙස, ඔබට තවමත් (!) දත්ත සමුදාය නිර්මාණය කිරීමට අවශ්‍ය නම් 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 යනු සරලම ක්‍රමයයි. සම්බන්ධතාවයක් හරහා ඔබට SQL විමසුම් ක්‍රියාත්මක කිරීමට සිදුවේ. කාලය.

මගේ වඩාත් කැමති ක්‍රමය, එය පයිතොනික් වන අතර ඒ වෙනුවට බලවත් SQLAlchemy භාවිතා කිරීමයි. මෙන්න විමසුම් ආශ්‍රිත නිබන්ධනයක් වන අතර SQLALchemy හි ORM හැකියාවන් පිළිබඳ නිබන්ධනයක් මෙහි ඇත.

ඔබ සමහර අනුපිටපතක් මම තව කෙනෙකුගේ පිළිතුර පිටපත් මා බව කලබල ලෙස මෙම සිදුකල හැකි වුවත්, මම ඇත්තටම Napik මහතා ප්රතිචාරය කිරීමේ පැතිකඩක් උද්දීපනය කිරීමට වගේ. මට මෙය මඟ හැරුණු නිසා, මම රටපුරා වෙබ් අඩවි අක්‍රීය වීමට හේතු විය (මිනිත්තු 9). යමෙකු මෙම තොරතුරු බෙදාගත්තේ නම්, මට එය වළක්වා ගත හැකිව තිබුණි!

මෙන්න ඔහුගේ කේතය:

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

මෙහි ඇති වැදගත් දෙය වන්නේ උත්සාහ කරන්න සහ අවසාන වශයෙන් වගන්තියයි. කේතයේ කර්සරය / වර්ගීකරණ කොටසෙහි කුමක් සිදුවේද යන්න නොසලකා සෑම විටම සම්බන්ධතා වසා දැමීමට මෙය ඉඩ දෙයි . සක්‍රීය සම්බන්ධතා රාශියක් DBLoadNoCPU වැඩි වීමට හේතු වන අතර db සේවාදායකයක් බිඳ වැටිය හැක.

මෙම අනතුරු ඇඟවීම සේවාදායකයන් සහ අවසානයේ රැකියා සුරැකීමට උපකාරී වනු ඇතැයි මම බලාපොරොත්තු වෙමි! : ඩී

පයිතන් සිට MySQL හා සම්බන්ධ වීමට හොඳම ක්‍රමය වන්නේ MySQL Connector / Python භාවිතා කිරීමයි, මන්ද එය Python සමඟ වැඩ කිරීම සඳහා MySQL සඳහා නිල ඔරකල් ධාවකයක් වන අතර එය Python 3 සහ Python 2 සමඟ ක්‍රියා කරයි.

MySQL සම්බන්ධ කිරීම සඳහා පහත සඳහන් පියවර අනුගමනය කරන්න

1. පයිප්ප භාවිතයෙන් සම්බන්ධකය ස්ථාපනය කරන්න

   pip install mysql-connector-python

හෝ ඔබට https://dev.mysql.com/downloads/connector/python/ වෙතින් ස්ථාපකය බාගත කළ හැකිය.

2. connect()MySQL.pass වෙත සම්බන්ධ වීමට mysql සම්බන්ධක පයිතන් ක්‍රමය භාවිතා කරන්න connect(). එනම් සත්කාරක, පරිශීලක නාමය, මුරපදය සහ දත්ත සමුදායේ නම.

3. SQL විමසුම් ක්‍රියාත්මක කිරීම සඳහා ක්‍රමවේදය cursorමඟින් ආපසු ලබා දුන් සම්බන්ධතා වස්තුවෙන් වස්තුවක් සාදන්න connect().

4. ඔබගේ කාර්යය අවසන් වූ පසු සම්බන්ධතාවය වසා දමන්න.

උදාහරණය :

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

යොමුව - https://pynative.com/python-mysql-database-connection/

MySQL Connector Python හි වැදගත් API

• ඩීඑම්එල් මෙහෙයුම් සඳහා - විමසුම භාවිතා කිරීම cursor.execute()සහ cursor.executemany()ක්‍රියාත්මක කිරීම. මෙම භාවිතයෙන් පසු connection.commit()ඔබේ වෙනස්කම් ඩී.බී.

• භාවිතා කරන්න - දත්ත ලබා ගැනීමට cursor.execute()විමසුම ක්රියාත්මක කිරීමට හා cursor.fetchall(), cursor.fetchone(), cursor.fetchmany(SIZE)දත්ත ලබා ගැනීමට

Python3.6 සඳහා මට ධාවක දෙකක් හමු විය: pymysql සහ mysqlclient. මම ඔවුන් අතර කාර්ය සාධනය පරීක්ෂා කර ප්‍රති result ලය ලබා ගත්තා: mysqlclient වේගවත්.

පහත දැක්වෙන්නේ මගේ පරීක්ෂණ ක්‍රියාවලියයි (කාලය ගතවීම විශ්ලේෂණය කිරීම සඳහා පයිතන් ලිබ් පැතිකඩ ස්ථාපනය කිරීම අවශ්‍ය වේ

අමු වර්ග: select * from FOO;

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

මෙන්න 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()

මෙන්න mysqlclient පැතිකඩ:

ඉතින්, mysqlclient pymysql ට වඩා වේගවත් බව පෙනේ

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 බලන්න

ඉහත පිළිතුරේ වෙනස් කිරීමක් පමණි. පයිතන් සඳහා mysql ස්ථාපනය කිරීමට මෙම විධානය ක්‍රියාත්මක කරන්න

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

මතක තබා ගන්න! එය සිද්ධි සංවේදී ය.

කුණාටුව දෙසද බලන්න . එය සරල SQL සිතියම්කරණ මෙවලමක් වන අතර එමඟින් විමසුම් ලිවීමෙන් තොරව පහසුවෙන් SQL ඇතුළත් කිරීම් සංස්කරණය කිරීමට සහ නිර්මාණය කිරීමට ඉඩ ලබා දේ.

මෙන්න සරල උදාහරණයක්:

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

භාවිතය සොයා ගැනීමට සහ වස්තු කිරීමට:

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

ප්‍රාථමික යතුර සමඟ සොයා ගන්න:

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

වැඩි විස්තර සඳහා නිබන්ධනය බලන්න .

මෙය 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()

ඔබට මේ ආකාරයෙන් ඔබේ පයිතන් කේතය mysql හා සම්බන්ධ කළ හැකිය.

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

cursor = db.cursor()

පයිතන් සඳහා 3.3

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

මගේ වින්ඩෝස් 7 හි පයිප්ප සවි කර ඇත, පයිප්ප ස්ථාපනය කරන්න cymysql

(ඔබට සයිතන් අවශ්‍ය නොවේ) ඉක්මන් හා වේදනා රහිත

පළමුව ධාවක ස්ථාපනය කරන්න

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 

පළමුව ධාවක ස්ථාපනය කරන්න (උබුන්ටු)

• 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

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

පළමුව, https://dev.mysql.com/downloads/connector/python/ වෙතින් python-mysql සම්බන්ධකය ස්ථාපනය කරන්න.

පයිතන් කොන්සෝලය මත ඇතුළත් කරන්න:

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