Python的MySQL操作

Python的DB-API,為大多數的數據庫實現了接口,使用它連接各數據庫后,就可以用相同的方式操作各數據庫。

Python DB-API使用流程:

• 引入API模塊。
• 獲取與數據庫的連接。
• 執行SQL語句和存儲過程。
• 關閉數據庫連接。

一、安裝MySQL客戶端　　

　　MySQLdb 是用於Python鏈接Mysql數據庫的接口，它實現了 Python 數據庫 API 規范 V2.0，基於 MySQL C API 上建立的。

　　如果是windows系統：登錄https://pypi.python.org/pypi/MySQL-python/1.2.5找到.exe結尾的包，下載安裝就好了，然后在cmd中執行：

　　

　　如果結果如上圖所示，則說明安裝成功了。

　　如果是Linux系統，可以下載源碼包進行安裝，https://pypi.python.org/pypi/MySQL-python/1.2.5中下載zip包，然后安裝：

yum install –y python-devel
yum install –y mysql-devel
yum install –y gcc
unzip MySQL-python-1.2.5.zip
cd MySQL-python-1.2.5
python setup.py build
python setup.py install
python
>>> import MySQLdb

 

二、數據庫連接

　　MySQLdb提供了connect方法用來和數據庫建立連接,接收數個參數,返回連接對象：代碼如下:

　　首先在mysql的數據庫中建立python庫

create database python;

conn=MySQLdb.connect(host="192.168.203.12",user="momo",passwd="123456",db="python",charset="utf8")

　　比較常用的參數包括:

　　host:數據庫主機名.默認是用本地主機

　　user:數據庫登陸名.默認是當前用戶

　　passwd:數據庫登陸的秘密.默認為空

　　db:要使用的數據庫名.沒有默認值

　　port:MySQL服務使用的TCP端口.默認是3306，數字類型

　　charset:數據庫編碼

　　推薦把所有數據庫的配置寫在一個字典中，如下所示：

def connect_mysql():
    db_config = {
        'host': '192.168.203.12',
        'port': 3306,
        'user': 'momo',
        'passwd': '123456',
        'db': 'python',
        'charset': 'utf8'
    }
    cnx = MySQLdb.connect(**db_config)
return cnx

　　

三、MySQL事物　　

　　MySQL 事務主要用於處理操作量大，復雜度高的數據。比如，你操作一個數據庫，公司的一個員工離職了，你要在數據庫中刪除他的資料，也要刪除該人員相關的，比如郵箱，個人資產等。這些數據庫操作語言就構成了一個事務。

　　在MySQL中只有使用了Innodb數據庫引擎的數據庫或表才支持事務，所以很多情況下我們都使用innodb引擎。

　　事務處理可以用來維護數據庫的完整性，保證成批的SQL語句要么全部執行，要么全部不執行。

　　一般來說，事務是必須滿足4個條件（ACID）： Atomicity（原子性）、Consistency（穩定性）、Isolation（隔離性）、Durability（可靠性）

　　1、事務的原子性：一組事務，要么成功；要么撤回。

　　2、穩定性 ： 有非法數據（外鍵約束之類），事務撤回。

　　3、隔離性：事務獨立運行。一個事務處理后的結果，影響了其他事務，那么其他事務會撤回。事務的100%隔離，需要犧牲速度。

　　4、可靠性：軟、硬件崩潰后，InnoDB數據表驅動會利用日志文件重構修改。可靠性和高速度不可兼得， innodb_flush_log_at_trx_commit選項 決定什么時候吧事務保存到日志里。

　　而mysql在默認的情況下，他是把每個select，insert，update，delete等做為一個事務的，登錄mysql服務器，進入mysql，執行以下命令：

mysql> show variables like 'auto%';
+--------------------------+-------+
| Variable_name            | Value |
+--------------------------+-------+
| auto_increment_increment | 1     |
| auto_increment_offset    | 1     |
| autocommit               | ON    |
| automatic_sp_privileges  | ON    |
+--------------------------+-------+
4 rows in set (0.00 sec)

　　如上所示： 有一個參數autocommit就是自動提交的意思，每執行一個msyql的select，insert，update等操作，就會進行自動提交。

　　如果把改選項關閉，我們就可以每次執行完一次代碼就需要進行手動提交，connect對象給我們提供了兩種辦法來操作提交數據。

　　a)        mysql事務的方法

　　commit():提交當前事務，如果是支持事務的數據庫執行增刪改后沒有commit則數據庫默認回滾，白操作了

　　rollback():取消當前事務

　　下面我們來看個例子：

　　我們先創建一個員工表：

  create table employees (
        emp_no int not null auto_increment,
        emp_name varchar(16) not null,
        gender enum('M', 'F') not null,
        hire_date date not null,
        primary key (emp_no)
        );

　　其中，emp_no為員工id，為主鍵且唯一

　　emp_name為：員工的名字

　　fender為：性別，只有M和F兩種選擇

　　hire_date為：雇佣的時間。

　　為了試驗的效果，我們插入幾條數據：

insert into employees(emp_no, emp_name, gender, hire_date) values(1001, 'lingjiang', 'M', '2015-04-01');
insert into employees(emp_no, emp_name, gender, hire_date) values(1002, 'xiang', 'M', '2015-04-01');
insert into employees(emp_no, emp_name, gender, hire_date) values(1003, 'shang', 'M', '2015-04-01');
mysql> select * from employees;
+--------+-----------+--------+------------+
| emp_no | emp_name  | gender | hire_date  |
+--------+-----------+--------+------------+
|   1001 | lingjiang | M      | 2015-04-01 |
|   1002 | xiang     | M      | 2015-04-01 |
|   1003 | shang     | M      | 2015-04-01 |
+--------+-----------+--------+------------+
e)    rows in set (0.00 sec)

 

 四、MySQL游標

　　

游標（cursor）

 　　游標是系統為用戶開設的一個數據緩沖區，存放SQL語句的執行結果，用戶可以用SQL語句逐一從游標中獲取記錄，並賦給主變量，交由python進一步處理，一組主變量一次只能存放一條記錄，僅使用主變量並不能完全滿足SQL語句向應用程序輸出數據的要求。

　　

　　游標和游標的優點：在數據庫中，游標是一個十分重要的概念。游標提供了一種對從表中檢索出的數據進行操作的靈活手段，就本質而言，游標實際上是一種能從包括多條數據記錄的結果集中每次提取一條記錄的機制。游標總是與一條SQL 選擇語句相關聯因為游標由結果集（可以是零條、一條或由相關的選擇語句檢索出的多條記錄）和結果集中指向特定記錄的游標位置組成。當決定對結果集進行處理時，必須聲明一個指向該結果集的游標。

　　常用方法:

　　cursor():創建游標對象
       close():關閉此游標對象
       fetchone():得到結果集的下一行
       fetchmany([size = cursor.arraysize]):得到結果集的下幾行
       fetchall():得到結果集中剩下的所有行
       excute(sql[, args]):執行一個數據庫查詢或命令
       executemany (sql, args):執行多個數據庫查詢或命令

　　程序例子： 

　　1.創建游標對象

import MySQLdb
 db_config = {
        'host': '192.168.203.12',
        'port': 3306,
        'user': 'momo',
        'passwd': '123456',
        'db': 'python',
        'charset': 'utf8'
    }
cnx = MySQLdb.connect(**db_config)
cus = cnx.cursor()

　　2.對游標的基本操作

import MySQLdb

def connect_mysql():
    db_config = {
        'host': '192.168.203.12',
        'port': 3306,
        'user': 'momo',
        'passwd': '123456',
        'db': 'python',
        'charset': 'utf8'
    }
    cnx = MySQLdb.connect(**db_config)
    return cnx

if __name__ == '__main__':
    cnx = connect_mysql()
    cus = cnx.cursor()
    sql  = '''select * from employees;'''
    try:
        cus.execute(sql)
        result1 = cus.fetchone()
        print('result1:')
        print(result1)
        result2 = cus.fetchmany(1)
        print('result2:')
        print(result2)
        result3 = cus.fetchall()
        print('result3:')
        print(result3)        cus.close()
        cnx.commit()
    except Exception as e:
        cnx.rollback()
        print('error')
        raise e
    finally:
        cnx.close()

　　結果：　

result1:

(1001L, u'lingjiang', u'M', datetime.date(2015, 4, 1))

result2:

((1002L, u'xiang', u'M', datetime.date(2015, 4, 1)),)

result3:

((1003L, u'shang', u'M', datetime.date(2015, 4, 1)),)

　　解釋：

　　  先通過MySQLdb.connect(**db_config)建立mysql連接對象

　　在通過 = cnx.cursor()創建游標

　　fetchone():在最終搜索的數據中去一條數據

　　fetchmany(1)在接下來的數據中在去1行的數據，這個數字可以自定義，定義多少就是在結果集中取多少條數據。

　　fetchall()是在所有的結果中搞出來所有的數據。

 

　　3.執行多行SQL語句

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# @Time    : 2017/9/18 22:17
# @Author  : lingxiangxiang
# @File    : domon3.py

from demon2 import connect_mysql


import MySQLdb


def connect_mysql():
    db_config = {
        "host": "192.168.203.12",
        "port": 3306,
        "user": "momo",
        "passwd": "123456",
        "db": "python",
        "charset": "utf8"
    }
    try:
        cnx = MySQLdb.connect(**db_config)
    except Exception as e:
        raise e
    return cnx
if __name__ == "__main__":
    sql = "select * from tmp;"
    sql1 = "insert into tmp(id) value (%s);"
    param = []
    for i in xrange(100, 130):
        param.append([str(i)])
    print(param)
    cnx = connect_mysql()
    cus = cnx.cursor()
    print(dir(cus))
    try:
        cus.execute(sql)
        cus.executemany(sql1, param)
        # help(cus.executemany)
        result1 = cus.fetchone()
        print("result1")
        print(result1)

        result2 = cus.fetchmany(3)
        print("result2")
        print(result2)

        result3 = cus.fetchall()
        print("result3")
        print(result3)
        cus.close()
        cnx.commit()

    except Exception as e:
        cnx.rollback()
        raise e
    finally:
        cnx.close()

 

五、數據庫連接池

　　python編程中可以使用MySQLdb進行數據庫的連接及諸如查詢/插入/更新等操作，但是每次連接mysql數據庫請求時，都是獨立的去請求訪問，相當浪費資源，而且
訪問數量達到一定數量時，對mysql的性能會產生較大的影響。因此，實際使用中，通常會使用數據庫的連接池技術，來訪問數據庫達到資源復用的目的。
　　

　　

python的數據庫連接池包 DBUtils：

DBUtils是一套Python數據庫連接池包，並允許對非線程安全的數據庫接口進行線程安全包裝。DBUtils來自Webware for Python。

DBUtils提供兩種外部接口：

* PersistentDB ：提供線程專用的數據庫連接，並自動管理連接。

* PooledDB ：提供線程間可共享的數據庫連接，並自動管理連接。

PooledDB的參數：

1. mincached，最少的空閑連接數，如果空閑連接數小於這個數，pool會創建一個新的連接

2. maxcached，最大的空閑連接數，如果空閑連接數大於這個數，pool會關閉空閑連接

3. maxconnections，最大的連接數，

4. blocking，當連接數達到最大的連接數時，在請求連接的時候，如果這個值是True，
請求連接的程序會一直等待，直到當前連接數小於最大連接數，如果這個值是False，會報錯，

5. maxshared 當連接數達到這個數，新請求的連接會分享已經分配出去的連接

在uwsgi中，每個http請求都會分發給一個進程，連接池中配置的連接數都是一個進程為單位的（即上面的最大連接數，都是在一個進程中的連接數），
而如果業務中，一個http請求中需要的sql連接數不是很多的話（其實大多數都只需要創建一個連接），配置的連接數配置都不需要太大。

連接池對性能的提升表現在：

1.在程序創建連接的時候，可以從一個空閑的連接中獲取，不需要重新初始化連接，提升獲取連接的速度

2.關閉連接的時候，把連接放回連接池，而不是真正的關閉，所以可以減少頻繁地打開和關閉連接

 六、數據庫的操作

1.建表

　　各個表的結構如下：

　　student表：

字段名	類型	是否為空	主鍵	描述
StdID	int	否	是	學生ID
StdName	varchar(100)	否		學生姓名
Gender	enum('M', 'F')	是		性別
Age	tinyint	是		年齡

　　course表：

字段名	類型	是否為空	主鍵	描述
CouID	int	否	是	課程ID
Cname	varchar(50)	否		課程名字
TID	int	否		老師ID

 

　　　Score表：

字段名	類型	是否為空	主鍵	描述
SID	int	否	是	分數ID
StdID	int	否		學生id
CouID	int	否		課程id
Grade	int	否		分數

 

　　teacher表：

字段名	類型	是否為空	主鍵	描述
TID	int	否	是	老師ID
Tname	varcher(100)	否		老師名字

 

　　在Linux中MySQL建立student表，然后在Python代碼中執行：

import MySQLdb
def connect_mysql():
    db_config = {
        'host': '192.168.203.12',
        'port': 3306,
        'user': 'momo',
        'passwd': '123456',
        'db': 'student',
        'charset': 'utf8'
    }
    cnx = MySQLdb.connect(**db_config)
    return cnx

if __name__ == '__main__':
    cnx = connect_mysql()
    cus = cnx.cursor()
    # sql  = '''insert into student(id, name, age, gender, score) values ('1001', 'ling', 29, 'M', 88), ('1002', 'ajing', 29, 'M', 90), ('1003', 'xiang', 33, 'M', 87);'''
    student = '''create table Student(
            StdID int not null,
            StdName varchar(100) not null,
            Gender enum('M', 'F'),
            Age tinyint
    )'''
    course = '''create table Course(
            CouID int not null,
            CName varchar(50) not null,
            TID int not null
    )'''
    score = '''create table Score(
                SID int not null,
                StdID int not null,
                CID int not null,
                Grade int not null
        )'''
    teacher = '''create table Teacher(
                    TID int not null,
                    TName varchar(100) not null
            )'''
     tmp = '''set @i := 0;
            create table tmp as select (@i := @i + 1) as id from information_schema.tables limit 10;
        '''
    try:
        cus.execute(student)
        cus.execute(course)
        cus.execute(score)
        cus.execute(thearch)
           cus.execute(tmp)
        cus.close()
        cnx.commit()
    except Exception as e:
        cnx.rollback()
        print('error')
        raise e
    finally:
        cnx.close()

　　結果：

mysql> show tables;

+------------------+

| Tables_in_python |

+------------------+

| Course           |

| Score            |

| Student          |

| Teacher          |

| tmp              |

+------------------+

1        rows in set (0.00 sec)

information_schema數據庫表說明:

 

SCHEMATA表：提供了當前mysql實例中所有數據庫的信息。是show databases的結果取之此表。

 

TABLES表：提供了關於數據庫中的表的信息（包括視圖）。詳細表述了某個表屬於哪個schema，表類型，表引擎，創建時間等信息。是show tables from schemaname的結果取之此表。

 

COLUMNS表：提供了表中的列信息。詳細表述了某張表的所有列以及每個列的信息。是show columns from schemaname.tablename的結果取之此表。

 

STATISTICS表：提供了關於表索引的信息。是show index from schemaname.tablename的結果取之此表。

 

USER_PRIVILEGES（用戶權限）表：給出了關於全程權限的信息。該信息源自mysql.user授權表。是非標准表。

 

SCHEMA_PRIVILEGES（方案權限）表：給出了關於方案（數據庫）權限的信息。該信息來自mysql.db授權表。是非標准表。

 

TABLE_PRIVILEGES（表權限）表：給出了關於表權限的信息。該信息源自mysql.tables_priv授權表。是非標准表。

 

COLUMN_PRIVILEGES（列權限）表：給出了關於列權限的信息。該信息源自mysql.columns_priv授權表。是非標准表。

 

CHARACTER_SETS（字符集）表：提供了mysql實例可用字符集的信息。是SHOW CHARACTER SET結果集取之此表。

COLLATIONS表：提供了關於各字符集的對照信息。

 

COLLATION_CHARACTER_SET_APPLICABILITY表：指明了可用於校對的字符集。這些列等效於SHOW COLLATION的前兩個顯示字段。

 

TABLE_CONSTRAINTS表：描述了存在約束的表。以及表的約束類型。

 

KEY_COLUMN_USAGE表：描述了具有約束的鍵列。

 

ROUTINES表：提供了關於存儲子程序（存儲程序和函數）的信息。此時，ROUTINES表不包含自定義函數（UDF）。名為“mysql.proc name”的列指明了對應於INFORMATION_SCHEMA.ROUTINES表的mysql.proc表列。

 

VIEWS表：給出了關於數據庫中的視圖的信息。需要有show views權限，否則無法查看視圖信息。

 

TRIGGERS表：提供了關於觸發程序的信息。必須有super權限才能查看該表

 

而TABLES在安裝好mysql的時候，一定是有數據的，因為在初始化mysql的時候，就需要創建系統表，該表一定有數據。

set @i := 0;
create table tmp as select (@i := @i + 1) as id from information_schema.tables limit 10;

mysql中變量不用事前申明，在用的時候直接用“@變量名”使用就可以了。set這個是mysql中設置變量的特殊用法，當@i需要在select中使用的時候，必須加:，這樣就創建好了一個表tmp，查看tmp的數據：

mysql> select * from tmp;

+------+

| id   |

+------+

|    1 |

|    2 |

|    3 |

|    4 |

|    5 |

|    6 |

|    7 |

|    8 |

|    9 |

|   10 |

+------+

10 rows in set (0.00 sec)

我們只是從information_schema.tables表中取10條數據，任何表有10條數據也是可以的，然后把變量@i作為id列的值，分10次不斷輸出，依據最后select的結果，創建表tmp。

 

2.增加數據

substr是一個字符串函數，從第二個參數1,開始取字符，取到3+ floor(rand() * 75)結束

floor函數代表的是去尾法取整數。

rand()函數代表的是從0到1取一個隨機的小數。

rand() * 75就代表的是：0到75任何一個小數，

3+floor(rand() * 75)就代表的是：3到77的任意一個數字

concat()函數是一個對多個字符串拼接函數。

sha1是一個加密函數，sha1(rand())對生成的0到1的一個隨機小數進行加密，轉換成字符串的形式。

       concat(sha1(rand()), sha1(rand()))就代表的是：兩個0-1生成的小數加密然后進行拼接。

substr(concat(sha1(rand()), sha1(rand())), 1, floor(rand() * 80))就代表的是：從一個隨機生成的一個字符串的第一位開始取，取到（隨機3-77）位結束。

Gender字段：case floor(rand()*10) mod 2 when 1 then 'M' else 'F' end,就代表的是，

       floor(rand()*10)代表0-9隨機取一個數

       floor(rand()*10) mod 2 就是對0-9取得的隨機數除以2的余數，

case floor(rand()*10) mod 2 when 1 then 'M' else 'F' end,代表：當余數為1是，就取M，其他的為F

Age字段：25-floor(rand() * 5)代表的就是，25減去一個0-4的一個整數

代碼如下：

import MySQLdb
def connect_mysql():
    db_config = {
        'host': '192.168.203.12',
        'port': 3306,
        'user': 'momo',
        'passwd': '123456',
        'db': 'student',
        'charset': 'utf8'
    }
    cnx = MySQLdb.connect(**db_config)
    return cnx

if __name__ == '__main__':
    cnx = connect_mysql()


    students = '''set @i := 10000;
            insert into Student select @i:=@i+1, substr(concat(sha1(rand()), sha1(rand())), 1, 3 + floor(rand() * 75)), case floor(rand()*10) mod 2 when 1 then 'M' else 'F' end, 25-floor(rand() * 5)  from tmp a, tmp b, tmp c, tmp d;
        '''
    course = '''set @i := 10;
            insert into Course select @i:=@i+1, substr(concat(sha1(rand()), sha1(rand())), 1, 5 + floor(rand() * 40)),  1 + floor(rand() * 100) from tmp a;
        '''
    score = '''set @i := 10000;
            insert into Score select @i := @i +1, floor(10001 + rand()*10000), floor(11 + rand()*10), floor(1+rand()*100) from tmp a, tmp b, tmp c, tmp d;
        '''
    theacher = '''set @i := 100;
            insert into Teacher select @i:=@i+1, substr(concat(sha1(rand()), sha1(rand())), 1, 5 + floor(rand() * 80)) from tmp a, tmp b;
        '''
    try:
        cus_students = cnx.cursor()
        cus_students.execute(students)
        cus_students.close()

        cus_course = cnx.cursor()
        cus_course.execute(course)
        cus_course.close()

        cus_score = cnx.cursor()
        cus_score.execute(score)
        cus_score.close()

        cus_teacher = cnx.cursor()
        cus_teacher.execute(theacher)
        cus_teacher.close()

        cnx.commit()
    except Exception as e:
        cnx.rollback()
        print('error')
        raise e
    finally:
        cnx.close()

 

3.查數據

在數據庫中查出來所有名字有重復的同學的所有信息，然后寫入到文件中，代碼如下：

import codecs

import MySQLdb
def connect_mysql():
    db_config = {
        'host': '192.168.203.12',
        'port': 3306,
        'user': 'momo',
        'passwd': '123456',
        'db': 'student',
        'charset': 'utf8'
    }
    cnx = MySQLdb.connect(**db_config)
    return cnx

if __name__ == '__main__':
    cnx = connect_mysql()

    sql = '''select * from Student where StdName in (select StdName from Student group by StdName having count(1)>1 ) order by StdName;'''
    try:
        cus = cnx.cursor()
        cus.execute(sql)
        result = cus.fetchall()
        with codecs.open('select.txt', 'w+') as f:
            for line in result:
                f.write(str(line))
                f.write('\n')
        cus.close()
        cnx.commit()
    except Exception as e:
        cnx.rollback()
        print('error')
        raise e
    finally:
        cnx.close()

解釋:

• 我們先來分析一下select查詢這個語句：select * from Student where StdName in (select StdName from Student group by StdName having count(1)>1 ) order by StdName;'
• 我們先來看括號里面的語句：select StdName from Student group by StdName having count(1)>1；這個是把所有學生名字重復的學生都列出來，
• 最外面select是套了一個子查詢，學生名字是在我們（）里面的查出來的學生名字，把這些學生的所有信息都列出來。
• result = cus.fetchall()列出結果以后，我們通過fetchall()函數把所有的內容都取出來，這個result是一個tuple
• 通過文件寫入的方式，我們把取出來的result寫入到select.txt文件中。得到最終的結果

4.刪除數據

　　刪除課程成績最差的5名老師，刪除之前要先進行查詢。代碼如下：

import codecs

import MySQLdb
def connect_mysql():
    db_config = {
        'host': '192.168.203.12',
        'port': 3306,
        'user': 'momo',
        'passwd': '123456',
        'db': 'student',
        'charset': 'utf8'
    }
    cnx = MySQLdb.connect(**db_config)
    return cnx

if __name__ == '__main__':
    cnx = connect_mysql()

    sql = '''delete from Teacher where TID in(
    select TID from (select Course.CouID, Course.TID, Teacher.TName, count(Teacher.TID) as count_teacher from Course
    left join Score on Score.Grade < 60 and Course.CouID = Score.CouID
    left join Teacher on Course.TID = Teacher.TID
    group by Course.TID
    order by count_teacher desc
    limit 5)  as test )
    '''
    try:
        cus = cnx.cursor()
        cus.execute(sql)
        result = cus.fetchall()
        cus.close()
        cnx.commit()
    except Exception as e:
        cnx.rollback()
        print('error')
        raise e
    finally:
        cnx.close()

　　　解釋：

• 先查詢出Course表中的Course.TID和Course.TID
• left join 是關聯Score表，查出Score.Grade > 59，並且，課程ID和課程表的CouID要對應上
• left join Teacher 是關聯老師表，課程中的了老師ID和老師表中的老師ID對應上
• select中加上老師的名字Teacher.Tname和count(Teacher.TID)
• group by Course.TID，在根據老師的的TID進行分組
• oder by 最后對count_teacher進行排序，取前5行，
• 在通過套用一個select子查詢，把所有的TID摟出來
• 然后delete from Teacher 最后刪除TID在上表中的子查詢中

5.修改數據

　　把分數低於5分的成績加上60分，代碼如下：

import codecs

import MySQLdb
def connect_mysql():
    db_config = {
        'host': '192.168.203.12',
        'port': 3306,
        'user': 'momo',
        'passwd': '123456',
        'db': 'student',
        'charset': 'utf8'
    }
    cnx = MySQLdb.connect(**db_config)
    return cnx

if __name__ == '__main__':
    cnx = connect_mysql()

    sql = '''select *, (grade+60) as newGrade from Score where Grade <5;'''
    update = '''update Score set grade = grade + 60 where grade < 5;  '''
    try:
        cus_start = cnx.cursor()
        cus_start.execute(sql)
        result1 = cus_start.fetchall()
        print(len(result1))
        cus_start.close()

        cus_update = cnx.cursor()
        cus_update.execute(update)
        cus_update.close()

        cus_end = cnx.cursor()
        cus_end.execute(sql)
        result2 = cus_end.fetchall()
        print(len(result2))
        cus_end.close()

        cnx.commit()
    except Exception as e:
        cnx.rollback()
        print('error')
        raise e
    finally:
        cnx.close()

解釋：

•  剛開始，我們可以查到分數小於5分的總個數有321個
• select *, (grade+60) as newGrade from Score where Grade <5;這個sql是把所有的成績小於5的都列出來，然后最后加一列分數加60分的結果。
•  update Score set grade = grade + 60 where grade < 5;是把分數小於5的所有成績都加60分
• 最后在檢查分數小於5的個數為0，說明所有低於5分的分數都發生了改變。

6.索引

　　MySQL索引的概念

　　索引是一種特殊的文件(InnoDB數據表上的索引是表空間的一個組成部分)，它們包含着對數據表里所有記錄的引用指針。更通俗的說，數據庫索引好比是一本書前面的目錄，能加快數據庫的查詢速度。

　　索引類別

　　普通索引

　　普通索引（由關鍵字 KEY 或 INDEX 定義的索引）的唯一任務是加快對數據的訪問速度。因此，應該只為那些最經常出現在查詢條件（WHERE column =）或排序條件（ORDER BY column）中的數據列創建索引。只要有可能，就應該選擇一個數據最整齊、最緊湊的數據列（如一個整數類型的數據列）來創建索引。

　　唯一索引

　　普通索引允許被索引的數據列包含重復的值。比如說，因為人有可能同名，所以同一個姓名在同一個“員工個人資料”數據表里可能出現兩次或更多次。

如果能確定某個數據列將只包含彼此各不相同的值，在為這個數據列創建索引的時候就應該用關鍵字UNIQUE 把它定義為一個唯一索引。這么做的好處：一是簡化了 MySQL 對這個索引的管理工作，這個索引也因此而變得更有效率；二是 MySQL 會在有新記錄插入數據表時，自動檢查新記錄的這個字段的值是否已經在某個記錄的這個字段里出現過了；如果是，MySQL 將拒絕插入那條新記錄。也就是說，唯一索引可以保證數據記錄的唯一性。事實上，在許多場合，人們創建唯一索引的目的往往不是為了提高訪問速度，而只是為了避免數據出現重復。

　　主索引

　　在前面已經反復多次強調過：必須為主鍵字段創建一個索引，這個索引就是所謂的“主索引”。主索引與唯一索引的唯一區別是：前者在定義時使用的關鍵字是 PRIMARY 而不是 UNIQUE。

　　外鍵索引

　　如果為某個外鍵字段定義了一個外鍵約束條件，MySQL 就會定義一個內部索引來幫助自己以最有效率的方式去管理和使用外鍵約束條件。

　　復合索引

　　索引可以覆蓋多個數據列，如像 INDEX (columnA, columnB) 索引。這種索引的特點是 MySQL 可以有選擇地使用一個這樣的索引。如果查詢操作只需要用到 columnA 數據列上的一個索引，就可以使用復合索引 INDEX(columnA, columnB)。不過，這種用法僅適用於在復合索引中排列在前的數據列組合。比如說，INDEX (A，B，C) 可以當做 A 或 (A,B) 的索引來使用，但不能當做 B、C 或 (B,C) 的索引來使用。

 

 

mysql主鍵和索引的區別:

 主鍵一定是唯一性索引，唯一性索引並不一定就是主鍵。

所謂主鍵就是能夠唯一標識表中某一行的屬性或屬性組，一個表只能有一個主鍵，但可以有多個候選索引。因為主鍵可以唯一標識某一行記錄，所以可以確保執行數據更新、刪除的時候不會出現張冠李戴的錯誤。主鍵除了上述作用外，常常與外鍵構成參照完整性約束，防止出現數據不一致。數據庫在設計時，主鍵起到了很重要的作用。主鍵可以保證記錄的唯一和主鍵域非空，數據庫管理系統對於主鍵自動生成唯一索引，所以主鍵也是一個特殊的索引。

一個表中可以有多個唯一性索引，但只能有一個主鍵。

 主鍵列不允許空值，而唯一性索引列允許空值。

 索引可以提高查詢的速度。

　　創建Course的CouID的字段為主鍵   Score的SID字段為主鍵    Student的StdID字段為主鍵  Teacher的TID字段為主鍵，代碼如下：

import codecs

import MySQLdb
def connect_mysql():
    db_config = {
        'host': '192.168.203.12',
        'port': 3306,
        'user': 'momo',
        'passwd': '123456',
        'db': 'student',
        'charset': 'utf8'
    }
    cnx = MySQLdb.connect(**db_config)
    return cnx

if __name__ == '__main__':
    cnx = connect_mysql()

    sql1 = '''alter table Teacher add primary key(TID);'''
    sql2 = '''alter table Student add primary key(StdID);'''
    sql3 = '''alter table Score add primary key(SID);'''
    sql4 = '''alter table Course add primary key(CouID);'''
    sql5 = '''alter table Score add index idx_StdID_CouID(StdID, CouID);'''
    # sql6 = '''alter table Score drop  index idx_StdID_CouID;'''   刪除索引
    sql7 = '''explain select * from Score where StdID = 16213;'''
    try:
        cus = cnx.cursor()
        cus.execute(sql1)
        cus.close()

        cus = cnx.cursor()
        cus.execute(sql2)
        cus.close()

        cus = cnx.cursor()
        cus.execute(sql3)
        cus.close()

        cus = cnx.cursor()
        cus.execute(sql4)
        cus.close()

        cus = cnx.cursor()
        cus.execute(sql5)
        cus.close()

        cus = cnx.cursor()
        cus.execute(sql7)
        result = cus.fetchall()
        print(result)
        cus.close()

        cnx.commit()
    except Exception as e:
        cnx.rollback()
        print('error')
        raise e
    finally:
        cnx.close()

結果：

((1L, u'SIMPLE', u'Score', u'ref', u'idx_StdID_CouID', u'idx_StdID_CouID', u'4', u'const', 4L, None),)

解釋：

Sql1， sql2， sql3， sql4是添加主鍵，sql5是增加一個索引，我們也可以在mysql的客戶端上執行sq7，得到如下的結果：

mysql> explain select * from Score where StdID = 16213;              

+----+-------------+-------+------+-----------------+-----------------+---------+-------+------+-------+

| id | select_type | table | type | possible_keys   | key             | key_len | ref   | rows | Extra |

+----+-------------+-------+------+-----------------+-----------------+---------+-------+------+-------+

|  1 | SIMPLE      | Score | ref  | idx_StdID_CouID | idx_StdID_CouID | 4       | const |    4 | NULL  |

+----+-------------+-------+------+-----------------+-----------------+---------+-------+------+-------+

1 row in set (0.00 sec)

這個說明，我們在搜索StdID的時候，是走了idx_StdID_CouID索引的。