Python列表、元组全面介绍 清晰明了

Python列表是啥？

列表是由一系列按特定顺序排列的元素组成。你可以将任意类型的元素插入到列表，无论是相同类型还是不同类型，元素之间没有任何关系。需要注意的是：列表的索引和C语言里边的数组一样都是从0开始的。

列表的遍历：

伪代码：

for 变量名 in 列表名:
    执行的操作1
    执行的操作2 

例如：

#coding:utf-8
lists_1=[]    #声明一个空列表，列表名字为"lists_1"
lists_2=[1,'a',1.5,'test_1',"test_2"] #声明一个列表lists_2,并且初始化为以上几个元素
for i in lists_2:   #for循环遍历输出列表的各个元素和数据类型
    print i,;
    print type(i);

关于python循环语句for和while请查看博客：

关于print语句为何后边多一个逗号，请查看博客：

运行结果：

1 <type 'int'>
a <type 'str'>
1.5 <type 'float'>
test_1 <type 'str'>
test_2 <type 'str'>

很显然，上面5各元素中包含了int、float、str三种类型，足以说明元素直接没有任何关系，可以将任意类型的元素插入列表。

如何访问列表中的元素：

对于以上列表lists_2，其访问方式为lists_2[0]，lists_2[1]，lists_2[2]......

例如：

#coding:utf-8
lists_2=[1,'a',1.5,'test_1',"test_2"] #声明一个列表lists_2,并且初始化为以上几个元素
n=0;
while n<5:
    print lists_2[n],;
    print type(lists_2[n]);
    n+=1;

运行结果：

1 <type 'int'>
a <type 'str'>
1.5 <type 'float'>
test_1 <type 'str'>
test_2 <type 'str'>

不难看出，结果与上边的一样。

Python常用方法（常用函数）

获取列表长度：

len(列表名称)

例如：

#coding:utf-8
lists_2=[1,'a',1.5,'test_1',"test_2"] #声明一个列表lists_2,并且初始化为以上几个元素
lengh=len(lists_2);
print lengh;

输出结果：5

增：

append()   #在末尾添加

insert(index, 元素)   #在index处添加（后边的元素自动后移）

例如：

#coding:utf-8
lists_2=[1,'a',1.5,'test_1',"test_2"] #声明一个列表lists_2,并且初始化为以上几个元素

lists_2.append(2);  #在列表的末尾添加元素2
lists_2.append("appendOne");   #在列表的末尾添加元素"test_3"
lists_2.insert(0, "insertOne"); #在列表的0索引处添加元素"insertOne"
lists_2.insert(2, 0.375);   #在列表的2索引处添加元素0.375

for i in lists_2:
    print i;

输出结果：

insertOne
1
0.375
a
1.5
test_1
test_2
2
appendOne

删：

del   #删除指定元素

pop(index)   #删除index处的元素并返回被删除的内容，pop()为默认弹出尾部元素并返回

remove(x)   #删除列表中第一次出现的x后边的元素自动前移

例如：

#coding:utf-8
lists_2=[1,'a',1.5,'test_1',"test_2"] #声明一个列表lists_2,并且初始化为以上几个元素

print "初始列表:";
print lists_2;  #输出列表

lists_2.append(2);  #在列表的末尾添加元素2
lists_2.append("appendOne");   #在列表的末尾添加元素"test_3"
lists_2.insert(0, "insertOne"); #在列表的0索引处添加元素"insertOne"
lists_2.insert(2, 0.375);   #在列表的2索引处添加元素0.375

print "\n添加元素后:";
print lists_2;  #输出列表

#如果知道要删除元素的位置，可以用del语句来删除
del lists_2[0]; #删除0索引处的元素
del lists_2[3]; #删除3索引处的元素

print "\ndel语句删除0和3索引处元素后:";
print lists_2;  #输出列表

popOne=lists_2.pop(0);  #弹出0索引处元素并返回给popOne
popLast=lists_2.pop();  #弹出列表尾部元素并返回给popLast

print "\npop()语句弹出后的列表：";
print lists_2;
print "被弹出的元素为：";
print popOne,;
print popLast;

lists_2.append(0.375);  #列表尾部添加一个0.375与前面的区分开
lists_2.remove(0.375);  #删除第一次出现的0.375

print "\nremove()语句删除第一个0.375后的列表：";
print lists_2;

输出结果：

初始列表:
[1, 'a', 1.5, 'test_1', 'test_2']

添加元素后:
['insertOne', 1, 0.375, 'a', 1.5, 'test_1', 'test_2', 2, 'appendOne']

del语句删除0和3索引处元素后:
[1, 0.375, 'a', 'test_1', 'test_2', 2, 'appendOne']

pop()语句弹出后的列表：
[0.375, 'a', 'test_1', 'test_2', 2]
被弹出的元素为：
1 appendOne

remove()语句删除第一个0.375后的列表：
['a', 'test_1', 'test_2', 2, 0.375]

查：

查即访问，上文已经涉及。

改：

访问后直接重新赋值即改，上文也已涉及。

排序：

sort()   #使列表永久排序

sorted()   #使列表临时排序

reverse()   #使列表逆序

例如：

#coding:utf-8
lists=[0,1,2,3,4,5,6,7,8,9];

print "初始列表："
print lists;

lists.reverse();    #使列表逆序
print "\nreverse()逆序后的列表："
print lists;

print "\n使用sorted()函数使列表临时排序并输出："
print sorted(lists);    #临时排序并输出

print "\n临时排序已失效后的列表："
print lists;

lists.sort();
print "\nsort()永久排序后的列表："
print lists;

print "\n永久排序后的列表不会失效："
print lists;

输出结果：

初始列表：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

reverse()逆序后的列表：
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

使用sorted()函数使列表临时排序并输出：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

临时排序已失效后的列表：
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

sort()永久排序后的列表：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

永久排序后的列表不会失效：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

数值列表

创建数值列表

我们可以用range()函数来创建数值列表：

numbers=list(range(1,20,3));
print numbers;

输出结果：

[1, 4, 7, 10, 13, 16, 19]

上边用range函数来生成一个数值列表。

数值列表常用函数

min()   #取数字列表最小值

max()   #取数字列表的最大值

sum()   #取数字列表的和值

例如：

numbers=list(range(1,20,3));

print "初始列表："
print numbers;

print "\n列表最小值为：";
print min(numbers);

print "\n列表最大值为：";
print max(numbers);

print "\n列表和值为：";
print sum(numbers);

输出结果：

初始列表：
[1, 4, 7, 10, 13, 16, 19]

列表最小值为：
1

列表最大值为：
19

列表和值为：
70

以上三个函数为python用于处理数值列表的专用函数，也适用于包含百万个数值的列表。

使用列表的一部分——列表切片

什么叫切片？

在python中，对于一个列表来说，我们通常希望只用到列表的一部分，比如列表中的某一段，这个时候，列表中的任意一段都可以成为列表的切片。

怎么切？

例如：

#coding:utf-8
numbers=list(range(0,20));

print "初始列表：";
print numbers;

print "\n0~3切片：";
print numbers[0:3];

print "\n1~4切片：";
print numbers[1:4];

print "\n从头部到5切片：";
print numbers[:5];

print "\n从6到尾部切片：";
print numbers[6:];

print "\n遍历从15~20切片";
for i in numbers[15:20]:
    print i,;

输出结果：

初始列表：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

0~3切片：
[0, 1, 2]

1~4切片：
[1, 2, 3]

从头部到5切片：
[0, 1, 2, 3, 4]

从6到尾部切片：
[6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

遍历从15~20切片
15 16 17 18 19

从输出结果不难看出，切片跟range函数一样，左包右不包，numbers[1:4]实际上包含1而不包含4。

Python元组是啥？和列表的异同点是啥？

我们已经知道：列表由一系列按特定顺序排列的元素组成。你可以将任意类型的元素插入到列表，无论是相同类型还是不同类型，元素之间没有任何关系。

那么元组呢？

元组是不变的列表。

列表元素可以修改，元组元素不能被修改；

列表使用方括号，元组使用小括号；

list1=[]
tuple1=()

元组中只包含一个元素时，需要在元素后面添加逗号；

tuple1=(1,)

元组与字符串类似，下标索引从0开始，可以进行截取，组合等；

tuple1 = (1,2,3);
tuple2 = (4,5,6);
tuple3 = tuple1 + tuple2;
print tuple3;

输出结果：

(1, 2, 3, 4, 5, 6)

元组的访问形式与列表一样，都是以索引的形式访问的，这里不再赘述。

元组的元素不能被删除，但是整个元组可以用del语句删除：

tuple1=(1,2,3);
del tuple1;
print tuple1;

报错：

NameError: name 'tuple1' is not defined

元组相关函数

方法及描述

cmp(tuple1, tuple2)
比较两个元组元素。

len(tuple)
计算元组元素个数。

max(tuple)
返回元组中元素最大值。

min(tuple)
返回元组中元素最小值。

tuple(seq)
将列表转换为元组。

注：此表格来自http://www.runoob.com/python/python-tuples.html点击链接可跳转到具体内容。