Python基础教程学习笔记第二章：列表和元组

第二章

本章新概念：数据结构--是通过某种方式组织在一起的数据元素的集合。其中数据元素可以是数字或字符，甚至是其他数据结构。

Python中最基本的数据结构是序列（sequence）。序列中每个元素被分配一个序号——即元素的位置，也称为索引。

本章会对序列做一个概览；  之后讲解对所有序列（包括元组和列表）都通用的操作，这些操作同样适用于字符串； 接着开始学习如何使用列表，同时看看它有什么特别之处。最后讨论元组。

2.1 序列概览

Python 中包含六种内建的序列（列表、元组、字符串、Unicode字符串、buffer对象、xrange对象）。本章重点讨论最常用两种：列表和元组

列表和元组最主要的区别是，列表可以修改，元组不能。一般，在几乎所有情况下列表都可以替代元组（例外：元组作为字典的键。键不可改，所以不能用列表）

1. 在操作一组数值的时候，序列很好用。如下列表：

>>> edward = ['Edward Gumby', 42]

2. 同时序列也可包含其他序列。如下列表：

>>> edward = ['Edward Gumby', 42]

>>> john = ['John Smith', 50]

>>> database = [edward, john]

>>> database

[['Edward Gumby', 42], [John Smith', 50]]

2.2 通用序列操作

所有序列类型都能进行的操作：分片、索引、加、乘和检查某元素的成员资格。Python中还有计算序列长度、找到最大元素和最小元素的内建函数。

2.2.1 索引：序列中所有元素都有编号——从0开始递增

字符串的索引：

>>> greeting = 'Hello'

>>> greeting[0]

'H'

>>> greeting[-1]

'o'

#涉及代码清单2-1 索引示例

2.2.2 分片 ：访问一定范围内的元素。

>>> numbers = [1,2,3,4,5,6,7,8,9,10]

>>> numbers[3:6]

[4,5,6]

>>> numbers[0:1]

[1]

分片操作的实现需提供两个索引为边界：第一个索引包含在分片内，第二个不包含在内。

1. 优雅的捷径

要索引最后三位：

>>> numbers[7:10]

[8,9,10]

索引10指向第十一个元素——这个元素其实不存在，但是要包含最后一位就要这样设置。其实还可以：

>>> numbers[7:]

[8,9,10]

当从列表末尾开始计数时：

>>> numbers[-3:-1]

[8,9]

>>>numbers[-3:0]

[]        #列表从前向后为排列顺序，分片中前一个索引对应元素要比后一个索引对应元素先出现才可以，否则就是一个空序列

捷径

>>> numbers[-3:]

[8,9,10]

>>> numbers[:3]

[1,2,3]

>>> numbers[:]

[1,2,3,4,5,6,7,8,9,10]  #复制整个序列

#代码清单2-2 分片示例

2. 更大的步长：分片默认步长为1 ——s[index1:index2:step]

>>> numbers[0:10:2]

[1,3,5,7,9]

>>> numbers[3:6:3]

[4]

步长为负数时，必须开始索引大于结束索引，然后会从右到左提取元素，否则就返回空列表：

>>> numbers[8:3:-1]

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

>>> numbers[10:0:-2]

[10,8,6,4,2]

>>> numbers[11:0:-2]

[10,8,6,4,2]

>>> numbers[9:0:-2]

[10,8,6,4,2]

>>> numbers[::-2]

[10,8,6,4,2]

2.2.3 序列相加：两种同类型的序列才能进行连接操作。

>>> [1,2,3] + [4,5,6]

[1,2,3,4,5,6]

2.2.4 乘法：用数字x乘以一个序列会生成一个新的序列——是原来的序列重复x次

>>>'Python' * 5

'PythonPythonPythonPythonPython'

>>> [42] * 3

[42,42,42]

None、空列表和初始化

空列表：（[]）

>>> Sequence = [None] * 4

[None, None, None, None]   #初始化一个长度为4的空列表

#代码清单2-3 序列（字符串）乘法示例

2.2.5 成员资格：检查一个值是否在序列中

使用in运算符来实现——其检查某条件是否为真，然后返回相应的值：条件为真返回True,条件为假返回False。布尔运算符，真值叫做布尔值

>>> users = ['mlh', 'foo', 'bar']

>>> raw_input('Enter your user name: ') in users     #执行某些安全策略，检查用户名是否正确或存在

Entr your user name: mlh

True

>>> subject = '$$$ Get rich now!!! $$$'       #垃圾邮件过滤的一部分

>>> '$$$' in subject       #in运算符可以检查长度大于1的字符串

True

涉及代码清单2-4  序列成员资格示例

2.2.6 长度、最小值和最大值：内建函数——len()、min()、max()

len返回序列所包含元素数量，min返回序列中最小的元素，max返回序列中最大的元素

>>> numbers = [100, 34, 678]

>>> len(numbers)

3

>>> min(numbers)

34

>>> max(numbers)

678

min和max以多个数字直接作为参数也可以：

>>> min(1,4,5,223,23,6)

1

2.3 列表：Python的苦力

列表不同于元组和字符串的地方：列表是可变的（mutable）,且有很多有用的、专门的方法。

2.3.1 list 函数：将序列转换为列表

list函数适用于所有序列，不只是字符串。

>>> list('Hello')

['H', 'e', 'l', 'l', 'o']

''.join(somelist)可将一个由字符组成的列表转化为字符串    #前边两个单引号是必须的

2.3.2 基本的列表操作

1. 改变列表：元素赋值

>>> x = [1,1,1]

>>> x[1] = 2

>>> x

[1,2,1]

2. 删除元素：使用del语句实现

>>> names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl']

>>> del names[2]

>>> names

['Alice', 'Beth', 'Dee-Dee', 'Earl']                    #此时列表长度也发生了变化

3. 分片赋值

>>> name = list('Perl')

>>> name

['P', 'e', 'r', 'l']

>>> name[2:] = list('ar')

>>> name

['P', 'e', 'a', 'r']

#可使用与原序列不等长的序列将分片替换

>>> name = list('Perl')

>>> name[1:] = list('ython')

>>> name

['P', 'y', 't', 'h', 'o', 'n']

#可直接插入新元素

>>> num = [1, 5]

>>> num[1:1] = [2,3,4]

>>> num

[1, 2, 3, 4, 5]

#也可以删除元素

>>> num = [1, 2, 3, 4, 5]

>>> num[1:4] = []

>>> num

[1, 5]

###步长不为1时，替换列表长度要和截取列表长度一致。。。。自行摸索

2.3.3 列表方法

方法是一个与某些对象有紧密联系的函数，对象可能是列表、数字、字符串或其他类型的对象。一般方法可这样调用：对象.方法（参数）

1.append

append方法用于在列表末尾追加新的对象

>>> lst = [1, 2, 3]      #变量名要定义有意义，可以代表它所包含的内容

>>> lst.append(4)

>>> lst

[1, 2, 3, 4]                   #append是直接改变原列表，而不是返回一个修改过的新列表

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

>>> ['to', 'be', 'or', 'not', 'to', 'be'],count('to')

2

>>> x = [[1, 2], 1, 1, [2,1,[1,2]]]

>>> x.count(1)

2

>>> x.count([1,2])

1

3. extend：在列表末尾一次性追加另一个序列的多个值——用新列表扩展原有列表

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

>>> b = [4, 5, 6]

>>> a.extend(b)

>>> a

[1, 2, 3, 4, 5, 6]         #修改了原始列表a,而a+b则返回一个全新的列表，而a不会发生改变

4. index：从列表中找出某个值第一个匹配项的索引位置

>>> knights = ['We', 'are', 'the', 'knight', 'who', 'say', 'ni')

>>> knights.index('who')

4

5, insert：将对象插入到列表中

>>> numbers = [1, 2, 3, 5, 6, 7]

>>> numbers.insert(3, 'four')           #3代表索引位置，‘four‘代表插入的元素

>>> numbers

[1, 2, 3, 'four', 5, 6, 7]

6. pop：移除列表中的一个元素（默认是最后一个），并且返回该元素的值

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

>>> x.pop()

3                                   #pop是唯一一个既能修改列表，又能返回元素值的列表方法

>>> x

[1, 2]

>>> x.pop(0)

1

>>> x

[2]

###pop方法可实现一种常见的数据结果——栈：原理就像堆盘子，只能在顶部放一个盘子，同样也只能从顶部拿走一个盘子。最后放入的栈最先被移除（此原则称为LIFO，即后进先出）。上述两个栈操作：放入和移除，有大家都认可的称谓——入栈（push）和出栈（pop），Python以append代替入栈方法，

7. remove ：移除列表中某个值的第一个匹配项

>>> x = ['to', 'be', 'or', 'not', 'to', 'be']

>>> x.remove('to')

>>> x

['be', 'or', 'not', 'to', 'be']

8. reverse：将列表中的元素反向存放

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

>>> x.reverse()

>>> x

[3, 2, 1]

9. sort：原位置对列表进行排序——改变原来的列表，使其按一定顺序排列，而不是返回一个已排序的列表副本

>>> x = [4, 6, 2, 1, 7, 9]

>>> x.sort()

>>> x

[1, 2, 4, 6, 7, 9]

# sort方法修改了x却返回了空值

>>> x = [4, 6, 2, 1, 7, 9]

>>> y = x.sort()

>>> print y

None

# 获取已排序的列表副本的一个方法是，使用sorted函数

>>> x = [4, 6, 2, 1, 7, 9]

>>> y =  x.sorted()

>>> x

[4, 6, 2, 1, 7, 9]

>>> y

[1, 2, 4, 6, 7, 9]

# 想把一些元素按相反的顺序排列，可以先用sort(或sorted)，然后在调用reverse方法。或者也可以使用reverse参数。

10. 高级排序：希望元素按照特定的方式进行排序，可以通过compare（x,y）的形式自定义比较函数

compare函数会在x<y时返回负数，x>y时返回正数，如果x=y则返回0（根据你的定义）。定义好函数就可以提供给sort方法做参数了。内建函数cmp就是上述比较函数的形式

# 参数cmp

>>> cmp(42, 32)

1

>>> cmp(99, 100)

-1

>>> cmp(10, 10)

0

>>> numbers = [5, 2, 7, 9]

>>> numbers.sort(cmp)

>>> numbers

[2, 5, 7, 9]

# 参数key:将一个函数赋予key，此函数为每一个元素创建一个键，然后所有元素根据键来排序。例如以元素长度进行排序，那就可以以len作为键函数

>>> x = ['aardvark', 'abalone', 'acme', 'add', 'aerate']

>>> x.sort(key = len)

>>> x

['add', 'acme', 'aerate', 'abalone', 'aardvark']

# 关键字参数reverse，是简单的布尔值，用来指明列表是否要进行反向排序

>>> x = [4, 6, 2, 1, 7, 9]

>>> x.sort(reverse = True)         #赋予参数reverse布尔值True,表示要反向排序

>>> x

[9, 7, 6, 4, 2, 1]

2.4 元组： 不可变序列

语法很简单：用逗号分隔了一些值，就自动创建了元组。

>>> 1, 2, 3

(1, 2, 3)            #元组是（大部分时候是）通过圆括号括起来的，空元组——（）

实现包括一个值的元组——必须加逗号，即使只有一个值

>>> 42

42

>>> 42,

(42,)

只加括号，不加逗号没用

>>> 3 * (40 +2)

126

>>> 3 * (40 + 2,)

(42, 42, 42)

2.4.1 tuple函数：以一个序列为参数并将其转化为元组。如果参数本来为元组，那该参数会原样返回。

>>> tuple([1, 2, 3])

(1, 2, 3)

>>> tuple('abc')

('a', 'b', 'c')

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

(1, 2, 3)

2.4.2 基本元组操作——创建元组、访问元组及序列的通用操作

>>> x = 1, 2, 3

>>> x[1]

2

>>> x[0:2]

(1, 2)

2.4.3 意义——不可替代有两个重要原因

1） 元组可以在映射（和集合的成员）中当做键使用——列表不行

2） 元组为很多内建函数和方法的返回值——即必须对元组进行处理。

2.5 小结

序列：一种数据结构，典型有：列表、字符串、元组。

成员资格：in操作符检查一个值是否存在于序列（或其他容器），对字符串其可以查找子字符串

方法：一些内建类型（如列表、字符串，元组不包含在内）具有很多有用的方法。

2.5.1 本章的新函数

cmp(x, y)         比较两个值

len(seq)           返回序列的长度

list（seq）      把序列转换成列表

max（args）   返回序列或参数集合中的最大值

min(args)         返回序列或参数集合中的最小值

reversed(seq)  对序列进行反向迭代

sorted(seq)      返回已排序的包含seq所有元素的列表

tuple(seq)        把序列转化为元组

#本章还有许多列表方法需要多加运用熟练