python2: 列表与元组

完整demo请点击这里：Saul’s github

列表与元组

1.序列概述

• 最常用两种序列：列表和元组。另一种重要的序列是字符串
• 列表和元组的主要不同在于，列表是可以修改的，而元组不可以。这意味着列表适用于需要 中途添加元素的情形，而元组适用于出于某种考虑需要禁止修改序列的情形。
• Python支持一种数据结构的基本概念，名为容器(container)。容器基本上就是可包含其 他对象的对象。两种主要的容器是序列(如列表和元组)和映射(如字典)。在序列中， 每个元素都有编号，而在映射中，每个元素都有名称(也叫键)。有一种既不是序列也不是映射的容器，它就是集合(set)。
• 用列表表示:所有元素都放在方括号内，并用逗 隔开

people1 = ["saul",19,"male"];
print(people1); # ['saul', 19, 'male']
people2 = ["xiaolin",16,"male"];
people =[people1, people2];
print(people); # [['saul', 19, 'male'], ['xiaolin', 16, 'male']]

2.通用的序列操作: 索引、切片、相加、相乘和成员资格检查。另外，Python还提供了一些内置函数，可用于确定序列的长度以及找出序列中最大和最小的元素。

2.1 索引

序列中的所有元素都有编号——从0开始递增。你可使用索引来获取元素。这种索引方式适用于所有序列。当你使 用负数索引时，Python将从右(即从最后一个元素)开始往左数，因此 -1 是最后一个元素的位置。

print(people[0][1]);  # 19
print(people[-1][-2]);  # 16

2.2切片

使用切片(slicing)来访问特定范围内的元素。为此， 可使用两个索引，并用冒号分隔。 切片适用于提取序列的一部分，其中第一个索引指定的元素包含在切片内，但第二个索引指定的元素不包含在切片内。

print([1,2,3,4,5][1:3]);  #[2, 3]

如果要从列表末尾开始数，可使用负数索引。

print([1,2,3,4][-3:-1]);  #[2, 3]

如果切片始于序列开头，可省略第一个索引。

print([1,2,3,4][:3]);   #[1, 2, 3]

要复制整个序列，可将两个索引都省略。

a = [1,2,3,4,5,6,7,8,9];
b = a[:];
print(b);      # [1,2,3,4,5,6,7,8,9]

更大的步长: 执行切片操作时，你显式或隐式地指定起点和终点，但通常省略另一个参数，即步长。在普 通切片中，步长为1。这意味着从一个元素移到下一个元素，因此切片包含起点和终点之间的所有元素。

print(a[0:9:2]);   #[1, 3, 5, 7, 9]

2.3 序列相加

可使用加法运算符来拼接序列.一般而言，不能拼接不同类型的序列

print([1,2,3] + [4,5,6]);    # [1, 2, 3, 4, 5, 6]

2.4 乘法

将序列与数x相乘时，将重复这个序列x次来创建一个新序列.

print([1,2,3]*3);   #[1, 2, 3, 1, 2, 3, 1, 2, 3]

None、空列表和初始化

空列表是使用不包含任何内容的两个方括号([])表示的. 在Python中，None表示什么 都没有。因此，要将列表的长度初始化为10，可像下面这样做:

sequence = [None]*10;
print(sequence);    # [None, None, None, None, None, None, None, None, None, None]

2.5 成员资格

要检查特定的值是否包含在序列中，可使用运算符in。

a = [1,2,3,4,5,6,7,8,9];
print(5 in a);  # True

长度、最小值和最大值

内置函数len、min和max很有用，其中函数len返回序列包含的元素个数，而min和max分别返 回序列中最小和最大的元素.

a = [1,2,3,4,5,6,7,8,9];
print(len(a));  # 9
print(max(a));  # 9
print(min(a));  # 1

3.列表

列表不同于元组和字符串的地方——列表是可变的，即可修改其内容。另外，列表有很多特有的方法。

3.1 基本的列表操作

给元素赋值、删除元素、给切片赋值以及使用列表的方法。

3.1.1 修改列表

给元素赋值. 使用索引表示法给特定位置的元素赋值，如x[1] = 2。

x = [1,1,1];
x[1] = 2;
print(x);    # [1, 2, 1]

3.1.2 删除元素

使用 del 语句.

x = [1,2,1];
del x[2];
print(x);   #[1, 2]

3.1.3 给切片赋值

name = list('perl');
print(name);            # ['p', 'e', 'r', 'l']
name[2:] = list('ar');
print(name);           # ['p', 'e', 'a', 'r']

可将切片替换为长度与其不同的序列。

name[1:] = list('ython');
print(name);                     #['p', 'y', 't', 'h', 'o', 'n']
print("".join(name));            #python

切片赋值还可在不替换原有元素的情况下插入新元素.

numbers = [1,5];
numbers[1:1] = [2,3,4];
print(numbers); # [1, 2, 3, 4, 5]

可采取相反的措施来删除切片。

numbers[1:4] = [];
print(numbers); # [1, 5] 等效于del numbers[1:4]

3.2 列表方法

3.2.1 append

用于将一个对象附加到列表末尾。

lists = [1,2,3];
lists.append(4);
print(lists); # [1, 2, 3, 4]

3.2.2 clear

就地清空列表的内容。

lists.clear();
print(lists);       # []

3.2.3 copy

常规复制只是将另一个名称关联到列表。要让a和b指向不同的列表，就必须将b关联到a的副本。

a = [1,2,3];
b = a;
b[1] = 4;
print(a); #[1, 4, 3]

b = a.copy();
b[1] = 199;
print(a); # [1, 4, 3]

3.2.4 count

计算指定的元素在列表中出现了多少次

print([1,1,2,4,5,1,2,6].count(1));     # 3

3.2.5 extend

方法extend让你能够同时将多个值附加到列表末尾，为此可将这些值组成的序列作为参数提 供给方法extend。换而言之，你可使用一个列表来扩展另一个列表.这可能看起来类似于拼接，但存在一个重要差别，那就是将修改被扩展的序列(这里是a)。在常规拼接中，情况是返回一个全新的序列。

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

3.2.6 index

列表中查找指定值第一次出现的索引

print([0,2,1,3,4,5,1,1,4].index(1));  # 2

3.2.7 insert

用于将一个对象插入列表。

number = [1,2,3,4,5];
number.insert(2,9);
print(number); #[1, 2, 9, 3, 4, 5]

3.2.8 pop

从列表中删除一个元素(末尾为最后一个元素)，并返回这一元素。
使用pop可实现一种常见的数据结构——栈(stack),后进先出(LIFO),。Python没有提供push，但可使用append来替代. 要创建先进先出(FIFO)的队列，可使用insert(0,…)代替append。另外也可继续使 用append，但用pop(0)替代pop()。一种更佳的解决方案是，使用模块collections中的 deque。

x = [1,2,3];
print(x.pop()); # 3
print(x); # [1, 2]

3.2.9 remove

用于删除第一个为指定值的元素。

x = [1,2,3,2,1,3];
x.remove(3);
print(x);        #[1, 2, 2, 1, 3]

3.2.10 reverse

按相反的顺序排列列表中的元素

x = [1,2,3];
x.reverse();
print(x);     #[3, 2, 1]

3.2.11 sort

用于对列表就地排序。就地排序意味着对原来的列表进行修改，使其元素按顺序
#排列，而不是返回排序后的列表的副本。

x = [1,2,9,4,5,6,3,2,0,1];
x.sort();
print(x);  #[0, 1, 1, 2, 2, 3, 4, 5, 6, 9]

获取排序后的列表的副本， 另一种方式是使用函数sorted。

x = [1,2,9,4,5,6,3,2,0,1];
y = sorted(x);
print(x);     # [1, 2, 9, 4, 5, 6, 3, 2, 0, 1]
print(y);     #[0, 1, 1, 2, 2, 3, 4, 5, 6, 9]

4. 元组

不可修改的序列.与列表一样，元组也是序列，唯一的差别在于元组是不能修改的
(字符串也不能修改)。元组语法很简单，只要将一些值用逗号分隔，就能自动创建一个元组。

空元组用两个不包含任何内容的圆括号表示。

a = ();

如何表示只包含一个值的元组呢?这有点特殊:虽然只有一个值，也必须在它后面加上逗号。

print((33,));  #(33,)

函数tuple的工作原理与list很像:它将一个序列作为参数，并将其转换为元组。如果参数已经是元组，就原封不动地返回它。

print(tuple([1,2,3]));     #(1, 2, 3)
print(tuple('apple'));     # ('a', 'p', 'p', 'l', 'e')

元组的创建及其元素的访问方式与其他序列相同。