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 permission
True
>>> 'x' in permission 
False

#检测字符串是否在字符串中，例如过滤垃圾邮件
>>> subject = '$$$ Get rich now!!! $$$'
>>> '$$$' in subject
True

#检测序列元素是否在序列中，例如检测用户是否合法，用于安全策略
>>> user=['aaa', 'bbb', 'ccc']
>>> raw_input("What's your name: ") in user
What's your name: abc
False
>>> raw_input("What's your name: ") in user
What's your name: aaa
True

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] = 2
   Traceback (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. 元组作为很多内建函数和方法的返回值。