数据库--import MySQLdb--cx_ora
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了数据库--import MySQLdb--cx_ora，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含41569字，纯文字阅读大概需要60分钟。
内容图文
--import------import mysqldb 模块---python操作数据库----------------------------------------------------------------------------
--********************************************************************************************************************************
--python实现读取excel写入mysql的小工具详解
EXCEL 和 MySQL 大体上来说都可以算是"数据库"，MySQL貌似有EXCEL的接口，但是最近在自学Python，用Python实现了一下，下面这篇文章主要给大家介绍了关于利用python实现读取excel写入mysql的一个小工具，需要的朋友可以参考下。
Python是数据分析的强大利器
利用Python做数据分析，第一步就是学习如何读取日常工作中产生各种excel报表并存入数据中，方便后续数据处理。
这里向大家分享python如何读取excel，并使用Python将数据存入Mysql中，有需要的朋友们一起来看看吧。
背景
需要导入全国高校名录到数据库，从教委网站下到了最新的数据，是excel格式，需要做一个工具进行导入，想试用一下python，说干就干。
库
xlrd : excel读写库
pymysql : mysql数据库驱动库，纯python打造
re : 正则表达式库，核心库
前两个用pip轻松完成安装，本人是在mac pro是进行的，过程很顺利，以前在mac上装mysqlclient一直安装不上，所以一度放弃使用python，但我在linux下安装mysqlclient却没有任何问题。
源代码
很简单的小脚本，留存纪念。值得注意的一点，数据库连接字段串中要设定字符编码，不然默认是lanti-1，写入会出错。
import xlrd
import pymysql
import re
conn = pymysql.connect(host='database connect address', port=1234, user='root',
passwd='****', db='database name', charset='utf8mb4')
p = re.compile(r'\s')
data = xlrd.open_workbook('./W020170616379651135432.xls')
table = data.sheets()[0]
t = table.col_values(1)
nrows = table.nrows
for i in range(nrows):
r1 = table.row_values(i)
if len(r1[2]) == 10:
cur = conn.cursor()
cur.execute('insert into `university` (`id`, `name`, `ministry`, `city`, `level`, `memo`) \
values (%s, %s, %s, %s, %s, %s)',
(r1[2], p.sub('', r1[1]), p.sub('', r1[3]), p.sub('', r1[4]), r1[5], r1[6]))
conn.commit()
cur.close()
conn.close()
心得
写惯了类C的语言，不太习惯python，想同时掌握两种风格的编程语言，好痛苦啊。python编程效率的确不错，这是我第一次用python写实用小程序，连查带写带调试，一共也就花了一个来小时。python库与资料丰富，不愁找不到合适的^_^
数据库写入优化
早上闲来无事，用批量写入优化了一下，任务秒完成，比一条条写入快了很多， 比我预想的差别还要大。看来，没有不好的工具，只是我们没有用好啊！
import xlrd
import pymysql
import re
conn = pymysql.connect(host='database connect address', port=1234, user='root',
passwd='****', db='database name', charset='utf8mb4')
p = re.compile(r'\s')
data = xlrd.open_workbook('./W020170616379651135432.xls')
table = data.sheets()[0]
t = table.col_values(1)
nrows = table.nrows
ops = []
for i in range(nrows):
r1 = table.row_values(i)
if len(r1[2]) == 10:
ops.append((r1[2], p.sub('', r1[1]), p.sub('', r1[3]), p.sub('', r1[4]), r1[5], r1[6]))
cur = conn.cursor()
cur.executemany('insert into `university_copy` (`id`, `name`, `ministry`, `city`, `level`, `memo`) \
values (%s, %s, %s, %s, %s, %s)', ops)
conn.commit()
cur.close()
conn.close()
python读取excel文件遇到的问题
1、mac安装xlrd模块，如果cmd下执行pip install xlrd安装不成功，可以直接去官网下载，名称类似这样的文件xlrd-1.0.0-py3-none-any.whl，切换到已下载的文件路径在cmd下执行pip3 install xlrd-1.0.0-py3-none-any.whl即可
http://pypi.python.org/pypi/xlrd
2、python打开excel报xlrd.biffh.XLRDError: Unsupported format, or corrupt file: Expected BOF record; found b'username'
可以确认下要打开的excel保存时是不是本身就存在兼容性等格式提示，如果有的话，需要重新建一个不存在格式问题的文件
import xlrd
from os.path import join,abspath,dirname
fname = join(dirname(dirname(abspath(__file__))),'test1.xls')
bk = xlrd.open_workbook(fname, encoding_override="utf-8")
shxrange = range(bk.nsheets)
try:
sh = bk.sheet_by_name("工作表1")
nrows = sh.nrows # 获取行数
ncols = sh.ncols # 获取列数
print("nrows %d, ncols %d" % (nrows, ncols))
cell_value = sh.cell_value(1, 1) # 获取第一行第一列数据
row_list = [] # print cell_value
for i in range(0, nrows): # 获取各行数据
row_data = sh.row_values(i)
row_list.append(row_data)
except:
print("no sheet in %s named Sheet1" % fname)
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对脚本之家的支持。
--12.4-------------import------import Mysql 模块
你可以访问Python数据库接口及API查看详细的支持数据库列表。
不同的数据库你需要下载不同的DB API模块，例如你需要访问Oracle数据库和Mysql数据，你需要下载Oracle和MySQL数据库模块。
DB-API 是一个规范. 它定义了一系列必须的对象和数据库存取方式, 以便为各种各样的底层数据库系统和多种多样的数据库接口程序提供一致的访问接口 。
Python的DB-API，为大多数的数据库实现了接口，使用它连接各数据库后，就可以用相同的方式操作各数据库。
Python DB-API使用流程:
引入 API 模块。
获取与数据库的连接。
执行SQL语句和存储过程。
关闭数据库连接。
--Python 操作 mysql 数据库----------------------------------------------------------------------------------------------------------------------------
什么是MySQLdb?
MySQLdb 是用于Python链接Mysql数据库的接口，它实现了 Python 数据库 API 规范 V2.0，基于 MySQL C API 上建立的。
如何安装MySQLdb?
为了用DB-API编写MySQL脚本，必须确保已经安装了MySQL。复制以下代码，并执行:
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import MySQLdb
如果执行后报错，意味着你没有安装 MySQLdb 模块:
安装MySQLdb，请访问 http://sourceforge.net/projects/mysql-python ，(Linux平台可以访问: https://pypi.python.org/pypi/MySQL-python)从这里可选择适合您的平台的安装包，分为预编译的二进制文件和源代码安装包。
如果您选择二进制文件发行版本的话，安装过程基本安装提示即可完成。如果从源代码进行安装的话，则需要切换到MySQLdb发行版本的顶级目录，并键入下列命令:
$ gunzip MySQL-python-1.2.2.tar.gz
$ tar -xvf MySQL-python-1.2.2.tar
$ cd MySQL-python-1.2.2
$ python setup.py build
$ python setup.py install
注意: 请确保您有root权限来安装上述模块。
--连接Mysql的TESTDB数据库
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import MySQLdb
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" ) # 打开数据库连接
cursor = db.cursor() # 使用cursor()方法获取操作游标
cursor.execute("SELECT VERSION()") # 使用execute方法执行SQL语句
data = cursor.fetchone() # 使用 fetchone() 方法获取一条数据
print "Database version : %s " % data # 输出结果 Database version : 5.0.45
db.close() # 关闭数据库连接
--创建数据库表---使用execute()方法来为数据库创建表
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import MySQLdb
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" ) # 打开数据库连接
cursor = db.cursor() # 使用cursor()方法获取操作游标
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE") # 如果数据表已经存在使用 execute() 方法删除表。
sql = """CREATE TABLE EMPLOYEE ( # 创建数据表SQL语句
FIRST_NAME CHAR(20) NOT NULL,
LAST_NAME CHAR(20),
AGE INT,
SEX CHAR(1),
INCOME FLOAT )"""
cursor.execute(sql)
db.close() # 关闭数据库连接
--数据库插入操作
<1> 不带变量
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import MySQLdb
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" ) # 打开数据库连接
cursor = db.cursor() # 使用cursor()方法获取操作游标
# SQL 插入语句
# 写法1
sql = """INSERT INTO EMPLOYEE(FIRST_NAME,
LAST_NAME, AGE, SEX, INCOME)
VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""
# 写法2
sql = "INSERT INTO EMPLOYEE(FIRST_NAME, \
LAST_NAME, AGE, SEX, INCOME) \
VALUES ('%s', '%s', '%d', '%c', '%d' )" % \
('Mac', 'Mohan', 20, 'M', 2000)
try:
cursor.execute(sql) # 执行sql语句
db.commit() # 提交到数据库执行
except:
db.rollback() # 发生错误时回滚
db.close() # 关闭数据库连接
<2> 带变量 使用变量向SQL语句中传递参数:
user_id = "test123"
password = "password"
con.execute('insert into Login values("%s", "%s")' % \
(user_id, password))
--数据库查询操作--Python查询Mysql使用 fetchone() 方法获取单条数据, 。
fetchone(): 该方法获取下一个查询结果集。结果集是一个对象
fetchall(): 使用fetchall()方法获取多条数据
rowcount: 这是一个只读属性，并返回执行execute()方法后影响的行数。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import MySQLdb
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )
cursor = db.cursor()
sql = "SELECT * FROM EMPLOYEE \ # SQL 查询语句
WHERE INCOME > '%d'" % (1000)
try:
cursor.execute(sql)
results = cursor.fetchall() # 获取所有记录列表 接收全部的返回结果行
for row in results:
fname = row[0]
lname = row[1]
age = row[2]
sex = row[3]
income = row[4]
# 打印结果
print "fname=%s,lname=%s,age=%d,sex=%s,income=%d" % \
(fname, lname, age, sex, income )
except:
print "Error: unable to fecth data"
db.close()
--数据库更新操作--更新数据表的的数据
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import MySQLdb
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )
cursor = db.cursor()
sql = "UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = '%c'" % ('M') # SQL 更新语句
try:
cursor.execute(sql)
db.commit()
except:
db.rollback()
db.close()
--删除操作---删除数据表中的数据
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import MySQLdb
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )
cursor = db.cursor()
sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (20) # SQL 删除语句
try:
cursor.execute(sql)
db.commit()
except:
db.rollback()
db.close()
--执行事务
事务机制可以确保数据一致性。
事务应该具有4个属性: 原子性、一致性、隔离性、持久性。这四个属性通常称为ACID特性。
原子性（atomicity）。一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做。
一致性（consistency）。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。
隔离性（isolation）。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
持久性（durability）。持续性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。
Python DB API 2.0 的事务提供了两个方法 commit 或 rollback。
对于支持事务的数据库， 在Python数据库编程中，当游标建立之时，就自动开始了一个隐形的数据库事务。
commit()方法游标的所有更新操作，rollback（）方法回滚当前游标的所有操作。每一个方法都开始了一个新的事务。
--Python下的Mysql模块MySQLdb安装详解
在Python环境下，如果想操作MySQL数据库，难免会调用相应的包，比如常用的: MySQLdb通过导入: import MySQLdb 后，可直接调用里面的方法
默认情况下，MySQLdb包是没有安装的，不信？ 看到类似下面的代码你就信了。
-bash-3.2# /usr/local/python2.7.3/bin/python get_cnblogs_news.py
Traceback (most recent call last):
File "get_cnblogs_news.py", line 9, in <module>
import MySQLdb
ImportError: No module named MySQLdb
这时我们就不得不安装MySQLdb包了。安装其实也挺简单，具体步骤如下:
1、下载 MySQL for Python
地址: http://sourceforge.net/projects/mysql-python/files/mysql-python/
我这里安装的是1.2.3版本
wget http://sourceforge.net/projects/mysql-python/files/mysql-python/1.2.3/MySQL-python-1.2.3.tar.gz
2、解压
tar zxvf MySQL-python-1.2.3.tar.gz
3、安装
$ cd MySQL-python-1.2.3
$ python setup.py build
$ python setup.py install
注:
如果在执行: python setup.py build 遇到以下错误:
EnvironmentError: mysql_config not found
首先查找mysql_config的位置，使用
find / -name mysql_config ，比如我的在/usr/local/mysql/bin/mysql_config
修改setup_posix.py文件，在26行:
mysql_config.path = “mysql_config” 修改为:
mysql_config.path = “/usr/local/mysql/bin/mysql_config”
保存后，然后再次执行:
python setup.py build
python setup.py install
OK，到此大功告成。
--12.4-------------import------import pymysql模块
--Python中操作mysql的pymysql模块详解
这篇文章给大家演示了如何安装以及使用Python中操作mysql的pymysql模块，本文介绍的很详细，对大家学习Python具有一定参考借鉴价值，有需要的朋友们一起来看看吧。
前言
pymsql是Python中操作MySQL的模块，其使用方法和MySQLdb几乎相同。但目前pymysql支持python3.x而后者不支持3.x版本。
本文测试python版本: 2.7.11。mysql版本: 5.6.24
一、安装
pip3 install pymysql
二、使用操作
1、执行SQL
#!/usr/bin/env pytho
# -*- coding:utf-8 -*-
import pymysql
# 创建连接
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='', db='tkq1', charset='utf8')
# 创建游标
cursor = conn.cursor()
# 执行SQL，并返回收影响行数
effect_row = cursor.execute("select * from tb7")
# 执行SQL，并返回受影响行数
#effect_row = cursor.execute("update tb7 set pass = '123' where nid = %s", (11,))
# 执行SQL，并返回受影响行数,执行多次
#effect_row = cursor.executemany("insert into tb7(user,pass,licnese)values(%s,%s,%s)", [("u1","u1pass","11111"),("u2","u2pass","22222")])
# 提交，不然无法保存新建或者修改的数据
conn.commit()
# 关闭游标
cursor.close()
# 关闭连接
conn.close()
注意: 存在中文的时候，连接需要添加charset='utf8'，否则中文显示乱码。
2、获取查询数据
#! /usr/bin/env python
# -*- coding:utf-8 -*-
# __author__ = "TKQ"
import pymysql
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='', db='tkq1')
cursor = conn.cursor()
cursor.execute("select * from tb7")
# 获取剩余结果的第一行数据
row_1 = cursor.fetchone()
print row_1
# 获取剩余结果前n行数据
# row_2 = cursor.fetchmany(3)
# 获取剩余结果所有数据
# row_3 = cursor.fetchall()
conn.commit()
cursor.close()
conn.close()
3、获取新创建数据自增ID
可以获取到最新自增的ID，也就是最后插入的一条数据ID
#! /usr/bin/env python
# -*- coding:utf-8 -*-
# __author__ = "TKQ"
import pymysql
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='', db='tkq1')
cursor = conn.cursor()
effect_row = cursor.executemany("insert into tb7(user,pass,licnese)values(%s,%s,%s)", [("u3","u3pass","11113"),("u4","u4pass","22224")])
conn.commit()
cursor.close()
conn.close()
#获取自增id
new_id = cursor.lastrowid
print new_id
4、移动游标
操作都是靠游标，那对游标的控制也是必须的
注: 在fetch数据时按照顺序进行，可以使用cursor.scroll(num,mode)来移动游标位置，如:
cursor.scroll(1,mode='relative') # 相对当前位置移动
cursor.scroll(2,mode='absolute') # 相对绝对位置移动
5、fetch数据类型
关于默认获取的数据是元祖类型，如果想要或者字典类型的数据，即:
#! /usr/bin/env python
# -*- coding:utf-8 -*-
# __author__ = "TKQ"
import pymysql
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='', db='tkq1')
#游标设置为字典类型
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
cursor.execute("select * from tb7")
row_1 = cursor.fetchone()
print row_1 #{u'licnese': 213, u'user': '123', u'nid': 10, u'pass': '213'}
conn.commit()
cursor.close()
conn.close()
6、调用存储过程
a、调用无参存储过程
#! /usr/bin/env python
# -*- coding:utf-8 -*-
# __author__ = "TKQ"
import pymysql
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='', db='tkq1')
#游标设置为字典类型
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
#无参数存储过程
cursor.callproc('p2') #等价于cursor.execute("call p2()")
row_1 = cursor.fetchone()
print row_1
conn.commit()
cursor.close()
conn.close()
b、调用有参存储过程
#! /usr/bin/env python
# -*- coding:utf-8 -*-
# __author__ = "TKQ"
import pymysql
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='', db='tkq1')
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
cursor.callproc('p1', args=(1, 22, 3, 4))
#获取执行完存储的参数,参数@开头
cursor.execute("select @p1,@_p1_1,@_p1_2,@_p1_3") #{u'@_p1_1': 22, u'@p1': None, u'@_p1_2': 103, u'@_p1_3': 24}
row_1 = cursor.fetchone()
print row_1
conn.commit()
cursor.close()
conn.close()
三、关于pymysql防注入
1、字符串拼接查询，造成注入
正常查询语句:
#! /usr/bin/env python
# -*- coding:utf-8 -*-
# __author__ = "TKQ"
import pymysql
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='', db='tkq1')
cursor = conn.cursor()
user="u1"
passwd="u1pass"
#正常构造语句的情况
sql="select user,pass from tb7 where user='%s' and pass='%s'" % (user,passwd)
#sql=select user,pass from tb7 where user='u1' and pass='u1pass'
row_count=cursor.execute(sql) row_1 = cursor.fetchone()
print row_count,row_1
conn.commit()
cursor.close()
conn.close()
构造注入语句:
#! /usr/bin/env python
# -*- coding:utf-8 -*-
# __author__ = "TKQ"
import pymysql
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='', db='tkq1')
cursor = conn.cursor()
user="u1' or '1'-- "
passwd="u1pass"
sql="select user,pass from tb7 where user='%s' and pass='%s'" % (user,passwd)
#拼接语句被构造成下面这样，永真条件，此时就注入成功了。因此要避免这种情况需使用pymysql提供的参数化查询。
#select user,pass from tb7 where user='u1' or '1'-- ' and pass='u1pass'
row_count=cursor.execute(sql)
row_1 = cursor.fetchone()
print row_count,row_1
conn.commit()
cursor.close()
conn.close()
2、避免注入，使用pymysql提供的参数化语句
正常参数化查询
#! /usr/bin/env python
# -*- coding:utf-8 -*-
# __author__ = "TKQ"
import pymysql
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='', db='tkq1')
cursor = conn.cursor()
user="u1"
passwd="u1pass"
#执行参数化查询
row_count=cursor.execute("select user,pass from tb7 where user=%s and pass=%s",(user,passwd))
row_1 = cursor.fetchone()
print row_count,row_1
conn.commit()
cursor.close()
conn.close()
构造注入，参数化查询注入失败。
#! /usr/bin/env python
# -*- coding:utf-8 -*-
# __author__ = "TKQ"
import pymysql
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='', db='tkq1')
cursor = conn.cursor()
user="u1' or '1'-- "
passwd="u1pass"
#执行参数化查询
row_count=cursor.execute("select user,pass from tb7 where user=%s and pass=%s",(user,passwd))
#内部执行参数化生成的SQL语句，对特殊字符进行了加\转义，避免注入语句生成。
# sql=cursor.mogrify("select user,pass from tb7 where user=%s and pass=%s",(user,passwd))
# print sql
#select user,pass from tb7 where user='u1\' or \'1\'-- ' and pass='u1pass'被转义的语句。
row_1 = cursor.fetchone()
print row_count,row_1
conn.commit()
cursor.close()
conn.close()
结论: excute执行SQL语句的时候，必须使用参数化的方式，否则必然产生SQL注入漏洞。
3、使用存mysql储过程动态执行SQL防注入
使用MYSQL存储过程自动提供防注入，动态传入SQL到存储过程执行语句。
delimiter \\
DROP PROCEDURE IF EXISTS proc_sql \\
CREATE PROCEDURE proc_sql (
in nid1 INT,
in nid2 INT,
in callsql VARCHAR(255)
)
BEGIN
set @nid1 = nid1;
set @nid2 = nid2;
set @callsql = callsql;
PREPARE myprod FROM @callsql;
-- PREPARE prod FROM 'select * from tb2 where nid>? and nid<?'; 传入的值为字符串，？为占位符
-- 用@p1，和@p2填充占位符
EXECUTE myprod USING @nid1,@nid2;
DEALLOCATE prepare myprod;
END\\
delimiter ;
set @nid1=12;
set @nid2=15;
set @callsql = 'select * from tb7 where nid>? and nid<?';
CALL proc_sql(@nid1,@nid2,@callsql)
pymsql中调用
#! /usr/bin/env python
# -*- coding:utf-8 -*-
# __author__ = "TKQ"
import pymysql
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='', db='tkq1')
cursor = conn.cursor()
mysql="select * from tb7 where nid>? and nid<?"
cursor.callproc('proc_sql', args=(11, 15, mysql))
rows = cursor.fetchall()
print rows #((12, 'u1', 'u1pass', 11111), (13, 'u2', 'u2pass', 22222), (14, 'u3', 'u3pass', 11113))
conn.commit()
cursor.close()
conn.close()
四、使用with简化连接过程
每次都连接关闭很麻烦，使用上下文管理，简化连接过程
#! /usr/bin/env python
# -*- coding:utf-8 -*-
# __author__ = "TKQ"
import pymysql
import contextlib
#定义上下文管理器，连接后自动关闭连接
@contextlib.contextmanager
def mysql(host='127.0.0.1', port=3306, user='root', passwd='', db='tkq1',charset='utf8'):
conn = pymysql.connect(host=host, port=port, user=user, passwd=passwd, db=db, charset=charset)
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
try:
yield cursor
finally:
conn.commit()
cursor.close()
conn.close()
# 执行sql
with mysql() as cursor:
print(cursor)
row_count = cursor.execute("select * from tb7")
row_1 = cursor.fetchone()
print row_count, row_1
总结
以上就是关于Python中pymysql模块的全部内容，希望对大家学习或使用python能有一定的帮助，如果有疑问大家可以留言交流。
--python实现读取excel写入mysql的小工具详解
EXCEL 和 MySQL 大体上来说都可以算是"数据库"，MySQL貌似有EXCEL的接口，但是最近在自学Python，用Python实现了一下，下面这篇文章主要给大家介绍了关于利用python实现读取excel写入mysql的一个小工具，需要的朋友可以参考下。
Python是数据分析的强大利器
利用Python做数据分析，第一步就是学习如何读取日常工作中产生各种excel报表并存入数据中，方便后续数据处理。
这里向大家分享python如何读取excel，并使用Python将数据存入Mysql中，有需要的朋友们一起来看看吧。
背景
需要导入全国高校名录到数据库，从教委网站下到了最新的数据，是excel格式，需要做一个工具进行导入，想试用一下python，说干就干。
库
xlrd : excel读写库
pymysql : mysql数据库驱动库，纯python打造
re : 正则表达式库，核心库
前两个用pip轻松完成安装，本人是在mac pro是进行的，过程很顺利，以前在mac上装mysqlclient一直安装不上，所以一度放弃使用python，但我在linux下安装mysqlclient却没有任何问题。
源代码
很简单的小脚本，留存纪念。值得注意的一点，数据库连接字段串中要设定字符编码，不然默认是lanti-1，写入会出错。
import xlrd
import pymysql
import re
conn = pymysql.connect(host='database connect address', port=1234, user='root',
passwd='****', db='database name', charset='utf8mb4')
p = re.compile(r'\s')
data = xlrd.open_workbook('./W020170616379651135432.xls')
table = data.sheets()[0]
t = table.col_values(1)
nrows = table.nrows
for i in range(nrows):
r1 = table.row_values(i)
if len(r1[2]) == 10:
cur = conn.cursor()
cur.execute('insert into `university` (`id`, `name`, `ministry`, `city`, `level`, `memo`) \
values (%s, %s, %s, %s, %s, %s)',
(r1[2], p.sub('', r1[1]), p.sub('', r1[3]), p.sub('', r1[4]), r1[5], r1[6]))
conn.commit()
cur.close()
conn.close()
心得
写惯了类C的语言，不太习惯python，想同时掌握两种风格的编程语言，好痛苦啊。python编程效率的确不错，这是我第一次用python写实用小程序，连查带写带调试，一共也就花了一个来小时。python库与资料丰富，不愁找不到合适的^_^
数据库写入优化
早上闲来无事，用批量写入优化了一下，任务秒完成，比一条条写入快了很多， 比我预想的差别还要大。看来，没有不好的工具，只是我们没有用好啊！
import xlrd
import pymysql
import re
conn = pymysql.connect(host='database connect address', port=1234, user='root',
passwd='****', db='database name', charset='utf8mb4')
p = re.compile(r'\s')
data = xlrd.open_workbook('./W020170616379651135432.xls')
table = data.sheets()[0]
t = table.col_values(1)
nrows = table.nrows
ops = []
for i in range(nrows):
r1 = table.row_values(i)
if len(r1[2]) == 10:
ops.append((r1[2], p.sub('', r1[1]), p.sub('', r1[3]), p.sub('', r1[4]), r1[5], r1[6]))
cur = conn.cursor()
cur.executemany('insert into `university_copy` (`id`, `name`, `ministry`, `city`, `level`, `memo`) \
values (%s, %s, %s, %s, %s, %s)', ops)
conn.commit()
cur.close()
conn.close()
python读取excel文件遇到的问题
1、mac安装xlrd模块，如果cmd下执行pip install xlrd安装不成功，可以直接去官网下载，名称类似这样的文件xlrd-1.0.0-py3-none-any.whl，切换到已下载的文件路径在cmd下执行pip3 install xlrd-1.0.0-py3-none-any.whl即可
http://pypi.python.org/pypi/xlrd
2、python打开excel报xlrd.biffh.XLRDError: Unsupported format, or corrupt file: Expected BOF record; found b'username'
可以确认下要打开的excel保存时是不是本身就存在兼容性等格式提示，如果有的话，需要重新建一个不存在格式问题的文件
import xlrd
from os.path import join,abspath,dirname
fname = join(dirname(dirname(abspath(__file__))),'test1.xls')
bk = xlrd.open_workbook(fname, encoding_override="utf-8")
shxrange = range(bk.nsheets)
try:
sh = bk.sheet_by_name("工作表1")
# 获取行数
nrows = sh.nrows
# 获取列数
ncols = sh.ncols
print("nrows %d, ncols %d" % (nrows, ncols))
# 获取第一行第一列数据
cell_value = sh.cell_value(1, 1)
# print cell_value
row_list = []
# 获取各行数据
for i in range(0, nrows):
row_data = sh.row_values(i)
row_list.append(row_data)
except:
print("no sheet in %s named Sheet1" % fname)
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对脚本之家的支持。
--Python xlrd读取excel日期类型的2种方法
这篇文章主要介绍了Python xlrd读取excel日期类型的2种方法,本文同时讲解了xlrd读取excel某个单元格的方法,需要的朋友可以参考下
有个excle表格需要做一些过滤然后写入数据库中，但是日期类型的cell取出来是个数字，于是查询了下解决的办法。
基本的代码结构
data = xlrd.open_workbook(EXCEL_PATH)
table = data.sheet_by_index(0)
lines = table.nrows
cols = table.ncols
print u'The total line is %s, cols is %s'%(lines, cols)
读取某个单元格:
table.cell(x, y).value
x: 行
y: 列
行，列都是从0开始
* 时间类型的转换，把excel中时间转成python 时间(两种方式)
excel某个单元格 2014/7/8
xlrd.xldate_as_tuple(table.cell(2,2).value, 0) #转化为元组形式
(2014, 7, 8, 0, 0, 0)
xlrd.xldate.xldate_as_datetime(table.cell(2,2).value, 1) #直接转化为datetime对象
datetime.datetime(2018, 7, 9, 0, 0)
table.cell(2,2).value #没有转化
41828.0
源码查看:
# @param xldate The Excel number
# @param datemode 0: 1900-based, 1: 1904-based.
xldate_as_tuple(xldate, datemode)
输入一个日期类型的单元格会返回一个时间结构组成的元组，可以根据这个元组组成时间类型
datemode 有2个选项基本我们都会使用1900为基础的时间戳
##
# Convert an Excel date/time number into a datetime.datetime object.
#
# @param xldate The Excel number
# @param datemode 0: 1900-based, 1: 1904-based.
#
# @return a datetime.datetime() object.
#
def xldate_as_datetime(xldate, datemode)
输入参数和上面的相同，但是返回值是一个datetime类型，就不需要在自己转换了
当然这两个函数都有相应的逆函数，把python类型变成相应的excle时间类型。
--Python导出数据到Excel可读取的CSV文件的方法
这篇文章主要介绍了Python导出数据到Excel可读取的CSV文件的方法,设计Python操作Excel的相关技巧,需要的朋友可以参考下
本文实例讲述了Python导出数据到Excel可读取的CSV文件的方法。分享给大家供大家参考。具体实现方法如下:
import csv
with open('eggs.csv', 'wb') as csvfile:
#spamwriter = csv.writer(csvfile, delimiter=' ',quotechar='|',
#quoting=csv.QUOTE_MINIMAL)
spamwriter = csv.writer(csvfile, dialect='excel')
spamwriter.writerow(['Spam'] * 5 + ['Baked Beans'])
spamwriter.writerow(['Spam', 'Lovely Spam', 'Wonderful Spam'])
希望本文所述对大家的Python程序设计有所帮助。
--Python中使用第三方库xlrd来读取Excel示例
这篇文章主要介绍了Python中使用第三方库xlrd来读取Excel示例,本文讲解了安装xlrd、xlrd的API、使用xlrd读取Excel代码示例,需要的朋友可以参考下
本篇文章介绍如何使用xlrd来读取Excel表格中的内容，xlrd是第三方库，所以在使用前我们需要安装xlrd。另外我们一般会使用xlwt来写Excel，所以下一篇文章我们会来介绍如何使用xlwt来写Excel。xlrd下载: xlrd 0.8.0
安装xlrd
安装xlrd，只需运行setup即可，另外你也可以直接解压缩到你的project中，也可以直接用
xlrd的API
获取Excel，这里称之为work book
open_workbook(file_name)
获取指定的Sheet，有两种方式
sheet = xls.sheet_by_index(sheet_no)
sheet = xls.sheet_by_name(sheet_name)
获取整行和整列的值（数组）
sheet.row_values(i)
sheet.col_values(i)
获取总行数和总列数
nrows = sheet.nrows
ncols = sheet.ncols
使用xlrd
使用xlrd这里就用一个简单的例子示例下:
# -*- coding: utf-8 -*-
'''''
Created on 2012-12-14
@author: walfred
@module: XLRDPkg.read
@description:
'''
import os
import types
import xlrd as ExcelRead
def readXLS(file_name):
if os.path.isfile(file_name):
try:
xls = ExcelRead.open_workbook(file_name)
sheet = xls.sheet_by_index(0)
except Exception, e:
print "open %s error, error is %s" %(file_name, e)
return
rows_cnt = sheet.nrows
for row in range(1, rows_cnt):
name = sheet.row_values(row)[0].encode("utf-8").strip()
sex = sheet.row_values(row)[1].encode("utf-8").strip()
age = sheet.row_values(row)[2]
if type(age) is types.FloatType:#判读下类型
no = str(int(age))
else:
age = no.encode("utf-8").strip()
country = sheet.row_values(row)[3].encode("utf-8").strip()
print "Name: %s, Sex: %s, Age: %s, Country: %s" %(name, sex, age, country)
if __name__ == "__main__":
readXLS("./test_read.xls");
很easy吧，需要说明的是，目前xlrd只支持95-03版本的MS Excel，所以使用之前需要核对自己的word版本。
--Python使用xlrd读取Excel格式文件的方法
这篇文章主要介绍了Python使用xlrd读取Excel格式文件的方法,实例分析了Python操作Excel文件的技巧,具有一定参考借鉴价值,需要的朋友可以参考下
本文实例讲述了Python使用xlrd读取Excel格式文件的方法。分享给大家供大家参考。具体如下:
使用xlrd能够很方便的读取excel文件内容，而且这是个跨平台的库，能够在windows，linux/unix，等平台上面使用，代码如下:
import xlrd
fname = "sample.xls"
bk = xlrd.open_workbook(fname)
shxrange = range(bk.nsheets)
try:
sh = bk.sheet_by_name("Sheet1")
except:
print "no sheet in %s named Sheet1" % fname
return None
nrows = sh.nrows
ncols = sh.ncols
print "nrows %d, ncols %d" % (nrows,ncols)
cell_value = sh.cell_value(1,1)
print cell_value
row_list = []
for i in range(1,nrows):
row_data = sh.row_values(i)
row_list.append(row_data)
希望本文所述对大家的Python程序设计有所帮助。
--Python读取Excel的方法实例分析
这篇文章主要介绍了Python读取Excel的方法,实例分析了Python操作Excel文件的相关技巧,非常具有实用价值,需要的朋友可以参考下
本文实例讲述了Python读取Excel的方法。分享给大家供大家参考。具体如下:
今天需要从一个Excel文档（.xls）中导数据到数据库的某表，开始是手工一行行输的。后来想不能一直这样，就用Python写了下面的代码，可以很方便应对这种场景。比如利用我封装的这些方法可以很方便地生成导入数据的SQL。 当然熟悉Excel编程的同学还可以直接用VBA写个脚本生成插入数据的SQL。
还可以将.xls文件改为.csv文件，然后通过SQLyog或者Navicat等工具导入进来，但是不能细粒度控制（比如不满足某些条件的某些数据不需要导入，而用程序就能更精细地控制了；又比如重复数据不能重复导入；还有比如待导入的Excel表格和数据库中的表的列不完全一致） 。
我的Python版本是3.0，需要去下载xlrd 3: http://pypi.python.org/pypi/xlrd3/ 然后通过setup.py install命令安装即可
import xlrd3
'''
author: jxqlove?
本代码主要封装了几个操作Excel数据的方法
'''
'''
获取行视图
根据Sheet序号获取该Sheet包含的所有行，返回值类似[ ['a', 'b', 'c'], ['1', '2', '3'] ]
sheetIndex指示sheet的索引，0表示第一个sheet，依次类推
xlsFilePath是Excel文件的相对或者绝对路径
'''
def getAllRowsBySheetIndex(sheetIndex, xlsFilePath):
workBook = xlrd3.open_workbook(xlsFilePath)
table = workBook.sheets()[sheetIndex]
rows = []
rowNum = table.nrows # 总共行数
rowList = table.row_values
for i in range(rowNum):
rows.append(rowList(i)) # 等价于rows.append(i, rowLists(i))
return rows
'''
获取某个Sheet的指定序号的行
sheetIndex从0开始
rowIndex从0开始
'''
def getRow(sheetIndex, rowIndex, xlsFilePath):
rows = getAllRowsBySheetIndex(sheetIndex, xlsFilePath)
return rows[rowIndex]
'''
获取列视图
根据Sheet序号获取该Sheet包含的所有列，返回值类似[ ['a', 'b', 'c'], ['1', '2', '3'] ]
sheetIndex指示sheet的索引，0表示第一个sheet，依次类推
xlsFilePath是Excel文件的相对或者绝对路径
'''
def getAllColsBySheetIndex(sheetIndex, xlsFilePath):
workBook = xlrd3.open_workbook(xlsFilePath)
table = workBook.sheets()[sheetIndex]
cols = []
colNum = table.ncols # 总共列数
colList = table.col_values
for i in range(colNum):
cols.append(colList(i))
return cols
'''
获取某个Sheet的指定序号的列
sheetIndex从0开始
colIndex从0开始
'''
def getCol(sheetIndex, colIndex, xlsFilePath):
cols = getAllColsBySheetIndex(sheetIndex, xlsFilePath)
return cols[colIndex]
'''
获取指定sheet的指定行列的单元格中的值
'''
def getCellValue(sheetIndex, rowIndex, colIndex, xlsFilePath):
workBook = xlrd3.open_workbook(xlsFilePath)
table = workBook.sheets()[sheetIndex]
return table.cell(rowIndex, colIndex).value # 或者table.row(0)[0].value或者table.col(0)[0].value
if __name__=='__main__':
rowsInFirstSheet = getAllRowsBySheetIndex(0, './产品.xls')
print(rowsInFirstSheet)
colsInFirstSheet = getAllColsBySheetIndex(0, './产品.xls')
print(colsInFirstSheet)
print(getRow(0, 0, './产品.xls'))
# 获取第一个sheet第一行的数据
print(getCol(0, 0, './产品.xls'))
# 获取第一个sheet第一列的数据
print(getCellValue(0, 3, 2, './产品.xls'))
# 获取第一个sheet第四行第二列的单元格的值
希望本文所述对大家的Python程序设计有所帮助。
--python文件读写并使用mysql批量插入示例分享(python操作mysql)
这篇文章主要介绍了python文件读写并使用mysql批量插入示例,可以学习到python操作mysql数据库的方法,需要的朋友可以参考下
# -*- coding: utf-8 -*-
'''
Created on 2013年12月9日
@author: hhdys
'''
import os
import mysql.connector
config = {
'user': 'root',
'password': '******',
'host': '127.0.0.1',
'database': 'test',
'raise_on_warnings': True,
}
cnx = mysql.connector.connect(**config)
class ReadFile:
def readLines(self):
f = open("E:/data/2013-11-5.txt", "r", 1, "utf-8")
i=0
list=[]
for line in f:
strs = line.split("\t")
if len(strs) != 5:
continue
data=(strs[0], strs[1], strs[2], strs[3], strs[4].replace("\n",""))
list.append(data)
cursor=cnx.cursor()
sql = "insert into data_test(uid,log_date,fr,is_login,url)values(%s,%s,%s,%s,%s)"
if i>5000:
cursor.executemany(sql,list)
cnx.commit()
print("插入")
i=0
list.clear()
i=i+1
if i>0:
cursor.executemany(sql,list)
cnx.commit()
cnx.close()
f.close()
print("ok")
def listFiles(self):
d = os.listdir("E:/data/")
return d
if __name__ == "__main__":
readFile = ReadFile()
readFile.readLines()
--python3.4用循环往mysql5.7中写数据并输出的实现方法
下面小编就为大家带来一篇python3.4用循环往mysql5.7中写数据并输出的实现方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
如下所示:
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __author__ = "blzhu"
"""
python study
Date: 2017
"""
import pymysql
# import MySQLdb #python2中的产物
try:
# 获取一个数据库连接，注意如果是UTF-8类型的，需要制定数据库
conn = pymysql.connect(host='localhost', user='root', passwd='root', db='zbltest1', port=3306, charset='utf8')
cur = conn.cursor() # 获取一个游标
for i in range(1, 10):
zbl_id = str(i)
zbl_name = 'zbl'+str(i)
zbl_gender = 'man'
# print("%s,%s,%s" % (zbl_id,zbl_name,zbl_gender))
# sql = "insert student VALUES (id='%s',name='%s',gender='%s')" % (zbl_id,zbl_name,zbl_gender)
sql = "insert student VALUES ('%s','%s','%s')" % (zbl_id, zbl_name, zbl_gender)
# print(sql)
cur.execute(sql)
conn.commit()# 将数据写入数据库
# try:
# cur.execute(sql)
# cur.commit()
# except:
# cur.rollback()
#cur.execute("""INSERT INTO 'student' ('id','name','gender') VALUES (%s,%s,%s ,(zbl_id,zbl_name,zbl_gender,))""")
#cur.execute("""INSERT INTO 'student' ('id','name','gender') VALUES (zbl_id,zbl_name,zbl_gender)""")
# cur.execute("INSERT student VALUES (zbl_id,zbl_name,zbl_gender)")
# cur.execute("INSERT student VALUES ('4', 'zbl4', 'man')")# 正确
#cur.execute("INSERT INTO 'student' ('id','name','gender') VALUES ('4', 'zbl4', 'man')")#错误
#cur.execute("INSERT student ('id','name','gender') VALUES ('4', 'zbl4', 'man')")
cur.execute('select * from student')
# data=cur.fetchall()
for d in cur:
# 注意int类型需要使用str函数转义
print("ID: " + str(d[0]) + ' 名字: ' + d[1] + " 性别: " + d[2])
print("row_number:", (cur.rownumber))
# print('hello')
cur.close() # 关闭游标
conn.close() # 释放数据库资源
except Exception:
print("发生异常")
上面代码是对的，但是是曲折的。
下面整理一下:
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __author__ = "blzhu"
"""
python study
Date: 2017
"""
import pymysql
try:
# 获取一个数据库连接，注意如果是UTF-8类型的，需要制定数据库
conn = pymysql.connect(host='localhost', user='root', passwd='root', db='zbltest1', port=3306, charset='utf8')
cur = conn.cursor() # 获取一个游标
for i in range(1, 10):
zbl_id = str(i)
zbl_name = 'zbl'+str(i)
zbl_gender = 'man'
# print("%s,%s,%s" % (zbl_id,zbl_name,zbl_gender))
# sql = "insert student VALUES (id='%s',name='%s',gender='%s')" % (zbl_id,zbl_name,zbl_gender)
sql = "insert student VALUES ('%s','%s','%s')" % (zbl_id, zbl_name, zbl_gender)
# print(sql)
cur.execute(sql)
conn.commit()# 将数据写入数据库
cur.execute('select * from student')
# data=cur.fetchall()
for d in cur:
# 注意int类型需要使用str函数转义
print("ID: " + str(d[0]) + ' 名字: ' + d[1] + " 性别: " + d[2])
print("row_number:", (cur.rownumber))
# print('hello')
cur.close() # 关闭游标
conn.close() # 释放数据库资源
except Exception:
print("发生异常")
#!/usr/bin/python3
import pymysql
import types
db=pymysql.connect("localhost","root","123456","python");
cursor=db.cursor()
#创建user表
cursor.execute("drop table if exists user")
sql="""CREATE TABLE IF NOT EXISTS `user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(255) NOT NULL,
`age` int(11) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=0"""
cursor.execute(sql)
#user插入数据
sql="""INSERT INTO `user` (`name`, `age`) VALUES
('test1', 1),
('test2', 2),
('test3', 3),
('test4', 4),
('test5', 5),
('test6', 6);"""
try:
# 执行sql语句
cursor.execute(sql)
# 提交到数据库执行
db.commit()
except:
# 如果发生错误则回滚
db.rollback()
#更新
id=1
sql="update user set age=100 where id='%s'" % (id)
try:
cursor.execute(sql)
db.commit()
except:
db.rollback()
#删除
id=2
sql="delete from user where id='%s'" % (id)
try:
cursor.execute(sql)
db.commit()
except:
db.rollback()
#查询
cursor.execute("select * from user")
results=cursor.fetchall()
for row in results:
name=row[0]
age=row[1]
#print(type(row[1])) #打印变量类型 <class 'str'>
print ("name=%s,age=%s" % \
(age, name))
以上这篇python3.4用循环往mysql5.7中写数据并输出的实现方法就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持脚本之家。
--Python操作MySQL数据库9个实用实例
这篇文章主要介绍了Python操作MySQL数据库9个实用实例，需要的朋友可以参考下
在Windows平台上安装mysql模块用于Python开发
用python连接mysql的时候，需要用的安装版本，源码版本容易有错误提示。下边是打包了32与64版本。
MySQL-python-1.2.3.win32-py2.7.exe
MySQL-python-1.2.3.win-amd64-py2.7.exe
实例 1、取得 MYSQL 的版本
# -*- coding: UTF-8 -*-
#安装 MYSQL DB for python
import MySQLdb as mdb
con = None
try:
#连接 mysql 的方法: connect('ip','user','password','dbname')
con = mdb.connect('localhost', 'root','root', 'test');
#所有的查询，都在连接 con 的一个模块 cursor 上面运行的
cur = con.cursor()
#执行一个查询
cur.execute("SELECT VERSION()")
#取得上个查询的结果，是单个结果
data = cur.fetchone()
print "Database version : %s " % data
finally:
if con:
#无论如何，连接记得关闭
con.close()
实例 2、创建一个表并且插入数据
import MySQLdb as mdb
import sys
#将 con 设定为全局连接
con = mdb.connect('localhost', 'root', 'root', 'test');
with con:
#获取连接的 cursor，只有获取了 cursor，我们才能进行各种操作
cur = con.cursor()
#创建一个数据表 writers(id,name)
cur.execute("CREATE TABLE IF NOT EXISTS \
Writers(Id INT PRIMARY KEY AUTO_INCREMENT, Name VARCHAR(25))")
#以下插入了 5 条数据
cur.execute("INSERT INTO Writers(Name) VALUES('Jack London')")
cur.execute("INSERT INTO Writers(Name) VALUES('Honore de Balzac')")
cur.execute("INSERT INTO Writers(Name) VALUES('Lion Feuchtwanger')")
cur.execute("INSERT INTO Writers(Name) VALUES('Emile Zola')")
cur.execute("INSERT INTO Writers(Name) VALUES('Truman Capote')")
实例 3、 python 使用 slect 获取 mysql 的数据并遍历
import MySQLdb as mdb
import sys
#连接 mysql，获取连接的对象
con = mdb.connect('localhost', 'root', 'root', 'test');
with con:
#仍然是，第一步要获取连接的 cursor 对象，用于执行查询
cur = con.cursor()
#类似于其他语言的 query 函数， execute 是 python 中的执行查询函数
cur.execute("SELECT * FROM Writers")
#使用 fetchall 函数，将结果集（多维元组）存入 rows 里面
rows = cur.fetchall()
#依次遍历结果集，发现每个元素，就是表中的一条记录，用一个元组来显示
for row in rows:
print row
运行结果:
(1L, ‘Jack London')
(2L, ‘Honore de Balzac')
(3L, ‘Lion Feuchtwanger')
(4L, ‘Emile Zola')
(5L, ‘Truman Capote')
上面的代码，用来将所有的结果取出，不过打印的时候是每行一个元祖打印，现在我们使用方法，取出其中的单个数据:
import MySQLdb as mdb
import sys
#获取 mysql 的链接对象
con = mdb.connect('localhost', 'root', 'root', 'test');
with con:
#获取执行查询的对象
cur = con.cursor()
#执行那个查询，这里用的是 select 语句
cur.execute("SELECT * FROM Writers")
#使用 cur.rowcount 获取结果集的条数
numrows = int(cur.rowcount)
#循环 numrows 次，每次取出一行数据
for i in range(numrows):
#每次取出一行，放到 row 中，这是一个元组(id,name)
row = cur.fetchone()
#直接输出两个元素
print row[0], row[1]
运行结果:
1 Jack London
2 Honore de Balzac
3 Lion Feuchtwanger
4 Emile Zola
5 Truman Capote
实例 4、使用字典 cursor 取得结果集（可以使用表字段名字访问值）
import MySQLdb as mdb
import sys
#获得 mysql 查询的链接对象
con = mdb.connect('localhost', 'root', 'root', 'test')
with con:
#获取连接上的字典 cursor，注意获取的方法，
#每一个 cursor 其实都是 cursor 的子类
cur = con.cursor(mdb.cursors.DictCursor)
#执行语句不变
cur.execute("SELECT * FROM Writers")
#获取数据方法不变
rows = cur.fetchall()
#遍历数据也不变（比上一个更直接一点）
for row in rows:
#这里，可以使用键值对的方法，由键名字来获取数据
print "%s %s" % (row["Id"], row["Name"])
实例 5、获取单个表的字段名和信息的方法
import MySQLdb as mdb
import sys
#获取数据库的链接对象
con = mdb.connect('localhost', 'root', 'root', 'test')
with con:
#获取普通的查询 cursor
cur = con.cursor()
cur.execute("SELECT * FROM Writers")
rows = cur.fetchall()
#获取连接对象的描述信息
desc = cur.description
print 'cur.description:',desc
#打印表头，就是字段名字
print "%s %3s" % (desc[0][0], desc[1][0])
for row in rows:
#打印结果
print "%2s %3s" % row
运行结果:
cur.description: ((‘Id', 3, 1, 11, 11, 0, 0), (‘Name', 253, 17, 25, 25, 0, 1))
Id Name
1 Jack London
2 Honore de Balzac
3 Lion Feuchtwanger
4 Emile Zola
5 Truman Capote
实例 6、使用 Prepared statements 执行查询（更安全方便）
import MySQLdb as mdb
import sys
con = mdb.connect('localhost', 'root', 'root', 'test')
with con:
cur = con.cursor()
#我们看到，这里可以通过写一个可以组装的 sql 语句来进行
cur.execute("UPDATE Writers SET Name = %s WHERE Id = %s",
("Guy de Maupasant", "4"))
#使用 cur.rowcount 获取影响了多少行
print "Number of rows updated: %d" % cur.rowcount
结果:
Number of rows updated: 1
实例 7、把图片用二进制存入 MYSQL
有人喜欢把图片存入 MYSQL（这种做法貌似很少吧），我看大部分的程序，图片都是存放在服务器上的文件，数据库中存的只是图片的地址而已，不过 MYSQL 是支持把图片存入数据库的，也相应的有一个专门的字段 BLOB (Binary Large Object)，即较大的二进制对象字段，请看如下程序，注意测试图片自己随便找一个，地址要正确:
首先，在数据库中创建一个表，用于存放图片:
CREATE TABLE Images(Id INT PRIMARY KEY AUTO_INCREMENT, Data MEDIUMBLOB);
然后运行如下 PYTHON 代码进行:
import MySQLdb as mdb
import sys
try:
#用读文件模式打开图片
fin = open("../web.jpg")
#将文本读入 img 对象中
img = fin.read()
#关闭文件
fin.close()
except IOError, e:
#如果出错，打印错误信息
print "Error %d: %s" % (e.args[0],e.args[1])
sys.exit(1)
try:
#链接 mysql，获取对象
conn = mdb.connect(host='localhost',user='root',passwd='root',
db='test')
#获取执行 cursor
cursor = conn.cursor()
#直接将数据作为字符串，插入数据库
cursor.execute("INSERT INTO Images SET Data='%s'" %
mdb.escape_string(img))
#提交数据
conn.commit()
#提交之后，再关闭 cursor 和链接
cursor.close()
conn.close()
except mdb.Error, e:
#若出现异常，打印信息
print "Error %d: %s" % (e.args[0],e.args[1])
sys.exit(1)
实例 8、从数据 本文系统来源：http://blog.51cto.com/liapple6/2054866
内容总结
以上是互联网集市为您收集整理的数据库--import MySQLdb--cx_ora全部内容，希望文章能够帮你解决数据库--import MySQLdb--cx_ora所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。