python——内置对象
python的内置对象
对象类型 | 常量示例/用法 |
Number(数字) | 3.14159, 1234, 999L 3+4j |
String(字符串) | ‘spam‘, "guido‘s" |
List(列表) | [1,[2, ‘Three‘],4] |
Dictionary(字典) | {‘food‘:‘spam‘, ‘taste‘:‘yum‘} |
Tuple(元组) | (1,‘spam‘,4,‘U‘) |
File(文件) | text=open(‘egges‘,‘r‘).read() |
数字
常量
常量 | 解释 |
1234, -24, 0 | 正常整数(C的长整型) |
999999999999999L | 长整数(无限大小) |
1.23, 3.14e-10, 4E210, 4.0e+210 | 浮点数(C的双整型) |
0177, 0x9ff | 八进制和十六进制常量 |
3+4j, 3.0+4.0j, 3J | 复数常量 |
数字的表达式操作和预处理
操作 | 描述 |
x or y | 逻辑或(只有x为假,y才被计算) |
lambda args: expression | 匿名函数 |
x and y | 逻辑与(只有x为真的时候,y才被计算) |
not x | 逻辑反 |
<,<=,>,>=,==,<>,!=, | 比较操作 |
is, is not, | 身份测试 |
in, not in | 序列成员关系测试 |
x | y | 位或 |
x ^ y | 位异或 |
x & y | 位与 |
x<<y, x>>y | 把x向左或向右移动y位 |
x+y, x-y | 相加/合并,相减 |
x*y, x/y, x%y | 乘/重复,除,余数/格式 |
-x, +x, ~x | 一元取反,一致,位取补 |
x[i], x[i:j], x.y, x(...) | 索引,分片,限定,函数调用 |
(...), [...], {...}, ‘...‘ | 元组,列表,字典,转化为字符串 |
内置函数和内置模块用于数字处理:(模块是外部组件,但内置函数却包含在名字空间中)
>>> import math
>>> math.pi
3.14159265359
>>> abs(-42), 2**4, pow(2,4)
(42,16,16)
字符串
字符串常量和操作
操作 | 解释 |
S1 = ‘ ‘ | 空字符串 |
S2 = "spam ‘s" | 双引号 |
block = " " " ..." " " | 三引号块 |
s1 + s2 | 合并 |
s2 * 3 | 重复 |
s2[i] | 索引 |
s2[i:j] | 分片 |
len(s2) | 长度 |
"a %s parror" % ‘dead‘ | 字符串格式 |
for x in s2, | 迭代 |
‘m‘ in s2 | 成员关系 |
string模块可到处大多数标准C库的字符串处理工具
regex和re模块为字符串田间了正则表达式匹配
空字符串可以写成中间为空的两个引号。注意字符串常量可以用单引号或双引号包围;两种方式都同样工作,但它们都允许一个引号字符出现在字符串内部而无需用反斜线转义。
三引号块(表第3行):当字符串被三个引号围起来时,它们可以跨过多行。python将所有三引号文本收集到一个多行字符串中,该字符串带有嵌入的换行符。
>>> import string #标准的模块
>>> S = "spammify"
>>> string.upper(S) #转化为大写
>>> string.find(S, "mm") #返回索引的子串
>>> string.atoi("42"),‘42‘ #转化字符串。atoi把字符串转化为一个数字,并把反引号所引的任何对象都转化为字符串形式的
(42,‘42‘)
>>> string.join(string.split(S, ”mm", "XX") #split把一个字符串截成一列被界定符和空格符围绕的子字符串。join把它们放在一起,两个中间有一个传递性的分界符或空格。以"XX"代 替"mm"像是一个迂回方法,但是这是一个任意替代全局子字符串的方法。
‘spaXXify‘
普通类型的概念
通用的概念在很多场合应用。就内置类型而言,同属一个类别的所有类型的操作都是相同的。
同种类型共享操作:字符串是不可变的序列,不能在原为被改变,而是有序的集合,可以根据偏移访问。
Python中有三种操作类别:
数字:支持+ 和* 的操作
序列:支持索引、分片、合并等操作
映射:支持键索引等操作
可变类型在原位可以改变,不可变类型在原位不可以改变,只能制作一个拷贝。
列表
主要属性:任意对象的有序集合,通过偏移存取,可变长度、异构、任意嵌套,属于序列可变的类型,对象应用的数组
常用列表常量和操作
操作 | 解释 |
L1 = [] | 一个空的列表 |
L2 = [0,1,2,3] | 四项:索引为0到3 |
L3 = [‘abc‘, [‘def‘, ‘ghi‘]] | 嵌套的子列表 |
L2[i], L3[i][j] | 索引 |
L2[i:j] | 分片 |
len(L2) | 求长度 |
L1 + L2 | 合并 |
L3 * 3 | 重复 |
for x in L2, | 迭代 |
3 in L2 | 成员关系 |
L2.append(4), | 方法:增长 |
L2.sort(), | 排序 |
L2.index(1), | 查找 |
L2.reverse() | 反转,等等 |
del L2[k] L2[i:j] = [] |
缩小 |
L2[i] = 1, | 索引赋值 |
L2[i:j] = [4,5,6] | 分片赋值 |
range(4), xrange(0,4) | 生成整数的列表/元组 |
append和sort在原位改变了关联的列表对象,但是不返回列表(严格地说,它们都返回一个叫None的值),如果写成L = L.append(X)的话,你不会得到L调整后的值(事实上,同时失去对列表的引用)。当使用append、sort这样的属性时,对象本身会同时被改 变,所以无需重新赋值。
L.append(X)与L+[X]效果是类似的,但前者是在原位改变,后者生成一个新的列表。与“+”合并不同,append无需生成新的对象,所以它更快。
字典
除了列表之外,字典可能是python中最有弹性的内置数据结构类型。列表是有序的对象集合,字典就是无序的集合;他们的主要区别就是字典中的项是通过键 来存取的,列表是通过偏移存取。字典的主要属性有:通过键而不是偏移量来存取,无序的任意对象集合,可变长度、异构、任意嵌套,属于可变映射类型,对象引 用表(散列表,但在底层,字典像列表一样存储对引用)
常见的字典对象常量和操作
操作 | 解释 |
d1 = {} | 空的字典 |
d2 = {‘spam‘:2, ‘eggs‘:3} | 两项的字典 |
d3 = {‘food‘:{‘ham‘:1,‘egg‘:2}} | 嵌套 |
d2[‘eggs‘],d3[‘food‘][‘ham‘] | 通过键索引 |
d2.has_key(‘eggs‘), | 方法:成员关系测试, |
d2.keys(), | 键的列表 |
d2.values() | 值的列表,等等 |
len(d1) | 长度(所存储的项的数目) |
d2[key] = new, del d2[key] |
添加/改变 删除 |
和列表一样,向字典中已经存在的索引进行赋值会改变与它相关联的值。与列表不同的是,一旦你给一个新的字典键赋值,你就在字典中生成了一个新的项。在列表 中不用,因为python认为超出了列表末尾的偏移就是越界的。要扩充一个列表,你要用append方法或者分片赋值。
>>> table = { ‘ Python‘: ‘Guido van Rossum‘, ‘Perl‘: ‘Larry Wall‘, ‘Tcl‘: ‘John Ousterhout‘ }
>>> for lang in table.keys(): print lang, ‘\t‘, table[lang]
因为字典不是序列的,你不能像在字符串和列表中那样直接通过一个for语句迭代它们。遍历各项就需要上面所述的方法。
请留意:字典接口
有些python扩展程序还提供了表面与实际工作都和字典一样的接口。
python的dbm按键存取文件接口看上去特别像一个已经打开的字典:可用键索引来存储、取得字符串:
import anydbm
file = anydbm.open("filename") #连接到扩展文件
file[‘key‘] = ‘data‘ #通过键存储数据
data = file[‘key‘] #通过键取得数据
如果我们用“shelve”代替“anydbm“,可以存储整个python的对象(shelve是通过键访问的持久的python数据库)
在Internet工作中,python的CGI脚本也支持实现了一个类似字典的接口。一个对cgi.FieldStorage范围的调用产生了一个类似字典的对象。在客户端Web页上每一个输入字段有一项:
import cgi
form = cgi.FieldStorage() #解析格式数据(stdin,environ)
if form.has_key(‘name‘) :
showReply(‘Hello, ‘+ form[‘name‘].value)
使用字典的注意事项:序列操作不能工作,赋值给新的索引将添加项,键没有必要总是字符串
元组tuple
元组由简单的对象组构成。除了不能原位改变(它们是不可变的),并且通常写成一串圆括号中的项之外,元组与列表类似。元组的属性有:任意对象的有序集合,通过偏移存取,属于不可变序列类型,固定长度、异常、任意嵌套,对象引用的数组
常见的元组常量和操作
操作 | 解释 |
() | 一个空的元组 |
t1 = (0,) | 只有一项的元组(不是一个表达式)单项元组 |
t2 = (0,1,2,3,4) | 一个有五项的元组 |
t2 = 0,1,2,3,4 | 另一个有五项的元组(同上一行一样) |
t3 = (‘abc‘, (‘def‘, ‘ghi‘)) | 嵌套 |
t1[i], t3[i][j] t1[i:j] len(t1) |
索引 分片 求长度 |
t1+t2 t2*3 |
合并 重复 |
for x in t2, 3 in t2 |
迭代 成员关系 |
+、*和分片操作将返回新的元组,并且元组不提供我们在列表和字典中的方法。一般的说,在python中,只有可变对象可以输出可调用方法。
有了列表,为何还要使用元组?
元组的不可变性可以提供某些整体性能;你能可定的是在一个程序中一个元组不会被另一个引用改变。而列表就没有这样的保证。
某些内置操作也需要元组而不是列表。例如,内置函数apply动态调用函数的时候,参数表由元组构成
有一个来自实践的原则:列表可以用于想变动的有序集合的工具;元组则处理其他事情
文件
内 置函数open创建了一个python文件对象,可作为计算机中一个文件的链接。调用open后,通过调用文件对象的方法,你可以读写相关的外部文件。严 格地说,文件就是一个预建立的C扩展类型,提供了底层C stdio文件系统之上的一个包裹层。事实上,文件对象方法和C标准库中的函数是一一对应的。
常见的文件操作
操作 | 解释 |
output = open(‘/tmp/spam‘, ‘w‘) | 生成输出文件(‘w‘代表写)(‘a‘代表为在文件尾部追加内容而打开文件) |
input = open(‘data‘, ‘r‘) | 生成输入文件(‘r‘代表读) |
S = input.read() | 把整个文件读到一个字符串中 |
S = input.read(N) | 读N个字节(1个或多个) |
S = input.readline() | 读下一行(越过行结束标记) |
L = input.readlines() | 读取整个文件到一个行字符串的列表中 |
output.write(S) | 把字符串S写入文件 |
output.writelines(L) | 将列表L中所有的行字符串写到文件中 |
output.close() | 手工关闭(或者在垃圾收集时进行) |
在一个文件中seek函数复位当前位置。flush强制刷新缓存种终止输出便于写等等
>>> myfile = open(‘myfile‘,‘w‘)
>>> myfile.write(‘hello text file\n‘)
>>> myfile.close()
>>> myfile = open(‘myfile‘,‘r‘)
>>> myfile.readline()
‘hello text file\012‘
>>> myfile.readline() #空字符串:文件结尾
‘ ‘
文件类的可用工具
基于描述文件的文件
os模块提供了使用低级基于描述文件的接口
DBM键(keyed)文件
anydbm提供了一个通过键访问文件的接口
持久文件
shelve和pickle模块对保存整个对象提供支持(不只是简单的字符串)
管道
os模块也提供了POSIX接口以便于处理管道
其他
还有些对数据库系统的可选接口,基于B树的文件,等等
======总结======
操作符重载:如果你想提供一个新的特殊的序列对象,它由内置序列组成,写一个类可以重载索引、分片、合并等操作:
class MySequence:
def __getitem__(self,index):
# [index], for x in self, x in self
def __getslice__(self,low,high):
# called on self[low:high]
def __add__(self,other):
# called on self + other
python的内置类型是真正的预编码C扩展程序类型。在你写自己的代码的时候,你需要知道类型的类别。
共性:列表、字典和元组可以包括任何种类的对象;列表、字典和元组可以任意嵌套;列表、字典可以动态扩大和缩小
比较、相等性和真值:
==操作符测试值是否相等
python运行了一个相等测试,递归比较所有的内嵌对象。
is 操作符测试对象的一致性
python测试它们是否真的是同一个对象(例如:在同一个地址中)
示例对象真值
对象 | 值 |
"spam" | 真 |
" " | 假 |
[ ] | 假 |
{ } | 假 |
1 | 真 |
0.0 | 假 |
None | 假 |
None总被认为是假的,他是python中唯一的特殊数据结构。它通常起一个空的占位作用,特别类似C语言中的Null指针。
Python的类型层次:Python中任何东西都是对象类型,可以由python程序处理
数字 → 整数 → 整数、长整数
→ 浮点数、复数
集合 → 序列 → 不可变的 → 字符串、元组
→ 可变的 → 列表
→ 映射 → 字典
可调用的 → 函数、类、方法 → 绑定
→ 非绑定
其他 → 模块、实例、文件、空
内部 → 类型、代码、框架、轨迹
内置类型的常见问题
- 赋值生成引用而不是拷贝
>>> L = [1,2,3]
>>> M = [‘X‘, L ,‘Y‘] #对L的嵌套引用
>>> M
[‘X‘, [1,2,3], ‘Y‘]
>>> L[1] = 0
>>> M
[‘X‘, [1,0,3], ‘Y‘]
解决方法:这种影响通常只在大型程序中会很重要,而有的时候共享引用绝不是你真正想要的。如果不是这样,你可以通过拷贝他们以避免共享对象。在列表中,你总能生成使用一个空的有限分片生成的高级拷贝。
>>> L = [1,2,3]
>>> M = [‘X‘, L[:] ,‘Y‘] #一个嵌入的L的拷贝
>>> L[1] = 0 #只改变L,不改变M
>>> M
[‘X‘, [1,2,3], ‘Y‘] - 同层深度的重复加。当我们介绍序列重复的时候,我们说他有些像在序列后加上自身的某些倍数。这是正确的,但是当可变的对象嵌套的时候,效果可能不总向我们想的那样。
>>> L = [4,5,6]
>>> X = L * 4 # 类似[4,5,6]+[4,5,6]+...
>>> Y = [L] * 4 # [L]+[L]+...
>>> X
[4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6]
>>> Y
[[4, 5, 6], [4, 5, 6], [4, 5, 6], [4, 5, 6]]
>>> L[1] = 0 # 影响Y但是不影响X
>>> X
[4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6]
>>> Y
[[4, 0, 6], [4, 0, 6], [4, 0, 6], [4, 0, 6]]
解决办法:这的确是另一个触发共享可被对象引用的方法,这样,上面同样的方法可以应用在左边。并且如果你记得重复、合并、分片复制只是在操作对象的顶层的话,这一类的例子更加有用。 - 不可变类型在原位不可以被改变
>>> T = (1,2,3)
>>> T[2]=4
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: object does not support item assignment
>>> T = T[:2]+(4,)
>>> T
(1, 2, 4)
解决办法:用分片、合并等等操作生成一个新的对象。但是如果需要的话向后赋值给原引用。这样看上去像额外的编码工作,但是这样做的优点就是,当使用元组和字符串这样的不可变对象的时候,不会发生先前的问题。因为他们在原位置可以被改变,不会产生类似列表中的副作用。
郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。