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之fetchoneimport 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文件出来，然后，先执行服务端程序，再执行两个客户端文件，就可以实现异步处理两个对话，也就是异步多线程处理