基本配置及基础语法(1, 2章)
1Python.exe 的解释器options:
1.1–d 提供调试输出
1.2–O 生成优化的字节码(生成.pyo文件)
1.3–S 不导入site模块以在启动时查找python路径
1.4–v 冗余输出(导入语句详细追踪)
1.5–m mod 将一个模块以脚本形式运行
1.6–Q opt 除法选项(参阅文档)
1.7–c cmd 运行以命令行字符串心事提交的python脚本
1.8file 以给定的文件运行python脚本
2_在解释器中表示最后一个表达式的值.
3print支持类c的printf格式化输出: print “%s is number %d!” % (“python”, 1)
4print的输入内容后面加逗号, 就会使其输入不换行
5把输出重定向到日志文件:
logfile = open(“c:/1.log”, “a”); //打开文件c:/1.log使用a模式..即add, 添加.
print >> logfile, “Fatal error: invalid input!”; >>为重定向..将print的结果重定向到logfile, 输出内容是”Fatal error: invalid input!”…
logfile.close(); //关闭文件流…
6程序输入: raw_input(“提示字符串”): user = raw_input(“请输入您的姓名”);
7int(数值)…..将数值字符串转换成整数值…
8运算符:
8.1+ - * / %是和其他语言相同的加减乘及取模运算.取余运算
8.2/ 在浮点取模中得到的结果是完整的浮点数
8.3// 在浮点取模中得到的结果是经过舍去运算的结果.
8.4** 是乘方
8.5>>和<<的移位运算也支持. 但不支持java中的>>> 和<<< 移位.
8.6< <= > >= ++ != <> 等比较运算符
8.7and or not 等逻辑运算符
9变量和赋值: python是弱类型语言..
10list, tuple, map * 4 得到的结果是一个新的list | tuple | map, 是原数据的4份
11数字:
11.1int(有符号整数)
11.2long(长整数)
11.3bool(布尔值)
11.4float(浮点值)
11.5complex(复数)
11.6python2.3开始, 如果结果从int溢出, 会自动转型为long
11.7python2.4开始支持decimal数字类型, 需要导入decimal模块..由于在二进制表示中会
有一个无限循环片段, 普通的浮点 1.1实际是不能被精确表示的, 被表示为
1.1000000000000001. 使用print decimal.Decimal(‘1.1’);则可以得到精确的1.1
12字符串: 引号之间的字符集合, 支持使用成对的单引号和双引号, 三引号(三个连续单引
号或双引号)可以用来包含特殊字符. 使用索引运算符[]和切片运算符[ : ]可以得到子字符串…字符串中第一个字符的索引是0, 最后一个字符的索引是-1;
13列表和元组: 可以看作是普通的数组, 能保存任意数量任意类型的python对象…
13.1列表元素用中括号包裹, 元素的个数及元素的值可以改变.
13.2元组元素用小括号包裹, 不可以更改, 尽管他们的内容可以, 元组可以看成是只读的
列表. 可以使用切片运算得到子集.
14字典: 相当于其他语言中的map, 使用{key: value}的方式表示. 取值的方式和其他语言的map一致. 也可以直接使用map[key] = value的方式为其赋值.
15条件语句:
if expression:
path 1
elif expression2:
path2
else:
path3
16while循环
while expression:
process business
17for循环
for item in list|tuple|map:
print item
17.1range(len(list))得到一个list长度范围内的整数list, 方便遍历过程中获取索引值. 17.2python2.3中增加了enumerate(), 可以通过它遍历list, 同时得到索引和值
for index, data in enumerate(list):
print index, “:”, data,
17.3列表解析: sqdEvens = [x ** 2 for x in range(8) if not x % 2], 获取一个序列, 该序列是0-8
的数字中所有x%2为0(false)的x的平方
18文件和内建函数: open(), file()
18.1handle = open(file_name, access_mode = “r”), 只读方式打开文件, 得到的句柄是
handle..该方法如果没有提供access_mode, 默认是r
19异常处理: raise可以故意引发异常
try:
# process
except IOError, e:
# error process
20函数: 如果函数中没有return语句, 自动返回None对象
def function_name([arguments]):
“optional document string”
function_suite
20.1python的函数调用中参数是引用传递
20.2可以在定义函数的时候, 在参数列表中通过=设置参数的默认值.
21类:
21.1定义:
class class_name:
static_variable_name = value
def __init__(self, [arguments]):
//operation
//self in here is the reference for this class instance
def general_method_name(self, [arguments]):
//operation
//self is the class instance
//if you want to use class variable, please use like self.__class__.__name__
21.2实例化: instance = class_name([arguments, …]);
22模块: 不带.py后缀名的文件名…一个模块创建之后, 可以使用import导入这个模块使用.
22.1访问模块内的函数或变量: module_name.function() | module_name.variable |
module_name.class_name
22.2sys模块概览
22.2.1sys.stdout.write(‘Hello World!\n’) //使用sys模块的标准输出
22.2.2sys.platform //返回系统的标记
22.2.3sys.version //返回系统的版本
23PEP: 一个PEP就是一个python增强提案(python enhancement proposal), 是在新版python 中增加新特性的方式…索引网址是: https://www.doczj.com/doc/765092970.html,/dev/peps
24一些常用函数
24.1dir([obj]) 显示对象的属性, 如果没有提供参数, 显示全局变量的名字
24.2help([obj]) 显示对象的文档, 如果没有参数, 进入交互式帮助
24.3int(obj) 将一个对象转换为整数
24.4len(obj) 返回对象的长度
24.5open(file_name, mode) 以mode(r|w|a…)方式打开一个文件
24.6range([[start, ]stop[, step]]) 返回一个整数列表…结束值是stop-1, step默认是1
24.7raw_input(str) 提示str等待用户输入
24.8str(obj) 将一个对象转换为字符串
24.9type(obj) 返回对象的类型…返回值本身是一个type对象
24.10sum(iterable[, start=0]) 可以对纯数值的list|tuple|map进行求和操作..
24.11dir([object]) 如果没有参数获得当前脚本scope内定义的对象, 如果有参数, 返回该
对象内部定义的对象, 如果该对象有一个__dir__方法, 该方法将被调用, 并且必须返回属性的列表…这就允许通过自定义__getattr__()或__getattribute__()方法的方式实现dir的自定义显示属性列表….如果没有指定参数, 是根据该对象的__dict__内存字典的最佳聚合信息显示的..
24.12type([object]) 参数为空显示
24.13type(name, bases, dict) 通过名称, 基类, 内存字典动态创建一个类型
24.14object__name.__doc__ 查看该对象的文档字符串
24.15__doc__ 对象的文档字符串, 该文档字符串在定义对象时写在对象语句块中第一句,
使用单纯的字符串的方式表示
24.16sys.exit() 退出python解释器
24.17append(Object) 给list添加一个元素
24.18os.linesep 返回的是系统换行符…不同的系统换行符是不同的, 使用linesep可以提高
代码跨平台性
24.19string_variable_name.strip([chars]) 脱离, 滤去字符串中的某些字符, 如果没有参数
返回原字符串
25数值按进制分为:
25.1二进制: 0b101010
25.2八进制: 07167
25.3十进制: 98767
25.4十六进制: 0xf2134
Python基础(chapter3)
1setence and syntax语句和语法
1.1#为注释符号
1.2\n是标准行分隔符, 通常一个语句一行
1.3反斜线\表示下一行继续, 用来将单条语句放入多行…尽量使用括号代替
1.4分号;表示将两个语句连接在一行中…不提倡
1.5冒号:表示将代码块的头和体分开
1.6语句(代码块)用缩进块方式体现: 同一个代码组的代码必须严格左对齐..由于不同的
editor制表符宽度不一, 为了使代码跨平台, 推荐使用4个空格缩进
1.7不同缩进深度分隔不同的代码块
1.8python文件以模块的形式组织: 模块以磁盘文件的形式存在, 不应该让某个模块充斥
的太大
2赋值
2.1赋值语句没有返回值, 但可以使用链式赋值
2.2python2.0开始支持增量赋值(算符和等号连接赋值), 但是python不支持++, --
2.3赋值操作中, 可变对象会被直接修改(引用位置值的修改), 不可变对象则被重新赋予新
的对象(引用修改)
2.4多元赋值: a, b, c = 1, 2, ‘string’, 建议使用tuple的方式进行多元赋值: (a, b, c) = (1, 2,
‘string’)
3swap操作: x, y = y, x
4标识符
4.1大小写敏感
4.2python的关键字列表和iskeyword()函数在keyword模块, 方便查阅
4.3内建: built-in可以看作是系统保留字….对于一些内建函数需要覆盖(重定义, 替
换)…built-in是__builtins__模块的成员, 该模块由解释器自动导入
4.4python不支持重载
4.5下划线: 作为变量前缀和后缀指定特殊变量
4.5.1_xxx: 不用’from module import*’导入
4.5.2__xxx__: 系统定义名字
4.5.3_xxx: 类中的私有变量名
5python之禅
The Zen of Python, by Tim Peters
python之禅. 作者Tim Peters
Beautiful is better than ugly.
漂亮胜于丑陋
Explicit is better than implicit.
详尽胜于含蓄
Simple is better than complex.
简单胜于复杂
Complex is better than complicated.
组合胜于复杂(结构)
Flat is better than nested.
单一胜于嵌套
Sparse is better than dense.
稀少胜于繁杂
Readability counts.
可读性价值
Special cases aren't special enough to break the rules.
特例不足以违反规则
Although practicality beats purity.
实践胜于理论
Errors should never pass silently.
错误可能从不沉默
Unless explicitly silenced.
除非明白沉默
In the face of ambiguity, refuse the temptation to guess.
面对歧义, 不被猜想诱惑
There should be one-- and preferably only one --obvious way to do it. 可能仅有一种更好的方法
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
现在胜于一切
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
难于解释的实现是不好的
If the implementation is easy to explain, it may be a good idea.
易于明白的实现可能是个好方案
Namespaces are one honking great idea -- let's do more of those!
名空间是一个好方案, 让我们去超越这些
6模块组织
# 起始行
# 模块文档
# 模块导入
# 变量定义
# 类定义
# 函数定义
# 主程序
7__name__用于指示模块应该如何被加载, 如果值是”__main__”说明是主模块, 如果是模块名, 说明是被导入的
8主模块测试代码
def main():
# business process
if(__name__ == ‘__main__’)
main()
9内存管理
9.1基本
9.1.1弱类型–动态类型
9.1.2programmer不关心内存管理
9.1.3变量并会被回收
9.1.4del语句能够直接释放资源
9.2变量未初始化不允许使用
9.3引用计数: 对于一个内存堆中的对象, 有多少个指针引用它..引用计数就是多少, 引用
计数为0时, 该对象可以被垃圾回收器回收
9.3.1增加
9.3.1.1对象创建
9.3.1.2别名创建(引用赋值)
9.3.1.3参数传递(引用传值)
9.3.1.4被容器引用
9.3.2减少
9.3.2.1引用生命周期结束
9.3.2.2对象别名被显示销毁del y
9.3.2.3对象别名被赋予其他引用
9.3.2.4窗口对象本身被销毁
9.3.3del
9.3.3.1从现在的名字空间中删除一个别名
9.3.3.2对象的引用计数减一
9.4垃圾回收: 有对象引用计数为0, 对象被显示告知需要销毁, 有内存消耗大户存在导致
系统压力较大时, 垃圾回收机制运行, 清理需要回收的内存区域…垃圾回收机制还有一个循环垃圾回收器, 确保释放循环引用对象(a引用b, b引用a, 导致其引用计数永远不为
0)
10将引入的其他模块中常用的变量重新赋予一个本地别名(ls = os.linesep)不仅可以避免冗长的变量名, 又可以提高加载速度(因为现在是本地变量了)
11重要的其他模块
11.1debugger: pdb允许设置断点, 逐行调试, 检查堆栈, 还支持事后调试
11.2logger: logging分紧急, 错误, 警告, 信息, 调试五级日志
11.3profilers: 性能测试器
11.3.1profile: python编写, 测试函数执行时间, 每次脚本执行总时间.
11.3.2hotshot: python2.2, c编写, 解决了性能测试过载问题, 但需要更多时间生成结果,
python2.5修正了hotshot的时间计量bug
11.3.3cProfile: python2.5, c编写, 需要较长时间从日志文件载入分析结果, 不支持子函
数状态细节, 某些结果不准
python对象(chapter4)
1python对象有三个特征: 身份和类型是只读的, 如果对象支持不支持更新操作, 那么值也就是只读的.
1.1身份: 唯一的身份标识, 可以使用内建函数id()得到, 可以看作是对象的内存地址…1.2类型: 对象的类型决定该对象保存什么类型的值, 可以进行什么操作, 遵循什么规则.,
可以使用内建函数type()查看python对象的类型.
1.3值: 对象表示的数据项
2对象属性: 主要有属性, 值, 相关联的可执行代码(method), 一些python类型也有数据属性, 含有数据属性的对象包括但不限于: 类, 类实例, 模块, 复数, 文件.
3基础数据类型: 数字, 整形, 布尔型, 长整型, 浮点型, 复数型, 字符串, 列表, 元组, 字典. 4其他内建类型: 类型, None, 文件, 集合/固定集合, 函数/方法, 模块, 类
4.1type(type(1)) 可以看出类型对象本身也是对象, 它的类型是type
4.2None的类型是NoneType, NoneType只有一个值, 就是None, 不支持任何运算也没有任
何内建方法, 布尔值总返回False
5每个对象天生都有布尔值, 以下对象的布尔值是False
5.1None
5.2False(bool类型)
5.3所有值为0的数
5.4‘’空字符串
5.5[] | () | {} 空列表, 空元组, 空字典
5.6用户创建的实例如果定义了nonzero(__nonzero__())或length(__len__())且值为0, 那么
返回的布尔值也是False
6当要获取一个对象的布尔值的时候, 首先会调用__nonzero__(必须返回布尔类型或者int类型.)方法, 如果实现了该方法, 就返回该方法返回的布尔值, 如果没有实现该方法, 继续调用__len__方法(该方法返回值必须是大于等于0的), 如果实现了__len__方法, 就根据其返回值返回布尔值.
7内部类型: python内部机制
7.1代码: 编译过的python的源代码片段, 是可执行对象. 通过调用内建函数compile()可
以得到代码对象. 代码对象可以被exec命令或eval()内建函数来执行. 代码是用户自定义函数的核心, 运行期获得上下文.. __code__是函数的一个属性, 函数除了代码这个属性, 还有函数名, 文档字符串, 默认参数, 全局命名空间等必须的属性
7.2帧对象: 用于跟踪记录对象
7.3跟踪记录: 用于异常发生时, 程序访问跟踪记录对象处理程序.
7.4切片:
7.4.1步进切片sequence[::number] number为负数, 倒序显示字符串, 正数则正序显示字
符串, 数值代表显示字符的step值.
7.4.2多维切片sequence[start1: end1, start2: end2]
7.4.3省略切片sequence[…, start1: end1]
7.4.4切片对象使用slice([start, ]stop[, step])可以创建一个切片对象
7.5省略对象: 用于扩展切片语法, 起记号作用..在切片语法中表示省略号, 省略对象有一
个唯一的名字Ellipsis, 布尔值始终是True
7.6Xrange: 调用xrange()生成Xrange对象, 类似内建函数range, 用于节省内存使用或
range无法完成的超大数据集场合
8标准类型运算符
8.1对象值比较
8.1.1数字根据大小比较
8.1.2字符串根据字符先后顺序比较
8.1.3list | tuple | dict顺序按照其中元素(dict按照键)比较
8.1.4链式比较相当于多个比较使用and连接
8.1.5自定义类型对象的比较是引用值比较, 也就是id(object_name)的比较
8.2对象身份比较
8.2.1is / is not用来比较两个别名是否引用同一个对象
8.2.2整数对象和字符串对象是不可变对象…
8.3布尔类型运算符: and, or, not
9标准类型内建函数
9.1cmp(obj1, obj2) 比较obj1和obj2, 根据比较结果返回整数i, i<0 →obj1
obj1>obj2, i==0 → obj1 == obj2….自定义类型中通过定义方法__cmp__(target)来实现….使用比较运算符, 或直接调用cmp时该方法被调用
9.2type(obj) 得到一个对象的类型, 返回相应的type对象
9.3str(obj) 返回对象适合可读性好的字符串表示…在自定义类中使用__str__(self)返回一
个字符串, 调用str(obj)时会被隐式调用
9.4repr(obj) 返回一个对象的字符串表示, repr返回的字符串通常可以被用于使用eval动
态创建一个对象. 通常obj == eval(repr(obj))是成立的
9.5``, 反单引号, `obj`和repr(obj)做的事情是一样的.
9.6isinstance(obj, (type[, type, …])) 判断obj是不是第二个参数tuple中的列举的类型的实
例
9.7types模块提供一些已知的类型
9.8由于每一种类型都只有一个类型对象, 所以, 可以使用引用比较代替值比较以提升性
能: 用if type(num) is types.IntType 替代if type(num) == types.IntType
9.9from-import: 只引入某个模块的一部分属性: 比如from types import IntType 这样做可
以有效的减少查询次数
9.10python的operator模块中有绝大多数运算符对应的同功能的函数可供使用.
10类型工厂函数: int(), long(), float(), complex(), str(), Unicode(), basestring(), list(), tuple(), type(), dict(), bool(), set(), frozenset(), object(), classmethod(), staticmethod(), super(), property(), file()
11标准类型的分类:
11.1标准类型是”基本内建数据对象原始类型”
11.1.1基本: 是python的标准或核心
11.1.2内建: python默认提供
11.1.3数据: 用于一般数据存储
11.1.4对象: 对象是数据和功能的默认抽象
11.1.5原始: 这些类型提供的是最底层的粒度数据存储
11.1.6类型: 本身就是数据类型
11.2按存储模型进行分类:
11.2.1标量/原子类型: 数值, 字符串等可以存储单一字面对象的类型.
11.2.2容器类型: 列表, 元素, 字典等可以存储多个字面变量的类型, python中的容器类
型都可以存储不同类型的元素
11.3按更新模型进行分类: 对象创建之后, 值不可以改变, 注意: 这里是对象, 而不是变
量
11.3.1可变类型: 列表, 字典
11.3.2不可变类型: 数字, 字符串, 元组
11.4按访问模型进行分类: 访问对象的方式
11.4.1直接访问: 数值
11.4.2顺序访问: 列表, 元组, 字符串等可以按照索引访问的类型
11.4.3映射访问: 字典
12不支持的类型: char, byte, pointer
数字(chapter5)
1支持的数字类型: 整型, 长整型, 布尔型, 双精度浮点型, 十进制浮点型和复数
2整型
2.1布尔型包含True和False两个值的整型
2.2标准整数类型0x表示十六进制, 无前缀表示十进制, 0表示八进制, 0b表示二进制2.3长整型整数后加L, 表示范围与可用内存大小有关..
3双精度浮点数: 一个符号位, 52个底位, 11个指数位. 使用后缀e表示指数
4复数: 实数+ 序数J构成一个复数
4.1python中的复数概念
4.1.1虚数不能单独存在, 总是和一个值为0.0的实数部分一起构成一个复数
4.1.2复数由实数部分和虚数部分组成
4.1.3表示虚数的语法: real + imagJ
4.1.4实数部分和虚数部分都是浮点数
4.1.5虚数部分必须有后缀j或J
4.2复数的内建属性
4.2.1real 复数的实部
4.2.2imag 复数的虚部
4.2.3conjugate() 返回该复数的共轭复数
5强制类型转换规则
6python提供python解释器的启动参数Qdivision_style, -Qnew执行新的除法行为, -Qold执行传统除法行为, 默认是-Qold…-Qwarn和-Qwarnall可以用来度过过渡期
7幂运算符** 比左侧单目运算符优先级高, 比右侧单目运算符优先级高
8位运算符: ~, &, |, ^, <<, >>
8.1负数会被当成正数的二进制补码处理
8.2左移和右移N位等同与无溢出检查的2的N次幂运算
8.3长整数的位运算使用一种经过修改的二进制补码形式, 使的符号位可以无限左移
8.4~是单目运算符
9内建函数和工厂函数
9.1数字类型函数:
9.1.1转换工厂函数: int(), long(), float(), complex(), 接受参数第一个是要转换的值, 第二
个是进制..如果要转换的值是string才能使用第二个函数指定进制.
9.1.1.1python2.2开始, 加入了bool(), 用来将整数1和0转换成为标准布尔值(所有非
0数都返回True).
9.1.1.2python2.3的标准数据类型添加了Boolean类型, true和false也有了常量值True
和False, 而不再是1和0
9.1.1.3bool(obj) 返回obj对象的布尔值, 也就是obj.__nonzero__()
9.1.1.4complex(real, imag=0.0)
9.1.2功能函数
9.1.2.1abs(number) 返回数字的绝对值, 如果是复数, 返回math.sqrt(num.real2 +
num.imag2)
9.1.2.2coerce(number1, number2): 返回按照类型转换规则转换得到的两个数字组成的
元组
9.1.2.3divmod(number1, number2) 返回一个包含商和余数的元组, 整数返回地板除
和取余操作结果, 浮点数返回的商部分是math.floor(number1/number2), 复数的商部分是ath.floor((number1/number2).real)
9.1.2.4pow()和**功能相同
9.1.2.5round(number[, base]) 对浮点数进行四舍五入运算, base参数是小数位参数, 如
果不指定, 返回与第一个参数最接近的整数的浮点形式
9.1.2.6int() 直接去掉小数部分, floor()得到最接近但小于原数的整数, round()得到最接
近原数的整数
9.1.3整数的内建函数: hex(), oct(), bin()…ord(“A”) 接受一个ascii或unicode字符, 返回相
应的unicode值 char(65L)接受unicode码值, 返回对应的unicode字符.
10其他数字类型
10.1布尔数:
10.1.1布尔型是整型的子类, 但是不能再被继承而生成它的子类.
10.1.2没有__nonzero__()方法的对象默认值是True
10.1.3对于值为0的任何数字或空集(空的list|tuple|dict)在python中值都是False
10.1.4数学运算中, True ==1, False == 0
10.2十进制浮点数: from decimal import Decimal
11数字科学计算的包
11.1高级的Third package: Numeric(NumPy)
11.2python自带的数字类型相关模块
11.2.1decimal 十进制浮点运算类Decimal
11.2.2array 高效数值数组(字符, 整数, 浮点数)
11.2.3match/cmatch 标准c库数学运算函数. 常规数学运算在match, 复数运算在
cmatch
11.2.4operator 数字运算符的函数实现
11.2.5random 伪随机数生成器
11.2.5.1randint(start, end)随机生成start, end之间的一个整数
11.2.5.2uniform(start, end)随机生成范围内的一个浮点数
11.2.5.3randrange([start ,]stop[, step])随机生成start, stop内按step步增数字范围的一
个整数
11.2.5.4choice(sequence)随机返回给定的序列中的一个元素
序列: 字符串, 列表和元组(chapter6)
1对所有序列类型都适用的操作符(优先级从高到低, 不适用于复合类型的对象比较)
1.1成员关系操作符: int, not in
1.2连接操作符: +
1.3重复操作符: *… sequence * int
1.4切片操作符: (利用子序列方式结合三种操作方式, 可以非常灵活的控制序列)
1.4.1[], 索引取值
1.4.2[start : end], 索引范围取值
1.4.3[::step], 切片的步长
1.4.4切片操作符不会带来索引超出下标的异常
2list.extend(iterable): 把另外一个序列追加到list中.
3list.insert(index, object): 把一个元素object插入到list的index位置, 如果index是负数, 从后面向前数, 超过list下标后, 在末尾添加
4类型转换
4.1list(iter) 把可迭代对象转换为列表
4.2str(obj) 把obj对象转换成字符串(对象的字符串表示法)
4.3unicode(obj) 把对象转换成Unicode字符串(使用默认编码), 使用u”汉字”可以得到其
unicode编码
4.4basestring() 抽象工厂函数, 不能被实例化, 不能被调用, 仅作为str和unicode的父类4.5tuple(iter) 把一个可迭代对象转换成元组对象
4.6enumerate(iterable) 生成由iterable每个元素的index值和item值组成的元组, 可以使
用for key, value in enumerate的方式进行迭代
4.7max(iterable, key=None) | max(arg0, arg1, …, key=None) 返回iterable或arg0…中的最大
值, 如果要指定key, 必须是一个可以传递给sort()方法的回调函数…..要使用key, 必须使用key=method_name的方式传参, key指定的函数接收的参数是迭代的当前元素, 在该函数中, 对元素进行处理, 返回一个对象, python会根据返回对象比较大小, 得到该结果最大的元素对应的list中的元素
4.8min同上面的max方法. 对于max和min方法, 如果是自定义类型, 又没有指定key,
那么默认是按照id(object)的结果计算的
4.9reversed(sequence) 返回逆序访问的迭代器
4.10sum(sequence, init=0) 返回sequence和可选参数init的总和, 等同于
reduce(operator.add, sequence, init)
4.11sorted(iterable, func=None, key=None, reverse=False) 接受一个可迭代对象, 返回一个
有序列表, 可选参数func, key, reverse含义和list.sort相同
4.12zip([item0, item1, …, itemn]) 返回一个列表, [(item0, ), (item1, ), …, (itemn, )]
4.13sort(cmp=None, key=None, reverse=False) 将序列进行排序, cmp指定一个接受两个参
数的回调函数, 该函数得到的两个参数是序列中的两个元素, 比较将按照cmp指定的回调函数进行, 返回数字类型的比较结果, , , key指定一个接受一个参数的回调函数句柄, 该参数就是迭代到的元素, 在比较之前, 将会根据这个回调函数对要比较的元素进行一次处理, 实际参与比较的是经过该回调函数处理之后的返回值. reverse指示是否对比较结果进行逆序
5利用已有功能函数定义动态参数的函数: method = lambda x, y: cmp(x + 10, y - 10), 调用时还是使用句柄加参数的方式: method(x, y)
6字符串: 如果先使用切片操作, 子串会被在内存中进行短时间的暂存, 可以通过id()得到值7比较: 普通字符串按照ascii值比较, Unicode字符串按照unicode值比较.
8字符串切片, 下图是字符串切片的索引值, 如果开始或结束的索引值没有指定, 默认为0, 或-1. [::step]用于指定步长
9成员操作符: in, not in, 可以判断一个子串是否在字符串中存在…使用find(), index(), rfind(), rindex()可以获得子串在源中的位置
10string模块有一些预定义的字符串: ascii_letters, ascii_lowercase, ascii_uppercase, digits
11循环的改善: 如果循环的终止条件是不变的(一般都是不变的), 那么尽量不在循环终止条件中调用方法是一个好的习惯, 在大量数据的情况下(5 * 10^8数据), 改善的循环效率提升了4秒左右, 平均计算得到改善后循环每次效率提升约为7.154 * 10^-8s 也就是71.54 ns 12for-else方式的循环, else子句会在所有的元素都被循环完成之后执行, 如果break, 就不执行
13join可以用来连接字符串, 这样的效率是更高的, 因为+连接必须为每个字符串创建内存14+连接字符串是运行时连接, “str1””str2”的方式则是编译时连接字符串
15普通字符串和unicode字符串连接, 会把普通字符串转换成unicode字符串进行连接16%格式化字符串的参数:
16.1%c 转换成字符(ascii值, 或长度为一的字符串)
16.2%r 优先使用repr()函数进行字符串转换
16.3%s 优先使用str()函数进行字符串转换
16.4%d / %i 转成有符号的十进制数
16.5%u 转成无符号的十进制数遇到负号添加-号
16.6%o 转成无符号八进制数遇到负号添加-号
16.7%x / %X 转成无符号十六进制数(x|X的大小写决定转换后得到十六进制数中的字母
的大小写) 遇到负数, 则转换得到的结果中添加一个-号
16.8%e / %E 转成科学计数法(e | E的大小写决定转换后得到的e的大小写)
16.9%f / %F 转成浮点数(小数部分自然截断)
16.10%% 输出%号
17其他格式化操作符辅助指令(位于%和格式化标识的中间)
17.1* 定义宽度或小数点精度"adfas%*dfasdf" % (5, 2.000000888)
17.2–用于左对齐
17.3+ 在正数前加+号
17.4(sp) 在正数前显示空格
17.5# 在八进制前加0, 十六进制前显示0x或0X, 取决于用的是x或X 比如:
"integer:%#X!" % 1984
17.6(var) 映射变量(字典参数)
17.7m.n m是显示的最小总宽度, n是小数点后的位数
18格式化字符串接收dict数据:”%(howmany)d days” % {“howmany”: 28}
19字符串模板s = Template(‘There are ${howmany} ${lang} Quotation Symbols’)
19.1s.substitute([key = value, key = value…]) 这个函数必须提供所有的占位参数, 否则报
错
19.2s.safe_substitute([key = value, key = value…]) 和substitute功能是一样的, 都是转成得
到一个字符串, 但是这个方法对参数没有要求, 如果没有提供对应的参数, 就直接输出. 20原始字符串操作符(r/R), 紧贴字符串左引号, 不区分大小写. 用来使字符串描述各自原始的意义, 而不使用转义
21使用正则查找空白字符: m = re.search(r‘\\[rtfvn]’, r’Hello World!\n’)…
22可以使用u | U ‘字符串’的方式创建unicode字符串, 该标识可以和r/R连用
23python参数有位置参数和关键字参数两种, 位置参数在定义时只有参数名, 关键字参数定义时是key=value的形式
24python也提供可变参, *为位置可变参, **为关键字可变参
25如果使用* | **方式传递实参, * 可以将序列参数转变成每个元素作为单独参数, **则可以将dict转换成关键字参数
26内建函数
26.1cmp, 使用字符的ascii值进行比较(Unicode字符串按照unicode值比较)
26.2max, min, len, enumerate, zip, 其中zip可以接受多个参数, 按照下面方式返回:
zip(“abcd”, “efg”, “hijk”, “lmn”) 返回: [('a', 'e', 'h', 'l'), ('b', 'f', 'i', 'm'), ('c', 'g', 'j', 'n')]
26.3str和unicode都是basestring的特化类, 但是, Unicode又包含(类之间仅仅是兄弟关系,
元素范围上有包含关系)str的表示范围
26.4chr(number), unichr(number), ord(string), chr和unichr分别用来把一个数字转换成一个
对应类型的字符串, ord则是将一个string类型的单字符对象转换成为对应的ascii码或unicode编码
27string模块的重要函数, 所有这些函数, 都可以省略第一个参数, 使用string.func的方式调用
27.1string.index()和string.find()方法是一样的功能, 但是, index方法在查找不到字符串的
时候, 会报一个异常, string.rfind(), string.rindex()用法相同, 是从右边开始查找
27.2string.join(sequence[, str]) 如果只有一个参数, 返回一个将所有元素插空一个空格的
字符串(如果是序列, 转换成为字符串), 如果有两个参数, 把第二个参数向第一个参数的每个空位进行插空
27.3string.ljust(string, width[, fillchar]) 填充fillchar(只能是一个字符)width个到string后面,
使string左对齐, 如果fillchar空, 填充空格, rjust为右对齐
27.4string.lower(), string.upper(), string.swapcase()大小写转换
27.5string.lstrip(), string.rstrip(), string.strip() 去除空格.
27.6string.split(string, sub, count) 将string截取sub, 从左向右截取count个, 返回list 27.7string.replace(string, old, new[, number=string.count(string, old)]) 将string的old子串
替换成new, 最多替换不超过number, number默认是old在string的数量
27.8string.translate
27.9string.zfill(string, width) 用width个0填充string的左面使其右对齐
28unicode.encode(CODE_STRING) 按照指定编码方式编码字符串, decode反之, 按照指定编码方式解码
29除了pickle模块之外, 其他模块都已经支持unicode..
30UnicodeError异常在exceptions模块中定义, 是ValueError的子类, 所有关于Unicode编解码的异常都要继承自UnicodeError
31与字符串类型有关的模块:
31.1string: 字符串相关操作函数和工具, 比如Template类
31.2re: 正则表达式
31.3struct: 字符串和二进制之间的转换
31.4c/StringIO 字符串缓冲对象, 操作方法类似于file对象
31.5base64 Base16, 32, 64数据编解码
31.6codecs 解码器注册和基类
31.7crypt 进行单方面加密
31.8difflib 找出序列间的不同
31.9hashlib 多种不同安全哈希算法和信息摘要算法的API
31.10hma HMAC信息鉴权算法的python实现
31.11md5 RSA的MD5信息摘要鉴权
31.12rotor 提供多平台的加解密服务
31.13sha NIAT的安全哈希算法SHA
31.14stringprep 提供用于IP协议的Unicode字符串
31.15textwrap 文本打包和填充
31.16unicodedata Unicode数据库
32字符串的关键点:
32.1不可分字符类型
32.2类似printf()的格式化字符串
32.3三引号内可以接受特殊字符(What You See Is What You Get)
32.4r | R原始字符串
32.5python字符串不通过NUL或者\0结束
33list的元素删除
33.1del list[index] 根据index删除list中的元素
33.2list.remove(value) 从list中移除值是value的第一个元素
33.3list.pop() 类似栈的出栈操作, 弹出栈顶并返回
34list的成员关系操作还是使用in | not in
35列表解析: [var_name for var_name in list if expression]if之后和for之前都可以使用var_name进行运算
36列表的比较操作, 隐式调用cmp方法, 比较规则是逐个扫描元素, 进行比较, 如果可以比较, 比较, 如果相等扫描下一个元素, 如果不相等返回结果, 如果两个元素类型不可以比较, 就比较两个对象的id()值.. 如果一直相等,直到一个列表扫描结束, 那么返回较长的列表较大
37序列类型函数
37.1len(), max(), min()
37.2sorted() 和reversed() 返回的是被排序或逆序之后的序列, 不会改变序列本身的引用,
而序列自己的成员方法则会改变自身
37.3enumerate() 返回一个key=>value方式的enumerate对象
37.4zip() 将多个列表压缩成为一个元组列表…..zip返回的元组列表可以使用足够元组内
元素数量的参数来迭代遍历每一个元素, 例如: for a, b, c, d in zip(alist, blist, clist, dlist) 37.5使用list()和tuple()可以完成列表和元组之间的转换, 但是这种转换是值的转换, 所以
他们是==的, 但是不是is的
37.6extend(列表)方法接受另外一个列表追加到原列表之后
37.7list.pop(index = -1) list的pop可以弹出指定索引的值
38处理一组对象的时候, 默认的是创建一个元组, 例如a = 1, 2, 3, 4 实际上是创建了一个元组(1, 2, 3, 4)
39单独使用del删除一个元组元素是不可行的, 只能通过重组
40元组的可变性: 元组的某一个元素指向了一个对象, 该对象是可变的, 那么改变该对象就相当于改变了元组的内容, 然而, 真正的我们的元组确实是没有改变的. It’s so wizardly. 为什么呢? 元组内部持有的是对方的引用, 那个对象无论怎么变都还是在那里, 所以, 元组内部的值(内存地址)是没有改变的.
41函数可以返回多对象, 返回的实际也是一个元组
42单元素元组使用括号创建时需要在后面显示的加上”, ”, 由于括号被重载作为一个分组操作符了, 在这里会优先使用分组功能, 所以, 返回的总是原始类型
43相关模块:
43.1数组array 受限的可变序列类型, 要求所有元素都是相同的类型
43.2operator 包含函数调用形式的序列操作符, operator.concat(m, n)相当于m+n
43.3re perl风格的正则查找
43.4StringIO / cStringIO 长字符串作为文件来操作, 比如read(), seek()函数……c版本的
速度更快一些
43.5Textwrap 包裹/填充文本的函数
43.6types 包含python支持的所有类型
43.7collections 高性能容器数据类型
43.8UserList 包含了list对象的完全的类实现, 允许用户获得类似list的类, 用以派生新的
类和功能
44浅拷贝: 拷贝原对象中的内容, 但是新创建对象. 比如一个list的浅拷贝就是把list中元素的引用值拷贝过去…浅拷贝实例: 完全切片操作, 利用工厂函数, 使用copy模块的copy 函数
45深拷贝: 拷贝源对象中的内容, 如果某个属性(或序列中的元素)是可变对象, 把该可变对象的内容也进行拷贝
46非容器类型对象没有拷贝一说
47可变参: f(*args1, **args2), 如果关键字可变参不指定key值, 会被作为位置参数和前面的参数放到一个元组中….位置可变参在倒数第二个位置, 关键字可变参在倒数第一个位置. 48map(function, iterable), 应用function在iterable的每一个元素, 返回值作为新的序列的元素
映射和集合类型(chapter7)
1字典使用keys()获得键的列表, values()获得值的列表, items()获得包含key->value对的元组的列表
2字典的创建和赋值
2.1dict = {key: value}
2.2dict = dict((key, value), (key, value))
2.3dict.fromkeys(sequence_keys, default_value) 创建一个key是sequence_keys中元素的字
典, 所有的value都是default_value, 如果不指定default_value, 默认是None
3使用dict.has_key()可以判断一个字典中是否有这个键, 该方法在后期python可能弃用, 推荐使用in和not in
4字典的键必须是可哈希的
5print中使用到字典的时候, 使用字符串格式化方式是非常优雅的
6dict1.update(dict2 | tuple_list[, **key=value])
6.1将dict2字典更新到dict1中
6.2如果参数是一个元组列表, 将元组列表解析到dict1中(元组列表中每个元组必须有两
个元素)
6.3可以在参数后面跟0—n个关键字参数, 以参数名: value的方式更新到dict1中
7元素的删除
7.1del dict[“key”] 删除键是key的条目
7.2dict.clear() 清空字典内的内容
7.3dict.pop(“name”) 删除键是key的条目并返回
8映射类型操作符
8.1标准类型操作符: <, >等比较操作符可以使用, 在比较过程中, 还是调用了字典的cmp
方法, 但是, 字典的cmp方法中指示, 首先比较字典的长度, 然后比较键的大小, 最后比较值的大小
8.2字典查找操作: [], 成员关系操作: in, not in
9dict工厂函数
9.1接受不定关键字参数: dict(a = 1, b = 2, c = 3)
9.2接受字典或关键字参数: 将原有的字典拷贝出来成为一个新的字典(这里使用的浅拷贝,
这里的浅拷贝得到的结果和使用copy函数得到的结果是一样的,但是, copy函数的效率更高)
9.3dict_instance.copy() 使用已有的字典拷贝一个字典(这里使用的也是浅拷贝)
10系统内建函数
10.1len(): 返回字典的key-value对的数目
10.2hash(): 这个函数不是为字典设计的, 但是它可以判断某个对象是否可以做一个字典
的键, 将一个对象作为参数传递给hash(), 会返回这个对象的哈希值. 如果对象是不可哈希的, 会返回TypeError, 提示该对象是unhashable的
10.3sorted(dict): 返回dict的所有key排序后的列表
11dict类型的内建方法
11.1keys(): 返回字典的所有key的列表
11.2values(): 返回字典的所有value的列表
11.3items(): 返回字典的所有key-value的元组的列表
11.4get(key, default = None): 获取字典内key对应的值, 如果没有该key, 返回default指
定的默认值
11.5setdefault(key, default=None): 如果字典中不存在key, 由dict[key]=default为其赋值11.6iterkeys(), itervalues(), iteritems() 对应没有iter命名的方法, 这里使用了惰性赋值的迭
代器, 节省内存
12数字作为字典的键的时候, 只要值相同, 就代表相同的键, 比如, 1, 和1.0代表的就是相同的键
13键必须是可哈希的, 所有的不可变对象都是可哈希的, 可变对象如果在定义中定义了__hash__()方法, 那么就可以作为键
14如果元组中的值都是不可变类型的, 那么元组也可以作为字典的键
15集合sets有两种不同的类型, 可变集合set和不可变集合frozenset…可变集合也是不可哈希的…
16集合中不能有重复的元素, 如果有元素和已有元素重复, 就不会被插入.集合是无序的, 但是, 可以使用排序函数为它排序
17集合中可以使用的数学符号
18集合只能使用工厂函数set和frozenset创建
19访问集合中的数据使用循环, 或者使用成员关系操作符in, not in判断元素是否属于集合20更新集合(只能是set, frozenset不能被更新)
20.1add() 添加一个元素
20.2s.update() 接受一个序列类型的参数, 把该序列中有而集合中没有的元素添加到集
合中
20.3s.remove() 从集合中移除一个元素
21集合可用的标准类型操作符
21.1成员关系: in, not in
21.2集合等价/不等价: ==, !=
21.3子集/超集: <, <=, >, >=
22集合类型操作符(所有的集合类型) 集合互相操作的时候, 最后产生的集合是可变集合还是不可变集合取决于第一个参与操作的集合的类型
22.1联合|
22.2交集&
22.3差补/相对补集- A-B就返回属于A 但不属于B的元素集合
22.4对称差分^ A^B = A-B + B-A
23可变集合特有的操作符
23.1|= 相当于update方法, 并集赋值
23.2&= 相当于intersection_update()方法, 交集赋值
23.3-= 相当于difference_update()方法, 差集赋值
23.4^= 相当于symmetric_difference_update()方法, 对称差分更新
24集合类型的内部方法:
24.1s.issubset(t) 判断s是不是t的子集
24.2s.issuperset(t) 判断s是不是t的超集
24.3s.union(t) 返回一个新集合, 该集合是s和t的并集
24.4s.intersection(t) 返回一个新集合, 该集合是s和t的交集
24.5s.difference(t) 返回一个新集合, 该集合是s的成员, 但不是t的成员, 即返回s不同
于t的元素
24.6s.symmetric_defference(t) 返回所有s和t独有的(非共同拥有)元素集合
24.7s.copy() 返回一个s的浅拷贝, 效率比工厂要好
25可变集合特有的方法: add, remove, discard, pop, clear, 这些接受对象的方法, 参数必须是可哈希的
26那些和操作符提供相同功能的函数, 有着更强的处理能力, 因为运算符两边的操作数必须都是集合, 然而函数可以接受任何的可迭代类型.
条件和循环(chapter8)
1如果循环体, 或条件语句体只有一句, 可以和头写在同一行.
2字典的搜索速度要比for, if, while等快得多
3True and object, 返回object, True or object 返回True, 因此可以使用expression and out1 or out2 模拟三元操作符
4python提供的三元操作: X if C else Y, 如果c输出x, 否则输出y
5xrange()不会在内存中创建列表的完整拷贝, 只被用在for循环中.
6reversed()和enumerate()内建函数返回的是一个迭代器
7迭代器的优点
7.1提供了可扩展的迭代器接口
7.2对列表迭代带来了性能上的增强
7.3在字典迭代中性能提升
7.4创建真正的迭代接口,而不是原来的随机对象访问
7.5与所有已经存在的用户定义的类以及扩展的模拟序列和映射的对象向后兼容
7.6迭代非序列集合(例如映射和文件)时, 可以创建更简洁的代码
8迭代器工作原理: next()方法取出元素, 元素全部取完后触发StopIteration异常, for可以根据异常结束循环
9any(), all()用来判断序列或迭代器中元素的真假, any为或操作, all为与操作
10iter(iterable) 用来创建一个迭代器
11文件的迭代器中调用next方法, 默认会调用readline方法. 如果直接使用for line in file 就可以创建一个默认的文件迭代器.
12在迭代的时候, 不要尝试改变可变对象
13列表解析:
13.1lambda, 动态创建函数
13.2map(function, sequence), 对sequence的每一个元素应用function, 返回一个新的列表13.3filter(function, sequence), 对sequence的每一个元素应用function, 某个元素应用该
function后如果返回false, 该元素将被从最后返回的列表中过滤掉
13.4列表解析中可以使用多个循环, 来达到生成矩阵或多维序列的目的..例如【(x, y) for x
in range(5) for y in range(3)】越靠后的循环就相当于普通循环中的内层循环
14生成器
14.1生成器表达式和列表解析表达式是一样的，但是生成器表达式没有中括号，单独使
用的时候，使用圆括号，作为参数的时候，不需要圆括号
14.2生成器表达式可以被用作迭代
14.3生成器表达式是lazy的
14.4示例: 获取文件的最长的行的长度: logest = max(len(line.strip()) for line in file)
文件和输入输出(chapter9)
1文件只是连续的字节序列
2file_object = open(file_name, access_mode = ‘r’, buffering = -1) mode有r, w, a, 分别表示读取, 写入, 追加. U模式代表通用换行符支持
2.1使用r, U打开的文件必须是已经存在的, 使用w打开的文件如果存在, 首先清空…使
用a模式打开的文件是为追加数据做准备, 所有写入数据被追加到文件末尾. +代表可读可写, b代表二进制访问… POSIX兼容的Unix系统中, ‘b’是可有可无的, 因为它们把所有的文件都当作二进制文件. 包括文本文件
2.2如果在mode中要使用b, b不能作为第一个字符出现
2.3buffering, 表示缓冲区大小, 0表示不缓冲, 1表示只缓冲一行数据, 其他大于1的值表示
使用定值作为缓冲区大小. 不提供该参数或给定负值代表使用系统默认的缓冲机制
2.4访问模式:
2.4.1r 只读方式打开
2.4.2rU或Ua 读方式打开, 同时提供通用换行符支持
2.4.3w 写方式打开
2.4.4a 追加模式打开, 必要时创建新文件
2.4.5r+ 读写方式打开
2.4.6w+ 读写方式打开
2.4.7a+ 读写方式打开
2.4.8rb 二进制读模式打开
2.4.9wb 二进制写模式打开
2.4.10ab 二进制追加模式打开
2.4.11rb+ 二进制读写模式
2.4.12wb+ 二进制读写模式
2.4.13ab+ 二进制读写模式
3file()内建函数和open的使用方式一样…但是推荐使用open, 除非特定的要处理文件对象时, 使用file()内建函数
4通用换行符支持: 任何系统下的文件, 不管换行符是什么, 使用U模式打开时, 换行符都会被替换为NEWLINE(\n)
5python默认打开UNS, 如果不需要通用换行符支持, 在运行configure脚本时, 可以使用—without-universal-newlines 开关关闭.
6文件方法:
6.1输入
6.1.1read(size=-1): 直接读取字节到字符串中, 最多读取给定数目个字节. 不指定size
参数, 或size值为负, 文件将被读取到末尾.
6.1.2readline(size = -1) size为负数或不指定, 读取至行末, 如果指定了其他的size值,
读取size个字节读到的换行符不会自动去掉, 而把这个操作留给程序员, 使用strip 去掉
6.1.3readlines(sizhint = -1) sizhint和size功能相同, 如果指定, 会读取sizhint个字节, 实
第10 章Python 操作数据库 Python 数据分析（进阶篇）
主要内容CONTENTS 02结构化查询语言SQL 03操作数据库核心API 04Python操作数据库案例01数据库基础
01数据库基础
Python操作数据库 数据库基础 数据库是数据的仓库，将大量数据按照一定的方式组织并存储起来，方便进行管理和维护，例如快速检索和统计等。数据库的主要特点： ?以一定的方式组织、存储数据； ?能为多个用户共享； ?与程序彼此独立。 ?…… 数据库管理系统是一种操纵和管理数据库的大型软件。它对数据库进行统一的管理和控制，以保证数据库的安全性和完整性。用户通过DBMS访问数据库中的数据，数据库管理员通过DBMS进行数据库的维护工作。主要功能包括：数据定义（创建数据库、表等）、数据操纵（增删查改等）、数据库控制（并发、权限等）、数据库维护（转存、恢复等）等。
Python操作数据库 常见的数据库类型 当前常见的数据库类型有：关系型数据库、键值存储数据库、面向文档数据库、图数据库等。 ?关系型数据库：当前应用最广泛的数据库类型，把复杂的数据结构归结为简单的二元关系（即二维表形式），例如MySQL、SQL Server、Oracle、SQLite等； ?键值存储数据库：使用简单的键值方法来存储数据，其中键作为唯一标记，是一种 非关系数据库，例如Redis； ?面向文档数据库：用于存放并获取文档，主要是XML、JSON等具备自我描述特性、呈现层次结构的文档，例如MongoDB； ?图数据库：一种存储图关系的数据库，应用图理论存储实体之间的关系信息，例如Neo4J。
本文由我司收集整编，推荐下载，如有疑问，请与我司联系Python 的MySQLdb 模块插入数据没有成功与autocommit（自动提 交）的关系 2013/11/17 0 在使用PYTHON mysqldb的时候插入数据发现数据库没有你当前插入的数据，这时候实际上跟commit有关系 ?用MySQLdb 操作数据库，插入数据之后发现数据库中依然为空，不知原因为何。开启mysqld 的log 设置项之后发现日志文档中更有执行sql 语句，直接复制语句在客户端中执行也没有问题，那么为什么通过MySQLdb 的插入全部没有结果呢？我怀疑是MySQLdb 的问题，在日志文件中仔细的看了一遍运行的所有sql 语句，在建立连接之后还运行了这句：set autocommit=0。这句话的嫌疑很大，因为这个涉及到一个语句提交执行的问题，而且对于commit 我有点印象，好像以前学习MySQLdb 的时候，特意注意到了这点。不管怎样，这就找准了关键字：MySQLdb autocommit根据网上搜到的结果，可以大概了解到，MySQLdb 在连接后关闭了自动提交，自动提交对于innodb 引擎很重要，没有这个设置，innodb 引擎就不会真正执行语句。解决的办法：1、语句末尾加上“COMMIT;”2、运行完语句，至少在关闭数据库之前提交一下，如：connmit()3、数据库连接建立之后，设置自动提交，如：conn.autocommit(1)只是不知道为什么innodb 会这样，可能是因为这是一个事务型数据库引擎，没有提交就不会在服务器上执行，只会缓存在客户端上的缘故吧！MySQL技术内幕:InnoDB存储引擎这本书好像出到第二版了，这些关于数据库方面的知识，还是要了解一下的。参考1、MySQLdb 插入数据失败？luchanghong/database/2012/06/20/mysqldb-insert-data-failed.html2、MySQLdb Python 模块autocommit属性测试及测试过程中关于数据库连接的理解 blog.csdn/gukesdo/article/details/7026371 ?tips:感谢大家的阅读，本文由我司收集整编。仅供参阅！
破釜沉舟: 为网站站长.设计师.编程开发者. 提供资源!https://www.doczj.com/doc/765092970.html, 用Python实现数据库编程 文章类别：Python 发表日期：2004-11-11 来源: CSDN 作者: wfh_178 <用PYTHON进行数据库编程> 老巫 2003.09.10 19 September, 2003 用PYTHON语言进行数据库编程, 至少有六种方法可供采用. 我在实际项目中采用,不但功能强大,而且方便快捷.以下是我在工作和学习中经验总结. 方法一:使用DAO (Data Access Objects) 这个第一种方法可能会比较过时啦.不过还是非常有用的. 假设你已经安装好了PYTHONWIN,现在开始跟我上路吧…… 找到工具栏上ToolsàCOM MakePy utilities,你会看到弹出一个Select Library的对话框, 在列表中选择'Microsoft DAO 3.6 Object Library'(或者是你所有的版本). 现在实现对数据的访问: #实例化数据库引擎 import win32com.client engine = win32com.client.Dispatch("DAO.DBEngine.35") #实例化数据库对象,建立对数据库的连接 db = engine.OpenDatabase(r"c:\temp\mydb.mdb") 现在你有了数据库引擎的连接,也有了数据库对象的实例.现在就可以打开一个recordset了. 假设在数据库中已经有一个表叫做 'customers'. 为了打开这个表,对其中数据进行处理,我们使用下面的语法: rs = db.OpenRecordset("customers") #可以采用SQL语言对数据集进行操纵 rs = db.OpenRecordset("select * from customers where state = 'OH'") 你也可以采用DAO的execute方法. 比如这样: db.Execute("delete * from customers where balancetype = 'overdue' and name = 'bill'") #注意,删除的数据不能复原了J
本文由我司收集整编，推荐下载，如有疑问，请与我司联系 Python操作MySQL案例 2016/01/23 0 最近都在学习Python代码，希望学会Python后，能给我带来更高的工作效率，因此每天坚持学习和拷代码，下面是一个Python操作MySQL的一个实例，该实例可以让更多的人更好了解MySQLdb模块的使用。我是Python菜鸟，通过学习别人的实例来让自己学到更多Python知识。 ? ?案例：用Python实现银行转账 ?一、在MySQL创建一张表account表，然后在里面插入两条数据： ?mysql show create table account\G*************************** 1. row *************************** Table: accountCreate Table: CREATE TABLE `account` ( `userid` int(11) DEFAULT NULL COMMENT ‘账号ID’, `money` int(11) DEFAULT NULL) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin1 row in set (0.02 sec)mysql 当前数据： ?mysql select * from account;+--------+-------+| userid | money |+--------+-------+| 1 | 200 || 2 | 200 |+--------+-------+2 rows in set (0.00 sec)mysql ?编辑脚本money.py文件，运行些脚本需要安装MySQLdb模块，详细安装和基本的使用可以参考我的博客：cnblogs/xuanzhi201111/p/5144982.html ?#!/usr/bin/env python#coding:utf-8#name:money.pyimport sysimport MySQLdb try: sql = “select * from account where userid = %s and money %s” % (source_userid,money) cursor.execute(sql) print “\033[;32m检查是否有足够的钱: \033[0m” + sql except Exception,e: raise Exception(‘执行sql错误：%s’ % e) else: rs = cursor.fetchall() if len(rs) != 1: raise Exception (“账号%s余额不足” % source_userid) finally: cursor.close()#用于减去转掉的部份金额def reduce_money(self,source_userid,money): cursor = self.conn.cursor() try: sql = “update account set money = money - %s where userid=%s” % (money,source_userid) cursor.execute(sql) print “\033[;32m从源账户%s 里扣掉对应的金额: \033[0m” % (source_userid) + sql except Exception,e: raise
python操作数据库PostgreSQL 1.简述 python可以操作多种数据库，诸如SQLite、MySql、PostgreSQL等，这里不对所有的数据库操作方法进行赘述，只针对目前项目中用到的PostgreSQL做一下简单介绍，主要包括python 操作数据库插件的选择、安装、简单使用方法、测试连接数据库成功。 2.数据库操作插件的选择 PostgreSQL至少有三个python接口程序可以实现访问，包括PsyCopg、PyPgSQL、PyGreSQL(PoPy已经整合在PyGreSQL中)，三个接口程序各有利弊，需要根据实践选择最适合项目的方式。 推荐使用PsyCopg，对python开发框架的兼容性都很好，本文中我们只讨论这个插件。 3.PsyCopg的下载 官网下载psycopg2-2.5.1.tar.gz：https://www.doczj.com/doc/765092970.html,/psycopg/ 本文使用windows系统开发，未使用官网版本，选择 psycopg2-2.4.2.win-amd64-py2.7-pg9.0.4-release.exe版，地址： https://www.doczj.com/doc/765092970.html,/s/Cd8pPaw56Ozys 4.PsyCopg的安装 直接exe，根据提示安装即可. ------------------------------------------------ 博主经营一家发饰淘宝店，都是纯手工制作哦，开业冲钻，只为信誉！需要的亲们可以光顾一下！谢谢大家的支持！ 店名： 小鱼尼莫手工饰品店 经营: 发饰、头花、发夹、耳环等（手工制作） 网店： https://www.doczj.com/doc/765092970.html,/ --------------------------------------------------------------------- 继续正题... 5.PsyCopg的使用 py文件代码： __author__ = 'qiongmiaoer'
2020年python的面试题整理数据库篇MySQL 198.主键超键候选键外键 主键：数据库表中对存储数据对象予以唯一和完整标识的数据列或属性的组合。一个数据列只能有一个主键，且主键的取值不能缺失，即不能为空值(Null). 超键：在关系中能唯一标识元组的属性集称为关系模式的超键。一个属性可以作为一个超键，多个属性组合在一起也可以作为一个超键。超键包含候选键和主键。 候选键：是最小超键，即没有冗余元素的超键。 外键：在一个表中存在的另一个表的主键称此表的外键。 199.视图的作用，视图可以更改么？ 视图是虚拟的表，与包含数据的表不一样，视图只包含使用时动态检索数据的查询;不包含任何列或数据。使用视图可以简化复杂的sql操作，隐藏具体的细节，保护数据;视图创建后，可以使用与表相同的方式利用它们。 视图不能被索引，也不能有关联的触发器或默认值，如果视图本身内有order by则对视图再次order by将被覆盖。 创建视图：create view xxx as xxxxxx 对于某些视图比如未使用联结子查询分组聚集函数Distinct Union等，是可以对其更新的，对视图的更新将对基表进行更新;但是视图主要用于简化检索，保护数据，并不用于更新，而且大部分视图都不可以更新。 200.drop,delete与truncate的区别 drop直接删掉表，truncate删除表中数据，再插入时自增长id又从1开始，delete删除表中数据，可以加where字句。 1.delete 语句执行删除的过程是每次从表中删除一行，并且同时将该行的删除操作作为事务记录在日志中保存以便进行回滚操作。truncate table则一次性地从表中删除所有的数据并不把单独的删除操作记录记入日志保存，删除行是不能恢复的。并且在删除的过程中不会激活与表有关的删除触发器，执行速度快。
python中cursor操作数据库 python 操作数据库，要安装一个Python和数据库交互的包MySQL-python-1.2.2.win32-py2.5.exe，然后我们就可以使用MySQLdb这个包进行数据库操作了。 操作步骤如下： 1、建立数据库连接 importMySQLdb conn=MySQLdb.connect(host="localhost",user="root",passw d="sa",db="mytable") cursor=conn.cursor() 2、执行数据库操作 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
Python与SQLite数据库应用系统 --Python之SQLite数据库应用 作者：XX （XXXX学院，班级:XX班） 摘要：Python自带一个轻量级的关系型数据库SQLite。这一数据库使用SQL语言。SQLite作为后端数据库，可以制作有数据存储需求的工具。Python标准库中的sqlite3提供该数据库的接口。现在作为初学者，我将进行初步的尝试与应用。 关键字：Python；SQLite；应用；数据库；编程 一·Python与SQLite数据库关系学习初步 作为新时代的大学生学会使用网络查询相关信息非常重要，现在经过初步的网络学习以及书籍查询，现在整理如下： （一）创建数据库 注：全文学习范例将以一个简单的关系型数据库为实例，为一个书店存储书的分类和价格。数据库中包含两个表：category用于记录分类，book用于记录某个书的信息。一本书归属于某一个分类，因此book 有一个外键(foreign key)，指向catogory表的主键id。 (一)导入Python SQLITE数据库模块 Python2.5之后，内置了SQLite3，成为了内置模块，这给我们省了安装的功夫，只需导入即可~ 在调用connect函数的时候，指定库名称，如果指定的数据库存在就直接打开这个数据库，如果不存在就新创建一个再打开。也可以创建数据库在内存中。 在使用connect()连接数据库后，我就可以通过定位指针cursor，来执行SQL命令：import sqlite3
#test.db is a file in the working directory. conn=sqlite3.connect("test.db") c=conn.cursor() #create tables c.execute('''CREATE TABLE category (id int primary key,sort int,name text)''') c.execute('''CREATE TABLE book (id int primary key, sort int, name text, price real, category int, FOREIGN KEY(category)REFERENCES category(id))''') #save the changes https://www.doczj.com/doc/765092970.html,mit() #close the connection with the database conn.close() SQLite的数据库是一个磁盘上的文件，如上面的test.db，因此整个数据库可以方便的移动或复制。test.db一开始不存在，所以SQLite将自动创建一个新文件。 利用execute()命令，我们执行了两个SQL命令，创建数据库中的两个表。创建完成后，保存并断开数据库连接。 （二）插入数据 上面创建了数据库和表，确立了数据库的抽象结构。下面将在同一数据库中插入数据： import sqlite3 conn=sqlite3.connect("test.db")
#!/ usr/ bin/ env python #-*- encoding: UTF- 8-*- """ 测试MySQL的连接及操作 """ import MySQLdb connstring= "host='localhost',port=3306,user='root',passwd='*****',db='python'" #连接字符串 try: conn= MySQLdb. connect( connstring) except Exception, e: print e break mycursor= conn. cursor() #获取游标，用游标操作数据库 #创建表 ctable="""CREATE TABLE test if not exists(name VARCHAR(30),uid INT(10) primary key)""" mycursor. execute( ctable) #插入数据 insert1="""INSERT INTO test(name='aaa',uid=111)""" insert2="""INSERT INTO test(name='bbb',uid=222)""" insert3="""INSERT INTO test(name='ccc',uid=333)""" inserts=[] inserts[ 0]. append( insert1) inserts[ 1]. append( insert2) inserts[ 2]. append( insert3) for insert in inserts: try: mycursor. execute( insert) except Exception, e: print e #删除数据 #注释掉，下边查询要用到数据，只记录操作 #mycursor. execute("""DELETE FROM test WHERE name='aaa'""") #多表删除 #delmany="""" DELETE FROM table1, table2, table3 WHERE table1. uid= XXX AND table2. uid= table3. uid""" #mycursor.execute(delmany) 继续......
python操作MySQL数据库 https://www.doczj.com/doc/765092970.html,/rollenholt/archive/2012/05/29/2524327.html https://www.doczj.com/doc/765092970.html,/rollenholt/archive/2012/05/29/2524327.html 2012-05-29 17:41 by Rollen Holt, 216851 阅读, 29 评论, 收藏, 编辑 坚持每天学一点，每天积累一点点，作为自己每天的业余收获，这个文章是我在吃饭的期间写的，利用自己零散的时间学了一下python操作MYSQL，所以整理一下。 我采用的是MySQLdb操作的MYSQL数据库。先来一个简单的例子吧： 请注意修改你的数据库，主机名，用户名，密码。 下面来大致演示一下插入数据，批量插入数据，更新数据的例子吧：
请注意一定要有https://www.doczj.com/doc/765092970.html,mit()这句来提交事务，要不然不能真正的插入数据。 运行之后我的 MySQL 数据库的结果就不上图了。
运行结果就不贴了，太长了。 查询后中文会正确显示，但在数据库中却是乱码的。经过我从网上查找，发现用一个属性有可搞定：
在Python代码 conn = MySQLdb.Connect(host='localhost', user='root', passwd='root', db='python ') 中加一个属性： 改为： conn = MySQLdb.Connect(host='localhost', user='root', passwd='root', db='python',ch arset='utf8') charset是要跟你数据库的编码一样，如果是数据库是gb2312 ,则写charset='gb2312'。 下面贴一下常用的函数： 然后,这个连接对象也提供了对事务操作的支持,标准的方法 commit() 提交 rollback() 回滚 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条. 参考资料： MySQLdb‘s user guide package MySQLdb ============================================================= ================= 我喜欢程序员，他们单纯、固执、容易体会到成就感；面对压力，能够挑灯夜战不眠不休；面对困难，能够迎难而上挑战自我。他 们也会感到困惑与傍徨，但每个程序员的心中都有一个比尔盖茨或是乔布斯的梦想“用智慧
SQLAlchemy中的Query方法 在SQLAlchemy中执行查询是通过session对象的query方法完成的。query方法非常灵活，你可以根据需要使用不同的查询方式查找数据，下面一一举例。 1.直接通过映射类查找： #Querying user instance for instance in session.query(User).order_by(User.id): print https://www.doczj.com/doc/765092970.html,,instance.fullname 这种方法只要在query方法中，将映射类作为参数，就可以查询出这个映射类代表的数据库表中的数据。其相当于下面的SQL语句： SELECT users.id AS users_id, https://www.doczj.com/doc/765092970.html, AS users_name, users.fullname AS users_fullname, users.password AS users_password FROM users ORDER BY users.id 2.通过映射类的属性字段查询： #Querying by ORM-instrument for name,fullname in session.query(https://www.doczj.com/doc/765092970.html,,User.fullname): print name,fullname 这种方法指定了查询的具体字段，而不是像第一种方法那样把映射类的所有字段都查询出来，其相当于执行了下面的SQL语句： SELECT https://www.doczj.com/doc/765092970.html, AS users_name, users.fullname AS users_fullname FROM users 3.query查询的结果是保存在一个元组中的，所以我们可以在query中指定返回整个的映射类对象和其中的部分属性字段： #Querying as a Python object for row in session.query(User,https://www.doczj.com/doc/765092970.html,).all(): print https://www.doczj.com/doc/765092970.html,er,https://www.doczj.com/doc/765092970.html, 这种查询方法可以返回一个User对象以及它的name属性字段的值，其相当于执行了下面的SQL语句： SELECT users.id AS users_id, https://www.doczj.com/doc/765092970.html, AS users_name, users.fullname AS users_fullname, users.password AS users_password FROM users 其输出结果为一个元组和一个字符串： <user("ed","Ed Jones","f8x902")> ed <user("Wendy","Wendy Williams","foobar")> Wendy <user("Marry","Marry Contrary","xxg527")> Marry <user("Fred","Fred Flinstone","blah")> Fred 4.我们还可以给返回的结果起一个别名，或者叫标签： #Querying labeled
本文介绍了Python操作MYSQL、执行SQL语句、获取结果集、遍历结果集、取得某个字段、获取表字段名、将图片插入数据库、执行事务等各种代码实例和详细介绍，代码居多，是一桌丰盛唯美的代码大餐。 实例1、取得MYSQL的版本 在windows环境下安装mysql模块用于python开发，请见我的另一篇文章： MySQL-python Windows下EXE安装文件下载 # -*- 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() 执行结果： Database version : 5.5.25 实例2、创建一个表并且插入数据 主要还是在cursor上面执行execute方法来进行，请见源码： # -*- coding: UTF-8 -*- # 来源于https://www.doczj.com/doc/765092970.html,总结整理 import MySQLdb as mdb import sys
一、首先下载驱动：（cx_Oracle） https://www.doczj.com/doc/765092970.html,/crew/atuining/cx_Oracle/ 不过要注意一下版本，根据你的情况加以选择。 二、安装： 首先配置oracle_home环境变量 执行那个exe安装程序就可以了，它会copy一个cx_Oracle.pyd到Libsite-packages目录下。如果是linux，执行 复制代码代码如下: python setup.py build python setup.py install 三、执行一段测试程序： 复制代码代码如下: import cx_Oracle con = cx_Oracle.connect( "xjtu_test", "37343734","xjtu.world") cursor = con.cursor() cursor.close() con.close() 里边connect中的3个参数从左到右分别是：user, pass, TNS。 那个TNS可以用Oracle客户端工具中的Net Configuration Assistant来配置。 四、具体的cx_Oracle API可以参考： https://www.doczj.com/doc/765092970.html,/crew/atuining/cx_Oracle/html/cx_Oracle.html 五、示例： 复制代码代码如下: >>> import cx_Oracle >>> conn=cx_Oracle.connect ('scott/tiger@oratest') >>> curs=conn.cursor () >>> sql='select * from emp' >>> rr=curs.execute (sql) >>> row=curs.fetchone() >>> row (7369, 'SMITH', 'CLERK', 7902, datetime.datetime(1980, 12, 17, 0, 0), 800.0, None, 20) >>> while row: (ID,NAME)=(row[0],row[1]) row=curs.fetchone ()
数据库的操作在目前的 Python 里面已经变得十分的好用，因为有了一套 API 标准。本文下面就讲讲如何使用这套API。它包括以下部分： ?模块接口 ?连接对象 ?游标对象 ?数据类型与定义 ?例子 一、模块接口 connect( parameters... ) 其中的参数格式如下： dsn 数据源名称 user 用户名(可选) password 密码(可选) host 主机名(可选) database 数据库名(可选) 举个例子: connect(dsn=''myhost:MYDB'',user=''guido'',password=''234$'') 或者 connect(''218.244.20.22'',''username'',''password'',''databas ename'') 此标准规定了以下的一些全局变量， apilevel： 表示 DB-API 的版本，分 1.0 和 2.0 。如果没有定义，则默认为 1.0。threadsafety： 0 Threads may not share the module. 1 Threads may share the module, but not connections.
2 Threads may share the module and connections. 3 Threads may share the module, connections and cursors. paramstyle： 用于表示参数的传递方法，分为以下五种： ''qmark'' 问号标识风格. e.g ''... WHERE name=?'' ''numeric'' 数字,占位符风格. e.g ''... WHERE name=:1'' ''named'' 命名风格. e.g ''WHERE name=:name'' ''format'' ANSI C printf风格. e.g ''... WHERE name=%s'' ''pyformat'' Python扩展表示法. e.g ''... WHERE name=%(name)s'' 异常类： StandardError |__Warning |__Error |__InterfaceError |__DatabaseError |__DataError |__OperationalError |__IntegerityError |__InternalError |__ProgrammingError |__NotSupportedError 二、连接对象 连接对象包含如下方法: .close() 关闭连接 .commit() 用于事务处理里面的提交操作 .rollback() 用于事务处理里面的回滚操作
Python存储数据的方式 在Python开发中，数据存储、读取是必不可少的环节，而且可以采用的存储方式也很多，常用的方法有json文件、csv文件、MySQL数据库、Redis数据库以及Mongdb数据库等。 1. json文件存储数据 json是一种轻量级的数据交换格式，采用完全独立于编程语言的文本格式来存储和表示数据，可以轻松解决py2和py3的编码问题，内容结构类似于python中的字典和列表，层次结构简洁而清晰，易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。 2. csv文件 Python可以将数据存储为CSV文件格式，我们可以用excel打开CSV文档，进行数据的浏览，十分方便，以下是将数据存储到test.csv文件的相关实例：import pandas as pd list=[[1，2，3]，[4，5，6]，[7，8，9]] name=[‘id’，’uid’，’time’] test=pd.DataFrame(columns=name，date=list) test.to_csv(‘E:/test.csv’) 3. MySQL数据库 MySQL数据库存储方式是使用Python数据存储最常用的存储方式，Python 标准数据库接口为Python DB-API，Python DB-API为开发人员提供了数据库应用程序接口，MySQLdb 是用于Python链接Mysql数据库的接口。MySQL数据库
存储过程是引入API模块、获取与数据库的连接、执行SQL语句和存储过程，最后关闭数据库连接。 4. Redis数据库 使用Python数据存储为Redis数据库，优点是方便、速度快，但是取出的数据是二进制数据，一般需要转为字符串再操作，以下是具体实例：import redis client = redis.Redis(host='lcoalhost'， port=8080) client.set('nums'， [6，7，8，5，4]) result = client.get('name') pipe = client.pipeline() pipe.set('name'， 'oldboy') pipe.execute() 5. Mongdb数据库 使用Python数据存储为Mongdb数据库，优点是不在乎数据结构，需要注意的是取出来的时候需要写个脚本整理一下，以下是具体实例： import pymongo client = pymongo.MongoClient('localhost'， 8080) test1_db = client.test1 sheet_stu = db.stu info = {name:'oldboy'，age:30} info_id = stu.insert_one(info).inserted_id cur_list = [cur for cur in stu.find()]
数据库连接 # coding:gbk ''' Created on 2010-7-15 @author: Administrator ''' import cx_Oracle dsn=cx_Oracle.makedsn("150.150.1.45",1521,"dx") conn=cx_Oracle.connect("test","123",dsn) print"连接oracle成功！" try: cur=conn.cursor() sql="select * from portt_type" rr=cur.execute(sql) row=cur.fetchall() for x in row: print"记录",x[0],x[1] cur.close() except Exception,e: print e else: print"一切正常" finally: conn.close() print"连接关闭" 数据库操作 # coding:gbk ''' Created on 2010-7-15 @author: Administrator ''' import cx_Oracle
#用户名，密码，服务名 db=cx_Oracle.connect("user","pass","tns_name") c=db.cursor(); #建表 c.execute("create table test(a int,b varchar2(100))") #建序列 c.execute("create sequence stest") #插入数据 c.execute("insert into test(a,b) values(stest.nextval,'Python')") c.execute("insert into test(a,b) values(stest.nextval,'Oracle')") #检索插入的数据 sql = "select * from test" r = c.execute(sql) row = c.fetchone() while row: (a,b)=(row[0],row[1]) print a,b row=c.fetchone() #删除插入的数据 sql = "delete from test where a=1" c.execute(sql) #检索
基于Python的身份证号码归属地数据库调用代码实例 代码描述：基于Python的身份证号码归属地数据库调用代码实例 关联数据：身份证查询 接口平台：聚合数据 #!/usr/bin/python # -*- coding: utf-8 -*- import json, urllib from urllib import urlencode #---------------------------------- # 身份证查询调用示例代码－聚合数据 # 在线接口文档：https://www.doczj.com/doc/765092970.html,/docs/38 #---------------------------------- def main(): #配置您申请的APPKey appkey ="*********************" #1.身份证信息查询 request1(appkey,"GET") #2.身份证泄漏查询 request2(appkey,"GET") #3.身份证挂失查询 request3(appkey,"GET") #身份证信息查询 def request1(appkey, m="GET"): url ="https://www.doczj.com/doc/765092970.html,/idcard/index" params ={ "cardno": "", #身份证号码 "dtype": "", #返回数据格式：json或xml,默认json "key": appkey, #你申请的key } params =urlencode(params)
if m =="GET": f =urllib.urlopen("%s?%s"%(url, params)) else: f =urllib.urlopen(url, params) content =f.read() res =json.loads(content) if res: error_code =res["error_code"] if error_code ==0: #成功请求 print res["result"] else: print"%s:%s"%(res["error_code"],res["reason"]) else: print"request api error" #身份证泄漏查询 def request2(appkey, m="GET"): url ="https://www.doczj.com/doc/765092970.html,/idcard/leak" params ={ "cardno": "", #身份证号码 "dtype": "", #返回数据格式：json或xml,默认json "key": appkey, #你申请的key } params =urlencode(params) if m =="GET": f =urllib.urlopen("%s?%s"%(url, params)) else: f =urllib.urlopen(url, params) content =f.read() res =json.loads(content) if res: error_code =res["error_code"] if error_code ==0: #成功请求 print res["result"] else: print"%s:%s"%(res["error_code"],res["reason"]) else: print"request api error"