• python操作MySQL数据库

    五，python 操作mysql数据库基础

    复制代码
    #coding=utf-8
import MySQLdb

conn= MySQLdb.connect(
        host='localhost',
        port = 3306,
        user='root',
        passwd='123456',
        db ='test',
        )
cur = conn.cursor()

#创建数据表
#cur.execute("create table student(id int ,name varchar(20),class varchar(30),age varchar(10))")

#插入一条数据
#cur.execute("insert into student values('2','Tom','3 year 2 class','9')")

    total=cur.execute("select * from corp_url_all_single");
    print total;
    
#修改查询条件的数据
#cur.execute("update student set class='3 year 1 class' where name = 'Tom'")

#删除查询条件的数据
#cur.execute("delete from student where age='9'")

cur.close()
conn.commit()
conn.close()
    复制代码

    >>> conn = MySQLdb.connect(host='localhost',port = 3306,user='root', passwd='123456',db ='test',)

    Connect() 方法用于创建数据库的连接，里面可以指定参数：用户名，密码，主机等信息。

    这只是连接到了数据库，要想操作数据库需要创建游标。

     

    >>> cur = conn.cursor()

    通过获取到的数据库连接conn下的cursor()方法来创建游标。

     

    >>> cur.execute("create table student(id int ,name varchar(20),class varchar(30),age varchar(10))")

    通过游标cur 操作execute()方法可以写入纯sql语句。通过execute()方法中写如sql语句来对数据进行操作。

     

    >>>cur.close()

    cur.close() 关闭游标

    >>>conn.commit()

    conn.commit()方法在提交事物，在向数据库插入一条数据时必须要有这个方法，否则数据不会被真正的插入。

    >>>conn.close()

    Conn.close()关闭数据库连接

     

    六，插入数据

    通过上面execute()方法中写入纯的sql语句来插入数据并不方便。如：

    >>>cur.execute("insert into student values('2','Tom','3 year 2 class','9')")

    我要想插入新的数据，必须要对这条语句中的值做修改。我们可以做如下修改：

    复制代码
    #coding=utf-8
import MySQLdb

conn= MySQLdb.connect(
        host='localhost',
        port = 3306,
        user='root',
        passwd='123456',
        db ='test',
        )
cur = conn.cursor()

#插入一条数据
sqli="insert into student values(%s,%s,%s,%s)"
cur.execute(sqli,('3','Huhu','2 year 1 class','7'))

cur.close()
conn.commit()
conn.close()
    复制代码

    假如要一次向数据表中插入多条值呢？

    复制代码
    #coding=utf-8
import MySQLdb

conn= MySQLdb.connect(
        host='localhost',
        port = 3306,
        user='root',
        passwd='123456',
        db ='test',
        )
cur = conn.cursor()

#一次插入多条记录
sqli="insert into student values(%s,%s,%s,%s)"
cur.executemany(sqli,[
    ('3','Tom','1 year 1 class','6'),
    ('3','Jack','2 year 1 class','7'),
    ('3','Yaheng','2 year 2 class','7'),
    ])

cur.close()
conn.commit()
conn.close()
    复制代码

    executemany()方法可以一次插入多条值，执行单挑sql语句,但是重复执行参数列表里的参数,返回值为受影响的行数。

     

    七，查询数据

    也许你已经尝试了在python中通过

    >>>cur.execute("select * from student")

    来查询数据表中的数据，但它并没有把表中的数据打印出来，有些失望。

    来看看这条语句获得的是什么

    >>>aa=cur.execute("select * from student")

    >>>print aa

    5

    它获得的只是我们的表中有多少条数据。那怎样才能获得表中的数据呢？进入python shell

    复制代码
    >>> import MySQLdb
>>> conn = MySQLdb.connect(host='localhost',port = 3306,user='root',    passwd='123456',db ='test',)
>>> cur = conn.cursor()
>>> cur.execute("select * from student")
5L
>>> cur.fetchone()
(1L, 'Alen', '1 year 2 class', '6')
>>> cur.fetchone()
(3L, 'Huhu', '2 year 1 class', '7')
>>> cur.fetchone()
(3L, 'Tom', '1 year 1 class', '6')
...
>>>cur.scroll(0,'absolute')
    复制代码

    　　fetchone()方法可以帮助我们获得表中的数据，可是每次执行cur.fetchone() 获得的数据都不一样，换句话说我没执行一次，游标会从表中的第一条数据移动到下一条数据的位置，所以，我再次执行的时候得到的是第二条数据。

    　　scroll(0,'absolute') 方法可以将游标定位到表中的第一条数据。

     还是没解决我们想要的结果，如何获得表中的多条数据并打印出来呢？

    复制代码
    #coding=utf-8
import MySQLdb

conn= MySQLdb.connect(
        host='localhost',
        port = 3306,
        user='root',
        passwd='123456',
        db ='test',
        )
cur = conn.cursor()

#获得表中有多少条数据
aa=cur.execute("select * from student")
print aa

#打印表中的多少数据
info = cur.fetchmany(aa)
for ii in info:
    print ii
cur.close()
conn.commit()
conn.close()
    复制代码

    　　通过之前的print aa 我们知道当前的表中有5条数据，fetchmany()方法可以获得多条数据，但需要指定数据的条数，通过一个for循环就可以把多条数据打印出啦！执行结果如下：

     

    复制代码
    5
(1L, 'Alen', '1 year 2 class', '6')
(3L, 'Huhu', '2 year 1 class', '7')
(3L, 'Tom', '1 year 1 class', '6')
(3L, 'Jack', '2 year 1 class', '7')
(3L, 'Yaheng', '2 year 2 class', '7')
[Finished in 0.1s]
    复制代码

    参考资料：

    MySQLdb‘s user guide

    package MySQLdb

    在上一讲中 已经连接了数据库。就数据库而言，连接之后就要对其操作。但是，目前那个名字叫做qiwsirtest的数据仅仅是空架子，没有什么可操作的，要操作它， 就必须在里面建立“表”，什么是数据库的表呢？下面摘抄字维基百科对数据库表的简要解释，要想详细了解，需要看官在找一些有关数据库的教程和书籍来看看。

    在关系数据库中，数据库表是一系列二维数组的集合，用来代表和储存数据对象之间的关系。它由纵向的列和横向的行组成，例如一个有关作者信息的名为 authors 的表中，每个列包含的是所有作者的某个特定类型的信息，比如“姓氏”，而每行则包含了某个特定作者的所有信息：姓、名、住址等等。

    对于特定的数据库表，列的数目一般事先固定，各列之间可以由列名来识别。而行的数目可以随时、动态变化，每行通常都可以根据某个（或某几个）列中的数据来识别，称为候选键。

    我打算在qiwsirtest中建立一个存储用户名、用户密码、用户邮箱的表，其结构用二维表格表现如下：

    usernamepasswordemail
    qiwsir 123123 qiwsir@gmail.com

    特别说明，这里为了简化细节，突出重点，对密码不加密，直接明文保存，虽然这种方式是很不安全的。但是，有不少网站还都这么做的，这么做的目的是比较可恶的。就让我在这里，仅仅在这里可恶一次。

    建数据库表并插入数据

    为了在数据库中建立这个表，需要进入到mysql>交互模式中操作。道理在于，如果qiwsirtest这个屋子里面没有类似家具的各种数据库表，即使进了屋子也没有什么好操作的东西，因此需要先到mysql>模式下在屋子里面摆家具。

    进入数据库交互模式：

    qw@qw-Latitude-E4300:~$ mysql -u root -p
Enter password:

    调用已经建立的数据库：qiwsirtest

    mysql> use qiwsirtest;
Database changed
mysql> show tables;
Empty set (0.00 sec)

    用show tables命令显示这个数据库中是否有数据表了。查询结果显示为空。

    下面就用如下命令建立一个数据表，这个数据表的内容就是上面所说明的。

    mysql> create table users(id int(2) not null primary key auto_increment,username varchar(40),password text,email text)default charset=utf8;
Query OK, 0 rows affected (0.12 sec)

    建立的这个数据表名称是：users，其中包含上述字段，可以用下面的方式看一看这个数据表的结构。

    mysql> show tables;
+----------------------+
| Tables_in_qiwsirtest |
+----------------------+
| users                |
+----------------------+
1 row in set (0.00 sec)

    查询显示，在qiwsirtest这个数据库中，已经有一个表，它的名字是：users。

    mysql> desc users;
+----------+-------------+------+-----+---------+----------------+
| Field    | Type        | Null | Key | Default | Extra          |
+----------+-------------+------+-----+---------+----------------+
| id       | int(2)      | NO   | PRI | NULL    | auto_increment |
| username | varchar(40) | YES  |     | NULL    |                |
| password | text        | YES  |     | NULL    |                |
| email    | text        | YES  |     | NULL    |                |
+----------+-------------+------+-----+---------+----------------+
4 rows in set (0.00 sec)

    显示表users的结构：

    • id：每增加一个用户，id号自动增加一个。
    • username：存储用户名，类型是varchar(40)
    • password：存储用户密码，类型是text
    • email：存储用户的邮箱，类型是text

    特别提醒：在这里，我没有对每个字段做注入不得为空等设置，在真正的开发中，或许必须让username和password不得为空。

    这个结构和上面所期望的结构是一样的，只不过这个表中还没有任何数据，是一个空表。可以查询一下看看：

    mysql> select * from users;
Empty set (0.01 sec)

    目前表是空的，为了能够在后面用python操作这个数据表，需要向里面插入点信息，就只插入一条吧。

    mysql> insert into users(username,password,email) values("qiwsir","123123","qiwsir@gmail.com");
Query OK, 1 row affected (0.05 sec)

mysql> select * from users;
+----+----------+----------+------------------+
| id | username | password | email            |
+----+----------+----------+------------------+
|  1 | qiwsir   | 123123   | qiwsir@gmail.com |
+----+----------+----------+------------------+
1 row in set (0.00 sec)

    到目前为止，在mysql>中的工作已经完成了，接下来就是用python操作了。

    python操作数据库

    要对数据库进行操作，需要先连接它。上一讲看官连接过了，但是，随后你关闭了python的交互模式，所以还要从新连接。这也是交互模式的缺点。不过在这里操作直观，所以暂且忍受一下，后面就会讲解如何在程序中自动完成了。

    >>> import MySQLdb
>>> conn = MySQLdb.connect(host="localhost",user="root",passwd="123123",db="qiwsirtest",charset="utf8")

    完成连接的过程，其实是建立了一个MySQLdb.connect()的实例对象conn，那么这个对象有哪些属性呢？

    • commit():如果数据库表进行了修改，提交保存当前的数据。当然，如果此用户没有权限就作罢了，什么也不会发生。
    • rollback():如果有权限，就取消当前的操作，否则报错。
    • cursor([cursorclass]):游标指针。下面详解。

    连接成功之后，开始操作。注意：MySQLdb用游标（指针）cursor的方式操作数据库，就是这样：

    >>> cur = conn.cursor()

    因该模块底层其实是调用CAPI的，所以，需要先得到当前指向数据库的指针。这也就提醒我们，在操作数据库的时候，指针会移动，如果移动到数据库最后一条了，再查，就查不出什么来了。看后面的例子就明白了。

    下面用cursor()提供的方法来进行操作，方法主要是:

    1. 执行命令
    2. 接收结果

    cursor执行命令的方法:

    • execute(query, args):执行单条sql语句。query为sql语句本身，args为参数值的列表。执行后返回值为受影响的行数。
    • executemany(query, args):执行单条sql语句,但是重复执行参数列表里的参数,返回值为受影响的行数

    例如，要在数据表users中插入一条记录，使得:username="python",password="123456",email="python@gmail.com"，这样做：

    >>> cur.execute("insert into users (username,password,email) values (%s,%s,%s)",("python","123456","python@gmail.com"))
1L

    没有报错，并且返回一个"1L"结果，说明有一行记录操作成功。不妨用"mysql>"交互方式查看一下：

    mysql> select * from users;
+----+----------+----------+------------------+
| id | username | password | email            |
+----+----------+----------+------------------+
|  1 | qiwsir   | 123123   | qiwsir@gmail.com |
+----+----------+----------+------------------+
1 row in set (0.00 sec)

    咦，奇怪呀。怎么没有看到增加的那一条呢？哪里错了？可是上面也没有报错呀。

    在这里，特别请列位看官注意，通过"cur.execute()"对数据库进行操作之后，没有报错，完全正确，但是不等于数据就已经提交到数据库中 了，还必须要用到"MySQLdb.connect"的一个属性：commit()，将数据提交上去，也就是进行了"cur.execute()"操作， 要将数据提交，必须执行：

    >>> conn.commit()

    在到"mysql>"中运行"select * from users"试一试：

    mysql> select * from users;
+----+----------+----------+------------------+
| id | username | password | email            |
+----+----------+----------+------------------+
|  1 | qiwsir   | 123123   | qiwsir@gmail.com |
|  2 | python   | 123456   | python@gmail.com |
+----+----------+----------+------------------+
2 rows in set (0.00 sec)

    good，very good。果然如此。这就如同编写一个文本一样，将文字写到文本上，并不等于文字已经保留在文本文件中了，必须执行"CTRL-S"才能保存。也就是在通 过python操作数据库的时候，以"execute()"执行各种sql语句之后，要让已经执行的效果保存，必须运行"commit()"，还要提醒， 这个属性是"MySQLdb.connect()"实例的。

    再尝试一下插入多条的那个命令"executemany(query,args)".

    >>> cur.executemany("insert into users (username,password,email) values (%s,%s,%s)",(("google","111222","g@gmail.com"),("facebook","222333","f@face.book"),("github","333444","git@hub.com"),("docker","444555","doc@ker.com")))
4L
>>> conn.commit()

    到"mysql>"里面看结果：

    mysql> select * from users;
+----+----------+----------+------------------+
| id | username | password | email            |
+----+----------+----------+------------------+
|  1 | qiwsir   | 123123   | qiwsir@gmail.com |
|  2 | python   | 123456   | python@gmail.com |
|  3 | google   | 111222   | g@gmail.com      |
|  4 | facebook | 222333   | f@face.book      |
|  5 | github   | 333444   | git@hub.com      |
|  6 | docker   | 444555   | doc@ker.com      |
+----+----------+----------+------------------+
6 rows in set (0.00 sec)

    成功插入了多条记录。特别请列位注意的是，在"executemany(query,args)"中，query还是一条sql语句，但是args 这时候是一个tuple，这个tuple里面的元素也是tuple，每个tuple分别对应sql语句中的字段列表。这句话其实被执行多次。只不过执行过 程不显示给我们看罢了。

    实例1、取得MYSQL的版本

    在windows环境下安装mysql模块用于python开发

    MySQL-python Windows下EXE安装文件下载

    复制代码 代码如下:

    # -*- coding: UTF-8 -*-

    #安装MYSQL DB for python
    import MySQLdb as mdb

    con = None

    try:
        #连接mysql的方法：connect('ip','user','password','dbname')
        con = mdb.connect('localhost', 'root',
            'root', 'test');

        #所有的查询，都在连接con的一个模块cursor上面运行的
        cur = con.cursor()

        #执行一个查询
        cur.execute("SELECT VERSION()")

        #取得上个查询的结果，是单个结果
        data = cur.fetchone()
        print "Database version : %s " % data
    finally:
        if con:
            #无论如何，连接记得关闭
            con.close()

     
     执行结果：

    复制代码 代码如下:

    Database version : 5.5.25

    实例2、创建一个表并且插入数据

    主要还是在cursor上面执行execute方法来进行，请见源码：

    复制代码 代码如下:

    # -*- coding: UTF-8 -*-
    # 来源于总结整理
    import MySQLdb as mdb
    import sys

    #将con设定为全局连接
    con = mdb.connect('localhost', 'root', 'root', 'test');

    with con:

        #获取连接的cursor，只有获取了cursor，我们才能进行各种操作
        cur = con.cursor()
        #创建一个数据表 writers(id,name)
        cur.execute("CREATE TABLE IF NOT EXISTS
            Writers(Id INT PRIMARY KEY AUTO_INCREMENT, Name VARCHAR(25))")
        #以下插入了5条数据
        cur.execute("INSERT INTO Writers(Name) VALUES('Jack London')")
        cur.execute("INSERT INTO Writers(Name) VALUES('Honore de Balzac')")
        cur.execute("INSERT INTO Writers(Name) VALUES('Lion Feuchtwanger')")
        cur.execute("INSERT INTO Writers(Name) VALUES('Emile Zola')")
        cur.execute("INSERT INTO Writers(Name) VALUES('Truman Capote')")



    运行结果（在phpmyadmin中查看，在mysql命令行查看结果是一样的）：



    实例3、python使用slect获取mysql的数据并遍历

    这个恐怕是用的最多的了，请速看代码：

    复制代码 代码如下:

    # -*- coding: UTF-8 -*-
    # 来源：整理总结
    import MySQLdb as mdb
    import sys

    #连接mysql，获取连接的对象
    con = mdb.connect('localhost', 'root', 'root', 'test');

    with con:
        #仍然是，第一步要获取连接的cursor对象，用于执行查询
        cur = con.cursor()
        #类似于其他语言的query函数，execute是python中的执行查询函数
        cur.execute("SELECT * FROM Writers")

        #使用fetchall函数，将结果集（多维元组）存入rows里面
        rows = cur.fetchall()

        #依次遍历结果集，发现每个元素，就是表中的一条记录，用一个元组来显示
        for row in rows:
            print row


    运行结果：

    复制代码 代码如下:

    (1L, ‘Jack London')
    (2L, ‘Honore de Balzac')
    (3L, ‘Lion Feuchtwanger')
    (4L, ‘Emile Zola')
    (5L, ‘Truman Capote')

    上面的代码，用来将所有的结果取出，不过打印的时候是每行一个元祖打印，现在我们使用方法，取出其中的单个数据：

    复制代码 代码如下:

    # -*- coding: UTF-8 -*-
    # 来源：疯狂的蚂蚁的博客总结整理

    import MySQLdb as mdb
    import sys

    #获取mysql的链接对象
    con = mdb.connect('localhost', 'root', 'root', 'test');

    with con:
        #获取执行查询的对象
        cur = con.cursor()

        #执行那个查询，这里用的是select语句
        cur.execute("SELECT * FROM Writers")

        #使用cur.rowcount获取结果集的条数
        numrows = int(cur.rowcount)

        #循环numrows次，每次取出一行数据
        for i in range(numrows):
            #每次取出一行，放到row中，这是一个元组(id,name)
            row = cur.fetchone()
            #直接输出两个元素
            print row[0], row[1]

     
     运行结果：

    复制代码 代码如下:

    1 Jack London
    2 Honore de Balzac
    3 Lion Feuchtwanger
    4 Emile Zola
    5 Truman Capote

    numrows = int(cur.rowcount)用于获取结果集的数目
    row = cur.fetchone()每次取出一行数据，同时记录集的指针执行下一行

    实例4、使用字典cursor取得结果集（可以使用表字段名字访问值）

    复制代码 代码如下:

    # -*- coding: UTF-8 -*-
    # 来源：疯狂的蚂蚁的博客总结整理

    import MySQLdb as mdb
    import sys

    #获得mysql查询的链接对象
    con = mdb.connect('localhost', 'root', 'root', 'test')

    with con:
        #获取连接上的字典cursor，注意获取的方法，
        #每一个cursor其实都是cursor的子类
        cur = con.cursor(mdb.cursors.DictCursor)

        #执行语句不变
        cur.execute("SELECT * FROM Writers")

        #获取数据方法不变
        rows = cur.fetchall()

        #遍历数据也不变（比上一个更直接一点）
        for row in rows:
            #这里，可以使用键值对的方法，由键名字来获取数据
            print "%s %s" % (row["Id"], row["Name"])

    实例5、获取单个表的字段名和信息的方法

    复制代码 代码如下:

    # -*- coding: UTF-8 -*-
    # 来源：疯狂的蚂蚁的博客总结整理

    import MySQLdb as mdb
    import sys

    #获取数据库的链接对象
    con = mdb.connect('localhost', 'root', 'root', 'test')

    with con:
        #获取普通的查询cursor
        cur = con.cursor()
        cur.execute("SELECT * FROM Writers")

        rows = cur.fetchall()

        #获取连接对象的描述信息
        desc = cur.description
        print 'cur.description:',desc

        #打印表头，就是字段名字
        print "%s %3s" % (desc[0][0], desc[1][0])

        for row in rows:
            #打印结果
            print "%2s %3s" % row

     
     运行结果：

    复制代码 代码如下:

    cur.description: ((‘Id', 3, 1, 11, 11, 0, 0), (‘Name', 253, 17, 25, 25, 0, 1))
    Id Name
    1 Jack London
    2 Honore de Balzac
    3 Lion Feuchtwanger
    4 Emile Zola
    5 Truman Capote

    实例6、使用Prepared statements执行查询（更安全方便）

    复制代码 代码如下:

    # -*- coding: UTF-8 -*-
    # 来源：疯狂的蚂蚁的博客总结整理
    import MySQLdb as mdb
    import sys

    con = mdb.connect('localhost', 'root', 'root', 'test')

    with con:   

        cur = con.cursor()
        #我们看到，这里可以通过写一个可以组装的sql语句来进行
        cur.execute("UPDATE Writers SET Name = %s WHERE Id = %s",
            ("Guy de Maupasant", "4"))
        #使用cur.rowcount获取影响了多少行
        print "Number of rows updated: %d" % cur.rowcount

    结果：

    复制代码 代码如下:

    Number of rows updated: 1

    实例7、把图片用二进制存入MYSQL
    有人喜欢把图片存入MYSQL（这种做法貌似很少吧），我看大部 分的程序，图片都是存放在服务器上的文件，数据库中存的只是图片的地址而已，不过MYSQL是支持把图片存入数据库的，也相应的有一个专门的字段BLOB (Binary Large Object)，即较大的二进制对象字段，请看如下程序，注意测试图片自己随便找一个，地址要正确：

    首先，在数据库中创建一个表，用于存放图片：

    复制代码 代码如下:

    CREATE TABLE Images(Id INT PRIMARY KEY AUTO_INCREMENT, Data MEDIUMBLOB);

    然后运行如下PYTHON代码进行：

    复制代码 代码如下:

    # -*- coding: UTF-8 -*-
    # 来源：疯狂的蚂蚁的博客总结整理
    import MySQLdb as mdb
    import sys

    try:
        #用读文件模式打开图片
        fin = open("../web.jpg")
        #将文本读入img对象中
        img = fin.read()
        #关闭文件
        fin.close()

    except IOError, e:
        #如果出错，打印错误信息
        print "Error %d: %s" % (e.args[0],e.args[1])
        sys.exit(1)

    try:
        #链接mysql，获取对象
        conn = mdb.connect(host='localhost',user='root',passwd='root', db='test')
        #获取执行cursor
        cursor = conn.cursor()
        #直接将数据作为字符串，插入数据库
        cursor.execute("INSERT INTO Images SET Data='%s'" % mdb.escape_string(img))

        #提交数据
        conn.commit()

        #提交之后，再关闭cursor和链接
        cursor.close()
        conn.close()

    except mdb.Error, e:
        #若出现异常，打印信息
        print "Error %d: %s" % (e.args[0],e.args[1])
        sys.exit(1)

      
        结果：



    escape_string函数将插入数据库的字符串进行转义，这会指一些SQL注入的攻击

    实例8、从数据库中把图片读出来

    复制代码 代码如下:

    # -*- coding: UTF-8 -*-
    # 来源：疯狂的蚂蚁的博客总结整理
    import MySQLdb as mdb
    import sys

    try:
        #连接mysql，获取连接的对象
        conn = mdb.connect('localhost', 'root', 'root', 'test');

        cursor = conn.cursor()

        #执行查询该图片字段的SQL
        cursor.execute("SELECT Data FROM Images LIMIT 1")

        #使用二进制写文件的方法，打开一个图片文件，若不存在则自动创建
        fout = open('image.png','wb')
        #直接将数据如文件
        fout.write(cursor.fetchone()[0])
        #关闭写入的文件
        fout.close()

        #释放查询数据的资源
        cursor.close()
        conn.close()

    except IOError, e:
        #捕获IO的异常 ，主要是文件写入会发生错误
        print "Error %d: %s" % (e.args[0],e.args[1])
        sys.exit(1)
     



        实例9、使用Transaction即事务（手动提交，自动回滚）

       

    复制代码 代码如下:

    # -*- coding: UTF-8 -*-
    # 来源：疯狂的蚂蚁的博客总结整理
    import MySQLdb as mdb
    import sys

    try:
        #连接mysql，获取连接的对象
        conn = mdb.connect('localhost', 'root', 'root', 'test');

        cursor = conn.cursor()
        #如果某个数据库支持事务，会自动开启
        #这里用的是MYSQL，所以会自动开启事务（若是MYISM引擎则不会）
        cursor.execute("UPDATE Writers SET Name = %s WHERE Id = %s",
            ("Leo Tolstoy", "1"))
        cursor.execute("UPDATE Writers SET Name = %s WHERE Id = %s",
            ("Boris Pasternak", "2"))
        cursor.execute("UPDATE Writer SET Name = %s WHERE Id = %s",
            ("Leonid Leonov", "3"))  

        #事务的特性1、原子性的手动提交
        conn.commit()

        cursor.close()
        conn.close()

    except mdb.Error, e:
        #如果出现了错误，那么可以回滚，就是上面的三条语句要么执行，要么都不执行
        conn.rollback()
        print "Error %d: %s" % (e.args[0],e.args[1])
     

      
        结果：

    1、因为不存在writer表（SQL第三条语句），所以出现错误：
    Error 1146: Table ‘test.writer' doesn't exist
    2、出现错误，出发异常处理，3条语句的前两条会自动变成了没有执行，结果不变
    3、如果本代码放到一个MyISAM引擎表，前两句会执行，第三句不会；如果是INNDB引擎，则都不会执行。

    为方便大家本地浏览特提供一个pdf版本下载

    先花点时间来说说一个程序怎么和数据库进行交互
    1.和数据库建立连接
    2.执行sql语句,接收返回值
    3.关闭数据库连接
    使用MySQLdb也要遵循上面的几步.让我们一步步的进行.

    1、MySQL数据库要用MySQLdb模块,但Python用来链接MySQL的第三方库MySQLdb不支持Python3.x

    特别说明：我在我的电脑上实验时，我的python是2.7.2版本，安装对应版本的MySQLdb之后直接可以运行，并与数据库连接成功，所以如 果大家也像我一样顺利的话，下面的就不需要看了，直接跳过，看第2点如何执行sql语句即可！如果安装之后出现异常，可以参考一下下面的解决办法。

    连接的关键是安装MySQLdb模块要下载与Python相对应的版本：

    下载好后安装，它会自动检测到计算机Python的安装路径，并自动填写模块解压路径（我的是：D:ProgramFilesActivePython 2.6.6.17Libsite-packages）。

    但解压完成后并不能使用，还要修改MySQLdb模块下的一些文件：

    ①.在MySQLdb目录下（我的是：D:ProgramFilesActivePython 2.6.6.17Libsite-packagesMySQLdb）找到__init__.py：

    注释第34、35行的from setsimport ImmutableSet、class DBAPISet(ImmutableSet):，在后面添加class DBAPISet(frozenset):

       

     

    #  from sets import ImmutableSet

     
     

    #  class DBAPISet(ImmutableSet):

     

     

     

     

    class  DBAPISet(frozenset):

     

    ②.打开converters.py：

    注释第37行的from sets import BaseSet, Set，将第45行的return Set([ i for i in s.split(',') ifi ])中的Set改为set；同样将第129行的Set: Set2Str,中的Set改为set（不要修改Set2Str），到这里就修改完毕了


    2.建立数据库连接
    import MySQLdb
    conn=MySQLdb.connect(host="localhost",user="root",passwd="sa",db="mytable")
    　
    比较常用的参数包括
    host: 连接的数据库服务器主机名，默认为本地主机(localhost)。

    user:数据库登陆名.默认是当前用户.
    passwd:数据库登陆的秘密.默认为空.
    db:要使用的数据库名.没有默认值.
    port:MySQL服务使用的TCP端口.默认是3306.
    conn连接有两个重要的方法commit【提交新增和修改】,rollback【撤销新增或修改】

    3、执行数据库操作
    n=cursor.execute(sql,param)
    我们要使用连接对象获得一个cursor对象,接下来,我们会使用cursor提供的方法来进行工作.
    这些方法包括两大类:1.执行命令,2.接收返回值
    cursor用来执行命令的方法:
    　 callproc(self, procname, args):用来执行存储过程,接收的参数为存储过程名和参数列表,返回值为受影响的行数
    　 execute(self, query, args):执行单条sql语句,接收的参数为sql语句本身和使用的参数列表,返回值为受影响的行数
    　 executemany(self, query, args):执行单挑sql语句,但是重复执行参数列表里的参数,返回值为受影响的行数
    　 nextset(self):移动到下一个结果集
    　 cursor用来接收返回值的方法:
    　 fetchall(self):接收全部的返回结果行.
    　 fetchmany(self, size=None):接收size条返回结果行.如果size的值大于返回的结果行的数量,则会返回cursor.arraysize条数据.
    　 fetchone(self):返回一条结果行.
    　 scroll(self, value, mode='relative'):移动指针到某一行.如果mode='relative',则表示从当前所在行移动value条,如果mode='absolute',则表示从结果集的第一行移动value条.
    下面的代码是一个完整的例子.
    #使用sql语句,这里要接收的参数都用%s占位符.要注意的是,无论你要插入的数据是什么类型,占位符永远都要用%s
    sql="insert into cdinfo values(%s,%s,%s,%s,%s)"
    #param应该为tuple或者list
    param=(title,singer,imgurl,url,alpha)
    #执行,如果成功,n的值为1
    n=cursor.execute(sql,param)
    #再来执行一个查询的操作
    cursor.execute("select * from cdinfo")
    #我们使用了fetchall这个方法.这样,cds里保存的将会是查询返回的全部结果.每条结果都是一个tuple类型的数据,这些tuple组成了一个tuple
    cds=cursor.fetchall()
    #因为是tuple,所以可以这样使用结果集
    print cds[0][3]
    #或者直接显示出来,看看结果集的真实样子
    print cds
    #如果需要批量的插入数据,就这样做
    sql="insert into cdinfo values(0,%s,%s,%s,%s,%s)"
    #每个值的集合为一个tuple,整个参数集组成一个tuple,或者list
    param=((title,singer,imgurl,url,alpha),(title2,singer2,imgurl2,url2,alpha2))
    #使用executemany方法来批量的插入数据.这真是一个很酷的方法!
    n=cursor.executemany(sql,param)
    需要注意的是(或者说是我感到奇怪的是),在执行完插入或删除或修改操作后,需要调用一下 conn.commit()方法进行提交.这样,数据才会真正保存在数据库中.我不清楚是否是我的mysql设置问题,总之,今天我在一开始使用的时候, 如果不用commit,那数据就不会保留在数据库中,但是,数据确实在数据库呆过.因为自动编号进行了累积,而且返回的受影响的行数并不为0.

    4、关闭数据库连接
    需要分别的关闭指针对象和连接对象.他们有名字相同的方法
    cursor.close()
    conn.close()
    5、

    5 编码（防止乱码）

    需要注意的点：

    1 Python文件设置编码 utf-8 （文件前面加上 #encoding=utf-8)
        2 MySQL数据库charset=utf-8
        3 Python连接MySQL是加上参数 charset=utf8
        4 设置Python的默认编码为 utf-8 (sys.setdefaultencoding(utf-8)

    1. #encoding=utf-8
    2. import sys
    3. import MySQLdb
    5. reload(sys)
    6. sys.setdefaultencoding('utf-8')
    8. db=MySQLdb.connect(user='root',charset='utf8')

    注：MySQL的配置文件设置也必须配置成utf8

    6.模块功能演示
    #!/usr/bin/python
    import MySQLdb

    Con= MySQLdb.connect(host='localhost',user='root',passwd='root',db='abc')

    cursor =con.cursor()

    sql ="select * from myt"

    cursor.execute(sql)

    row=cursor.fetchone()

    print row

    cursor.close()

    con.close()

    执行以下SQL语句获取返回值：
    //获取连接的游标
    cursor=conn.cursor()
    //查询
    sql = "select * from 【table】"
    //新增
    sql = "insert into 【table】(字段,字段) values(值，值)"
    //修改
    sql = "update 【table】 set 字段 =‘值’where 条件 "
    //删除
    sql = "delete from 【table】where 条件"
    cursor.execute(sql)

    返回值
    cur.execute('select * from tables')
    其返回值为SQL语句得到的行数，如：2L，表示2行。
    然后，可以从该对象的fetchone或fetchall方法得到行信息。

    获取行信息
    指针对象的fetchone()方法，是每次得到一行的tuple返回值：
    引用
    >>> row=cur.fetchone()
    >>> print row
    ('user1', '52c69e3a57331081823331c4e69d3f2e', 1000L, 1000L, '/home/FTP/user1','')

    指针对象的fetchall()方法，可取出指针结果集中的所有行，返回的结果集一个元组(tuples)：
    引用
    >>> cur.scroll(0,'absolute')
    >>> row=cur.fetchall()
    >>> print row
    (('user1', '52c69e3a57331081823331c4e69d3f2e', 1000L, 1000L, '/home/FTP/user1',''), ('user2', '7e58d63b60197ceb55a1c487989a3720', 1000L, 1000L,'/home/FTP/user2', None))

    移动指针
    当使用fetchone()方法是，指针是会发生移动的。所以，若不重置指针，那么使用fetchall的信息将只会包含指针后面的行内容。
    手动移动指针使用：
    cur.scroll(int,parm)
    含义为：
    引用
    int：移动的行数，整数；在相对模式下，正数向下移动，负值表示向上移动。
    parm：移动的模式，默认是relative，相对模式；可接受absoulte，绝对模式。

    修改数据
    修改数据，包括插入、更新、删除。它们都是使用指针对象的execute()方法执行：
    cur.execute("insert into table (row1, row2) values ('111', '222')")
    cur.execute("update table set row1 = 'test' where row2 = 'row2' ")
    cur.execute("delete from table where row1 = 'row1' ")

    因单引号“'”用于SQL语句中的标识，所以，python中的字符串需使用双引号括住。
    此外，也可以使用python的“格式化字符串”写法，简化命令，例如：
    cur.execute("update table set row1 = '%s' where row2 = '%s' "%('value1','value2'))

    ※请注意，'%s'的单引号是SQL语句的间隔符，'value1'的单引号是python的字符串间隔符，其含义是不同的。是否需要间隔符，以及使用双引号还是单引号作为间隔，需根据其含义决定。例如，还有：
    cur.execute("update FTPUSERS set passwd=%s where userid='%s' "%("md5('123')",'user2'))

    这里，paswd=%s是因SQL的md5()函数是不需要单引号间隔的；"md5('123')"是python的字符串中含有单引号，所以用双引号括住。

    提交修改
    一般情况下，MySQLdb模块会自动提交修改。但我们在更新数据后，手动运行一次：
    conn.commit()

    关闭数据库连接
    需要分别的关闭指针对象和连接对象.他们有名字相同的方法
    cursor.close()
    conn.close()

    python使用mysql数据库

    2014-02-25 08:54 by 虫师, 32384 阅读, 1 评论, 收藏, 编辑

     

    一，安装mysql

     

    如果是windows 用户，mysql 的安装非常简单，直接下载安装文件，双击安装文件一步一步进行操作即可。

    Linux 下的安装可能会更加简单，除了下载安装包进行安装外，一般的linux 仓库中都会有mysql ，我们只需要通过一个命令就可以下载安装：

    Ubuntudeepin

    >>sudo apt-get install mysql-server 

    >>Sudo apt-get install  mysql-client

    centOS/redhat

    >>yum install mysql

     

    二，安装MySQL-python

    要想使python可以操作mysql 就需要MySQL-python驱动，它是python 操作mysql必不可少的模块。

    下载地址：https://pypi.python.org/pypi/MySQL-python/

    下载MySQL-python-1.2.5.zip 文件之后直接解压。进入MySQL-python-1.2.5目录:

    >>python setup.py install

     

    三，测试

    测试非常简单，检查MySQLdb 模块是否可以正常导入。

     

    复制代码
    fnngj@fnngj-H24X:~/pyse$ python 
Python 2.7.4 (default, Sep 26 2013, 03:20:56) 
[GCC 4.7.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import MySQLdb
    复制代码

     

    没有报错提示MySQLdb模块找不到，说明安装OK ，下面开始使用python 操作数据库之前，我们有必要来回顾一下mysql的基本操作：

     

     

    四，mysql 的基本操作

     

    $ mysql -u root -p  （有密码时）

    $ mysql -u root     （无密码时）

     

    复制代码
    mysql> show databases;  // 查看当前所有的数据库
+--------------------+
| Database           |
+--------------------+
| information_schema |
| csvt               |
| csvt04             |
| mysql              |
| performance_schema |
| test               |
+--------------------+
6 rows in set (0.18 sec)

mysql> use test;   //作用与test数据库
Database changed
mysql> show tables;   //查看test库下面的表
Empty set (0.00 sec)

//创建user表，name 和password 两个字段
mysql> CREATE  TABLE  user (name VARCHAR(20),password VARCHAR(20));  Query OK, 0 rows affected (0.27 sec)

//向user表内插入若干条数据
mysql> insert into user values('Tom','1321');
Query OK, 1 row affected (0.05 sec)

mysql> insert into user values('Alen','7875');
Query OK, 1 row affected (0.08 sec)

mysql> insert into user values('Jack','7455');
Query OK, 1 row affected (0.04 sec)

//查看user表的数据
mysql> select * from user;
+------+----------+
| name | password |
+------+----------+
| Tom  | 1321     |
| Alen | 7875     |
| Jack | 7455     |
+------+----------+
3 rows in set (0.01 sec)

//删除name 等于Jack的数据
mysql> delete from user where name = 'Jack';
Query OK, 1 rows affected (0.06 sec)

//修改name等于Alen 的password 为 1111
mysql> update user set password='1111' where name = 'Alen';
Query OK, 1 row affected (0.05 sec)
Rows matched: 1  Changed: 1  Warnings: 0

//查看表内容
mysql> select * from user;
+--------+----------+
| name   | password |
+--------+----------+
| Tom    | 1321     |
| Alen   | 1111     |
+--------+----------+
3 rows in set (0.00 sec)
    复制代码

     

     

     

    五，python 操作mysql数据库基础

    复制代码
    #coding=utf-8
import MySQLdb

conn= MySQLdb.connect(
        host='localhost',
        port = 3306,
        user='root',
        passwd='123456',
        db ='test',
        )
cur = conn.cursor()

#创建数据表
#cur.execute("create table student(id int ,name varchar(20),class varchar(30),age varchar(10))")

#插入一条数据
#cur.execute("insert into student values('2','Tom','3 year 2 class','9')")


#修改查询条件的数据
#cur.execute("update student set class='3 year 1 class' where name = 'Tom'")

#删除查询条件的数据
#cur.execute("delete from student where age='9'")

cur.close()
conn.commit()
conn.close()
    复制代码

    >>> conn = MySQLdb.connect(host='localhost',port = 3306,user='root', passwd='123456',db ='test',)

    Connect() 方法用于创建数据库的连接，里面可以指定参数：用户名，密码，主机等信息。

    这只是连接到了数据库，要想操作数据库需要创建游标。

     

    >>> cur = conn.cursor()

    通过获取到的数据库连接conn下的cursor()方法来创建游标。

     

    >>> cur.execute("create table student(id int ,name varchar(20),class varchar(30),age varchar(10))")

    通过游标cur 操作execute()方法可以写入纯sql语句。通过execute()方法中写如sql语句来对数据进行操作。

     

    >>>cur.close()

    cur.close() 关闭游标

    >>>conn.commit()

    conn.commit()方法在提交事物，在向数据库插入一条数据时必须要有这个方法，否则数据不会被真正的插入。

    >>>conn.close()

    Conn.close()关闭数据库连接

     

     

    六，插入数据

     

    通过上面execute()方法中写入纯的sql语句来插入数据并不方便。如：

    >>>cur.execute("insert into student values('2','Tom','3 year 2 class','9')")

    我要想插入新的数据，必须要对这条语句中的值做修改。我们可以做如下修改：

    复制代码
    #coding=utf-8
import MySQLdb

conn= MySQLdb.connect(
        host='localhost',
        port = 3306,
        user='root',
        passwd='123456',
        db ='test',
        )
cur = conn.cursor()

#插入一条数据
sqli="insert into student values(%s,%s,%s,%s)"
cur.execute(sqli,('3','Huhu','2 year 1 class','7'))

cur.close()
conn.commit()
conn.close()
    复制代码

     

    假如要一次向数据表中插入多条值呢？

    复制代码
    #coding=utf-8
import MySQLdb

conn= MySQLdb.connect(
        host='localhost',
        port = 3306,
        user='root',
        passwd='123456',
        db ='test',
        )
cur = conn.cursor()

#一次插入多条记录
sqli="insert into student values(%s,%s,%s,%s)"
cur.executemany(sqli,[
    ('3','Tom','1 year 1 class','6'),
    ('3','Jack','2 year 1 class','7'),
    ('3','Yaheng','2 year 2 class','7'),
    ])

cur.close()
conn.commit()
conn.close()
    复制代码

    executemany()方法可以一次插入多条值，执行单挑sql语句,但是重复执行参数列表里的参数,返回值为受影响的行数。

     

     

    七，查询数据

     

    也许你已经尝试了在python中通过

    >>>cur.execute("select * from student")

    来查询数据表中的数据，但它并没有把表中的数据打印出来，有些失望。

    来看看这条语句获得的是什么

    >>>aa=cur.execute("select * from student")

    >>>print aa

    5

    它获得的只是我们的表中有多少条数据。那怎样才能获得表中的数据呢？进入python shell

     

    复制代码
    >>> import MySQLdb
>>> conn = MySQLdb.connect(host='localhost',port = 3306,user='root',    passwd='123456',db ='test',)
>>> cur = conn.cursor()
>>> cur.execute("select * from student")
5L
>>> cur.fetchone()
(1L, 'Alen', '1 year 2 class', '6')
>>> cur.fetchone()
(3L, 'Huhu', '2 year 1 class', '7')
>>> cur.fetchone()
(3L, 'Tom', '1 year 1 class', '6')
...
>>>cur.scroll(0,'absolute')
    复制代码

     

    　　fetchone()方法可以帮助我们获得表中的数据，可是每次执行cur.fetchone() 获得的数据都不一样，换句话说我没执行一次，游标会从表中的第一条数据移动到下一条数据的位置，所以，我再次执行的时候得到的是第二条数据。

    　　scroll(0,'absolute') 方法可以将游标定位到表中的第一条数据。

     

    还是没解决我们想要的结果，如何获得表中的多条数据并打印出来呢？

    复制代码
    #coding=utf-8
import MySQLdb

conn= MySQLdb.connect(
        host='localhost',
        port = 3306,
        user='root',
        passwd='123456',
        db ='test',
        )
cur = conn.cursor()

#获得表中有多少条数据
aa=cur.execute("select * from student")
print aa

#打印表中的多少数据
info = cur.fetchmany(aa)
for ii in info:
    print ii
cur.close()
conn.commit()
conn.close()
    复制代码

    　　通过之前的print aa 我们知道当前的表中有5条数据，fetchmany()方法可以获得多条数据，但需要指定数据的条数，通过一个for循环就可以把多条数据打印出啦！执行结果如下：

     

    复制代码
    5
(1L, 'Alen', '1 year 2 class', '6')
(3L, 'Huhu', '2 year 1 class', '7')
(3L, 'Tom', '1 year 1 class', '6')
(3L, 'Jack', '2 year 1 class', '7')
(3L, 'Yaheng', '2 year 2 class', '7')
[Finished in 0.1s]
    复制代码

    python操作MySQL数据库

    2012-05-29 17:41 by Rollen Holt, 148468 阅读, 22 评论, 收藏, 编辑

    坚持每天学一点，每天积累一点点，作为自己每天的业余收获，这个文章是我在吃饭的期间写的，利用自己零散的时间学了一下python操作MYSQL，所以整理一下。

    我采用的是MySQLdb操作的MYSQL数据库。先来一个简单的例子吧：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    import MySQLdb
     
    try:
        conn=MySQLdb.connect(host='localhost',user='root',passwd='root',db='test',port=3306)
        cur=conn.cursor()
        cur.execute('select * from user')
        cur.close()
        conn.close()
    except MySQLdb.Error,e:
         print "Mysql Error %d: %s" % (e.args[0], e.args[1])

    　　请注意修改你的数据库，主机名，用户名，密码。

    下面来大致演示一下插入数据，批量插入数据，更新数据的例子吧：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    import MySQLdb
     
    try:
        conn=MySQLdb.connect(host='localhost',user='root',passwd='root',port=3306)
        cur=conn.cursor()
         
        cur.execute('create database if not exists python')
        conn.select_db('python')
        cur.execute('create table test(id int,info varchar(20))')
         
        value=[1,'hi rollen']
        cur.execute('insert into test values(%s,%s)',value)
         
        values=[]
        for i in range(20):
            values.append((i,'hi rollen'+str(i)))
             
        cur.executemany('insert into test values(%s,%s)',values)
     
        cur.execute('update test set info="I am rollen" where id=3')
     
        conn.commit()
        cur.close()
        conn.close()
     
    except MySQLdb.Error,e:
         print "Mysql Error %d: %s" % (e.args[0], e.args[1])

    　　请注意一定要有conn.commit()这句来提交事务，要不然不能真正的插入数据。

    运行之后我的MySQL数据库的结果就不上图了。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    import MySQLdb
     
    try:
        conn=MySQLdb.connect(host='localhost',user='root',passwd='root',port=3306)
        cur=conn.cursor()
         
        conn.select_db('python')
     
        count=cur.execute('select * from test')
        print 'there has %s rows record' % count
     
        result=cur.fetchone()
        print result
        print 'ID: %s info %s' % result
     
        results=cur.fetchmany(5)
        for r in results:
            print r
     
        print '=='*10
        cur.scroll(0,mode='absolute')
     
        results=cur.fetchall()
        for r in results:
            print r[1]
         
     
        conn.commit()
        cur.close()
        conn.close()
     
    except MySQLdb.Error,e:
         print "Mysql Error %d: %s" % (e.args[0], e.args[1])

    　　运行结果就不贴了，太长了。

    查询后中文会正确显示，但在数据库中却是乱码的。经过我从网上查找，发现用一个属性有可搞定：

    在Python代码 

    conn = MySQLdb.Connect(host='localhost', user='root', passwd='root', db='python') 中加一个属性：
     改为：
    conn = MySQLdb.Connect(host='localhost', user='root', passwd='root', db='python',charset='utf8') 
    charset是要跟你数据库的编码一样，如果是数据库是gb2312 ,则写charset='gb2312'。

    下面贴一下常用的函数：

    然后,这个连接对象也提供了对事务操作的支持,标准的方法
    commit() 提交
    rollback() 回滚

    cursor用来执行命令的方法:
    callproc(self, procname, args):用来执行存储过程,接收的参数为存储过程名和参数列表,返回值为受影响的行数
    execute(self, query, args):执行单条sql语句,接收的参数为sql语句本身和使用的参数列表,返回值为受影响的行数
    executemany(self, query, args):执行单挑sql语句,但是重复执行参数列表里的参数,返回值为受影响的行数
    nextset(self):移动到下一个结果集

    cursor用来接收返回值的方法:
    fetchall(self):接收全部的返回结果行.
    fetchmany(self, size=None):接收size条返回结果行.如果size的值大于返回的结果行的数量,则会返回cursor.arraysize条数据.
    fetchone(self):返回一条结果行.
    scroll(self, value, mode='relative'):移动指针到某一行.如果mode='relative',则表示从当前所在行移动value条,如果 mode='absolute',则表示从结果集的第一行移动value条.

    参考资料：

    MySQLdb‘s user guide

    package MySQLdb
  • 相关阅读:
    判断负环
    Max GEQ Sum （区间最大值>最大值的覆盖+区间和的最值问题>前缀和最值问题(l1,r)+是否合格，存在问题变化为最值问题）
    生物芯片 （大数据+打表找规律）（数论小知识）
    幂一矩阵 （矩阵找规律+最小公倍数）
    Log大侠 蓝桥杯（势能线段树）
    intergal test
    水群 题意转化建图+最短路 问题
    chino with c language （理解题意形模拟题）
    jmeter转义
    C# 常用类型互转总结
  • 原文地址：https://www.cnblogs.com/timssd/p/4688032.html
Copyright © 2020-2023  润新知