python基础—列表

序列概览

在Python中有六种内建的序列：列表、元组、字符串、Unicode字符串、buffer对象和xrange对象。在这里暂时只讨论列表和元组。列表和元组的主要区别在于：列表可以修改，元组(不可变)不能。

1. 通用序列操作

所有的序列都可以进行某些特定的操作。这些操作包括：

• 索引(indexing)
• 分片(sliceing)
• 加(adding)
• 乘(multiplying)
• 检查某个元素是否属于这序列(index)
• 计算序列长度(len)
• 找出最大元素和最小元素(min/max)

1.1 索引

序列中所有元素都是有编号的，索引从0开始递增。使用负数索引时，Python会从右边开始计数(-1指的是序列最右边的元素)

1 # -- coding: utf-8 --
2 fruit = 'apple'
3 # 输出：a
4 print fruit[0]
5 # 输出：e
6 print fruit[-1]

1.2 分片

除了可以使用索引访问当个元素，还可以使用分片操作来访问一定范围内元素。分片操作需要两个索引来作为边界，第一个索引的元素是包含在分片内的，而第二个则不包含(这是Python的惯例)。

1 # -- coding: utf-8 --
2 numbers = [1,2,3,4,5,6,7,8,9,10]
3 
4 # 输出：[4, 5, 6]
5 print numbers[3:6]
6 
7 # 输出：[2, 3, 4, 5]
8 print numbers[1:-5]

1.2.1 序列分片语法糖

分片中的第二个索引是不包含在返回的分片内的，如果我们需要将一个序列最后的元素包含在分片中该如何操作呢？很简单：

1 # -- coding: utf-8 --
2 numbers = [1,2,3,4,5,6,7,8,9,10]
3 
4 # 输出：[8, 9, 10]
5 # 注意：序列中最大的索引为9，而分片中的第二个索引为10
6 print numbers[7:10]

Python同时为提供了为序列进行分片的语法糖，如下示例：获取最后3位元素：

1 # -- coding: utf-8 --
2 numbers = [1,2,3,4,5,6,7,8,9,10]
3 
4 # 输出：[8, 9, 10]
5 print numbers[-3:]

获取序列前3个元素：

1 # -- coding: utf-8 --
2 numbers = [1,2,3,4,5,6,7,8,9,10]
3 
4 # 输出：[1, 2, 3]
5 print numbers[:3]

获取整个序列：

1 # -- coding: utf-8 --
2 numbers = [1,2,3,4,5,6,7,8,9,10]
3 
4 # 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
5 print numbers[:]

1.2.2 分片中的步长

在进行分片的时候开始和结束点需要进行指定(显式或隐式)。而另一个参数——步长(setp length)通常都是隐式设置的，默认值为1。如果步长为1：分片操作就是按照这个步长逐个遍历序列的元素，然后返回开始和结束点之间的所有元素。例 如，下面两个表达式输出的值相等：

1 # -- coding: utf-8 --
2 numbers = [1,2,3,4,5,6,7,8,9,10]
3 
4 # 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
5 print numbers[0:10:1]
6 
7 # 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
8 print numbers[0:10]

步长也支持下面的简写形式：

1 # -- coding: utf-8 --
2 numbers = [1,2,3,4,5,6,7,8,9,10]
3 
4 # 输出：[1, 5, 9]
5 print numbers[::4]

步长不能为0，但是可以为负数 —— 即从右到左提取元素。使用一个负数作为步长时，必须让开始点(开始索引)大于结束点。如下：

 1 # -- coding: utf-8 --
 2 numbers = [1,2,3,4,5,6,7,8,9,10]
 3 
 4 # 输出：[7, 6, 5]
 5 print numbers[6:3:-1]
 6 
 7 # 输出：[10, 8, 6, 4, 2]
 8 print numbers[::-2]
 9 
10 # 输出：[6, 4, 2]
11 print numbers[5::-2]
12 
13 # 输出：[10, 8]
14 print numbers[:5:-2]

1.3 序列相加

可以使用加号对两个类型相同的序列进行连接操作，如下：

1 # -- coding: utf-8 --
2 numbers1 = [1,2,3]
3 numbers2 = [4,5,6]
4 
5 # 输出：[1, 2, 3, 4, 5, 6]
6 print numbers1 + numbers2

1.4 乘法

使用数字n乘以一个序列会生成新的序列，在新的序列中，原来的序列将被重复n次。初始化一个长度为10的列表，每个元素的值为None(None为Python内建值，表示：这里什么也没有)可以这样：

1 # -- coding: utf-8 --
2 sequence = [None] * 10
3 
4 # 输出：[None, None, None, None, None, None, None, None, None, None]
5 print sequence

1.5 成员资格

可以使用in运算符判断一个对象是否为某个序列的成(元素)，如下：

 1 # --- coding:utf-8 ---   
 2 permissions = 'rw'
 3 fruits = ['apple','peach','grape']
 4 
 5 # 输出:True
 6 print 'w' in permissions
 7 
 8 # 输出:True
 9 print 'apple' in fruits
10 
11 # 输出:False
12 print 'orange' in fruits

1.6 长度、最小值和最大值

Python的内建函数：len/min/max的作用分别是：返回序列中包含元素的数量，返回序列中最小和最大元素。如下：

 1 # -- coding: utf-8 --
 2 numbers = [-1,21,89]
 3 
 4 # 输出：3
 5 print len(numbers)
 6 
 7 # 输出：-1
 8 print min(numbers)
 9 
10 # 输出：89
11 print max(numbers)

2. 列表

列表是可变的(mutable)，且提供很多有用的函数。

2.1 list函数

通过使用list函数可以将字符串转换为一个序列。(注意：list函数适用于所有类型的序列，而不只是字符串)，如下：

1 # -- coding: utf-8 --
2 python = list('python')
3 
4 # 输出：['p', 'y', 't', 'h', 'o', 'n']
5 print python

2.2 基本的列表操作

列表可以使用所有适用于序列的标准操作，如索引、分片、连接和乘法。

改变列表：元素赋值

1 # --- coding: utf-8 ---
2 x = [1,1,1]
3 
4 # 改变索引1元素的值
5 x[1] = 2
6 
7 # 输出2
8 print x[1]

删除元素

1 # -- coding: utf-8 --
2 fruits = ['apple','orange','banana']
3 
4 # 使用del语句删除元素
5 del fruits[1]
6 
7 # 输出：['apple', 'banana']
8 print fruits

分片赋值

通过分片赋值可以：一次为多个元素赋值、插入元素、删除元素,如下：

 1 # -- coding: utf-8 --
 2 name = list('perl')
 3 # 输出：['p', 'e', 'r', 'l']
 4 print name
 5 
 6 # 一次为多个元素赋值
 7 name[2:] = list('ar')
 8 
 9 # 输出：['p', 'e', 'a', 'r']
10 print name
11 
12 # 通过分片赋值插入元素
13 numbers = [1,5]
14 numbers[1:1] = [2,3,4]
15 
16 # 输出：[1, 2, 3, 4, 5]
17 print numbers
18 
19 #通过分片赋值删除元素
20 numbers[1:4] = []
21 
22 # 输出：[1, 5]
23 print numbers

2.3 列表方法

更多列表的使用方法和API，请参考Python文档：http://docs.python.org/2/library/functions.html#list

append：用于在列表末尾追加新对象：

1 # -- coding: utf-8 --
2 
3 # append函数
4 lst = [1,2,3]
5 lst.append(4)
6 # 输出：[1, 2, 3, 4]
7 print lst 

count：用于统计某个元素在列表中出现的次数：

1 # count函数
2 temp_str = ['to','be','not','to','be']
3 # 输出：2
4 print temp_str.count('to') 

extend：可以在列表末尾一次性追加另一个序列中的多个值，和连接操作不同，extend方法是修改了被扩展的序列(调用extend方法的序列)，而原始的连接操作返回的是一个全新的列表

 1 # extend函数
 2 a = [1,2,3]
 3 b = [4,5,6]
 4 a.extend(b)
 5 #输出：[1, 2, 3, 4, 5, 6]
 6 print a 
 7 # 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9]
 8 print a + [7,8,9]
 9 # 输出：[1, 2, 3, 4, 5, 6]
10 print a

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

1 # index函数
2 knights = ['we','are','the','knights','who','say','ni']
3 # 输出：4
4 print knights.index('who')
5 # 抛出异常：ValueError: 'me' is not in list
6 print knights.index('me')

insert：用于将对象插入到列表中

1 # insert函数
2 numbers = [1,2,3,5,6]
3 numbers.insert(3,'four')
4 # 输出：[1, 2, 3, 'four', 5, 6]
5 print numbers

pop：移除列表中的一个元素(默认是最后一个)，并且返回该元素的值。通过pop方法可以实现一种常见的数据结构——栈（LIFO，后进先出）。

 1 # pop函数
 2 x = [1,2,3]
 3 x.pop()
 4 # 输出：[1, 2]
 5 print x
 6 y = x.pop(0)
 7 # 输出：[2]
 8 print x
 9 # 输出：1
10 print y

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

1 # remove函数
2 x = ['to','be','not','to','be']
3 x.remove('to')
4 # 输出：['be', 'not', 'to', 'be']
5 print x
6 # 移除列表没有的元素会抛出异常
7 x.remove('too')

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

1 # reverse函数
2 x = [1,2,3]
3 x.reverse()
4 # 输出：[3, 2, 1]
5 print x

sort：对列表进行排序。注意：sort函数时没有返回值的(None),它作用于源序列。可以通过sorted函数来获取已排序的列表副本。

 1 # sort函数
 2 x = [3,1,2,7,6,9,5,4,8]
 3 y = x[:]
 4 z = x
 5 y.sort()
 6 # 输出：[3, 1, 2, 7, 6, 9, 5, 4, 8]
 7 print x
 8 # 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9]
 9 print y
10 # 输出：[3, 1, 2, 7, 6, 9, 5, 4, 8]
11 print z

cmp(x,y)：通过自定义比较函数(compare)，可以实现自定义排序

3. 元组：不可变序列

元组和列表最大的区别在于：元组不能修改。

3.1 创建元组

创建元组很简单，只需要将元素用括号(可选)括起来，并使用逗号分隔符(即使只有一个元素)来分隔各个元素即可：

1 # -- coding: utf-8 --
2 fruits = ('apple','orange','banana')
3 none_tuple = ()
4 fruits_1 =('apple',)
5 
6 # 输出：<type 'tuple'>
7 print type(fruits)
8 print type(none_tuple)
9 print type(fruits_1)

3.2 使用tuple函数

通过tuple函数可以将一个序列转换为元组。如下：

1 # -- coding: utf-8 --
2 temp_tuple = tuple([1,2,3])
3 
4 # 输出：(1, 2, 3)
5 print temp_tuple
6 # 输出：('a', 'b', 'c')
7 print tuple('abc')

3.3 基本元组操作

由于元组是不可变的，所有没有提供像列表一样的函数，基本元组操作就是创建和访问。同样，元组作为序列的一种，也支持分片：

1 # -- coding: utf-8 --
2 temp_tuple = tuple([1,2,3])
3 
4 # 输出：1
5 print temp_tuple[0]
6 # 输出：(1, 2)
7 print temp_tuple[0:2]

3.4 那些地方需要使用元组

• 元组可以在映射(和集合的成员)中作为键(key)使用，而列表不行
• 元组作为很多内建函数和方法的返回值存在

关于深拷贝和浅拷贝：

浅拷贝：lis.copy()

深拷贝：lis.deepcopy()

浅拷贝顾名思义，只是浅浅的拷贝，搞不定深层次的，列表中的嵌套列表可以理解为内存的引用，而列表中其他的元素或者值可以理解为开辟了新内存。

如果lis1中有嵌套列表，此时修改列表的第一层，只会更改修改的那个列表（浅浅的拷贝（此时开辟新空间）），如果此时修改嵌套列表中的内容，那么就会修改两个列表中的内容（搞不定深层次的（此时为引用））

深拷贝顾名思义，完全给拷贝下来，从头到脚，从里到外。

拷贝下来不管是一层列表还是二层列表或者多层列表，属于完全开辟一个空间来放拷贝下来的元素或者值。lis1是lis1，lis2是lis2。

修改lis2并不会修改lis1中的值

总结：

深拷贝：开辟新空间放置拷贝的值或元素

浅拷贝：一层列表为开辟新空间，二层列表为引用