5.Python操作MySQL,三層架構,Socket網絡編程

Python操作MySQL

- MySQL之查詢操作

- MySQL之插入數據

- MySQL之批量插入數據

- MySQL之刪除數據

- MySQL之更新數據庫

- MySQL之事務

- MySQL之批量獲取字典類型數據

- MySQL之fetchone

- MySQL之獲取自增ID

三層架構（程序分成三種架構）

- 三層架構之公共層

- 三層架構之model層

- 三層架構之配置文件

Socket網絡編程

【Python操作MySQL】

準備工作：

Windows下載鏈接，Python操作MySQL模塊：

http://pan.baidu.com/s/1o7JuMgU

提示：Windows安裝了mysql模塊后，因為我用的是Eclipse，所以我還要在Eclipse下做一下設置，如下：

在Eclipse菜單欄上點擊Windows->Preferences->PyDev-Interpreter-Python->Forced Builtins->New->MySQLdb->ok->Apply，必要時重啟Eclipse

Linux直接安裝Python操作MySQL模塊 yum -y install python-mysqldb

建表語句

create table students
    (
        id int  not null auto_increment primary key,
        name char(8) not null,
        sex char(4) not null,
        age tinyint unsigned not null,
        tel char(13) null default "-"
    );

插入數據：

insert into students(name,sex,age,tel) values('wsyht','man',20,'1319')

數據庫和表

mysql> select database();
+------------+
| database() |
+------------+
| wsyht      |
+------------+
1 row in set (0.00 sec)
mysql> select *from students;
+----+---------+-----+-----+---------+
| id | name    | sex | age | tel     |
+----+---------+-----+-----+---------+
|  2 | wsyht   | man |  22 | 1231313 |
|  3 | jack    | man |  23 | 12313   |
|  4 | jenkins | man |  25 | 123     |
|  5 | peter   | man |  23 | 123     |
|  6 | wsyht90 | man |  23 | 123     |
|  8 | wsyht11 | man |  26 | 12345   |
|  9 | wsyht12 | man |  26 | 12345   |
| 10 | wsyht1  | man |  26 | 12345   |
| 11 | wsyht2  | man |  26 | 12345   |
+----+---------+-----+-----+---------+
9 rows in set (0.00 sec)

1）MySQL之查詢操作

import MySQLdb   #必須在導入MySQLdb模塊之前，要先裝python操作mysql模塊

#創建連接

conn = MySQLdb.connect(host='192.168.1.113',user='root',passwd='123456',db='wsyht') #這里可以理解為打開門的鑰匙 
cur = conn.cursor()  #這里可以理解為伸出手，這里可以理解為伸出手，獲取表數據

#數據查詢操作

reCount = cur.execute('select * from students') #然后執行動作，只是查詢影響了多少行，并不是查詢相關表的數據
data = cur.fetchall()  #把select查詢影響到的行的數據全拿出來

#關閉連接

cur.close()   #收回手
conn.close()  #關門

#輸出信息

print reCount #輸出查詢影響到的行數
print data    #輸出查詢影響到的行的數據

2）MySQL之插入數據

import MySQLdb

#創建連接

conn = MySQLdb.connect(host='192.168.1.113',user='root',passwd='123456',db='wsyht') #這里可以理解為打開門的鑰匙 
cur = conn.cursor()  #這里可以理解為伸出手，這里可以理解為伸出手，獲取表數據

#數據插入操作

sql = "insert into students(id,name,sex,age,tel) values(%s,%s,%s,%s,%s)" #不管什么類型，占位符都是給%s，五個占位符，就給五個%s
params = ('6','peter','man','23','123')  #如果這里id設了自增，那么這排第一位和上面一排第一位id可以不用寫
reCount = cur.execute(sql,params)  #插入數據   
conn.commit()  #提交數據，insert,update,delete都要加commit，而select則不用

#關閉連接

cur.close()   #收回手
conn.close()  #關門
print reCount #輸出影響到的行數

3）MySQL之批量插入數據

import MySQLdb   #必入MySQLdb模塊之前，要先裝python操作mysql模塊

#創建連接

conn = MySQLdb.connect(host='192.168.1.113',user='root',passwd='123456',db='wsyht') #這里可以理解為打開門的鑰匙
cur = conn.cursor()  #這里可以理解為伸出手，這里可以理解為伸出手，獲取表數據

#批量插入數據操作

li = [
    ('wsyht11','man','26','12345'),
    ('wsyht12','man','26','12345'),
]
#sql = 'insert into students(name,sex,age,tel) values(%s,%s,%s,%s)'
#reCount = cur.executemany(sql,li) 
reCount = cur.executemany('insert into students(name,sex,age,tel) values(%s,%s,%s,%s)',li)  #刪除數據
conn.commit()  #提交數據，insert,update,delete都要加commit，而select則不用

#關閉連接

cur.close()   #收回手
conn.close()  #關門
print reCount #輸出影響到的行數

4）MySQL之刪除數據庫

import MySQLdb   #必入MySQLdb模塊之前，要先裝python操作mysql模塊

#創建連接

conn = MySQLdb.connect(host='192.168.1.113',user='root',passwd='123456',db='wsyht') #這里可以理解為打開門的鑰匙
cur = conn.cursor()  #這里可以理解為伸出手，這里可以理解為伸出手，獲取表數據

#數據刪除操作

sql = "delete from students where id=%s" #不管什么類型，占位符都是給%s，
params = (7,)  #把%s需要刪除的數據內容添加到params變量就可以了，如果是字符，則需要用單引號引起來如：('n1',)
reCount = cur.execute(sql,params)  #刪除數據
conn.commit()  #提交數據，insert,update,delete都要加commit，而select則不用

#關閉連接

cur.close()   #收回手
conn.close()  #關門
print reCount #輸出影響到的行數

5）MySQL之更新數據庫

import MySQLdb   #必入MySQLdb模塊之前，要先裝python操作mysql模塊

#創建連接

conn = MySQLdb.connect(host='192.168.1.113',user='root',passwd='123456',db='wsyht') #這里可以理解為打開門的鑰匙
cur = conn.cursor()  #這里可以理解為伸出手，這里可以理解為伸出手，獲取表數據

#數據更新操作

sql = "update students set name=%s where id=6" #不管什么類型，占位符都是給%s，
params = ('wsyht90')  #把id為6那一行數據中的name內容改為wsyht90
reCount = cur.execute(sql,params)  #更新數據
conn.commit()  #提交數據，insert,update,delete都要加commit，而select則不用

#關閉連接

cur.close()   #收回手
conn.close()  #關門
print reCount #輸出影響到的行數

6）事務，要所有提交成功才會執行成功

mysql> select *from students;
+----+---------+-----+-----+---------+
| id | name    | sex | age | tel     |
+----+---------+-----+-----+---------+
|  2 | wsyht   | man |  22 | 1231313 |
|  3 | jack    | man |  23 | 12313   |

import MySQLdb   #必入MySQLdb模塊之前，要先裝python操作mysql模塊
conn = MySQLdb.connect(host='192.168.1.113',user='root',passwd='123456',db='wsyht') #這里可以理解為打開門的鑰匙
cur = conn.cursor()  #這里可以理解為伸出手
sql = "update students set age=%s where id=2"
params = (0)
reCount = cur.execute(sql,params)
sql = "update students set age=%s where id=3"
params = (46)
reCount = cur.execute(sql,params)
conn.commit()
cur.close()   #收回手
conn.close()  #關門
print reCount #輸出影響到的行數

mysql> select *from students;
+----+---------+-----+-----+---------+
| id | name    | sex | age | tel     |
+----+---------+-----+-----+---------+
|  2 | wsyht   | man |   0 | 1231313 |
|  3 | jack    | man |  46 | 12313   |

7）MySQL之批量獲取字典類型數據

import MySQLdb   #必入MySQLdb模塊之前，要先裝python操作mysql模塊

#創建鏈接

conn = MySQLdb.connect(host='192.168.1.113',user='root',passwd='123456',db='wsyht') #這里可以理解為打開門的鑰匙 
#cur = conn.cursor()  #這里可以理解為伸出手，這里可以理解為伸出手，獲取表數據
cur = conn.cursor(cursorclass = MySQLdb.cursors.DictCursor)  #以字典類型獲取數據，也就是獲取表的列名和列的數據

#數據操作

reCount = cur.execute('select * from students') #然后執行動作，只是查詢影響了多少行，并不是查詢相關表的數據
data = cur.fetchall()  #把select查詢影響到的行的數據全拿出來

#關閉連接

cur.close()   #收回手
conn.close()  #關門
print reCount #輸出查詢影響到的行數
print data    #輸出查詢影響到的行的數據

8）MySQL之fetchone

import MySQLdb
conn = MySQLdb.connect(host='192.168.1.113',user='root',passwd='123456',db='wsyht') #這里可以理解為打開門的鑰匙 
cur = conn.cursor()  #這里可以理解為伸出手，獲取表數據
#cur = conn.cursor(cursorclass = MySQLdb.cursors.DictCursor)

#數據操作

reCount = cur.execute('select * from students') #然后執行動作，只是查詢影響了多少行，并不是查詢相關表的數據
data = cur.fetchone()  #只輸出取到數據的第一行
print data    #輸出查詢影響到的行的數據
#cur.scroll(0,mode='absolute')   #覺對模式，往上走一層，從重輸出
data = cur.fetchone()  #輸出取到數據的第二行
print data    #輸出查詢影響到的行的數據
cur.scroll(-1,mode='relative')  #相對模式，往上走一層，從重新輸出
data = cur.fetchone()  #輸出取到數據的第三行
cur.close()
conn.close()
print data    #輸出查詢影響到的行的數據

9）MySQL之獲取自增ID

#可看到下表ID是12，然后我插入三次數據就會變成十五，代碼如下所示

mysql> select *from students;
+----+-------+-----+-----+-------+
| id | name  | sex | age | tel   |
+----+-------+-----+-----+-------+
|  3 | jack  | man |  22 | 12313 |
| 12 | peter | man |  23 | 123   |
+----+-------+-----+-----+-------+

import MySQLdb
conn = MySQLdb.connect(host='192.168.1.113',user='root',passwd='123456',db='wsyht') #這里可以理解為打開門的鑰匙 
cur = conn.cursor()  #這里可以理解為伸出手，獲取表數據

#數據操作

sql = "insert into students(name,sex,age,tel) values(%s,%s,%s,%s)" #不管什么類型，占位符都是給%s，四個占位符，就給四個%s
params = ('peter','man','23','123')  
reCount = cur.execute(sql,params)  #插入數據   
conn.commit()  #提交數據，insert,update,delete都要加commit，而select則不用
new_id = cur.lastrowid   #自動自增ID
print new_id #輸出新的ID
#關閉連接
cur.close()   #收回手
conn.close()  #關門

#再次查看數據表

mysql> select *from students;
+----+-------+-----+-----+-------+
| id | name  | sex | age | tel   |
+----+-------+-----+-----+-------+
|  3 | jack  | man |  22 | 12313 |
| 12 | peter | man |  23 | 123   |
| 13 | peter | man |  23 | 123   |
| 14 | peter | man |  23 | 123   |
| 15 | peter | man |  23 | 123   |
+----+-------+-----+-----+-------+

【三層架構】 （程序分成三種架構）

數據訪問層

業務處理層

表示層，UI層

08day10  #工程（項目）
  - model     #（包）數據庫里有幾張表，這里就建幾個文件，并且跟數據庫的名要一一對應，也就是要對什么表操作就建什么名字的模塊文件
    - __init__.py
    - students.py   #有一個表叫students，可以調用sql_helper模塊文件對students表做增刪改查操作，公共配置配寫在sql_helper，增刪改查寫在students，最后由admin去做執行
  - utility   #（包）公共層，這里寫公共的一些功能，比如說對數據庫的操作,又比如說你要用網絡服務的時候，你需要請求哪個地址，那你可以再為他建一個單獨文件，統一操作，所有一類的都通過我去執行，如下
    - __init__.py
    - sql_helper.py   #數據庫的公共配置操作
  - conf.py   #（模塊）這里面放配置文件，比如：要連接的數據庫或者要連接的接口把他的URL放在這里
  - index.py  #（模塊）主文件，程序進來首先執行的文件，index再起觸發其他模塊的其他類，或其它類里的方法

1)三層架構之公共層

cat sql_helper.py
#!/usr/bin/env python
#coding:utf-8
import MySQLdb
import conf
class MySQLHelper(object):
    def __init__(self):
        self.__conn_dict = conf.conf_dict
    def Get_Dict(self,sql,params):
        conn = MySQLdb.connect(host='192.168.1.113',user='root',passwd='123456',db='wsyht')
        cur = conn.cursor()
        reCount = cur.execute(sql,params)
        data = cur.fetchall()
        cur.close()
        conn.close()
        return data    #返回值給調用方
    def Get_One(self,sql,params):
        conn = MySQLdb.connect(**self.__conn_dict)  #兩個*以字典方式傳多個值，一個*以列表方式傳值，傳多個值
        cur = conn.cursor()
        reCounts = cur.execute(sql,params)
        data = cur.fetchone()
        cur.close()
        conn.close()
        return data    #返回值給調用方
'''   #注意：調用的話不是直接寫在這個文件調用，這不過是為了演示
helper = MySQLHelper()
sql = "select *from students where id > %s"
params = (15)
one_data = helper.Get_one(sql, params)
dict_data = helper.Get_Dict(sql, params)
print one_data
print dict_data
'''

2）三層架構之model層

cat students.py
#!/usr/bin/env python
#coding:utf-8
from  utility.sql_helper import MySQLHelper  #把類導入進來
class Students(object):
    def __init__(self):
        self.__helper = MySQLHelper()    #面向對像賦值給私有字段
    def Get_One(self,id):
        sql = "select *from students where id = %s"
        params = (id)
        return self.__helper.Get_One(sql,params)
    def CheckValidate(self,username,password):
        sql = "select * from students where name = %s and password = %s"
        params = (username,password)
        return self.__helper.Get_One(sql,params)
3）三層架構之配置文件 
conf一般與utility這一層進行相應的設置
#!/usr/bin/env python
#coding:utf-8
#以字典方式傳值,第一排和第二排勻是用字典方式傳值，任選其一即可，以后要改IP啥的來這里改即可
conf_dict = dict(host='192.168.1.113',user='root',passwd='123456',db='wsyht')
#conf_dict = {'host':'192.168.1.113','user':'root','passwd':'123456','db':'wsyht'}

#主程序執行文件

cat index.py
#!/usr/bin/env python
#coding:utf-8
from model.students import Students
def main():
    user = raw_input('username:')
    pwd = raw_input('password:')
    students = Students()
    result = students.CheckValidate(user,pwd)
    if not result:
        print '你輸入的用戶名或密碼有誤'
    else:
        print '歡迎登陸后臺管理頁面'
if __name__ == '__main__':
    main()

#wsyht庫下的students表

mysql> select *from students;
+----+---------+-----+-----+----------+
| id | name    | sex | age | password |
+----+---------+-----+-----+----------+
|  1 | wsyht   | man |  18 | 123456   |
|  2 | jenkins | man |  20 | 13579    |
+----+---------+-----+-----+----------+

執行順序總結：        -->1、調用配置文件

主程序（index文件）--> model層（students表文件）--> 公共層（sql_helper數據庫公共操作文件）

       -->2、調用數據庫

寫法總結： 寫法則是按執行順序從后往上

1、先寫公共層

2、寫model層

3、寫主程序文件

4、寫配置文件

【Socket網絡編程】

- main 包
   - client.py 
   - server.py 
示例1：
#!/usr/bin/env Python
#coding:utf-8
import socket
def handle_request(client):  
    buf = client.recv(1024)   #客戶端接收服務端數據，緩存區1024字節，最多只能拿1024字節
    client.send("HTTP/1.1 200 OK\r\n\r\n")  #服務端發送信息
    client.send("Hello,World!123")   #服務端發送信息
    print buf
def main():
    sock = socket.socket()         #建立socket對像
    sock.bind(('localhost',5821))  #監聽本地8080端口
    sock.listen(5)           #允許建立的最大連接數
    while True:
        connection, address = sock.accept()    #阻塞直接有客戶端請求，connectin就是客戶端的socket對像，address代表客戶端的地址
        handle_request(connection)
        connection.close()
    
if __name__ == '__main__':
    main()
#瀏覽器訪問測試 http://localhost:5821

示例2：

main    #包
  - init.py
  - server.py
  - client.py
服務端腳本
cat server.py 
#!/usr/bin/env python
#coding:utf-8
import  socket
sk = socket.socket()   #調用socket的這個類對像，創建對像
ip_port = ('127.0.0.1',873)
sk.bind(ip_port)       #監聽服務器的IP和端口
sk.listen(5)           #允許的最大接數為5
while True:            #創建一個死循環，讓他不停的接收用戶發過來的請求
    conn,address = sk.accept()       #阻塞等待直到有客戶端連接，conn就是客戶端的socket對像，address代表客戶端的地址
    conn.send('Hello,Wo2ld!')               #向客戶端發送數據
    conn.close()                     #對客戶端關閉連接

客戶端腳本

cat client.py
#!/usr/bin/env python
#coding:utf-8
import socket
client = socket.socket()              #創建客戶端socket
ip_port = ('127.0.0.1',873)           
client.connect(ip_port)              #連接服務端
data = client.recv(1024)              #接收服務端數據
print  data

執行腳本：先執行服務端腳本，再執行客戶端腳本

socket服務端執行步驟：

1、創建socket對像

2、監聽服務器IP和端口

3、設置最大連接數

4、阻塞等待直到有客戶端連接

5、發送數據

6、關閉連接

socket客戶端執行步驟

1、創建socket對像

2、與服務器端建立連接

3、請求數據

Socket客戶端與服務端的交互示例：

-

main 包
   - client.py 
   - server.py 
服務器端演示：
#!/usr/bin/env Python
#coding:utf-8
import socket
sk = socket.socket()
ip_port = ('127.0.0.1',995)
sk.bind(ip_port)
sk.listen(5)     #阻塞數量
while True:
    conn,address = sk.accept()
    conn.send('hello')
    print '新用戶進入系統'
    print 'server：hello'
    flag = True
        while flag:
            data = conn.recv(1024)              #接收客戶端數據
            if data == 'exit':
                flag = False
                print '對方已退出系統'
                break
            print 'client:',data
            inp = raw_input('server：')
            conn.send(inp)
        conn.close()

客戶端演示：

#!/usr/bin/env Python
#coding:utf-8
import socket
client = socket.socket()
ip_port = ('127.0.0.1',995)
client.connect(ip_port)
while True:
    data = client.recv(1024)          #接收服務端數據
    print 'server:',data
    inp = raw_input('client：')
    client.send(inp)
    if inp == 'exit':
        break

#異步多線程服務端

cat server.py
#!/usr/bin/env Python
#coding:utf-8
import SocketServer
class MyServer(SocketServer.BaseRequestHandler):
    def setup(self):
        pass
def handle(self):
    conn = self.request
    conn.send('hello')
    print '新用戶進入系統'
    print 'server：hello'
    flag = True
    while flag:
        data = conn.recv(1024)
        if data == 'exit':
            flag = False
            print '對方已退出系統'
            break
        print 'client:',data
        inp = raw_input('server：')
        conn.send(inp)
    conn.close()
def  finish(self):
    pass
if __name__ == '__main__':
    server = SocketServer.ThreadingTCPServer(('127.0.0.1',995),MyServer)
    server.serve_forever()

#客戶端

cat client.py
#!/usr/bin/env Python
#coding:utf-8
import socket
client = socket.socket()
ip_port = ('127.0.0.1',995)
client.connect(ip_port)
while True:
    data = client.recv(1024)
    print 'server：',data
    inp = raw_input('client：')
    client.send(inp)
    if inp == 'exit':
        break

#可以拷貝多一個client.py文件出來，然后，先執行服務端程序，再執行兩個客戶端文件，就可以實現異步處理兩個對話，也就是異步多線程處理