本帖最后由 馒头 于 2013-6-23 15:02 编辑

. ~5 K6 ]5 t* ]: {7 [2 D2 m

; c3 x% `0 ~" ^0 r(一)环境搭建, G2 m# `5 v$ L: m5 k% i3 {1 h3 D. P

为了更好的学习Python，建议搭建一些软件环境来提高学习开发效率。8 t- i% o1 g" ?+ i6 A. N

Python是一门开源的程序设计语言，是一种可交互执行的解释性脚本语言，非常适合简单应用和插件开发。如果只是编写xbmc插件，并且在xbmc里面进行调试的话，可以不用下载安装python软件包。在官方下载地址上有多个版本下载，因为XBMC内置的解释器是基于python2的，所以请大家下载2.7.3版本进行安装。特别注意，python 3在很多地方与python 2是不兼容的。+ Q1 D- W5 @5 o+ G2 L

, J1 J6 Y+ U& C) t    DreamPie是一个很好的Python Shell，我经常拿它来进行交互开发，或者作为高级计算器。Python有个优势，不像其他编译性语言一样，一定要等到程序写完，编译通过以后才能运行得到结果。而Python却可以在Python Shell中单独允许一条语句。比如说，你不知道字符串去空格的函数是不是strip了，那么很简单，直接到pytho shell中跑一句 ' abc '.strip() 看得到的结果是不是'a'就知道了，不对再去查文档也不迟。很多时候，一个很大的py文件里面某地方出错了，你完全可以把其中某一些语句挑出来单独在python shell里面去跑，省去反复不停的执行整个文件，而且减少依赖。7 z( I) l3 M" ?5 D' m( J% e8 ^# R; V    我是用的最多的Python开发环境是Ulipad，因为本身是python写的，跨平台，windows/linux/mac os都可以用。另外一款PyScripter是针对windows平台开发的优秀IDE。两者都具有语法高亮、自动缩进、类型浏览等多种特性，可以提高代码编制效率。当然不嫌麻烦的话，也可以使用记事本来写代码。" Y' ~( @0 }# d$ i

" g+ Q! i3 w$ }! O7 \4 ~4 b8 L) d7 W6 t8 }

(二)变量

# {$ D* B+ I# X* z# d9 T$ @- I9 u$ y: m

Python的变量是没有类型的，可以赋任意类型的值。变量不需单独定义，一旦赋值即可使用。print函数可以输出变量内容。>>> url = 'http://www.baidu.com'

>>> page = 4

>>> print url

http://www.baidu.com

>>> print page

4

>>> page += 5

>>> url += '?page=' + str(page)

>>> print url

http://www.baidu.com?page=91 ^8 C4 m2 a% b0 g' r, Y/ s, i7 L/ ]# V2 h0 x3 P, \5 P

复制代码9 `- c' q! ~- o6 d

上面的示例都是在python shell中交互运行的结果，以>>>开头的是输入的语句，其他的部分是显示结果。可以看到不需要像有些语言用var声明变量，也不需要int/string/char []*之类的类型定义符来进行定义。很简单，你想用的时候，直接赋值就行了，然后就可以对变量进行任意操作，比如用+=进行自加/连接，作为print函数的参数来输出变量的值。>>> a = 123

>>> print a

123

>>> a = 1.24

>>> print a

1.24

>>> a = "I'm a fine"

>>> print a

I'm a fine

>>> a = (1, 2.4, "hello", {'a': 0, 'b': 1})

>>> print a

(1, 2.4, 'hello', {'a': 0, 'b': 1})4 g8 {0 b* r: F6 h

' }9 O) Q. \/ I+ Q0 R+ u4 ]  ?$ `0 ~复制代码" @8 K' w% N2 C/ X- ?9 y# n4 Y

在上面的示例中，可以看到同一个变量可以赋不同的值。最后一个看起来稍微复杂点，将在后面的数据类型中一一讲到。

8 b# j( f, T1 J1 Z7 V+ i6 m9 s7 C* X4 _+ c5 n8 _  L$ D; h5 t

4 \) d8 j7 j4 V6 i(三)数字

/ L. s# X) M& H, f! R  b8 ]  g+ u8 G8 @7 C! _3 L. U

Python中的数字分整数和浮点数。python的整数有int和long，但是我们使用的时候不用管他。python中整数长度是没有限制的，这和别的很多语言不同，也就是说可以轻松的在python中完成大整数的运算。>>> 2**30

186: 1073741824

>>> 9**99

187: 29512665430652752148753480226197736314359272517043832886063884637676943433478020332709411004889L

>>> 2358321783728157823*23594389258432 + 29512665430652752148753480226197736314359272517043832886063884637676943433478020332709411004889

210: 29512665430652752148753480226197736314359272517043832886063884693320105595399861474399840518425L

>>> (1+2)*(39-13)

9 @; F* Q2 x8 e9 c1 Y% n

* H4 ]. K2 t* j1 S+ G复制代码* G' Y9 b# ]& e: f: ?) R

在Python中，long类型的数值会在最后加上一个大写的L，但是你在输入的时候完全可以不用写。这是内部的类型转换，是无需关注和进行显示转换的。整数和浮点数进行运算时，会自动将整数转化为浮点后进行运算，得到浮点数结果。用int函数将浮点数转换为整数时，不进行四舍五入，而是简单的抛弃小数部分，这点需要注意。我们可以用int(x+0.5)的方式来进行四舍五入，当然也可以直接使用round()函数。. L0 _( o" T: F: }* N6 b2 e5 F8 G

0 W  c0 [1 V9 y0 T+ r

还有一点需要注意的是，/在python 2.x中，对于整数而言跟//的用法是相同的，都是取整数部分，这点很容易被忽略。%符号是用于取余数的运算符。divmod可以同时获得商和余数。>>> 5/3

221: 1

>>> 5%3

222: 2

>>> 5/3.0

223: 1.6666666666666667

>>> 5//3

224: 1

>>> 5//3.0

225: 1.0

>>> divmod(5, 3)

226: (1, 2)# G: K! ]$ ?# a+ ?. l

3 |' u# S7 G! g; k5 Q; X9 V复制代码+ P& p+ ~4 K5 `7 f4 n

对于变量加1，没有像c语言里面那样的x++，一般用x=x+1，或者简化为x+=1。

1 L2 ~  l" I2 |, t% a% d$ u# R$ Q7 o% r) A) B3 N: P5 g. @6 G6 b0 ^% d1 {! \

(四)字符串

5 L: k! `0 l: ]' A  S) C: U4 E# K9 Y- G: h6 h6 G

字符串是我们在程序中使用最多的类型。Python中没有字符类型，只有字符串。字符串可以用单引号或者双引号包围起来。可以用\符号在行的末尾进行换行，这是一种语法形式的换行，在很多地方使用，比如这行代码太长了。\换行的字符串实际并不包括换行符。236: 'bbb'

>>> print 'hello'

hello

>>> print "hello"

hello

>>> 'hello' == "hello"

237: True

>>> print 'hello \

... world'

hello world

0 @4 i7 }0 K, S8 o/ G6 H+ F. A

复制代码

2 g  z/ _1 l( F4 W/ @" y单引号和双引号可以嵌套使用。这点在使用中很方便，比如一个html代码片段，里面有双引号，在字符串里面就必须进行转义。但是使用单引号就可以省却这个麻烦。>>> "test"

238: 'test'

>>> 'test'

239: 'test'5 G6 v; j3 }. k. B' H* z1 C9 F4 H, g

复制代码

% Y/ G8 ?" b4 c: G0 A1 k6 A+ n: n把几个字符串放到一起，Python会自动进行拼接，也可以用+号进行显示拼接。>>> print 'hello'   "world"

helloworld

>>> print 'hello' +"world"

helloworld

4 {/ M! J8 z1 H1 G9 }2 x$ G" e) A2 z* O& Y: P, B2 I, I1 Y0 F

复制代码

7 L7 v8 o# c: B8 |8 f- u% q字符串中包含换行符的，需要用\n进行表示。但是Python有一种很方便的方法，就是使用连续三个’或者"将字符串包围起来，则其中所有字符都原封不动的保留，包括空格和回车。这在构造一段html代码的时候很有用。>>> print 'Dear J:\n    Hi.\n          yours.'7 T, B/ S1 S0 `1 v( P: @  D9 V

1 {- b" t5 ~8 ~3 Y" ~复制代码

3 l4 u; Q: e3 t- _: f正则表达式是我们在编写插件过程中最常见的技巧，但是正则表达式本身有\符号进行转义。比如\\表示\，\*表示*。但是\本身在python字符串中也是起转移作用的，那么要么你多转义几次，要么使用raw string，就是在字符串加上一个r，表示字符串内不需要进行转义。下面的示例在正则表达式中表示三个字符：^\*>>> print '\\^\\\\\\*'

\^\\\*

>>> print r'\^\\\*'

\^\\\*

- I1 o, X. O% O  W, w2 k" k* q! t% T! M* Y4 k, ^. [- a

复制代码5 ]" N  c" w; k; x0 V" \2 j

字符串是只读的，不能修改其中的某些字符。如果需要修改，必须重新构造一个字符串。>>> s='abb'

>>> s[0]='b'

Traceback (most recent call last):

File "", line 1, in

s[0]='b'

TypeError: 'str' object does not support item assignment

>>> s='b' + s[1:]

>>> s

236: 'bbb'( f! `: e0 a7 M! r6 i

% {& N! F: t3 r! M4 D2 l复制代码4 ?% p! l2 l8 P9 M2 H

上例中的s[1:]用法在python中叫做切片(slice)。不仅对于字符串，对于后面讲到的tuple和列表都是同样的用法。基本的用法是s[start:end:step]，start是切片开始的位置，python中从0开始，end表示结束的位置，注意s[end]这个字符本身不包含在内。这样end-start就是最后切片的长度，当然如果end小于start，得到的是空字符串''。step表示切片的步长，默认为1。简单来说，就是从start开始取，依次是start+step、start+step*2、...一致到小于end的所有字符。start、end、step都可以为负数，start和end负数表示从字符串后面开始数起，-1表示最后一个字符，step为负数就从后往前切片，这要求start大于end。len()函数用来获取字符串长度。几个参数都可以省略，start省略表示从0开始，end省略表示取到最后，step默认就是1了。说起来有点犯迷糊，看下面的例子就容易理解了。>>> a='hello world'

>>> len(a)

240: 11

>>> a[:] #copy of string

241: 'hello world'

>>> a[2:] #from the third

242: 'llo world'

>>> a[2:-1] #except the last one

243: 'llo worl'

>>> a[::2] # the even chars

244: 'hlowrd'

>>> a[::-1] #reverse of string

245: 'dlrow olleh'

>>> 'magnet:?xt=urn:btih:8fcffdf6062379a6a1a0505bb809919870d240eb&dn=%5B%E8%A5%BF%E6%B8%B8%E9%99%8D%E9%AD%94%E7%AF%87%5D.2013.HDTV.720p.x264.AAC-iSCG%5B%E5%9B%BD%E8%AF%AD%E4%B8%AD%E8%8B%B1%E5%AD%97%E5%B9%951.7G%5D'[20:60]

246: '8fcffdf6062379a6a1a0505bb809919870d240eb'

7 ~/ u0 M& O" \7 R* B) R: }  [7 K$ R

复制代码& @7 e; E! m6 d- a$ Z2 M8 ?! t

下面的例子里面有一些字符串常见操作：>>> 'hello world'.upper() #大写

247: 'HELLO WORLD'

>>> 'HELLO WORLD'.lower() #小写

248: 'hello world'

>>> 'hello world'.capitalize() #首字母大写

249: 'Hello world'

>>> '  ab '.strip() #去空格

250: 'ab'

>>> ' ab  '.lstrip() #去除左侧空格

251: 'ab  '

>>> ' ab '.rstrip() #取出右侧空格

252: ' ab'

>>> 'bc' in 'abcd' #判断是否包含某字符串

253: True

>>> '中文test123'.encode('base64') #base64编码

262: '5Lit5paHdGVzdDEyMw==\n'

>>> print '5Lit5paHdGVzdDEyMw==\n'.decode('base64')  #base64解码

中文test123

>>> '中文test123'.encode('hex').upper() #十六进制编码

264: 'E4B8ADE6968774657374313233'

>>> print 'E4B8ADE6968774657374313233'.decode('hex')

中文test123

>>> 'abcdabc'.replace('ab', '**') #替换

265: '**cd**c'

>>> 'ab|cd|ef'.split('|') #按指定符号分割字符串

267: ['ab', 'cd', 'ef']

>>> 'ab cd ef'.split() #按空格分割字符串

268: ['ab', 'cd', 'ef']

>>> 'http://www.baidu.com'.partition('://') #按制定字符串分割成两部分，比split效率更高

271: ('http', '://', 'www.baidu.com')

>>> ' , '.join(['hello', 'world', '!']) #连接字符串

270: 'hello , world , !'

* W  G( d1 p; ]5 D4 _( F3 X

$ V$ J8 m5 \3 s3 ~) n& M; V复制代码

% y) E! p# u& z0 X9 H1 q! }0 }) k- o上面提到用join来将一个列表拼接成字符串的方法经常要用到，而且是效率最高的方法。一些需要动态拼接的字符串，都先append到一个列表，最后用join来形成最终的字符串。

& W- D/ I! n& w& _: U1 v3 g; Y8 c' A5 {# g! r    检查字符串是否以xx开头或者结尾，分别用'abc'.startswith('ab')和'abc'.endswith('bc')的函数来校验。更复杂的需要用到正则表达式，在Python中有re模块对正则表达式进行支持。由于正则是一个非常庞大的话题，在此不做详解。

/ g5 D7 J/ s% Z- F: {* O+ w2 r2 Q  w; x# M+ E# i    转换和格式化>>> str(10)

272: '10'

>>> str(1.5)

273: '1.5'

>>> int('335')

274: 335

>>> 'htt://%s/test/?page=%d' % ('www.baidu.com', 11)

275: 'htt://www.baidu.com/test/?page=11'

1 V* N- c$ D4 T4 o# s

1 e6 h8 x  ^9 ]. X1 k复制代码

8 A2 E8 @7 \; A" _3 x/ _

: n) i4 k  W' B' h8 J* t0 Q. o, W% R+ T9 H% q1 j- j# e+ r. @

(五)列表和tuple" c2 m% b7 m2 E0 N7 o) Q" R) ~: U" T

. F( [3 D$ z; b3 w

列表(list)在Python中的地位也非常重要，在插件开发过程中更是经常用到。list有点像C语言的数组，可以按索引遍历访问其中的每一个元素，可以对其进行修改。但是list与c的数组有天壤之别，便利之处也是数组遥不可及的。# f- x% _2 i7 H! ~5 P# W9 ^

6 @0 @$ f7 T6 r# h, {

首先，list长度不固定，可以任意追加、插入、删除元素，也可以一个元素都没有，即经常用到的空列表[]。从某种意义上说，list更像数据结构里面的链表，在内存中并不占有连续的空间。list元素也不限定数据类型，可以是任意Python类型，数字、字符串、字典...，甚至是另一个list，或者一个函数。

' T  ]1 R: W& v  q3 @" Z5 J9 |: B- I    list可以用索引进行访问，比如x[2]；可以切片，比如x[:-3]；还可以迭代for item in aList: print item。下面来看看list长什么样子吧。>>> urls = []

>>> urls.append('www.baidu.com')

>>> urls.append('www.google.com')

>>> urls.insert(0, 'xbmc.org') #注意顺序，在最前方插入

>>> urls.extend(['a', 'b', 'c'])

>>> urls

278: ['xbmc.org', 'www.baidu.com', 'www.google.com', 'a', 'b', 'c']

>>> urls.pop() #pop the last one and return

279: 'c'

>>> urls

280: ['xbmc.org', 'www.baidu.com', 'www.google.com', 'a', 'b']

>>> urls.pop(0) # pop the first

281: 'xbmc.org'

>>> urls

282: ['www.baidu.com', 'www.google.com', 'a', 'b']

>>> urls[2:]

283: ['a', 'b']

>>> urls[2] = [1,2,3]

>>> urls

284: ['www.baidu.com', 'www.google.com', [1, 2, 3], 'b']

>>> urls[2:2] = [4, 5, 6]

>>> urls

285: ['www.baidu.com', 'www.google.com', 4, 5, 6, [1, 2, 3], 'b']

>>> len(urls)

286: 7

. Y" }8 v' r- W* u* q0 E3 X1 m1 I( B; K, `8 ?) ~# D( B0 O

复制代码

4 r$ M; `! V0 W% H从上面的示例可以看到，可以在列表中任意追加、插入、替换元素。请大家不要误会，list不是一定要从空列表[]开始。你完全可以一开始就 urls = ['a', 'b','c']。切片的操作和字符串类似，只不过字符串不能修改，而列表是可以修改的。urls[2:2]=[4,5,6]就利用这个技巧，在2的位置上加了三个元素，注意和urls[2]=进行区别。extend函数直接将另一个list直接追加到最后，省的一个一个append。& M6 w) R9 Q! h5 v4 z" x& ?' Y

1 C6 R" l4 d& W" S3 `9 ?8 s

列表可以查找和删除指定元素，不仅仅是通过索引位置，还可以根据元素的值进行定位和删除，分别是index和remove函数。需要注意的是，如果多个元素值相同的话，只针对第一个出现的元素。sort和reverse函数分别对list进行排序和反转，这两个函数都不返回值，这点需要注意一下。如果需要排序结果，但不影响原list的话，就使用sorted函数。>>> urls.append(4)

>>> urls.count(4)

287: 2

>>> urls.index(4)

288: 2

>>> urls.remove(4)

>>> urls

289: ['www.baidu.com', 'www.google.com', 5, 6, [1, 2, 3], 'b', 4]

>>> urls.sort()

>>> urls

290: [4, 5, 6, [1, 2, 3], 'b', 'www.baidu.com', 'www.google.com']

>>> urls.reverse()

>>> urls

291: ['www.google.com', 'www.baidu.com', 'b', [1, 2, 3], 6, 5, 4]

>>> sorted(urls)

292: [4, 5, 6, [1, 2, 3], 'b', 'www.baidu.com', 'www.google.com']3 i8 S- c+ v; T. I$ b& |1 t$ H+ I0 ]2 V* k8 ]2 I4 v% c

复制代码3 [5 @7 V. K' o2 B- U0 v

range函数返回一个数字列表。参数和切片有些类似，可以指定起至值和step。看下面的例子就明白了：>>> range(10)

293: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> range(5, 10)

294: [5, 6, 7, 8, 9]

>>> range(10, -1, -2)

295: [10, 8, 6, 4, 2, 0]' v: D* o( |& h% N* }7 V5 n

7 @7 f  D8 W8 g# I" M; F0 ~复制代码

: M2 M- l4 _' e  Z因为返回的结果是一个list，是需要在内存中真实存在的。所以如果你需要一个从1到一百万的序列，请不要使用range函数，而是用xrange，得到的是一个迭代器(iterator)，不会一次性在内存中生成。

# l+ e* V1 t4 e" j: P1 K. M9 ^3 d7 v2 u

下面要讲一下关于迭代的问题。对于任意可以迭代的数据，我们用 for 变量 in 数据 的语法形式来进行访问。我们已经知道，list可以根据索引访问。那么类似c语言数组的做法，很容易想到的是下面的用法：>>> aList = ['a', 'b', 3, 4, 'e', 'f', 3.9]

>>> for i in range(len(aList)):

...     print aLista

b

3

4

e

f

3.9; O  i. M9 b6 c2 }. c2 D( a* }' ^" W- f# Z" L0 t& I8 m2 K% _

复制代码

1 {3 K6 D; q8 K1 E& F* c但是，这种访问方式很明显多此一举了。按照Python的思想，要用最简单的语句最多的事情。>>> for item in aList:

...     print item

a

b

3

4

e

f

3.9

( p0 W2 W/ M+ k+ `0 S9 x

% h; p/ e4 q8 n/ G8 u9 s$ }7 H. P  }0 Y复制代码

+ j% K7 W' Z9 n' C即简单，又简洁。如果同时确实元素的索引值，可以用enumerate函数>>> for i, item in enumerate(aList):

...     print i, item

0 a

1 b

2 3

3 4

4 e

5 f

6 3.9

7 @* Q/ Y* N$ i9 b4 C' X. B# t! l5 B

复制代码6 ~1 p' G/ p& k+ {1 t

enumerate返回的一个元素为tuple的list，可能类似[(0, 'a'), (1, 'b'), ...]这样的形式。我们在for里面用到了两个变量，这叫做unpack(好像是这么称呼)，就是将一个序列解开到多个变量。顺便先提一下， a,b这样的形式就叫做tuple，它和(a,b)是一样的，类似list，区别在于它不能修改。我们来看看upack怎么用。>>> a,b = [1,2]

>>> a, b

296: (1, 2)

>>> print a, b

1 2

>>> a, b = ('hello', 'world')

>>> print a,b

hello world

>>> (a, b, c) = [3, 4, 5]

>>> print a, b, c

3 4 5

>>> name, url = ('百度', 'www.baidu.com')

>>> print name

百度

>>> print url

www.baidu.com

>>> name, url = url, name

>>> print name

www.baidu.com

>>> print url

百度, }+ a# z$ f/ f, M% h4 h# h* a0 Z' x; l$ c. b

复制代码s6 h" }5 c* J* }$ d% e% V! o

可以看到，unpack在变量赋值的过程中是非常有用的。name, url = aList 相当于name=aList[0] url=aList[1]。显然前面的方式更加简洁明了。甚至我们用name, url = url, name这样的语句，简单的交换了两个变量的值，这在c语言里面不用第三个变量中转是无法做到的。) o) b+ {+ U, p5 D& \

' Q* n) [  `/ \1 [) I1 o: w+ e

list的迭代使用的确很方便，很强大。但是很多情况下还不需要这么复杂，因为有list comprehension，就是用一种表达式将原来的list进行运算变形，得到新的表达式。比如我需要得到1-10这10个数的平方，保存为一个列表。采用传统的方法：>>> aList = []

... for i in range(11):

...     aList.append(i*i)

>>> aList

298: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

! S" L  r, w8 p  x  @, Y& j3 }

6 \; ^5 o! w$ ^复制代码3 \: W  Z9 F, G) Y8 h& ~* y: G

你再看看下面更简洁的方法：298: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

>>> aList = [i*i for i in range(11)]

>>> aList

299: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

1 W* @7 m( I0 S+ a; Z& \7 O* X) |( b9 I& q/ _; I/ ^

复制代码

, i4 X- k- y- h) c别看这个例子很简单，其实在我们写程序的过程中经常会用到，大大简化我们的程序。有兴趣也可以翻翻我写的插件源代码，到处充斥这这样的应用。. f8 y8 l) @# W1 ]( S

6 ?3 c' |0 x1 o0 p. R    我们还可以用if来对产生的结果进行过滤。比如上例中，我要挑出3次方被3除余2的数字的平方(有点绕口)。

>>> [i*i for i in range(11) if i**3 % 3 == 2]3 s% m3 w2 O' B2 J+ j3 r

; H9 S# I5 V8 S( Z+ K# g# A复制代码

" I0 u5 t( S; k再来说说tuple，前面已经大致提到过。形如(1,2,3)用括号和逗号构造的序列就叫做tuple，有的翻译为元组，我觉得不习惯。它和list很相似，可以用索引进行访问，可以进行迭代，可以切片。tuple和list最大的区别就是它和字符串一样，不能对它进行任何修改。字符串从某种意义来讲，可以认为是单个字符组成的tuple。9 U' C7 Q1 \  x* {% u# B. h1 y- p

# v% ^5 w! q  E6 k' J0 L' X! q

tuple用于某些不希望别人修改它的场合，比如作为函数参数传入，作为字典的key等等。构造tuple很简单，需要注意的是，如果一个tuple只有一个元素，不是(1)这样的形式，这样会当作括号符进行运算，得到1这个整数。正确的语法是(1,)，就是后面一定要有一个逗号，虽然有点怪异，但是习惯就好了。讲到这里，顺便提一下，tuple、list和我们后面要讲到的dict(字典)，最后一个元素后面都可以带一个逗号，不会出现语法错误。我们经常会这么干，便于追加记录，比如a = [

'a',

'b',

]+ J3 s0 b9 Y; h$ e

, B1 s! i5 }. W6 X复制代码

9 S9 ]9 v( u  b, a& n7 Xtuple也可以用+连接，构造新的tuple。下面的例子介绍一些常见的tuple形式和运算>>> (1, 2, 'a', 'b')

300: (1, 2, 'a', 'b')

>>> (1, 2, 'a', 'b') + (4, 5)

301: (1, 2, 'a', 'b', 4, 5)

>>> (1, 2, 'a', 'b') + (6, )

302: (1, 2, 'a', 'b', 6)

>>> ()

303: ()

>>> (1,)

304: (1,)- ^7 |7 Z( h3 W' p

6 {( B8 b9 a! o) L# r- \复制代码7 V! Z0 j& _6 E5 Q5 V  R) o2 V6 S

tuple和list可用tuple和list内置函数进行相互转换>>> aList = range(10)

>>> aList

307: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> t = tuple(aList)

>>> t

308: (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

>>> list(aList)

309: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]+ U& h' E* l; j' p) S/ N3 O0 y" }- K' `1 D$ Y5 O* U

复制代码

* g& w  ?8 V0 U: ~' c迭代同样适用于tuple>>> ''.join(str(i) for i in t)

311: '0123456789'% ~$ q2 `: V! H& @. j+ [1 V2 \/ r

4 x  C4 x) O! G7 I1 J3 \复制代码

$ p' t6 K- ^7 V* c上例中，t是一个10个数字的tuple。通过list comprehension表达式，将t里面的每一个数字用str函数转换成字符串。最后的得到一个generator用''.join连接在一起，形成最终的字符串。中间的表达式的结果实际上是一个generator，不用了解太深，知道可以这么用就可以了。>>> (str(i) for i in t)

312: at 0x3144140>

+ R+ z& R' C  X! Z

0 z# p, ?2 T* n% B7 U复制代码

4 O0 U4 J/ R6 c+ d我们可以用in来判断某个指定的元素在list/tuple中是否存在。比如 'a' in ('a', 'b')，'b' not in ['a', 'b']

' [7 Z0 n6 ^4 y7 r2 M& Q0 H4 S5 ?1 j2 M3 W1 m+ z

最后，来看一个稍微复杂点的例子吧，将文件中以LOG: 开头的行显示出来，并且去掉LOG:。print ''.join([line[4:] for line in open('a.txt') if line.startswith('LOG:')])

. C( P/ \/ J8 _5 x, _  {  K3 \' V& x6 F* \2 p' ?" ]

复制代码

! h8 S. u& `" s  h& A其中open函数打开一个文件，返回一个每行数据的迭代，基本上你可以认为返回一个list，每个元素表示一行。

; L8 F' P& I& B7 y, W* _- Q, A( B1 S7 \6 }1 N; V$ }

7 Z7 y: v9 T/ ^; c) c2 V4 e" P* o6 z& W* S; l7 X6 ?) i% q* F

4 ~  n9 H8 h. i% v3 n/ _! A4 g6 m2 p5 O" ?, O- H0 m$ p1 u9 W" c, c

; O: e" v2 e0 m0 s

6 }8 l: c( ?. C$ l7 X6 A$ o: d% x