python学习之列表

python的6个序列的内置类型

序列是python的最基本数据结构，序列的每个元素都分配一个数字，它的索引，第一个是0，第二个是1，依次类推；
python的6个内建的序列分别是列表，元祖，字符串，unicode字符串，buffer对象和xrange对象；
序列通用操作包含：索引，长度，组合（序列相加），重复（乘法），分片，检查成员，遍历，最大值和最小值；

列表

列表是python最常用的数据类型,使用方括号定义，元素之间使用逗号隔开；

列表的常用方法

1.定义一个列表

#定义一个空的列表
list1 = []
print(list1,type(list1))
#定义一个单值列表
list2 = ['hello']
print(list2,type(list2))
#定义一个普通列表
list3 = [1,'hello',[2,'world']]
print(list3,type(list3))
输出结果：
[] <class 'list'>
['hello'] <class 'list'>
[1, 'hello', [2, 'world']] <class 'list'>

2.列表的索引

list4 = [1,2,3,4,5,6]
print(list4[:])   #索引从0开始到索引值为列表长度结束
print(list4[:4])  #索引从0开始到4结束
print(list4[2:])  #索引从0开始到列表长度结束
print(list4[1:6:2]) #索引从1开始到6结束，步长为2
print(list4[::-1])  #将列表元素进行反转显示
输出结果：
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4]
[3, 4, 5, 6]
[2, 4, 6]
[6, 5, 4, 3, 2, 1]

3.列表的增加

1.使用append()函数追加其他元素到列表里
list4.append(7)
print(list4)
list4.append('abc')
print(list4)
输出结果：
[1, 2, 3, 4, 5, 6, 7]
[1, 2, 3, 4, 5, 6, 7, 'abc']

3.2.extend()函数追加其他列表的元素到指定的列表；
list4.extend(list3)
print(list4)
输出结果：
[1, 2, 3, 4, 5, 6, 7, 'abc', 1, 'hello', [2, 'world']]

3.使用insert()函数为列表指定位置添加元素
list4.insert(2,'100')
print(list4)
输出结果：
[1, 2, '100', 3, 4, 5, 6]

4.列表的删除

1.remove()函数删除后列表的值进行改变
list4.remove('100')
print(list4)
list4.remove(5)
print(list4)
输出结果：
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 6]

2.pop（）函数删除指定索引值
list4.pop()        #默认情况下删除最后一个元素
print(list4)
list4.pop(-1)     #删除列表最后一个元素
print(list4)
list4.pop(1)      #删除列表索引值为2的元素
print(list4)
输出结果：
[1, 2, 3, 4]
[1, 2, 3]
[1, 3]

3.del()删除列表元素，也可以通过索引以及切片删除指定位置的元素
del(list4[0])
print(list4)
del(list4)  #将整个列表删除，输出值没有
print(list4)
输出结果：
[3]

4.clear()函数清空列表的元素，使之成为空元素
list5 = [9,8,7,6,5]
list5.clear()
print(list5)
输出结果：
[]

5.列表的修改

l1 = [0,1,2,3,4,5]
l1[3] = 'abc'
print(l1)
输出结果：
[0, 1, 2, 'abc', 4, 5]

l1 = [0,1,2,3,4,5]
l1[:3]='abcdef'
print(l1)
输出结果：
['a', 'b', 'c', 'd', 'e', 'f', 3, 4, 5]

6.列表的复制
在python中，对于复制问题，存在深拷贝和浅拷贝问题；两者的区别在于，从原来的列表里面复制出新的列表，修改其中的任意一个是否会对另外一个造成影响，即这两个列表在内存中是否存储在同一区域，这是区分深拷贝和浅拷贝的重要依据；
复制的愿望是复制的列表之间不会相互影响；

1.直接赋值方法，是一种非拷贝方法；
l1 = [1,2,3,4,5]
l2 = l1                  #将l1的值赋值给l2
print(l1,id(l1))
print(l2,id(l2))
#修改l1查看是否会影响到l2
l1.append(6)
print(l1,id(l1))
print(l2,id(l2))
输出结果：
[1, 2, 3, 4, 5] 7758408
[1, 2, 3, 4, 5] 7758408
[1, 2, 3, 4, 5, 6] 7758408
[1, 2, 3, 4, 5, 6] 7758408
修改l1导致l2也随之变化；

2.浅拷贝的方式
l2 = [1,2,3,'abc','efg']
l3 = l2.copy()
print(l2,id(l2))
print(l3,id(l3))
l2.append('hij')
print(l2,id(l2))
print(l3,id(l3))
输出结果：
[1, 2, 3, 'abc', 'efg'] 5136968
[1, 2, 3, 'abc', 'efg'] 5137032
[1, 2, 3, 'abc', 'efg', 'hij'] 5136968
[1, 2, 3, 'abc', 'efg'] 5137032

l2 = [1,2,3,'abc','efg']
l4 = l2[:]
print(l2,id(l2))
print(l4,id(l4))
输出结果：
[1, 2, 3, 'abc', 'efg'] 34807752
[1, 2, 3, 'abc', 'efg'] 33972808

3.深拷贝的方式
deepcopy()方法，无论多少层，无论怎样的形式，得到新的列表和原来无关；
使用该函数时需要导入copy模块；
import copy
l2 = [1,2,3,'abc','efg']
l3 = copy.deepcopy(l2)
print(l2,id(l2))
print(l3,id(l3))
l3.append('hij')
print(l2,id(l2))
print(l3,id(l3))
输出结果：
[1, 2, 3, 'abc', 'efg'] 31946504
[1, 2, 3, 'abc', 'efg'] 31945288
[1, 2, 3, 'abc', 'efg'] 31946504
[1, 2, 3, 'abc', 'efg', 'hij'] 31945288

7.列表的长度，重复，组合，成员操作以及遍历

l1 = [0,1,2,3,4,5]
l2 = [1,2,3,'abc','efg']
print(len(l2))
print(l1+l2)
print(l1*3)
print(5 in l1)
for i in l1:
    print(i)
输出结果：
5
[0, 1, 2, 3, 4, 5, 1, 2, 3, 'abc', 'efg']
[0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5]
True
0
1
2
3
4
5

8.反向列表中的元素

l1 = [0,1,2,3,4,5]
l1.reverse()
print(l1)
输出结果：
[5, 4, 3, 2, 1, 0]

9.列表的排序
列表的sort函数是按照ASSIC码进行排序

l2 = [1,7,3,9,8,5]
l2.sort()
print(l2)
l3 = ['a','f','r','d']
l3.sort()
print(l3)
l4 = [5,8,1,4,'c','f']  #列表的sort函数不支持整型和字符串的排序，不然执行会报错
l4.sort()
print(l4)
输出结果：
[1, 3, 5, 7, 8, 9]
['a', 'd', 'f', 'r']
报错：
TypeError: '<' not supported between instances of 'str' and 'int'

10.列表的zip（）函数
zip（）将多个序列中的元素配对，从而产生新的元组列表；zip可以接受任意数量的序列，最终得到的元组数量由最短的序列决定；

l1 = [1,2,3,4,5]
l2 = ['a','b','c','d','e']
l3 = [6,7,8,9,10]
l4 = zip(l1,l2,l3)
print(l4,type(l4))
for i in l4:
    print(i)
输出结果：
<zip object at 0x00000000021C7388> <class 'zip'>
(1, 'a', 6)
(2, 'b', 7)
(3, 'c', 8)
(4, 'd', 9)
(5, 'e', 10)

对于“已压缩的”（zipped）序列，对该序列进行解压（unzip，用*表示）；就是将一组行转换为一组列

l4 = [(1, 'a', 6),(2, 'b', 7),(3, 'c', 8),(4, 'd', 9),(5, 'e', 10)]
n1,n2,n3 = zip(*l4)
print(n1)
print(n2)
print(n3)
输出结果：
(1, 2, 3, 4, 5)
('a', 'b', 'c', 'd', 'e')
(6, 7, 8, 9, 10)

列表作为栈使用

使用列表作为堆栈使用，最后一个插入，第一个先出，（后近先出）。要添加到堆栈的顶端使用append()函数，取出堆栈的第一个元素使用pop（）函数；

l2 = ['abc',5,8,'efc']
l2.append(1000)
print(l2)
l2.pop()
print(l2)
输出结果：
['abc', 5, 8, 'efc', 1000]
['abc', 5, 8, 'efc']

列表作为队列使用

列表也可以用作队列，其中先添加的元素被最先取出 (“先进先出”)；然而列表用作这个目的相当低效。因为在列表的末尾添加和弹出元素非常快，但是在列表的开头插入或弹出元素却很慢 ；
若要实现一个队列， collections.deque 被设计用于快速地从两端操作；

转载于:https://blog.51cto.com/13606177/2352325