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