列表类型

列表(List)

列表是Python中最基本也是最常用的数据结构之一。列表中的每个元素都被分配一个数字作为索引，用来表示该元素在列表内所排在的位置。第一个元素的索引是0，第二个索引是1，依此类推。

Python的列表是一个有序可重复的元素集合，可嵌套、迭代、修改、分片、追加、删除，成员判断。

从数据结构角度看，Python的列表是一个可变长度的顺序存储结构，每一个位置存放的都是对象的指针。

比如，对于这个列表 alist = [1, “a”, [11,22], {“k1”:”v1”}]，其在内存内的存储方式是这样的：

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型。

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

创建列表

list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]

print(list1)
print(list2)
print(list3)

['Google', 'Runoob', 1997, 2000]
[1, 2, 3, 4, 5]
['a', 'b', 'c', 'd']

与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。

 访问列表中的元素

列表从0开始为它的每一个元素顺序创建下标索引，直到总长度减一。要访问它的某个元素，以方括号加下标值的方式即可。注意要确保索引不越界，一旦访问的 索引超过范围，会抛出异常。所以，一定要记得最后一个元素的索引是len(list)-1。

list1 = ['Google', 'Runoob', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];
  
print ("list1[0]: ", list1[0])
print ("list2[1:5]: ", list2[1:5])

以上实例输出结果：

list1[0]:  Google
list2[1:5]:  [2, 3, 4, 5]

下标越界

list1 = ['Google', 'Runoob', 1987, 2018]
print(list1[4])

以上实例输出结果：

Traceback (most recent call last):
  File "<input>", line 1, in <module>
IndexError: list index out of range

更新列表中的元素

你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项，如下所示：

list = ['Google', 'Runoob', 1997, 2000]
  
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])

以上实例输出结果：

第三个元素为 :  1997
更新后的第三个元素为 :  2001

 删除列表中的元素

 使用del语句或者remove(),pop()方法删除指定的元素。

list = ['Google', 'Runoob', 1997, 2000]
  
print (list)
del list[2]
print ("删除第三个元素 : ", list)

以上实例输出结果：

删除第三个元素 : ['Google', 'Runoob', 2000]

列表的特殊操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

语句	结果	描述
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合两个列表
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	列表的乘法
3 in [1, 2, 3]	True	判断元素是否存在于列表中
for x in [1, 2, 3]: print x,	1 2 3	迭代列表中的每个元素

lis = [1, 2, 3] + [4, 5, 6]

lis = ['hh'] * 5

lis = [1, 2, 3]
print(3 in lis)

lis = [1, 2, 3]
for index in lis:
    print(index)

以上实例输出结果：

[1, 2, 3, 4, 5, 6]

['hh', 'hh', 'hh', 'hh', 'hh']

True

1
2
3

 切片

切片指的是对序列进行截取，选取序列中的某一段。

语法

list[start:end]

 以冒号分割索引，start代表起点索引，end代表结束点索引。省略start表示以0开始，省略end表示到列表的结尾。注意，区间是左闭右开的！也就是说[1:4]会截取列表的索引为1/2/3的3个元素，不会截取索引为4的元素。分片不会修改原有的列表，可以将结果保存到新的变量，因此切片也是一种安全操作，常被用来复制一个列表，例如newlist = lis[:]。


 如果提供的是负整数下标，则从列表的最后开始往头部查找。例如-1表示最后一个元素，-3表示倒数第三个元素。

切片过程中还可以设置步长，以第二个冒号分割，例如list[3:9:2]，表示每隔多少距离取一个元素。

列子

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

>>> a[3:6]  # 获取列表3-6的元素
[4, 5, 6]

>>> a[:7]  # 获取列表从开头到第七个元素
[1, 2, 3, 4, 5, 6, 7]

>>> a[2:]  # 获取列表从下标为2的元素至最后
[3, 4, 5, 6, 7, 8, 9, 10]

>>> s = a[:]  # 拷贝列表
>>> s
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> s.remove(4)  # 删除第四个元素
>>> s
[1, 2, 3, 5, 6, 7, 8, 9, 10]

>>> a[-1]  # 获取最后一个元素
10

>>> a[-3]  # 获取倒数第三个元素
8

>>> a[-5:]  # 获取后5个元素
[6, 7, 8, 9, 10]

>>> a[::-1]  # 反向获取列表中所有元素
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

>>> a [1:8:2]  # 步长获取1-8之间隔一个获取一个
[2, 4, 6, 8]

>>> a[1:8:-2]
[]

>>> a[-8::-2]
[3, 1]

>>> a[-8::2]
[3, 5, 7, 9]

列表两个冒号语法：

>>> lis = [i for i in range(0,15)]
>>> lis
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
>>> lis[::2]
[0, 2, 4, 6, 8, 10, 12, 14]

我们可以看到lis后面跟了两个冒号，还有个2 。

语法

l[start:end:span]

遍历 [start,end)，间隔为 span，当 span>0 时顺序遍历, 当 span<0 时，逆着遍历。
start 不输入则默认为 0，end 不输入默认为列表长度。

嵌套列表

列表可以嵌套列表，形成多维列表，形如矩阵。其元素的引用方法是list[i][j][k].....。当然，也可以嵌套别的数据类型。

>>> a = [[1,2,3],[4,5,6],[7,8,9]]
>>> a[0][1]  # 获取内层列表中下标为1的元素
2

>>> a = [[1,2,3],[4,5,6],[7,8,9],{"k1":"v1"}]
>>> a[3]["k1"]  # 获取字典中的数据
'v1'

 列表转换字符串

1.列表中只有字符串，使用join方法

实例

>>> li = ["123","xiao"]
>>> v = "".join(li)
>>> v
'123xiao'
>>> type(v)
<class 'str'>

2.列表中既有字符串又有数字，写for循环处理

实例

>>> li = [1,2,3,4,"342"]
>>> s = ""
>>> for i in li:
...     s = s+str(i)
...
>>> s
'1234342'

 列表遍历

列表有好几种遍历方式：

a = [1,2,3,4,5,6]
---------------------------
for i in a:             # 遍历每一个元素本身
    print(i)
------------------------------
for i in range(len(a)):     # 遍历列表的下标，通过下标取值
    print(i, a[i])
--------------------------------
x = 9
if x in a:      # 进行是否属于列表成员的判断。该运算速度非常快。
    print("True")
else:
    print("False")

列表方法

Python列表包含以下方法: 

序号	方法及描述
1	append(obj) 在列表末尾追加新的对象
2	clear()  清空列表
3	copy() 复制（浅拷贝）列表
4	count(obj) 统计某个元素在列表中出现的次数
5	extend(iterable) 通过在列表末尾追加可迭代对象中的元素来扩展列表
6	index(obj[,start=0[,stop=len(list)]]) 从列表中找出某个对象第一个匹配项的索引位置
7	insert(index, obj) 将指定对象插入到列表中的指定位置
8	pop([index=-1]) 通过指定元素的索引值来移除列表中的某个元素（默认是最后一个元素），并返回该元素的值
9	remove(obj) 通过指定元素的值来移除列表中的某个元素的第一个匹配项
10	reverse() 对列表中的元素进行反向排序
11	sort([key=None][,reverse=False]) 对列表进行排序
12	cmp(L1,L2) Python2中使用 比较两个列表的元素大小
13	max(L) 返回列表元素最大值
14	min(L) 返回列表元素最小值
15	list(iterable) 将可迭代对象转换为列表

将列表当做堆栈

Python的列表特别适合也很方便作为一个堆栈来使用。堆栈是一种特定的数据结构，最先进入的元素最后一个被释放（后进先出）。将列表的表头作为栈底，表尾作为栈顶，就形成了一个堆栈。用列表的append()方法可以把一个元素添加到堆栈顶部（实际上就是在列表的尾部添加一个元素）。用不指定索引的pop()方法可以把一个元素从堆栈顶释放出来（也就是从列表尾部弹出一个元素）。例如：

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

列表在内存内部是顺序存储结构的，所以在其尾部的添加和删除动作，也就是append和pop方法的效率非常高，具备随机存取速度，也就是O(1)的时间复杂度，因此用作堆栈是再合适不过了。

将列表当作队列

也可以把列表当做队列用。队列是一种先进先出的数据结构。但是用Python的列表做队列的效率并不高。因为，虽然在列表的最后添加或者弹出元素速度很快，但在列头部弹出第一个元素的速度却不快（因为所有其他的元素都得跟着一个一个地往左移动一位）。通常我们使用queue.Queue作为单向队列，使用collections.deque作为双向队列。

 

转载于:https://www.cnblogs.com/xiaohei001/p/10167887.html