运算符

终于还是决定在最前面介绍一下 python 的这些个运算符先，基本上都是些很常见的符号， 只要有基本的计算机和数学常识，所以理解起来应当不会有什么困难。

由于 python 支持所谓的运算符重载，某些类型为了方便可能会改变一些运算符本来的含义， 比如加号，对于整数来说它就是数学中的加法，而对于字符串来说确实字符串之间的连接。 这些特殊的含义先放到一边，等后面遇到了我们再另行介绍。 这里先介绍的都是这些运算符最直观、最基本的含义。

数值运算	加 + 、减 - 、乘 * 、除 / 、取模 % 、指数运算 ** 、取相反数 -
位运算	按位取反 ~ 、按位与 & 、按位或 | 、按位异或 ^ ，左移 << 、右移 >>
比较操作	小于 < 、大于 > 、等于 == 、大于等于 >= 、 小于等于 <= 、不等于 <> 、不等于 !=
布尔操作	not 、 and 、 or

>>> 10/3
3
>>> 10%3
1
>>> 2**3
8
>>> a=1
>>> -a
-1

>>> 2>>1   # 0010 -> 0001
1
>>> 2<<1   # 0010 -> 0100
4
>>> 5 | 10 # 0101 | 1010 -> 1111
15
>>> 5 & 10 # 0101 & 1010 -> 0000
0

>>> 1 < 2
True
>>> 'b'>'a'
True
>>> 1!=2
True

（这几个例子好弱智啊！= ="）

布尔

True 或者 False ，这就是布尔类型，干脆利落。

在 python 中，所有对象在需要的时候都可以自动地转换成布尔对象， 所以那些虽然看上去是针对布尔对象的操作，实际上可以操作任何对象， python 会按照一定规则自动地将对象转换成合适的 True 或者 False 。 这一点常常让人觉得布尔对象神龙见首不见尾，似乎无处不在却又很少见到其真正的本尊。 其实通过 bool 对象的构造函数，你就可以方便地检查普通对象到布尔对象的转换规则， 看看究竟哪些对象是 True ，哪些对象是 False ：

>>> bool(1)
True
>>> bool(0)
False
>>> bool('hello')
True
>>> bool('')
False
>>> class FooBar(object):      # 这里涉及到 class ，请参考类与对象，或者直接跳过。
...     def __nonzero__(self):
...         return False
...
>>> foobar = FooBar()          # 创建 FooBar 类的实例。
>>> bool(foobar)
False
>>> 0 or 0L or 0.0 or 0j or '' or () or [] or {} or False
False

如果你拥有基本的逻辑知识的话，从上面最后一句代码中，应该就能看出那些参与 or 操作的对象都是 False ， 因为 or 的规则是只要有一个对象为真，整个表达式就为真了。

任何涉及布尔的地方总免不了 not 、 and 、 or 这三个运算。 python 的布尔类型自然也不例外。 不过在这里他们虽然叫还是叫做布尔运算，但像刚才说过的，任何对象都可以进行这种所谓的“布尔”运算， 而且 python 又对这三种运算的语义做了细微的调整，在保留布尔操作本身语义的同时，大大增强了他们的灵活性与实际用途。

python 中这三种运算的详细规则定义如下：

示例：:

>>> not True
False
>>> def get_length(s):
...     # 等价于:
...     # if(s==None):
...     #     return len('None')
...     # else:
...     #     return len(s)
...     return len(s==None and 'None')
...
>>> get_length(None)
4
>>> # get_length 函数也可以写成这样：
>>> def get_length(s):
...     # 等价于:
...     # if(s):
...     #     return len(s)
...     # else:
...     #     return len('None')
...     return len(s or 'None')
...
>>> get_length(None)
4

and or 在实际的编程中是很有用的，在习题一中你还会看到它们的结合甚至可以模式 c 语言中的三元操作符 ? : 。

另外，进行数值运算的时候布尔对象会自动地转换成整数， True 对应的是 1 ， False 对应的是 0 ：

>>> int(True)
1
>>> int(False)
0
>>> True+1
2
>>> False+1
1

整数

如果此前你还没有接受过其他编程语言的“熏陶”的话，那你大可把 python 的整数就当作你小学数学学的那个整数的概念来理解了。 而对于不幸受过某些编程语言熏陶的朋友来说，有一点是必须要注意的： python 的整数只有一个（不像 c 语言还分 short long 之类的），它也没有大小的限制！

>>> 1
1
>>> 9999999999999999999999
9999999999999999999999L
>>> 99999999999999999 * 9999999999999999999
999999999999999989900000000000000001L

>>> a = 10
>>> b = 10
>>> id(a)
11163620
>>> id(b)
11163620
>>> a = 999999999999999999
>>> id(a)
11314456
>>> b = 999999999999999999
>>> id(b)
11314960   # 显然 b 与 a 不是一个对象。

浮点数

python 的浮点数就是数学中的小数， c 语言中的 double 。

在数值运算中，整数与浮点数运算的结果是浮点数，这就是所谓的“提升规则”， 也就是“小”类型会被提升为“大”类型参与计算，许多语言都是这样的。 从这个角度去看，也就不难理解为什么布尔对象参与数值运算时会被自动地转换成整数了 ;-)

>>> 3/2
1
>>> 3/2.0
1.5

复数

复数~~，貌似终于升级到高中的层次了 = =" 如果你不知复数为何物，大可直接跳过，好像一般的开发中也用不上这玩意。

既然你懂复数的话，你应该会发现 python 的复数其实非常直观，和数学中学到的没有什么不同。

>>> 1+1j
(1+1j)
>>> 1+1j +3
(4+1j)
>>> 1+1j +3j
(1+4j)
>>> (1+1j)*5
(5+5j)
>>> (1+1j)*(2+2j)
4j
>>> (1+1j)/(2+2j)
(0.5+0j)
>>> (1+1.0j)/(2+2j)
(0.5+0j)
>>> (1+1j)**(2+2j) # 指数运行，见 数值运算_
(-0.26565399884924118+0.31981811385613623j)

字符串转义

那字符串里要是既有单引号又有双引号怎么办？答案就是字符串转义：

>>> 'My \'name\' is "python"!'
'My \'name\' is "python"!'

我们总是要面对各种各样的符号，有的符号比如字母数字，可以正常地显示出来， 但是有些特殊字符却不能那么方便表示出来，于是人们发明了转义。 大意就是通过转义符 \ 改变一些普通符号的含义，让他们能够表达一些特殊字符。

Python 字符转义的规则与 c 语言基本一样，学过 c 的同学有福了。 下面这个表列出所有转义符及其简要说明， 要是觉得这点简要的解释不过瘾的话， 直接跑到 python shell 下面去试验一下，马上就清楚了：

>>> print '\a' # 发出"滴"声

>>> print 'aa\bbb'
abb
>>> print 'a\tb\nab'
a       b
ab

序列操作

其实是要讲 字符串 的，不过由于许多字符串对象的接口其实都来自于序列类型， 而且后面还会介绍到其他的序列类型，不如就在第一个序列类型对象出现的地方把它介绍掉吧。

序列类型（Sequence Types）其实是一个抽象接口， 内置类型中实现了这一接口的有字符串、Unicode 对象、元组、列表、 buffer、xrange。所谓抽象接口，就是它定义了一系列的方法和操作， 所有实现这一接口的对象都支持这些方法和操作。

以下便是字符串对这些操作的具体实现，其他序列类型虽然都支持相同的操作， 不过不同类型实现的同样操作肯定是会有不同的具体含义的（你可以想象一下整数的 + 和字符串的 + ）， 虽然大部分你可以通过直觉和常识举一反三，不过也不绝对。 所以对后面遇到的每个序列类型我们都会把这些操作重新拿出来介绍一遍。

>>> 'python' in 'I love python!'
True
>>> 'c' not in 'I love python!'
False

>>> 'I '+'love '+'python!'
'I love python!'

>>> print 'I love python!\n'*3
I love python!
I love python!
I love python!

>>> 'python'[0]
'p'
>>> 'python'[3]
'h'
>>> 'python'[-1]
'n'
>>> 'python'[-3]
'h'

>>> 'python'[0:6:2] # 完整版本
'pto'
>>> 'python'[0:6]   # 忽略 step
'python'
>>> 'python'[:3]    # 忽略 start 和 step
'pyt'
>>> 'python'[3:]    # 忽略 end 和 step
'hon'
>>> 'python'[:]     # 全部忽略
'python'

常用字符串操作

上面这一节讲的其实已经是属于常用字符串操作了，不过那些是所有序列对象都共同拥有的东西， 而这一节要介绍的是专门为字符串提供的操作。

>>> dir(str)
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__
ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__g
t__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__
', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '
__rmul__', '__setattr__', '__str__', 'capitalize', 'center', 'count', 'decode',
'encode', 'endswith', 'expandtabs', 'find', 'index', 'isalnum', 'isalpha', 'isdi
git', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lst
rip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit'
, 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', '
translate', 'upper', 'zfill']

其实里面许多的方法，都是看到名字就能联想到其功能的。 稍微复杂点的方法，只要在 python shell 里面做点实验也都能猜个八九不离十。 如果还剩下些什么疑问呢，就到这里来找答案吧。

>>> a = 'python'
>>> b = 'python'
>>> id(a)
11361984
>>> id(b)
11361984

>>> 'I '+'love '+'python!'
'I love python!'

>>> ' '.join(['I', 'love', 'python!'])
'I love python!'

>>> '--'.join(['I', 'love', 'python!'])
'I--love--python!'

>>> 'I love python!'.split(' ')
['I', 'love', 'python!']
>>> 'I--love--python!'.split('--')
['I', 'love', 'python!']

>>> 'I love     python!'.split(' ') # 使用空格分割
['I', 'love', '', '', '', '', 'python!']
>>> 'I love     python!'.split()    # 默认分割策略
['I', 'love', 'python!']

>>> 'I love python!'.split(' ', 1)
['I', 'love python!']

>>> 'I love python!'.rsplit(' ', 1)
['i love', 'python']

>>> 'Python'.upper()
'PYTHON'
>>> 'Python'.lower()
'python'
>>> 'Python'.swapcase()
'pYTHON'
>>> 'the python book'.title()
'The Python Book'

>>> 'python'.islower()      # 是否都是小写
True
>>> 'PYTHON'.isupper()      # 是否都是大写
True
>>> 'The Python Book'.istitle() # 是否 ... (参考上面对 title 方法的解释)
True
>>> 'python'.isalpha()      # 是否都是字母
True
>>> 'python12'.isalnum()    # 是否由字母和数字组成
True
>>> '42'.isdigit()          # 是否都是数字
True
>>> '  '.isspace()          # 是否都是空格
True
>>> ''.islower() or ''.isupper() or ''.istitle() or ''.isalpha() or ''.isdigit() or ''.isspace()
False

>>> 'I love python!'.find('love')
2
>>> 'I love python!'.find('c')
-1
>>> 'I love python!'.index('c')
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ValueError: substring not found
>>> 'python is pythonic!'.find('python')
0
>>> 'python is pythonic!'.rfind('python')
10

>>> 'python'.startswith('pyt')
True
>>> 'python'.endswith('hon')
True
>>> 'python'.startswith('th', 2)
True
>>> 'python'.endswith('th', 0, -2)
True

>>> 'I love python'.replace('python', 'c')
'I love c'

>>> 'python'.ljust(10)
'python    '
>>> 'python'.rjust(10)
'    python'
>>> 'python'.center(10)
'  python  '

>>> (
...  ( ('name', 10), ('addr', 20) ),
...  ( ('hy', 10), ('whu', 20) ),
...  ( ('zq', 10), ('beijin', 20) ),
... )
((('name', 10), ('addr', 20)), (('hy', 10), ('whu', 20)), (('zq', 10), ('beijin'
, 20)))
>>> print '\n'.join(''.join(s.ljust(width) for s, width in row) for row in _)
name      addr
hy        whu
zq        beijin

字符串与字节流

Unicode 字符串

Unicode 是一个很重要的话题，也是一个现代程序员所必备的知识之一。

说起 Unicode ，那还是在很久，很久以前 ...

话说老美刚整出计算机的那会，老美还在说英文（当然，现在也还在说英文），大家知道，英文 abc 总共也没几个字符， 就算加上一些稀奇古怪的!@#$%^&这样的字符， 也就那么些了，最后把各种奇怪字符都加在一起算了一下，大概 127 个， 而一个字节能表达 256 种字符呢，用一个字节表示一个字符都还绰绰有余。 当时谁都觉得用一个字节表示一个字符真好。这种编码方式叫做 ASCII 。

后来计算机便传入了中国和许多其他国家，很快就遇到了一个大问题，汉语言文字博大精深，又岂是小小一个字节能表达得了的？ 于是有人发明了用两个字节表达汉字的编码方法，叫做 gbk 。这种现象同样也在其他非英语国家上演着。 大家都用着各自不同的互相冲突的编码方式，这给交流带来极大不便，此时的世界亟需一个统一的标准。

于是 Unicode 便应运而生了！Unicode 定义了一个大表，里面包含了全世界所有已知的字符，然后给这些字符编号，每个字符对应一个数字， 也就是所谓的代码点（code-point）。

需要注意的是 Unicode 本身是不在乎字符在计算机上是如何存储的，一个字节还是两个字节还是三个字节与 Unicode 无关， 你可以采取各种存储策略，甚至你可以直接把字符在 Unicode 大表中的编号——也就是代码点——来当作字符在计算机中的表示， 而规定如何存储 Unicode 字符的规范就叫做编码！

现在世界上的编码成百上千，以前的 gbk 在现在 Unicode 新环境下也仍然存在，不过它只能处理 Unicode 字符的一部分了。 如果希望自己的程序能够跨越国界的话，最好还是使用一种能够处理所有 Unicode 字符的全能编码。 最流行的全能编码应该是 utf-8 了，它使用一种变长的存储方式，对传统的 ASCII 字符还是使用一个字节来存储， 这样那些英文国家的程序可以完全不受影响。当然这样的话它就要使用更多的字节来存储其他非英文字符了。

在 python 中定义一个 Unicode 字符串非常简单，在普通字符串前面加一个 u 即可， 还可以使用转义符 \u 直接使用代码点来定义 Unicode 字符串：

>>> u'派松'
u'\u6d3e\u677e'
>>> print u'\u4e2d\u56fd'
中国
>>> print u'派松\u4e2d\u56fd'
派松中国

>>> import sys
>>> sys.getdefaultencoding()
'ascii'

使用 encode （编码） decode （解码） 方法，就可以在普通字符串和 Unicode 字符串之间进行转换， 两个方法的原型分别为： encode( [encoding[,errors]]) 和 decode( [encoding[,errors]]) 这两个方法都接受两个可选参数，第一个是编码名称，默认是系统默认编码， 第二个参数是个字符串，用来指定错误处理方式，可以使用的值有：

 >>> print u'派\uffff松'.encode('gbk', 'strict')
 Traceback (most recent call last):
   File "<stdin>", line 1, in ?
 UnicodeEncodeError: 'gbk' codec can't encode character u'\uffff' in position 1:
 illegal multibyte sequence
>>> print u'派\uffff松'.encode('gbk', 'ignore')
 派松
 >>> print u'派\uffff松'.encode('gbk', 'replace')
 派?松
 >>> '派\xff\xff松'.decode('gbk', 'replace')
 u'\u6d3e\ufffd\u677e'
 >>> print u'派\uffff松'.encode('gbk', 'xmlcharrefreplace')
 派&#65535;松
 >>> print u'派\uffff松'.encode('gbk', 'backslashreplace')
 派\uffff松

直接在普通字符串中使用中文时，使用的编码方式取决于源代码文件本身所使用的编码， 在中文平台上一般默认都是 gbk ，中文平台的 console 中一般也都是 gbk。 下面我们来体验几种不同编码之间的差异：

>>> u'派松'                 # 无编码
u'\u6d3e\u677e'
>>> '派松'                  # 默认的 gbk 编码
'\xc5\xc9\xcb\xc9'
>>> u'派松'.encode('utf-8') # 使用 encode 从 Unicode 字符串转换成 普通字符串
'\xe6\xb4\xbe\xe6\x9d\xbe'
>>> '派松'.decode('gbk')    # 使用 decode 从普通字符串转换成 Unicode 字符串
u'\u6d3e\u677e'
>>> len(u'派松')
2
>>> len('派松')
4
>>> len(u'派松'.encode('utf-8'))
6

我们说过 Unicode 本身不定义字符在计算机中的表现方式，所以当我们需要将 Unicode 字符串保存到文件， 或是在网络中传输，或是从 console 中 print 出来时，都需要以某种方式编码 Unicode 字符串先。 不过很多操作面对 Unicode 字符串时都能够智能地选择某种默认编码进行处理， 比如在一般的中文平台上， print 默认便使用 gbk 来进行输出：

>>> print u'\uFFFF'
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
UnicodeEncodeError: 'gbk' codec can't encode character u'\uffff' in position 0:
illegal multibyte sequence

还有要注意的一点就是在源代码文件中定义包含非 ASCII 字符的 Unicode 字符串时， 最好是文件的顶部（第一行或第二行）用注释的方式定义一下此文件本身所使用的编码， 因为 python 虚拟机在解析的时候需要从编码后的字符串解码得到 Unicode 字符串， 所以如果不知道源文件本身使用的编码，虚拟机就使用默认的 ASCII 进行处理， 这样就很可能出现乱码甚至是抛出异常。

对于大部分编辑器都应该这么写：

#!/usr/bin/python
# -*- coding: utf-8 -*-
python = u'派松'

使用 vim 的同学可以这样写：

#!/usr/bin/python
# vim: set fileencoding=utf-8 :
python = u'派松'

上面两种写法都可以同时被 python 虚拟机和相应的编辑器识别 （当然其中的 utf-8 可以换成任何合法的编码名称）。

字符串格式化

上面已经介绍过几种构造字符串的方法：不适合大量使用的 + 操作和字符串的 join 方法。 他们都可以把几个小字符串拼接成一个大字符串。 但是它们并不能很好得处理其他类型的对象的字符串表示，换句话说就是“字符串格式化”问题。

简单的说字符串格式化就是将其他的对象以合适的格式转换为字符串的过程。 python 的字符串对象重载了操作符 % ，用以实现该功能。

先给大家看几个例子：

>>> '%d'%1          # %d 显示一个整数
'1'
>>> '%3d'%1         # %3d 用空格补齐至3个字符宽
'  1'
>>> '%03d'%1        # %03d 用 0 补齐至3个字符宽
'001'
>>> '%f'%1.0        # %f 显示一个浮点数
'1.000000'
>>> '%10f'%1.0      # %10f 用空格补齐至10个字符宽
'  1.000000'
>>> '%010f'%1.0     # %010f 用 0 补齐至10个字符宽
'001.000000'
>>> '%010.4f'%1.0   # %010.4f 只显示4位小数
'00001.0000'
>>> '%*.*f'%(10, 1, 1.0)
'       1.0'
>>> '%s - %03d' % ('python', 5)
'python - 005'
>>> '%03d - %010.4f'%(1, 1.0)
'001 - 00001.0000'

是不是觉得很神奇？哈哈，详尽的规则且听我慢慢道来。

拿这个例子来说吧： '%s - %03d' % ('python', 5) ，其中 '%s - %03d' 叫做格式字符串， 它定义了两个格式指示符 %s 和 %03d ，操作符 % 右边是一个容器类型（这里用的是元组，实际上也可以是列表、字典等）， 字符串格式化的过程其实就是使用容器中的对象，根据格式字符串定义的格式，构造出一个新字符串的过程。每一个格式指示符都对应 着容器中的某一个对象，定义将该对象转换成字符串的格式，通常格式指示符与容器中的对象通过其位置一个一个对应， 上面所有例子都是这样的。但其实格式指示符还可以通过名字显示的指定其格式化的目标对象，像这样：

>>> '%(name)s is %(name)s'%{'name':'python'}
'python is python'
>>> '%(name)s is %(name)s'%{'name':'ruby'}
'ruby is ruby'

% 右边的容器是一个字典，这在后面还有详细介绍。

格式指示符从左到右的组成成分如下：

• 格式指示符以 % 开头
• 映射名字(可选)，是小括号括起来的一个字符串
• 特殊转换标记(可选)，可能只对某些类型的转换起作用
• 最小宽度(可选)，如果指定一个 * ，则获取下一个值作为最小宽度。（* 号规则详见下面示例）
• 精度(可选)，. 号加一个精度值，和上面一样，如果精度值指定为 * ，则获取下一个值作为精度。
• 长度修正符(可选)，可以是 h、l 或 L，不过在 python 中他们完全不起任何作用 ;-)
• 转换类型

所有支持的转换类型及其含义如下：

上面说格式标识符时简单提到 * 号规则，自然语言不方便表达，还是用代码来说话吧：:

>>> '%7.3f'%(1.5,)
'  1.500'
>>> '%*.3f'%(7, 1.5)
'  1.500'
>>> '%*.*f'%(7, 3, 1.5)
'  1.500'
>>> '%*.*f'%(8, 4, 1.5)
'  1.5000'

不过显然了，如果你在格式标识符中使用了 * 的话，后面的容器就不能使用字典了， 这样格式符也就不能通过名字来指定目标对象，只能按照出现位置一一对应了。

元组

通过逗号分隔的一些对象，这就是元组了：

>>> 1,2,3
(1, 2, 3)

不过通常我们都用一对小括号扩着，主要是为了避免歧义：

>>> (1,2,3)
(1, 2, 3)

千万要注意的是，如果元组中只有一个对象，一定记得要在对象后面加一个逗号，因为否则的话， python 会把它当作一个对象，就算加了括号也没用！

>>> 1
1
>>> 1,
(1,)
>>> (1)
1
>>> (1,)
(1,)

首先元组属于序列类型，自然就拥有所有的序列操作：

>>> (1,2,3)+(5,6,7)
(1, 2, 3, 5, 6, 7)
>>> (1,2)*3
(1, 2, 1, 2, 1, 2)
>>> 2 in (1,2)
True
>>> (1,2,3,4,5,6,7)[1:-1:2]
(2, 4, 6)

元组还是不可变对象，所以对其中的元素不能修改：

>>> (1,2,3)[0] = 0
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: object does not support item assignment

另外，元组和下面马上要介绍的列表都还支持一个非常有趣的特性，就是所谓的“并行绑定”： （上面代码中等号左边的元组都可以替换成列表，效果一样）

>>> (a, b) = (1, (2, 3))
>>> print a, b
1 (2, 3)
>>> (a, (b, c)) = (1, (2, 3))
>>> print a, b, c
1 2 3
>>> (a, b, c) = 'pyt'
>>> print a, b, c
p y t

相信聪明的你已经看出来了，当绑定一个元组/列表的时候，它会自动去绑定元组/列表中每一个元素。 这个过程甚至还是可以递归的！ 而等号右边可以是任何支持索引的数据类型，比如大家了解的序列类型就可以。

列表

使用中括号括起来的一组对象，对象之间以逗号分隔，就是列表了。 列表的中括号可不像元组的小括号那样可以省略，否则就会有歧义。

首先列表属于序列类型：

>>> [1,2,3]+[5,6,7]
[1, 2, 3, 5, 6, 7]
>>> [1,2]*3
[1, 2, 1, 2, 1, 2]
>>> 2 in [1,2]
True
>>> [1,2,3,4,5,6,7][1:-1:2]
[2, 4, 6]

列表还是可变数据类型，我们可以通过索引和切片随意修改和删除其中的元素：

>>> a = [1,2]
>>> a[0] = 0
>>> a
[0, 2]
>>> a = [1,2,3,4,5,6,7]
>>> a[1:-1:2]
[2, 4, 6]
>>> a[1:-1:2] = [0]*3
>>> a
[1, 0, 3, 0, 5, 0, 7]
>>> del a[1:-1:2]
>>> a
[1, 3, 5, 7]

此外，列表还提供了许多强大的操作。

>>> a = [1, 2, 3]
>>> a.append(4)       # 在列表末尾追加一个对象
>>> a
[1, 2, 3, 4]
>>> a.extend([5,6,7]) # 用另一个列表来扩展这个列表
>>> a
[1, 2, 3, 4, 5, 6, 7]
>>> a.insert(0, 2)    # 在索引为 0 的位置上插入对象 2
>>> a
[2, 1, 2, 3, 4, 5, 6, 7]
>>> a.count(2)        # 计算对象出现的次数
2
>>> a.index(2)        # 返回对象第一次出现的位置
0
>>> a.index(2, 3, -1) # 后面两个参数分别为 ``start`` 和 ``end`` ，表示在列表中查找的范围，
                      # 找不到就抛出异常
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ValueError: list.index(x): x not in list
>>> a.pop()           # 返回列表中最后一个对象，并把该对象从列表中删除
7
>>> a
[1, 1, 2, 3, 4, 5, 6]
>>> a.pop(-2)         # 返回列表中位置为 -2 (也就是倒数第二个) 的对象，并把该对象从列表中删除
5
>>> a
[1, 1, 2, 3, 4, 6]
>>> a.remove(1)       # 删除列表中位置为 1 的对象
>>> a
[1, 2, 3, 4, 6]
>>> a.reverse()       # 反转列表
>>> a
[6, 4, 3, 2, 1]

>>> data = [1,3,5,2,4]
>>> data.sort()
>>> data
[1, 2, 3, 4, 5]
>>> data.sort(reverse=True) # 倒排
>>> data
[5, 4, 3, 2, 1]

>>> from datetime import datetime
>>> data = []
>>> data.append(datetime(2007, 4, 12)) # 年,月,日
>>> data.append(datetime(2003, 5, 22))
>>> data.append(datetime(2005, 2, 2))
>>> data
[datetime.datetime(2007, 4, 12, 0, 0), datetime.datetime(2003, 5, 22, 0, 0), dat
etime.datetime(2005, 2, 2, 0, 0)]
>>> data.sort(key=lambda o:o.year)
>>> data
[datetime.datetime(2003, 5, 22, 0, 0), datetime.datetime(2005, 2, 2, 0, 0), date
time.datetime(2007, 4, 12, 0, 0)]
>>> data.sort(key=lambda o:o.month) # 或者又突然改变心意，要根据月份进行排序。
>>> data
[datetime.datetime(2005, 2, 2, 0, 0), datetime.datetime(2007, 4, 12, 0, 0), date
time.datetime(2003, 5, 22, 0, 0)]

>>> data = ['Python', 'ruby', 'c', 'java']
>>> data.sort()                 # 考虑大小写排序
>>> data
['Python', 'c', 'java', 'ruby']
>>> data.sort(key=str.lower)    # 忽略大小写排序
>>> data
['c', 'java', 'Python', 'ruby']

字典

其他语言中它也常被叫做哈希表或是关联数组，在这里我们叫它字典。

语法是两个大括号，中间括着一个或多个以逗号分隔的 key:value 对，``key`` 、 value 都是普通 python 对象， 看下代码你就全明白了：:

>>> numbers = {'one':1, 'two':2, 'three':3}
>>> numbers['one']
1

组合其他数据结构：:

>>> article = {
...         'title':'About Python',
...         'author':'someone',
...         'content':'...',
...         'comments':[
...             {'title':'the article is great!',
...              'author':'annoynouse',
...              'content':'...'},
...             {'title':'the article is good!',
...              'author':'someone',
...              'content':'...'},
...         ]
... }
>>> article['title']
'About Python'
>>> article['comments']
[{'content': '...', 'author': 'annoynouse', 'title': 'the article is great!'}, {
'content': '...', 'author': 'someone', 'title': 'the article is good!'}]
>>> article['comments'][0]['author']
'annoynouse'

说白了，它其实就是一个 key、value 之间的映射，而它的好处就是，通过 key 来对 value 的查找非常快。

比如说你要管理许多员工信息，你常常需要通过员工的名字来找到相应的员工信息对象，那么你就可以建立这样一个映射， 也就是字典，来加速这一查找的过程：:

>>> usermap = {'wukong':user1, 'bajie':user2, 'tangceng':user3}
>>> usermap['wukong']
<__main__.User object at 0x00C269D0>

而如果不用字典做，你就需要对一个一个 User 对象的名字进行比较，看它是否是 'wukong' ，是则罢了， 否则的话还要继续比较下去。显然不如字典来得高效快捷。

要做字典的 key 也是要满足一定条件的，这个条件就是该对象必须是不可修改的（具体原因留作作业给大家思考）， 除了元组以为的不可变对象都能够满足要求，对于元组来说，虽然它是不可变对象，但由于它其中可以包含可变对象， 所以并不是所有元组都是不可修改，只有那些只包含不可变对象的元组才能满足做 key 的要求。

了解内幕的朋友会知道，字典内部其实会对 key 对象进行一个哈希操作，得到一个整数，以此作为 value 对象实际存储的位置， 这也就是字典能够快速查找的根本原因。python 有一个内置函数 hash``，它会调用对象的一个叫做 ``__hash__ 的方法， 来返回对象的哈希值。这个 __hash__ 方法便是真正执行这个“哈希”操作的地方，当然并非所有对象都能正常完成这个哈希操作， 原因我们刚刚说过了：:

>>> hash(1)
1
>>> hash('python')
1142331976
>>> 'python'.__hash__()
1142331976
>>> hash((1,2,3))
-378539185
>>> hash([1,2,3])
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: list objects are unhashable
>>> hash((1,2,[1,2,3]))
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: list objects are unhashable

集合

集合的概念应该很多人都不会陌生，集合中元素不能重复，集合之间可以进行并、交、补等操作。 在 python 中，对应的就是集合（ set ）数据类型。 不过集合类型可没有上面那些类型那样的语法支持，没办法，小括号中括号大括号都被用光了 ;-(

>>> set1 = set()
>>> set1.add(1)
>>> set1.add(2)
>>> set1
set([1, 2])
>>> 1 in set1
True
>>> 4 not in set1
True

>>> set1 = set([1,2])
>>> set2 = set([1,2,3])
>>> set1 <= set2    # set1 是否是 set2 的子集，set1.issubset(set2)
True
>>> set2 >= set1    # set2 是否是 set1 的超集，set2.issuperset(set1)
True

>>> set1 = set([1,2,3])
>>> set2 = set([2,3,4])
>>> set1 | set2     # 并   set1.union(set2)
set([1, 2, 3, 4])
>>> set1 & set2     # 交   set1.intersection(set2)
set([2, 3])
>>> set1 - set2     # 差   set1.difference(set2)
set([1])
>>> set1 ^ set2     # 异或 set1.symmetric_difference(set2)
set([1, 4])

集合还有一个特性就是它能保证其中的元素不重复：:

>>> set([1,2,2,3,3,4,4])
set([1, 2, 3, 4])