当前位置：首页 » 编程语言 » fetchonepython

fetchonepython

发布时间: 2021-03-22 13:20:40

Ⅰ python fetchone 返回的是什么类型

1 你是根据数据库来进行语句分割，评价分析的吗。
如果是的话，那就把分析结果存到字典里就可以了。(也就是你说的保存)
使用呢，就是对这个字典进行判断处理。
2 如果不是的话，你是想收集语料库放到字典里，然后再利用这个字典对象去判断?
保存大词典对象的话可以用gdbm来读写。

Ⅱ Python 中用 Tkinter GUI编程

可以使用sqlite,下面是使用方法。

导入PythonSQLITE数据库模块

Python2.5之后，内置了SQLite3，成为了内置模块，这给我们省了安装的功夫，只需导入即可~

importsqlite3

2.创建/打开数据库

在调用connect函数的时候，指定库名称，如果指定的数据库存在就直接打开这个数据库，如果不存在就新创建一个再打开。

cx=sqlite3.connect("E:/test.db")

也可以创建数据库在内存中。

con=sqlite3.connect(":memory:")

3.数据库连接对象

打开数据库时返回的对象cx就是一个数据库连接对象，它可以有以下操作：

commit()--事务提交

rollback()--事务回滚

close()--关闭一个数据库连接

cursor()--创建一个游标

关于commit()，如果isolation_level隔离级别默认，那么每次对数据库的操作，都需要使用该命令，你也可以设置isolation_level=None，这样就变为自动提交模式。

4.使用游标查询数据库

我们需要使用游标对象SQL语句查询数据库，获得查询对象。通过以下方法来定义一个游标。

cu=cx.cursor()

游标对象有以下的操作：

execute()--执行sql语句

executemany--执行多条sql语句

close()--关闭游标

fetchone()--从结果中取一条记录，并将游标指向下一条记录

fetchmany()--从结果中取多条记录

fetchall()--从结果中取出所有记录

scroll()--游标滚动

1.建表

cu.execute("createtablecatalog(idintegerprimarykey,pidinteger,namevarchar(10)UNIQUE,nicknametextNULL)")

上面语句创建了一个叫catalog的表，它有一个主键id，一个pid，和一个name，name是不可以重复的，以及一个nickname默认为NULL。

2.插入数据

请注意避免以下写法：

#Neverdothis--insecure会导致注入攻击

pid=200

c.execute("...wherepid='%s'"%pid)

正确的做法如下，如果t只是单个数值，也要采用t=(n,)的形式，因为元组是不可变的。

fortin[(0,10,'abc','Yu'),(1,20,'cba','Xu')]:

cx.execute("insertintocatalogvalues(?,?,?,?)",t)

简单的插入两行数据,不过需要提醒的是,只有提交了之后,才能生效.我们使用数据库连接对象cx来进行提交commit和回滚rollback操作.

cx.commit()

3.查询

cu.execute("select*fromcatalog")

要提取查询到的数据,使用游标的fetch函数,如:

In[10]:cu.fetchall()

Out[10]:[(0,10,u'abc',u'Yu'),(1,20,u'cba',u'Xu')]

如果我们使用cu.fetchone(),则首先返回列表中的第一项,再次使用,则返回第二项,依次下去.

4.修改

In[12]:cu.execute("updatecatalogsetname='Boy'whereid=0")

In[13]:cx.commit()

注意,修改数据以后提交

5.删除

cu.execute("deletefromcatalogwhereid=1")

cx.commit()

6.使用中文

请先确定你的IDE或者系统默认编码是utf-8,并且在中文前加上u

x=u'鱼'

cu.execute("updatecatalogsetname=?whereid=0",x)

cu.execute("select*fromcatalog")

cu.fetchall()

[(0,10,u'u9c7c',u'Yu'),(1,20,u'cba',u'Xu')]

如果要显示出中文字体，那需要依次打印出每个字符串

In[26]:foritemincu.fetchall():

....:forelementinitem:

....:printelement,

....:print

....:

010鱼Yu

120cbaXu

7.Row类型

Row提供了基于索引和基于名字大小写敏感的方式来访问列而几乎没有内存开销。原文如下：

sqlite3.Rowprovidesbothindex-basedandcase-insensitivename-.-basedapproachorevenadb_rowbasedsolution.

Row对象的详细介绍

classsqlite3.Row

_factoryforConnectionobjects..

,iteration,representation,equalitytestingandlen().

,theycompareequal.

Changedinversion2.6:Addediterationandequality(hashability).

keys()

.Immediatelyafteraquery,.description.

Newinversion2.6.

下面举例说明

In[30]:cx.row_factory=sqlite3.Row

In[31]:c=cx.cursor()

In[32]:c.execute('select*fromcatalog')

Out[32]:<sqlite3.Cursorobjectat0x05666680>

In[33]:r=c.fetchone()

In[34]:type(r)

Out[34]:<type'sqlite3.Row'>

In[35]:r

Out[35]:<sqlite3.Rowobjectat0x05348980>

In[36]:printr

(0,10,u'u9c7c',u'Yu')

In[37]:len(r)

Out[37]:4

In[39]:r[2]#使用索引查询

Out[39]:u'u9c7c'

In[41]:r.keys()

Out[41]:['id','pid','name','nickname']

In[42]:foreinr:

....:printe,

....:

010鱼Yu

使用列的关键词查询

In[43]:r['id']

Out[43]:0

In[44]:r['name']

Out[44]:u'u9c7c'

Ⅲ python怎么把查询结果输出出来

试试这个fetchone函数
conn=MySQLdb.connect(host='localhost',user='root',passwd='root',db='test',port=3306)
cur=conn.cursor()
cur.execute('select * from user')
data = cur.fetchone()
print "Database : %s " % data
conn.commit()
cur.close()
conn.close()

Ⅳ python fetchone 取出的数据是什么类型

请问如何来暂时保存这些数据？如何使用这些数据？
不太确定理解了你的问题：
1 你是根据数据库来进行语句分割，评价分析的吗。
如果是的话，那就把分析结果存到字典里就可以了。(也就是你说的保存)
使用呢，就是对这个字典进行判断处理。
2 如果不是的话，你是想收集语料库放到字典里，然后再利用这个字典对象去判断?
保存大词典对象的话可以用gdbm来读写。

Ⅳ 如何使用python连接数据库，插入并查询数据

你可以访问Python数据库接口及API查看详细的支持数据库列表。不同的数据库你需要下载不同的DB API模块，例如你需要访问Oracle数据库和Mysql数据，你需要下载Oracle和MySQL数据库模块。
DB-API 是一个规范. 它定义了一系列必须的对象和数据库存取方式, 以便为各种各样的底层数据库系统和多种多样的数据库接口程序提供一致的访问接口。
Python的DB-API，为大多数的数据库实现了接口，使用它连接各数据库后，就可以用相同的方式操作各数据库。
Python DB-API使用流程：

引入 API 模块。
获取与数据库的连接。
执行SQL语句和存储过程。
关闭数据库连接。

什么是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 模块：
Traceback (most recent call last):
File "test.py", line 3, in <mole>
import MySQLdb
ImportError: No mole named MySQLdb

安装MySQLdb，请访问，(Linux平台可以访问：)从这里可选择适合您的平台的安装包，分为预编译的二进制文件和源代码安装包。
如果您选择二进制文件发行版本的话，安装过程基本安装提示即可完成。如果从源代码进行安装的话，则需要切换到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权限来安装上述模块。

数据库连接

连接数据库前，请先确认以下事项：

您已经创建了数据库 TESTDB.
在TESTDB数据库中您已经创建了表 EMPLOYEE
EMPLOYEE表字段为 FIRST_NAME, LAST_NAME, AGE, SEX 和 INCOME。
连接数据库TESTDB使用的用户名为 "testuser" ，密码为 "test123",你可以可以自己设定或者直接使用root用户名及其密码，Mysql数据库用户授权请使用Grant命令。
在你的机子上已经安装了 Python MySQLdb 模块。
如果您对sql语句不熟悉，可以访问我们的 SQL基础教程

实例：

以下实例链接Mysql的TESTDB数据库：
#!/usr/bin/python
# -*- coding: UTF-8 -*-

import MySQLdb

# 打开数据库连接
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# 使用cursor()方法获取操作游标
cursor = db.cursor()

# 使用execute方法执行SQL语句
cursor.execute("SELECT VERSION()")

# 使用 fetchone() 方法获取一条数据库。
data = cursor.fetchone()

print "Database version : %s " % data

# 关闭数据库连接
db.close()

执行以上脚本输出结果如下：
Database version : 5.0.45

创建数据库表

如果数据库连接存在我们可以使用execute()方法来为数据库创建表，如下所示创建表EMPLOYEE：
#!/usr/bin/python
# -*- coding: UTF-8 -*-

import MySQLdb

# 打开数据库连接
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# 使用cursor()方法获取操作游标
cursor = db.cursor()

# 如果数据表已经存在使用 execute() 方法删除表。
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

# 创建数据表SQL语句
sql = """CREATE TABLE EMPLOYEE (
FIRST_NAME CHAR(20) NOT NULL,
LAST_NAME CHAR(20),
AGE INT,
SEX CHAR(1),
INCOME FLOAT )"""

cursor.execute(sql)

# 关闭数据库连接
db.close()

数据库插入操作

以下实例使用执行 SQL INSERT 语句向表 EMPLOYEE 插入记录：
#!/usr/bin/python
# -*- coding: UTF-8 -*-

import MySQLdb

# 打开数据库连接
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# 使用cursor()方法获取操作游标
cursor = db.cursor()

# SQL 插入语句
sql = """INSERT INTO EMPLOYEE(FIRST_NAME,
LAST_NAME, AGE, SEX, INCOME)
VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""
try:
# 执行sql语句
cursor.execute(sql)
# 提交到数据库执行
db.commit()
except:
# Rollback in case there is any error
db.rollback()

# 关闭数据库连接
db.close()

以上例子也可以写成如下形式：
#!/usr/bin/python
# -*- coding: UTF-8 -*-

import MySQLdb

# 打开数据库连接
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# 使用cursor()方法获取操作游标
cursor = db.cursor()

# SQL 插入语句
sql = "INSERT INTO EMPLOYEE(FIRST_NAME, \
LAST_NAME, AGE, SEX, INCOME) \
VALUES ('%s', '%s', '%d', '%c', '%d' )" % \
('Mac', 'Mohan', 20, 'M', 2000)
try:
# 执行sql语句
cursor.execute(sql)
# 提交到数据库执行
db.commit()
except:
# 发生错误时回滚
db.rollback()

# 关闭数据库连接
db.close()

实例：

以下代码使用变量向SQL语句中传递参数:
..................................
user_id = "test123"
password = "password"

con.execute('insert into Login values("%s", "%s")' % \
(user_id, password))
..................................

数据库查询操作

Python查询Mysql使用 fetchone() 方法获取单条数据, 使用fetchall() 方法获取多条数据。

fetchone(): 该方法获取下一个查询结果集。结果集是一个对象
fetchall():接收全部的返回结果行.
rowcount: 这是一个只读属性，并返回执行execute()方法后影响的行数。

实例：

查询EMPLOYEE表中salary（工资）字段大于1000的所有数据：
#!/usr/bin/python
# -*- coding: UTF-8 -*-

import MySQLdb

# 打开数据库连接
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# 使用cursor()方法获取操作游标
cursor = db.cursor()

# SQL 查询语句
sql = "SELECT * FROM EMPLOYEE \
WHERE INCOME > '%d'" % (1000)
try:
# 执行SQL语句
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()

以上脚本执行结果如下：
fname=Mac, lname=Mohan, age=20, sex=M, income=2000

数据库更新操作

更新操作用于更新数据表的的数据，以下实例将 TESTDB表中的 SEX 字段全部修改为 'M'，AGE 字段递增1：
#!/usr/bin/python
# -*- coding: UTF-8 -*-

import MySQLdb

# 打开数据库连接
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# 使用cursor()方法获取操作游标
cursor = db.cursor()

# SQL 更新语句
sql = "UPDATE EMPLOYEE SET AGE = AGE + 1
WHERE SEX = '%c'" % ('M')
try:
# 执行SQL语句
cursor.execute(sql)
# 提交到数据库执行
db.commit()
except:
# 发生错误时回滚
db.rollback()

# 关闭数据库连接
db.close()

删除操作

删除操作用于删除数据表中的数据，以下实例演示了删除数据表 EMPLOYEE 中 AGE 大于 20 的所有数据：
#!/usr/bin/python
# -*- coding: UTF-8 -*-

import MySQLdb

# 打开数据库连接
db = MySQLdb.connect("localhost","testuser","test123","TESTDB" )

# 使用cursor()方法获取操作游标
cursor = db.cursor()

# SQL 删除语句
sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (20)
try:
# 执行SQL语句
cursor.execute(sql)
# 提交修改
db.commit()
except:
# 发生错误时回滚
db.rollback()

# 关闭连接
db.close()

执行事务

事务机制可以确保数据一致性。

事务应该具有4个属性：原子性、一致性、隔离性、持久性。这四个属性通常称为ACID特性。

原子性（atomicity）。一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做。
一致性（consistency）。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。
隔离性（isolation）。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
持久性（rability）。持续性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。

Python DB API 2.0 的事务提供了两个方法 commit 或 rollback。

Ⅵ fetchone函数和fetchall函数返回值的区别

DLL文件(Dynamic Linkable Library 即动态链接库文件)，是一种不能单独运行的文件，它允许程序共享执行特殊任务所必需的代码和其他资源比较大的应用程序都由很多模块组成，这些模块分别完成相对独立的功能。
fetchone() 返回单个的元组，也就是一条记录(row)，如果没有结果则返回 None
注：在MySQL中是NULL，而在Python中则是None

fetchall() 返回多个元组，即返回多个记录(rows),如果没有结果则返回 ()

Ⅶ python 怎么调用odbc

入门
连接到数据库
调用connect方法并传入ODBC连接字符串，其会返回一个connect对象。通过connect对象，调用cursor()方法,可以获取一个游标cursor。如下代码示例：
import pyodbc
#连接示例: Windows系统, 非DSN方式, 使用微软 SQL Server 数据库驱动
cnxn =pyodbc.connect('DRIVER={SQL Server};SERVER=localhost;PORT=1433;DATABASE=testdb;UID=me;PWD=pass')
#连接示例: Linux系统, 非DSN方式, 使用FreeTDS驱动
cnxn =pyodbc.connect('DRIVER={FreeTDS};SERVER=localhost;PORT=1433;DATABASE=testdb;UID=me;PWD=pass;TDS_Version=7.0')
#连接示例:使用DSN方式
cnxn = pyodbc.connect('DSN=test;PWD=password')
# 打开游标
cursor =cnxn.cursor()
以上示例只是标准示例，具体的ODBC连接字符串以你自己使用的驱动为准。
查询一些数据
所有SQL语句都使用Cursor.execute()方法执行。比如select语句会返回一些结果行，你可以使用游标（Cursor）相关的函数功能（fetchone，fetchall，fetchmany）对结果进行检索。
Cursor.fetchone 用于返回一个单行（ Row）对象:
cursor.execute("selectuser_id, user_name from users")
row =cursor.fetchone()
if row:
print(row)
Row 对象是类似一个python元组（tuples），不过也可以通过列名称来访问，例如:
cursor.execute("selectuser_id, user_name from users")
row =cursor.fetchone()
print('name:',row[1]) # 使用列索引号来访问数据
print('name:',row.user_name) # 或者直接使用列名来访问数据
当所有行都已被检索，则fetchone返回None.
while 1:
row = cursor.fetchone()
if not row:
break
print('id:', row.user_id)
Cursor.fetchall方法返回所有剩余行并存储于一个列表中。如果没有行，则返回一个空列表。（注意：如果有很多行，会造成大量内存占用。Fetchall会一次性将所有数据查询到本地，然后再遍历）
cursor.execute("selectuser_id, user_name from users")
rows = cursor.fetchall()
for row in rows:
print(row.user_id, row.user_name)
如果并不在意数据处理时间，可以使用光标本身作为一个迭代器，逐行迭代。这样可以节省大量的内存开销，但是由于和数据来回进行通信，速度会相对较慢：
cursor.execute("selectuser_id, user_name from users"):
for row in cursor:
print(row.user_id, row.user_name)
由于Cursor.execute总是返回游标（cursor）, 所以也可以简写成:
for row incursor.execute("select user_id, user_name from users"):
print(row.user_id, row.user_name)
我们可以在execut中使用”””三重引号，来应用多行SQL字符串。这样sql的可读性大大增强。这是python特有的特性：
cursor.execute(
"""
select user_id, user_name
from users
where last_logon < '2001-01-01'
and bill_overe = 1
""")
SQL参数
ODBC支持使用问号作为SQL的查询参数占位符。可以在execute方法的SQL参数之后，提供SQL参数占位符的值:
cursor.execute(
"""
select user_id, user_name
from users
where last_logon < ?
and bill_overe = ?
""", '2001-01-01', 1)
这样做可以防止SQL注入攻击，提高安全性。如果使用不同的参数反复执行相同的SQL它效率会更高，这种情况下该SQL将只预装（prepared ）一次。（pyodbc只保留最后一条编写的语句，所以如果程序在语句之间进行切换，每次都会预装，造成多次预装。）
Python的DB API指定参数应以序列（sequence）对象传递，所以pyodbc也支持这种方式：
cursor.execute(
"""
select user_id, user_name
from users
where last_logon < ?
and bill_overe = ?
""", ['2001-01-01', 1])
插入数据
插入数据使用相同的函数 - 通过传入insert SQL和相关占位参数执行插入数据：
cursor.execute("insertinto procts(id, name) values ('pyodbc', 'awesome library')")
cnxn.commit()
cursor.execute("insertinto procts(id, name) values (?, ?)", 'pyodbc', 'awesome library')
cnxn.commit()
注意：调用cnxn.commit()。发成错误可以回滚。具体需要看数据库特性支持情况。如果数据发生改变，最好进行commit。如果不提交，则在连接中断时，所有数据会发生回滚。
更新和删除数据
更新和删除工作以同样的方式：通过特定的SQL来执行。通常我们都想知道更新和删除的时候有多少条记录受到影响，可以使用Cursor.rowcount来获取值:
cursor.execute("deletefrom procts where id <> ?", 'pyodbc')
print('Deleted {}inferior procts'.format(cursor.rowcount))
cnxn.commit()
由于execute 总是返回游标（允许你调用链或迭代器使用），有时我们直接这样简写：
deleted =cursor.execute("delete from procts where id <> 'pyodbc'").rowcount
cnxn.commit()
注意一定要调用commit。否则连接中断时会造成改动回滚。
技巧和窍门
引号
于单引号SQL是有效的，当值需要使用单引号时，使用用双引号包围的SQL:
cursor.execute("deletefrom procts where id <> 'pyodbc'")
如果使用三重引号, 我们可以这样使用单引号:
cursor.execute(
"""
delete
from procts
where id <> 'pyodbc'
""")
列名称
Microsoft SQLServer之类的一些数据库不会产生计算列的列名，在这种情况下，需要通过索引来访问列。我们也可以使用sql列别名的方式，为计算列指定引用名称：
row =cursor.execute("select count(*) as user_count fromusers").fetchone()
print('{}users'.format(row.user_count)
当然也可以直接使用列索引来访问列值:
count =cursor.execute("select count(*) from users").fetchone()[0]
print('{}users'.format(count)
注意，上例的首列不能是Null。否则fetchone方法将返回None并且会报NoneType不支持索引的错误。如果有一个默认值，经常可以是ISNULL或合并：
maxid =cursor.execute("select coalesce(max(id), 0) fromusers").fetchone()[0]
自动清理
连接（默认）在一个事务中。如果一个连接关闭前没有提交，则会进行当前事务回滚。很少需要finally或except 语句来执行人为的清理操作，程序会自动清理。
例如，如果下列执行过程中任何一条SQL语句出现异常，都将引发导致这两个游标执行失效。从而保证原子性，要么所有数据都插入发生，要么所有数据都不插入。不需要人为编写清理代码。
cnxn =pyodbc.connect(...)
cursor = cnxn.cursor()
cursor.execute("insertinto t(col) values (1)")
cursor.execute("insertinto t(col) values (2)")
cnxn.commit()

Ⅷ python如何访问数据库

1.背景：

python提供了很多数据库接口，常用的数据库有 MS SQL Server /mysql /oracle 等。

打开链接 https://wiki.python.org/moin/DatabaseInterfaces

是python 关于数据库接口的一个总结，可以看到python支持的访问的数据库系统。

2.模块：

python 主要是通过模块和数据库连接的。

2.1 安装模块：

如果使用anconda，本身就会集合很多模块，不需要手动安装。如果用pycharm就要手动安装模块。

安装模块流程：

下载模块扩展包放到路径下——>cmd找到相应路径——> pip install +扩展包名字

下面列举一些常用连接数据库的模块：pymssql / sqlite3/ PyMySQL/pyodbc/odbc/adodbapi

不同模块连接的数据库不同，支持的版本系统有的也不一样。但是大体用法都是相近的，因为有DB-API

fetchonepython

与fetchonepython相关的阅读推荐