《Python基础教程》学习笔记 Chap2 列表和元组

1.序列概览

Python中包含6种内建序列：列表、元组、字符串、Unicode字符串、buffer对象、xrange对象。

列表和元组的主要区别：列表可以修改，元组不能修改

2.通用序列操作

所有序列类型都可以进行某些特定的操作。包括：索引（indexing）、分片（slicing）、加（adding）、乘（multiplying）以及检查某个元素是否属于序列的成员（成员资格）。除此之外，Python还有计算序列长度、找出最大元素和最小元素的内建函数。

索引

索引可以为正也可以为负。索引0表示序列最左边第一个元素，索引-1表示序列最后一个元素。

>>> greeting = 'Hello'
>>> greeting[0]
'H'
>>> greeting[-2]
'l'

分片

可以使用分片操作来访问一定范围内的元素。分片通过冒号隔开的两个索引来实现。也是左闭右开区间。例：

>>> path = 'http://my.csdn.net/my/mycsdn'
>>> path[5:-10]
'//my.csdn.net'

只要分片中最左边的索引比它右边的索引晚出现在序列中，结果就是一个空的序列。例：

>>> nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> nums[-3:0]
[]

如果分片要取得序列中结尾的元素，可以置空最后一个索引；如果要取得第一个元素，可以置空第一个索引；如果需要复制整个序列，则可以将两个索引都置空。

>>> nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> nums[-5:]
[6, 7, 8, 9, 10]
>>> nums[:4]
[1, 2, 3, 4]
>>> nums[:]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

在普通分片中，隐式设置的步长是1。步长也可以显示设置，如果步长大于1，就会跳过某些元素；如果步长为负数，那么分片就从右到左提取元素。

>>>nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> nums[0:10:2]
[1, 3, 5, 7, 9]
>>> nums[10:0:-2]
[10, 8, 6, 4, 2]

使用负数作为步长时，必须让开始点（开始索引）大于结束点。否则是一个空序列。例：

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

>>> nums[4:9:-2]
[]

序列相加

通过使用加运算符可以进行序列的连接操作。

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

两种相同类型的序列才能进行连接操作，否则会出错。例：

>>> [1,2] + "Hello"
Traceback (most recent call last):
  File "<interactive input>", line 1, in <module>
TypeError: can only concatenate list (not "str") to list

乘法

用数字x乘以一个序列会生成新的序列，而在新的序列中，原来的序列会被重复x次。

>>> 'Python ' *3
'Python Python Python '

空列表可以简单的通过两个中括号进行表示（[]）。如果想初始化一个长度为10的空列表，可以如下所示进行初始化。

>>> [None ] * 3 
[None, None, None]

None是Python中的内建值，含义是“这里什么也没有”。

成员资格

可以使用in运算符。返回的值是布尔值，True或者False。

>>> x = 'Python'
>>> 'y' in x
True
>>> '2' in x
False

>>> x = '$$$ get rich now !!! $$$'
>>> '$$$' in x
True

从Python2.3开始，in运算符也支持检查某个字符串是否在指定的字符串中。

长度、最小值和最大值

>>> nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> len(nums)
10
>>> max(nums)
10
>>> min(nums)
1

3.列表

列表是可变的，可以改变列表中的内容。

list函数

将序列转换成列表，如果本身是列表，则保持不变。

>>> list('Hello')
['H', 'e', 'l', 'l', 'o']
>>> list([1,2,3])
[1, 2, 3]

元素赋值

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

删除元素

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

分片赋值

>>> name = list('Perl')
>>> name
['P', 'e', 'r', 'l']
>>> name[2:] = list('ar')
>>> name
['P', 'e', 'a', 'r']

在使用分片赋值是，可以使用与原序列不等长的序列将分片替换，例：

>>> names = list('Python')
>>> names
['P', 'y', 't', 'h', 'o', 'n']
>>> names[1:] = list('eople')
>>> names
['P', 'e', 'o', 'p', 'l', 'e']

分片赋值语句可以在不需要替换任何元素的情况下插入新的元素，也可以通过分片赋值来删除元素。

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

append

append方法用于在列表末尾追加新的对象。它不是简单地返回一个修改过的新列表，而是直接修改原来的列表。

>>> name = list('Perl')
>>> name
['P', 'e', 'r', 'l']
>>> name.append('hello')
>>> name
['P', 'e', 'r', 'l', 'hello']
>>> name.append(['h', 'i'])
>>> name
['P', 'e', 'r', 'l', 'hello', ['h', 'i']]

count

count方法统计某个元素在列表中出现的次数

>>> x = ['1','11','1','123',['1','1',]]
>>> x.count('1')
2

extend

extend方法可以在列表的末尾一次性追加另一个序列中的多个值。即可以用心列表扩展原有的列表。

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

这个操作看起来很像连接符，两者最主要的区别是：extend方法修了了被扩展的序列，而原始的连接操作不会，它会返回一个全新的列表。例：

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> a + b
[1, 2, 3, 4, 5, 6]
>>> a
[1, 2, 3]
>>> b
[4, 5, 6]

我们也可以使用分片赋值来实现同样的结果，但是可读性不如extend方法，例：

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> a[len(b):] = b
>>> a
[1, 2, 3, 4, 5, 6]

index

index方法用于从列表中找出某个值第一个匹配项的索引位置，如果没有找到，就会引发一个异常。

>>> a = [1, 2, 3, 4, 5, 6]
>>> a.index(3)
2
>>> a.index(0)
Traceback (most recent call last):
  File "<interactive input>", line 1, in <module>
ValueError: 0 is not in list

insert

insert方法用于将对象插入到列表中。

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

insert方法的操作也可以用分片赋值来实现，只是可读性如如insert方法。

>>> a = [1, 2, 3, 4, 5, 6]
>>> a[6 : 6]= [7]
>>> a
[1, 2, 3, 4, 5, 6, 7]

pop

pop方法会移除列表中的一个元素（默认是最后一个），并且返回该元素的值。pop方法时唯一一个能既修改列表又返回元素值（除了None）的列表方法。

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

>>> a = [None ] *3
>>> a.pop()
>>> a
[None, None]

append方法和pop方法的操作结果是相反的，类似于入栈（push）和出栈（pop）。如果入栈刚刚出栈的值，最后得到的结果还是原来的栈。

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

注：如果要实现一个先进先出（FIFO）的队列，那么可以使用insert（0，...）来代替append方法。或者，也可以继续使用append方        法，但必须使用pop（0）来代替pop（）。

remove

remove方法用于移除列表中某个值的第一个匹配项。不存在列表中的元素使用remove方法时会产生异常。remove是一个没有返回值的原位置改变方法，它修改了列表却没有返回值。

>>> x = [1,2,3]
>>> x.remove(1)
>>> x
[2, 3]
>>> x.remove(1)
Traceback (most recent call last):
  File "<interactive input>", line 1, in <module>
ValueError: list.remove(x): x not in list

reverse

reverse方法将列表中的元素反向存放。该方法也改变了列表，但是不返回值。

>>> x = [1,2,3]
>>> x.reverse()
>>> x
[3, 2, 1]

sort

sort方法用于在原位置对列表进行排序。在“原位置排序”意味着改变原来的列表，从而让其中的元素能按一定的顺序排列，而不是简单地返回一个已排序的列表副本。

>>> x = [1,5,3]
>>> x.sort()
>>> x
[1, 3, 5]

高级排序

如果希望元素能按照特定的方式进行排序，那么可以通过compare（x，y）的形式自定义比较函数。compare（x，y）函数会在x < y时返回负数，在x > y时返回正数，在x = y时返回0。

>>> x = [1,5,3]
>>> x.sort(cmp)
>>> x
[1, 3, 5]

sort方法有另外两个可选的参数：key和reverse。如果要使用它们，那么就要通过名字开制定。

根据元素的长度进行排序：

>>> x = ['dfede', 'dfm;lkede', 'd15fede', 'dfejode', 'dfafeede', 'dfede15235']
>>> x.sort(key = len)
>>> x
['dfede', 'd15fede', 'dfejode', 'dfafeede', 'dfm;lkede', 'dfede15235']

根据reverse值来排序

>>> x = ['dfede', 'dfm;lkede', 'd15fede', 'dfejode', 'dfafeede', 'dfede15235']
>>> x.sort(reverse = True)
>>> x
['dfm;lkede', 'dfejode', 'dfede15235', 'dfede', 'dfafeede', 'd15fede']
>>> x = [1,5,89,4,6,715,1655,8615]
>>> x.sort(reverse=True)
>>> x
[8615, 1655, 715, 89, 6, 5, 4, 1]

4.元组

元组不能修改。创建元组的语法很简单：使用逗号隔开一些值，就自动创建了元组。元组大部分时候是通过圆括号括起来的。

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

空元组可以用没有包含内容的两个圆括号来表示：

>>> ()
()

一个值的元组也要加逗号，不加逗号只加圆括号是没有用的。

>>> 1,
(1,)

>>> 3*(2+1)
9
>>> 3*(2+1,)
(3, 3, 3)

tuple

tuple函数将一个序列转换为元组，如果序列就是元组，就原样返回。

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

元组也可以通过索引来访问。元组的分片还是元组。

>>> x = 1,2,3,4
>>> x
(1, 2, 3, 4)
>>> x[1]
2
>>> x[0:3]
(1, 2, 3)

5.新函数

cmp（x，y） 比较两个值

len（seq） 返回序列的长度

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

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

min（seq） 返回序列或者参数集合中的最小值

reversed（seq） 对序列进行反向迭代

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

tuple（seq） 把序列转换为元组