Python学习笔记【二】——《python基础教程》:: 列表和元组

第2章 列表和元组

2.1. 序列概述

1. python内建序列
   1）列表：可修改
   2）元组：不可修改
   3）字符串
   4）Unicode字符串
   5）buffer对象
   6）xrange对象
2. 赋值。序列元素可为数字、字符或其他序列。

>>> edward=['Edward Gumby', 42]>>> john=['John Smith', 50]>>> database=[edward, john]>>> database[['Edward Gumby', 42], ['John Smith', 50]]

2.2. 通用序列操作

索引（indexing）、分片（slicing）、加（adding）、乘（multiplying）、检查某元素是否属于序列（成员资格）、计算序列长度、找出最大和最小元素、迭代（iteration）。

2.2.1. 索引

1. 获取某个元素，假设序列名为seq，序列索引用法为seq[n]。
2. 索引编号对应关系如下，假设序列长度为N：

正序 0 1 2 … N-3 N-2 N-1 倒叙 -N -(N-1) -(N-2) … -3 -2 -1

- 可见，seq[m] = seq[-(N-m)]。

3.若函数返回序列，可直接对返回结果进行索引。

>>>function()[m]

2.2.2. 分片

1. 访问一定范围内元素，假设序列名称为seq，长度为N。
2. 隐式步长
   
   1. 用法：seq[m:n]，提取序列中从第m个元素到第(n-1)个元素
   2. 索引m之后的所有元素：seq[m:N]，索引N为不存在的元素，并在最后一个元素之后
   3. 空序列：seq[m:n]，当索引m比n晚出现在序列中时为空
   4. 索引m之后的所有元素：seq[m:]
   5. 索引n之前的所有元素：seq[:n+1]
   6. 整个序列：seq[:]
3. 显式步长：seq[m:n:step]
   
   1. 当step>0，m在n之前，从m到n每隔step-1提取一个元素正序显示
   2. 当step<0，m在n之后，从m到n每个|step|-1提取一个元素反序显示
   3. m与n的规则与隐式步长定义相同

2.2.3. 序列相加

加号表示序列的连接操作，只有相同类型的序列才能进行连接。

#错误语法>>> [1, 2, 3]+'world'Traceback (most recent call last):  File "<stdin>", line 1, in <module>TypeError: can only concatenate list (not "str") to list#正确语法>>> [1, 2, 3]+['world'][1, 2, 3, 'world']

2.2.4. 乘法

1. 用数字x乘以一个序列会生成新序列，新序列内容为将原序列重复x次。

   >>> [1, 2, 'abc']*5[1, 2, 'abc', 1, 2, 'abc', 1, 2, 'abc', 1, 2, 'abc', 1, 2, 'abc']

2. 空列表，占用空间但是使用空值（None）来赋值。

   >>> sequence=[None]*5>>> sequence[None, None, None, None, None]

2.2.5. 成员资格

布尔运算，运算符 in。以下为常见用法及使用环境。

#检测字符是否在字符串中，例如检测文件权限>>> permission='rw'>>> 'r' in permissionTrue>>> 'x' in permission False#检测字符串是否在字符串中，例如过滤垃圾邮件>>> subject = '$$$ Get rich now!!! $$$'>>> '$$$' in subjectTrue#检测序列元素是否在序列中，例如检测用户是否合法，用于安全策略>>> user=['aaa', 'bbb', 'ccc']>>> raw_input("What's your name: ") in userWhat's your name: abcFalse>>> raw_input("What's your name: ") in userWhat's your name: aaaTrue

2.2.6. 长度、最小值和最大值

len、min和max

2.3. 列表：Python的“苦力”

2.3.1. list函数

list（序列）将“序列”转化为列表

2.3.2. 基本的列表操作

列表适用于所有序列的标准操作（2.2节），下述操作为修改列表方法。

1. 改变列表：元素赋值

1. 使用索引为位置明确的元素赋值。

2. 不能为位置不存在的元素赋值。

   >>> seq=[None]*3#正确语法>>> seq[2] = 1>>> seq[None, None, 1]#错误语法>>> seq[3] = 2Traceback (most recent call last):  File "<stdin>", line 1, in <module>IndexError: list assignment index out of range

2. 删除元素

delete语句。用法如下：

```>>> seq=['aaa', 'bbb','ddd','ddd','eee','fff']>>> del seq[3]>>> seq['aaa', 'bbb', 'ddd', 'eee', 'fff']```

3. 分片赋值

1. 等长替换

   >>> seq = list('python')>>> seq[-2:] = list('er')>>> seq['p', 'y', 't', 'h', 'e', 'r']

2. 不等长替换

   >>> seq = list('python')>>> seq[-2:] = list('ern')>>> seq['p', 'y', 't', 'h', 'e', 'r', 'n']

3. 插入

   >>> seq = list('python')>>> seq[1:1] = list('---')>>> seq['p', '-', '-', '-', 'y', 't', 'h', 'o', 'n']

4. 删除

   >>> seq = list('python')>>> seq[1:4] = []>>> seq['p', 'o', 'n']

2.3.3. 列表方法

方法：一个与某些对象（列表、数字、字符串或其他类型对象）有紧密联系的函数。
方法调用：对象.方法 ()

1. append：列表后追加

>>> testlist=[1, 2, 3]>>> testlist.append(10)>>> testlist[1, 2, 3, 10]

2. count：统计某元素在列表中出现次数

>>> ['a', 'b', 'c', 'd', 'e', 'a', 'd', 'c'].count('c')2

3. extend： 在列表后追加另一个序列

>>> a = [1, 2, 3]>>> a.extend([4, 5, 6])>>> a[1, 2, 3, 4, 5, 6]

4. index：从列表中找出某个值第一个匹配项的索引位置。当搜索的值不存在是，触发异常。

>>> testseq = ['Tell', 'me', 'who', 'is', 'talking']>>> testseq.index('who')2>>> testseq.index('whos')Traceback (most recent call last):  File "<stdin>", line 1, in <module>ValueError: 'whos' is not in list

5. insert：对象插入到列表中

>>> numbers = [1, 2, 3, 4, 5, 6, 7]>>> numbers.insert(3, 'four')>>> numbers[1, 2, 3, 'four', 4, 5, 6, 7]

6. pop：移除列表中的一个元素（缺省为最后一个），并且返回该元素的值。

>>> testlist = [1, 2, 3]>>> testlist.pop()3>>> testlist.pop(1)2>>> testlist[1]

pop常用于栈的实现。

7. remove：移除列表中某个值得第一个匹配项，没有返回值。若要移除的值不在列表中，会触发异常。

>>> testlist = [1, 2, 3, 4, 5, 6, 7]>>> testlist.remove(4)>>> testlist[1, 2, 3, 5, 6, 7]>>> testlist.remove(4)Traceback (most recent call last):  File "<stdin>", line 1, in <module>ValueError: list.remove(x): x not in list

8. reverse：将列表中的元素反响存放，没有返回值。

>>> testlist = [1, 2, 3, 4, 5, 6, 7]>>> testlist.reverse()>>> testlist[7, 6, 5, 4, 3, 2, 1]

9. sort：在原位置对列表进行排序，没有返回值。

1. >>> testlist = [1, 4, 7, 6, 2, 3, 5]>>> testlist.sort()>>> testlist[1, 2, 3, 4, 5, 6, 7]

2. 保持原列表不变，并获取列表的有序副本方法有二：

   1. >>> x = [1, 4, 7, 6, 2, 3, 5]>>> y = x[:] #不可使用 y=x，该操作将 y 指向 x 所表示的列表；>>>          #而 x[:] 是复制整个列表>>> y.sort()>>> x[1, 4, 7, 6, 2, 3, 5]>>> y[1, 2, 3, 4, 5, 6, 7]

   2. 使用sorted函数

      >>> x = [1, 4, 7, 6, 2, 3, 5]>>> y = sorted(x)>>> x[1, 4, 7, 6, 2, 3, 5]>>> y[1, 2, 3, 4, 5, 6, 7]

2.4. 元组：不可变序列

创建元组：用逗号分割一些值，自动创建元组。

#创建元组>>> 1,2,3(1, 2, 3)>>> (4,5,6)(4, 5, 6)#创建空元组>>> ()()#创建只有一个元素的元组，必须在元素后添加“，”#错误创建示例>>> (2)2#正确创建示例>>> (2,)(2,)

2.4.1. tuple函数

以一个序列为参数并将其转换为元组。

>>> tuple('abc')('a', 'b', 'c')

2.4.2. 基本元组操作

参照其他类型序列。

2.4.3. 那么，意义何在

1. 元组可在映射（集合的成员）中作键——列表不行。
2. 元组作为很多内建函数和方法的返回值。