python教程18、python操作Mysql,pymysql,SQLAchemy
-->数据库范围：
对于目标数据库以及内部其他： 数据库名.* 数据库中的所有 数据库名.表 指定数据库中的某张表 数据库名.存储过程 指定数据库中的存储过程 *.* 所有数据库
-->用户范围：
用户名@IP地址 用户只能在改IP下才能访问用户名@192.168.1.% 用户只能在改IP段下才能访问(通配符%表示任意)用户名@% 用户可以再任意IP下访问(默认IP地址为%)4、表操作
(1)、创建表
| 1234 | create table 表名( 列名 类型 是否可以为空， 列名 类型 是否可以为空) |
约束(1)是否可空null
是否可空，null表示空，非字符串 not null - 不可空 null - 可空
约束(2)默认值default
默认值，创建列时可以指定默认值，当插入数据时如果未主动设置，则自动添加默认值 create table tb1( nid int not null defalut 2, num int not null )
约束(3)自增auto_increment
自增，如果为某列设置自增列，插入数据时无需设置此列，默认将自增（表中只能有一个自增列） create table tb1( nid int not null auto_increment primary key, num int null ) 或 create table tb1( nid int not null auto_increment, num int null, index(nid) ) 注意：1、对于自增列，必须是索引（含主键）。 2、对于自增可以设置步长和起始值 show session variables like ‘auto_inc%‘; set session auto_increment_increment=2; set session auto_increment_offset=10; shwo global variables like ‘auto_inc%‘; set global auto_increment_increment=2; set global auto_increment_offset=10;
约束(4)主键primary key
主键，一种特殊的唯一索引，不允许有空值，如果主键使用单个列，则它的值必须唯一，如果是多列，则其组合必须唯一。 create table tb1( nid int not null auto_increment primary key, num int null ) 或 create table tb1( nid int not null, num int not null, primary key(nid,num) )
约束(5)唯一键unique key
create table tb1( nid int not null auto_increment primary key, num int null unique key, )
约束(6)外键foreign key
外键，一个特殊的索引，只能是指定内容 creat table color( nid int not null primary key, name char(16) not null ) create table fruit( nid int not null primary key, smt char(32) null , color_id int not null, constraint fk_cc foreign key (color_id) references color(nid) )
(2)、删除表
| 1 | drop table 表名 |
(3)、清空表
| 12 | delete from 表名truncate table 表名 # 和上面的区别在于，这条语句能够使自增id恢复到0 |
(4)、修改表
| 1234567891011121314151617 | 添加列：alter table 表名 add 列名 类型删除列：alter table 表名 drop column 列名修改列： alter table 表名 modify column 列名 类型; -- 类型 alter table 表名 change 原列名 新列名 类型; -- 列名，类型 添加主键： alter table 表名 add primary key(列名);删除主键： alter table 表名 drop primary key; alter table 表名 modify 列名 int, drop primary key; 添加外键：alter table 从表 add constraint 外键名称（形如：FK_从表_主表） foreign key 从表(外键字段) references 主表(主键字段);删除外键：alter table 表名 drop foreign key 外键名称 修改默认值：ALTER TABLE testalter_tbl ALTER i SET DEFAULT 1000;删除默认值：ALTER TABLE testalter_tbl ALTER i DROP DEFAULT; |
(5)、基本数据类型
MySQL的数据类型大致分为：数值、时间和字符串
http://www.runoob.com/mysql/mysql-data-types.html
五、基本操作1、增加数据
insert into 表 (列名,列名...) values (值,值,值...)insert into 表 (列名,列名...) values (值,值,值...),(值,值,值...)insert into 表 (列名,列名...) select (列名,列名...) from 表
2、删除数据
delete from 表delete from 表 where id＝1 and name＝‘alex‘
3、修改数据
update 表 set name ＝ ‘alex‘ where id>1
4、查询数据
select * from 表select * from 表 where id > 1select nid,name,gender as gg from 表 where id > 1
5、其他
View Code一些总结和练习
六、视图视图是一个虚拟表（非真实存在），其本质是【根据SQL语句获取动态的数据集，并为其命名】，用户使用时只需使用【名称】即可获取结果集，并可以将其当作表来使用。
临时表搜索1、创建视图
View Code2、删除视图
View Code3、修改视图
View Code4、使用视图
使用视图时，将其当作表进行操作即可，由于视图是虚拟表，所以无法使用其对真实表进行创建、更新和删除操作，仅能做查询用。
View Code七、触发器对某个表进行【增/删/改】操作的前后如果希望触发某个特定的行为时，可以使用触发器，触发器用于定制用户对表的行进行【增/删/改】前后的行为。
1、创建基本语法
View Code 插入前触发器 插入后触发器特别的：NEW表示即将插入的数据行，OLD表示即将删除的数据行。
2、删除触发器
DROP TRIGGER tri_after_insert_tb1;
3、使用触发器
触发器无法由用户直接调用，而知由于对表的【增/删/改】操作被动引发的。
insert into tb1(num) values(666)八、存储过程
存储过程是一个SQL语句集合，当主动去调用存储过程时，其中内部的SQL语句会按照逻辑执行。
1、创建存储过程和执行过程
View Code对于存储过程，可以接收参数，其参数有三类：
有参数的存储过程2、删除存储过程
drop procedure proc_name;
3、执行存储过程
-- 无参数call proc_name()-- 有参数，全incall proc_name(1,2)-- 有参数，有in，out，inoutDECLARE @t1 INT;DECLARE @t2 INT default 3;call proc_name(1,2,@t1,@t2)
pymysql执行存储过程九、函数MySQL中提供了许多内置函数，例如：
部分内置函数更多：
http://doc.mysql.cn/mysql5/refman-5.1-zh.html-chapter/functions.html#encryption-functions
http://dev.mysql.com/doc/refman/5.7/en/string-functions.html
1、自定义函数
View Code2、删除函数
drop function func_name;
3、执行函数
View Code十、索引事务用于将某些操作的多个SQL作为原子性操作，一旦有某一个出现错误，即可回滚到原来的状态，从而保证数据库数据完整性。
支持事务的存储过程 执行存储过程十一、索引索引，是数据库中专门用于帮助用户快速查询数据的一种数据结构。类似于字典中的目录，查找字典内容时可以根据目录查找到数据的存放位置，然后直接获取即可。
MySQL中常见索引有：
1、普通索引
普通索引仅有一个功能：加速查询
创建表+索引 创建索引 删除索引 查看索引注意：对于创建索引时如果是BLOB 和 TEXT 类型，必须指定length。
View Code2、唯一索引
唯一索引有两个功能：加速查询 和 唯一约束（可含null）
创建表+索引 创建唯一键索引 删除唯一键索引3、主键索引
主键有两个功能：加速查询 和 唯一约束（不可含null）
创建表+主键索引 创建主键 删除主键4、组合索引
组合索引是将n个列组合成一个索引
其应用场景为：频繁的同时使用n列来进行查询，如：where n1 = ‘redhat‘ and n2 = 666。
创建表 创建组合索引如上创建组合索引之后，查询：
注意：对于同时搜索n个条件时，组合索引的性能好于多个单一索引合并。
其他1、条件语句
View Code2、循环语句
while循环 repeat循环 loop循环3、动态执行SQL语句
View Code二、pymsql模块pymsql是Python中操作MySQL的模块，其使用方法和MySQLdb几乎相同。这里介绍pymysql
一、下载安装：| 1 | pip install pymysql |
# 先往数据库插入点数据mysql> CREATE DATABASE IF NOT EXISTS testdb DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;mysql> use testdb;mysql> CREATE TABLE hosts (id int not null auto_increment primary key,ip varchar(20) not null,port int not null);mysql> INSERT INTO hosts (ip,port) values (‘1.1.1.1‘,22),(‘1.1.1.2‘,22), (‘1.1.1.3‘,22),(‘1.1.1.4‘,22), (‘1.1.1.5‘,22);
1、执行SQL
| 12345678910111213141516171819202122232425262728 | #!/usr/bin/env python# -*- coding:utf-8 -*-import pymysql # 创建连接conn = pymysql.connect(host=‘127.0.0.1‘, port=3306, user=‘root‘, passwd=‘123456‘, db=‘testdb‘, charset=‘utf8‘) # 创建游标cursor = conn.cursor() # 执行SQL，并返回收影响行数r = effect_row = cursor.execute("update hosts set ip = ‘1.1.1.2‘")print(r)# 执行SQL，并返回受影响行数effect_row = cursor.execute("update hosts set ip = ‘1.1.1.6‘ where id > %s", (6,)) # 执行SQL，并返回受影响行数effect_row = cursor.executemany("insert into hosts(ip,port) values(%s,%s)", [("1.1.1.7",21),("1.1.1.8",23)]) # 提交，不然无法保存新建或者修改的数据conn.commit() # 关闭游标cursor.close() # 关闭连接conn.close() |
2、获取新创建数据自增ID
| 1234567891011121314 | #!/usr/bin/env python# -*- coding:utf-8 -*-import pymysql conn = pymysql.connect(host=‘127.0.0.1‘, port=3306, user=‘root‘, passwd=‘123456‘, db=‘testdb‘)cursor = conn.cursor()cursor.executemany("insert into hosts(ip,port) values(%s,%s)", [("1.1.1.9",21),("1.1.1.10",222)])conn.commit()cursor.close()conn.close() # 获取最新自增IDnew_id = cursor.lastrowidprint(new_id)<br><br># 获取当前行行号<br>current_row = cursor.rownumber<br>print(current_row) |
3、获取查询数据
| 1234567891011121314151617181920212223242526272829 | #!/usr/bin/env python# -*- coding:utf-8 -*-import pymysql conn = pymysql.connect(host=‘127.0.0.1‘, port=3306, user=‘root‘, passwd=‘123456‘, db=‘testdb‘)cursor = conn.cursor()cursor.execute("select * from hosts") # 获取第一行数据row = cursor.fetchone()print(row)print(cursor.rownumber) # 获取第二行数据row_1 = cursor.fetchone()print(row_1)print(cursor.rownumber) # 获取前n行数据row_2 = cursor.fetchmany(3)print(row_2) # 获取所有数据row_3 = cursor.fetchall()print(row_3) conn.commit()cursor.close()conn.close() |
注：在fetch数据时按照顺序进行，可以使用cursor.scroll(num,mode)来移动游标位置，如：
4、fetch数据类型
关于默认获取的数据是元祖类型，如果想要或者字典类型的数据，即：
| 1234567891011121314151617 | #!/usr/bin/env python# -*- coding:utf-8 -*-import pymysql conn = pymysql.connect(host=‘127.0.0.1‘, port=3306, user=‘root‘, passwd=‘123456‘, db=‘testdb‘) # 游标设置为字典类型cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)r = cursor.execute("select * from hosts")print(r) result = cursor.fetchone()print(result) conn.commit()cursor.close()conn.close() |
SQLAlchemy是Python编程语言下的一款ORM框架，该框架建立在数据库API之上，使用关系对象映射进行数据库操作，简言之便是：将对象转换成SQL，然后使用数据API执行SQL并获取执行结果。
SQLAlchemy安装
| 1 | pip install sqlalchemy |
SQLAlchemy本身无法操作数据库，其必须以来pymsql等第三方插件，Dialect用于和数据API进行交流，根据配置文件的不同调用不同的数据库API，从而实现对数据库的操作，如：
| 12345678910111213 | MySQL-Python mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname> pymysql mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>] MySQL-Connector mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname> cx_Oracle oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...] 更多详见：http://docs.sqlalchemy.org/en/latest/dialects/index.html |
使用 Engine/ConnectionPooling/Dialect 进行数据库操作，Engine使用ConnectionPooling连接数据库，然后再通过Dialect执行SQL语句。
| 1234567891011121314151617181920212223242526272829303132333435 | #!/usr/bin/env python# -*- coding:utf-8 -*-from sqlalchemy import create_engine engine = create_engine("mysql+pymysql://root:123456@127.0.0.1:3306/testdb", max_overflow=5) # max_overflow可以超出连接池5个连接 #执行SQLcur = engine.execute( "INSERT INTO hosts (ip,port) VALUES (‘1.1.1.11‘, 22)") #新插入行自增IDcur.lastrowid #执行SQLcur = engine.execute( "INSERT INTO hosts (ip,port) VALUES(%s, %s)",[(‘1.1.1.12‘, 22),(‘1.1.1.13‘, 55),]) #执行SQLcur = engine.execute( "INSERT INTO hosts (ip,port) VALUES (%(ip)s, %(port)s)", ip=‘1.1.1.15‘, port=80) #执行SQLcur = engine.execute(‘select * from hosts‘)#获取第一行数据cur.fetchone()#获取第n行数据cur.fetchmany(3)#获取所有数据cur.fetchall() |
使用 ORM/Schema Type/SQL Expression Language/Engine/ConnectionPooling/Dialect 所有组件对数据进行操作。根据类创建对象，对象转换成SQL，执行SQL。
1、创建表
| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778 | #!/usr/bin/env python# -*- coding:utf-8 -*-from sqlalchemy.ext.declarative import declarative_basefrom sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Indexfrom sqlalchemy.orm import sessionmaker, relationshipfrom sqlalchemy import create_engine engine = create_engine("mysql+pymysql://root:123456@127.0.0.1:3306/testdb", max_overflow=5) Base = declarative_base() # 创建单表class Users(Base): __tablename__ = ‘users‘ id = Column(Integer, primary_key=True,autoincrement=True) name = Column(String(32)) extra = Column(String(16)) __table_args__ = ( UniqueConstraint(‘id‘, ‘name‘, name=‘uix_id_name‘), # 设置组合唯一键约束 Index(‘ix_id_name‘, ‘name‘, ‘extra‘), # 创建索引 ) # 一对多关系class Favor(Base): __tablename__ = ‘favor‘ nid = Column(Integer, primary_key=True,autoincrement=True) caption = Column(String(50), default=‘playing‘, unique=True) class Person(Base): __tablename__ = ‘person‘ nid = Column(Integer, primary_key=True,autoincrement=True) name = Column(String(32), index=True, nullable=True) favor_id = Column(Integer, ForeignKey("favor.nid")) # 设置外键,外键依赖于主表favor的主键nid # 与生成表结构无关，仅用于外键查询方便 favor = relationship("Favor", backref=‘pers‘) # 多对多class Group(Base): __tablename__ = ‘group‘ id = Column(Integer, primary_key=True,autoincrement=True) name = Column(String(64), unique=True, nullable=False) # group = relationship(‘Group‘,secondary=ServerToGroup,backref=‘host_list‘) class Server(Base): __tablename__ = ‘server‘ id = Column(Integer, primary_key=True, autoincrement=True) hostname = Column(String(64), unique=True, nullable=False) port = Column(Integer, default=22) class ServerToGroup(Base): """多对多关系,则是多生成一张表用来存储主键""" __tablename__ = ‘servertogroup‘ nid = Column(Integer, primary_key=True, autoincrement=True) server_id = Column(Integer, ForeignKey(‘server.id‘)) # 设置主键 group_id = Column(Integer, ForeignKey(‘group.id‘)) # 设置主键 def init_db(): """创建表的函数,调用之后会创建表""" Base.metadata.create_all(engine) def drop_db(): """删除表的函数,调用之后会删除表""" Base.metadata.drop_all(engine) init_db() # 创建完最好注释,如果表已经创建,执行此步不会再创建表# drop_db() # 想要对表进行操作则需要绑定会话Session = sessionmaker(bind=engine)session = Session() |
2、操作表
(1)增加数据
| 123456789101112131415 | # 插入一条obj = Users(name=‘redhat‘, extra=‘rh‘)print(obj)session.add(obj) # 插入多条session.add_all([ Users(name=‘centos‘, extra=‘ct‘), Users(name=‘debian‘, extra=‘db‘), Users(name=‘ubuntu‘, extra=‘ub‘), Users(name=‘fedora‘, extra=‘fd‘),]) # 插入完需要提交否则不生效session.commit() |
(2)删除数据
| 12 | session.query(Users).filter(Users.id > 5).delete()session.commit() |
(3)修改数据
| 1234 | session.query(Users).filter(Users.id > 2).update({"name" : "opensuse"})session.query(Users).filter(Users.id > 2).update({Users.name: Users.name + "099"}, synchronize_session=False)#session.query(Users).filter(Users.id > 2).update({"num": Users.num + 1}, synchronize_session="evaluate")session.commit() |
(4)查询数据(如果没有使用ORM则返回的是一个表对象)
| 1234 | ret = session.query(Users).all()ret = session.query(Users.name, Users.extra).all()ret = session.query(Users).filter_by(name=‘opensuse099‘).all()ret = session.query(Users).filter_by(name=‘opensuse099‘).first() |
(5)其他一些查询操作
| 12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061 | # 条件ret = session.query(Users).filter_by(name=‘centos‘).all()ret = session.query(Users).filter(Users.id > 1, Users.name == ‘centos‘).all()ret = session.query(Users).filter(Users.id.between(1, 3), Users.name == ‘centos‘).all()ret = session.query(Users).filter(Users.id.in_([1,3,4])).all()ret = session.query(Users).filter(~Users.id.in_([1,3,4])).all()ret = session.query(Users).filter(Users.id.in_(session.query(Users.id).filter_by(name=‘centos‘))).all() from sqlalchemy import and_, or_ret = session.query(Users).filter(and_(Users.id > 3, Users.name == ‘centos‘)).all()ret = 小编还为您整理了以下内容，可能对您也有帮助： Python之MySQL操作 MySQL 是目前使用最广泛的数据库之一，它有着良好的性能，能够跨平台，支持分布式，能够承受高并发。下载地址： MySQL :: Download MySQL Community Server 安装参考： 图解MySQL5.7.20免安装版配置方法-百度经验 (.com) Python 大致有如下 5 种方式操作 MySQL。 先使用如下建表语句创建一张简单的数据库表。 2.1 mysqlclient 执行 pip install mysqlclient 进行安装，看一下具体操作。 新增 查询 cursor 查看方法 修改 删除 2.2 PyMySQL 执行 pip install pymysql 进行安装，使用方式与 mysqlclient 基本类似。 2.3 peewee 执行 pip install peewee 进行安装，看一下具体操作。 定义映射类 新增 查询 修改 删除 2.4 SQLAlchemy 执行 pip install sqlalchemy 进行安装，看一下具体操作。 定义映射类 新增 查询 修改 删除 Python学习日记 Python操作MySQL的驱动有哪些？ 使用Python操作MySQL数据库的方式(驱动)有很多种，比如：PyMySQL、MySQLdb、mysqlclient、SQLAlchemy等等 MySQLdb MySQLdb是 Python 连接 MySQL 最流行的一个驱动，很多框架都也是基于此库进行开发，遗憾的是它只支持 Python2.x，它是基于C开发的库，和Windows 平台的兼容性不友好，现在基本不推荐使用，取代的是它的衍生版本。 mysqlclient 由于 MySQLdb 年久失修，后来出现了它的 Fork 版本 mysqlclient，完全兼容 MySQLdb，同时支持 Python3.x，是 Django ORM的依赖工具，如果你想使用原生 SQL 来操作数据库，那么推荐此驱动。 PyMySQL PyMySQL是纯 Python 实现的驱动，速度上比不上 MySQLdb，最大的特点可能就是它的安装方式没那么繁琐，同时也兼容 MySQLdb。 SQLAlchemy SQLAlchemy是一种既支持原生 SQL，又支持 ORM 的工具，它非常接近 Java 中的 Hibernate 框架。 作为一个测试人员，数据库的操作也必须是要掌握的，如果想系统的学习接口测试相关的技术，可以了解一下黑马程序员的软件测试课程，里面讲的非常详细。 python3.4怎么连接mysql pymysql连接mysql数据库 1、python安装目录设定为d:/python34 2、pymysql安装方法为：解压下载的文件，在cmd中运行: python setup.py install。 检验安装安装是否成功的方法：import pymysql 。 如果不报错 说明安装成功。 3、mysql安装目录为D:/phpStudy/MySQL。为避免更多配置问题，可在启动phpstudy后，将其设为系统服务 4、基本操作： （1）导入pymysql: import pymysql （2）连接数据库： conn=pymysql.connect(host='localhost',user='root',passwd='root',db='ere'，charset='utf8') 务必注意各等号前面的内容！charset参数可避免中文乱码 （3）获取操作游标：cur=conn.cursor() （4）执行sql语句,插入记录：sta=cur.execute("insert 语句") 执行成功后sta值为1。更新、删除语句与此类似。 （5）执行sql语句，查询记录：cur.execute("select语句") 执行成功后cur变量中保存了查询结果记录集，然后再用循环打印结果： for each in cur: print(each[1].decode('utf-8')) # each[1] 表示当前游标所在行的的第2列值，如果是中文则需要处理编码 python怎么连接mysql数据库 1、和数据库建立连接 2、执行sql语句,接收返回值 3、关闭数据库连接 1、MySQL数据库要用MySQLdb模块,但Python用来链接MySQL的第三方库MySQLdb不支持Python3.x 特别说明：我在我的电脑上实验时，我的python是2.7.2版本，安装对应版本的MySQLdb之后直接可以运行，并与数据库连接成功，所以如果大家也像我一样顺利的话，下面的就不需要看了，直接跳过，看第2点如何执行sql语句即可！如果安装之后出现异常，可以参考一下下面的解决办法。 连接的关键是安装MySQLdb模块要下载与Python相对应的版本： 下载好后安装，它会自动检测到计算机Python的安装路径，并自动填写模块解压路径（我的是：D:\ProgramFiles\ActivePython 2.6.6.17\Lib\site-packages\）。 但解压完成后并不能使用，还要修改MySQLdb模块下的一些文件： ①.在MySQLdb目录下（我的是：D:\ProgramFiles\ActivePython 2.6.6.17\Lib\site-packages\MySQLdb）找到__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) #encoding=utf-8 import sys import MySQLdb reload(sys) sys.setdefaultencoding('utf-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()
显示全文
|