Learn_Python_列表05

最新推荐文章于 2021-05-21 09:51:33 发布

ZPILOTE

最新推荐文章于 2021-05-21 09:51:33 发布

阅读量246

点赞数 2

分类专栏： Python 文章标签： Python 列表学习笔记 list

本文链接：https://blog.csdn.net/MRZHUGH/article/details/102577565

版权

Python 专栏收录该内容

29 篇文章 0 订阅

订阅专栏

什么是列表

为了使程序能方便地存储和操作数据，Python语言提供了一些内置的数据结构，

例如：列表，元组，字典和集合等。所谓“内置”，指的是它们是Python语言的一部分，因此在程序中可以直接使用它们。

列表的示意图:列表相当于其它编程语言中的数组。列表的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

from IPython.display import Image
Image(filename = 'F:/Jupyter/Python/liebiao.jpg', width=400, height=200)

列表的特点：

1.列表中的所有数据是按顺序有序排列的，也就是说，列表属于序列类型；

2.列表中的所有数据都有两个整数类型的索引，通过指定的索引总能映射到唯一确定的数据；

3.列表中可以存在重复的数据；

4.列表中可以保存任何类型的数据，多种类型的数据可以混合存储在一个列表中；

5.列表可以根据需要动态地伸缩，也就是说，系统会根据需要动态地分配和回收内存，因此，在使用前无须预先声明列的容量。

创建列表的常见方式有两种：

1.使用中括号

当把列表赋值给变量时，变量名不要取名为list或l，因为list是列表对应的类名，l容易被误读或误写为阿拉伯数字1 .

L = ['Python',18,True]
print(L)

['Python', 18, True]

# 空列表
print([])

[]

2.调用内置函数list（类list的构造函数）

print(list(range(1,6)))
print(list(['Python',18,True]))
# 空列表
print(list())

[1, 2, 3, 4, 5]
['Python', 18, True]
[]

一.列表中元素的索引

列表中的每个元素都有两个整数类型的索引

1.第1个元素的索引是0，后面元素的索引依次递增1；

2.最后一个元素的索引是 -1，前面元素的索引依次递减1.

二.获得列表中指定元素的索引

如果想要获得列表中指定元素的索引，可以调用方法index,该方法只返回两个整数索引中大于0的那个。

from IPython.display import Image
Image(filename = 'F:/Jupyter/Python/liebiao1.jpg', width=400, height=200)

L = [5,3,7,9,2,1,7,6]
print(L.index(9))   #只会返回3，不回返回9的索引 -5

如果列表中存在多个指定元素，方法index只返回第1个指定元素的索引值

print(L.index(7))

print(L.index(8))  # 如果列表中不存在，index是索引不到的  ValueError: 8 is not in list

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-17-677d1e19b6ec> in <module>()
----> 1 print(L.index(8))  # 如果列表中不存在，index是索引不到的


ValueError: 8 is not in list

调用方法index时，还可以指定起始索引start 和结束索引stop 两个参数

可以只指定起始索引start（不能只指定结束索引）

print(L.index(7,3))
print(L.index(7,3,5))  #ValueError: 7 is not in list

6



---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-18-936a9ac102e9> in <module>()
      1 print(L.index(7,3))
----> 2 print(L.index(7,3,5))


ValueError: 7 is not in list

三.列表的“查”操作之使用索引一次只获得一个元素

print(L[0])   #索引为0的元素
print(L[-8])  #索引为-10的元素

5
5

四.列表的“查”操作之使用索引一次只获得多个元素

可以使用切片获得列表中的元素，一次可以获得多个元素。

切片的语法格式：[start:stop:step]，其中，

1.得到的切片仍然是列表，是原始列表的片段的一份拷贝。

2.得到的切片不包括索引stop对应的元素。

3.如果不指定step，其默认值是1，此时语法格式可以简化为[start:stop].

4.当step为正数时，

如果不指定start,切片的第一个元素默认是列表的第一个元素。

如果不指定stop，切片的最后一个元素默认是列表的最后一个元素。

从索引start开始往后计算切片。

当step为负数时，

如果不指定start，切片的第一个元素默认是列表的最后一个元素。

如果不指定step，切片的最后一个元素默认是列表的第一个元素。

从索引start开始往前计算切片。

L = [5,3,9,4,0,6,8,1,7,2]
from IPython.display import Image
Image(filename = 'F:/Jupyter/Python/liebiao2.jpg', width=400, height=200)

print(L[1:7:2])
print(L[1:7:])
print(L[1:7])
print(L[::])

[3, 4, 6]
[3, 9, 4, 0, 6, 8]
[3, 9, 4, 0, 6, 8]
[5, 3, 9, 4, 0, 6, 8, 1, 7, 2]

print(L[::-1]) # 列表的反转

[2, 7, 1, 8, 6, 0, 4, 9, 3, 5]

print(L[6:0:-2])

[8, 0, 9]

print(L[0:6:-2])

[]

print(L[6::-2])

[8, 0, 9, 5]

print(L[:5:-2])

[2, 1]

5.切片操作是允许索引越界的。

print(L[:100])

[5, 3, 9, 4, 0, 6, 8, 1, 7, 2]

print(L[-100:])

[5, 3, 9, 4, 0, 6, 8, 1, 7, 2]

可以调用内置函数slice（类slice的构造函数方法）创建slice类型的对象

内置函数slice有三种调用方式：

1.slice（stop)

2.slice(start,stop)

3.slice(start,stop,step)

start,step和stop的默认值都是None。

slice(start,stop,step）与start:step:step是等价的

L = [5,3,9,4,0,6,8,1,7,2]
print(L[1:7:2])
print(L[slice(1,7,2)])

[3, 4, 6]
[3, 4, 6]

print(L[::])
print(L[slice(None,None,None)])

[5, 3, 9, 4, 0, 6, 8, 1, 7, 2]
[5, 3, 9, 4, 0, 6, 8, 1, 7, 2]

print(L[1:7])
print(L[slice(1,7,None)])

[3, 9, 4, 0, 6, 8]
[3, 9, 4, 0, 6, 8]

print(L[:7])
print(L[slice(7)])
print(L[slice(None,7,None)])

[5, 3, 9, 4, 0, 6, 8]
[5, 3, 9, 4, 0, 6, 8]
[5, 3, 9, 4, 0, 6, 8]

五.列表的“查"操作之使用运算符in检查是否存在指定元素

可以使用运算符in(not in)检查列表中是否存在（不存在）指定元素。

对于in，如果存在，返回True；如果不存在，返回False。

对于not in，如果不存在，返回True；如果存在，返回False。

L = [3,4,5,6,7]
print(5 in L)
print(8 in L)

True
False

print(5 not in L)
print(8 not in L)

False
True

六.列表的改操作

如果想要修改列表中的元素，有两种常见的方式：

1.为指定索引的元素赋予一个新值（一次只修改一个元素）

L = [3,4,5,6,7]
L[2] = 8
print(L)

[3, 4, 8, 6, 7]

2.为指定的切片赋予一个新值（一次至少修改一个元素）

L[1:4] = [1,9,2]
print(L)

[3, 1, 9, 2, 7]

等号左右的元素个数可以不同

此时，列表中其他的元素索引也会发生改变。

from IPython.display import Image
Image(filename = 'F:/Jupyter/Python/liebiao3.jpg', width=200, height=100)

L[1:4] = [1,8]
print(L)

[3, 1, 8, 7]

七.列表的增操作

如果想往列表中添加元素，有四种常见的方式：

1.调用方法append（在列表的末尾一次只添加一个元素）

L = [3,4,5,6,7]
L.append(8)
print(L)
L.append([9,10])
print(L)

[3, 4, 5, 6, 7, 8]
[3, 4, 5, 6, 7, 8, [9, 10]]

2.调用方法extend

L = [3,4,5,6,7,8]
L.extend([9,10])
print(L)

[3, 4, 5, 6, 7, 8, 9, 10]

3.调用方法insert（在列表的任意元素一次只添加一个元素）

第1个参数指定插入元素，第2个参数指定被插入的元素。

插入位置后面的所有元素依次后移一个位置。

L = [3,4,5,6,7]
L.insert(3,8)
print(L)

[3, 4, 5, 8, 6, 7]

# 调用内置函数len可以获取列表中的元素个数，再最后添加 元素
L.insert(len(L),9)
print(L)

[3, 4, 5, 8, 6, 7, 9, 9]

4.为指定的切片赋予一个新值（在列表的任意位置一次至少添加一个元素）

# 与列表的“改”操作结合对比学习更容易理解
L = [3,4,5,6]
L[2:2] = [8,9]
print(L)

[3, 4, 8, 9, 5, 6]

L[len(L):] = [1,2]
print(L)

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

八.列表的“删”操作

如果想要删除列表中的元素，有五种常见的方式：

1.调用方法remove（一次只删除一个指定的元素）

被删除元素后面的所有元素依次前移一个位置

L = [3,4,5,6,5,7]
L.remove(4)
print(L)

[3, 5, 6, 5, 7]

如果列表中存在多个指定元素，只删除第1个指定元素。

L.remove(5)
print(L)

[3, 6, 5, 7]

如果要删除的指定元素在列表中不存在，抛出ValueError.

2.调用方法pop（一次只删除一个指定索引的元素）

该方法返回被删除的元素。

L = [3,4,5,6,7]
print(L.pop(2)) # 删除的元素
print(L)

5
[3, 4, 6, 7]

如果指定的索引不存在，抛出IndexError.

L.pop(8)

---------------------------------------------------------------------------

IndexError                                Traceback (most recent call last)

<ipython-input-22-8511fa18fe3d> in <module>()
----> 1 L.pop(8)


IndexError: pop index out of range

如果没有指定索引，默认删除列表中的最后一个元素。

print(L.pop())

3.使用del语句（一次至少删除一个元素）

L = [3,4,5,6,7,8,9]
del L[2]
print(L)

[3, 4, 6, 7, 8, 9]

del L[1:4]
print(L)

[3, 8, 9]

4.给指定的切片赋值一个空列表（一次至少删除一个元素）

L = [3,4,5,6,7,8,9]
L[2:3] = []
print(L)

[3, 4, 6, 7, 8, 9]

# 清空列表
L[:] = []
print(L)

[]

5.调用方法clear清空列表

L = [3,4,5,6,7]
L.clear()
print(L)

[]

九.使用加法和乘法运算符操作列表

使用加法运算符操作列表

可以使用加法运算符将两个列表合并后生成一个新列表，被合并的两个列表不发生任何改变。

L1 = [1,2,3]
L2 = [4,5,6]
L3 = L1 + L2
print(L3)
print(L1)
print(L2)

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

参数赋值运算符+=会对列表本身进行修改。

L1 = L2 = [1,2]
L1 = L1 + [3,4]
print(L1,L2)
from IPython.display import Image
Image(filename = 'F:/Jupyter/Python/liebiao4.jpg', width=200, height=100)

[1, 2, 3, 4] [1, 2]

L1 = L2 = [1,2]
L1 += [3,4]   #看图，对比+ 运算符对列表的作用不同
print(L1,L2)
from IPython.display import Image
Image(filename = 'F:/Jupyter/Python/liebiao5.jpg', width=200, height=100)

[1, 2, 3, 4] [1, 2, 3, 4]

使用乘法运算符操作列表

可以使用乘法运算符将列表中的元素重复n次后生成一个新列表，被乘的列表不发生任何改变。

L1 = [1,2,3]
L = L1 * 3
print(L)
print(L1)

[1, 2, 3, 1, 2, 3, 1, 2, 3]
[1, 2, 3]

# 常用于列表的初始化
L = [0] * 5
print(L)

[0, 0, 0, 0, 0]

参数赋值运算符 *= 会对列表本身进行修改。

L1 = L2 = [1,2]
L1 = L1 * 3
print(L1,L2)

[1, 2, 1, 2, 1, 2] [1, 2]

L1 = L2 = [1,2]
L1 *= 3
print(L1,L2)

[1, 2, 1, 2, 1, 2] [1, 2, 1, 2, 1, 2]

十.使用比较运算符比较两个列表

可以使用比较运算符对两个列表进行比较：

;>;>=;<;<=;==;!=

比较规则：首先比较两个列表中的第一个元素，如果相等则继续比较下一个元素，依次比较下去，直到两个列表中

的元素不相等时其比较结果就是两个列表的比较结果，两个列表中的所有后续元素将不再被比较。

from IPython.display import Image
Image(filename = 'F:/Jupyter/Python/liebiao6.jpg', width=300, height=150)

print([2,3,8,6,7] < [2,3,9,5,1])

True

还可以使用 is 对两个列表进行比较。

<> 与 is 的区别：是“相等性测试”，is是“同一性”测试。

a = b = [1,2,3]
c = [1,2,3]
print(a == b)
print(a == c)
print(a is b)
print(a is c)

True
True
True
False

十一.列表的反转

如果相对列表中的所有元素进行反转，常见的方式有两种：

1.调用方法reverse

L = [1,2,3,4,5]
L.reverse()
print(L)

[5, 4, 3, 2, 1]

2.调用内置函数reversed

内置函数reversed的返回值是一个迭代器对象，且被反转的列表不发生变化。

L = [1,2,3,4,5]
iterator = reversed(L)
print(iterator)   # 列表反转迭代器对象
print(list(iterator)) #转换成列表更容易看

<list_reverseiterator object at 0x000001F8E21168D0>
[5, 4, 3, 2, 1]

print(L)

[1, 2, 3, 4, 5]

十二.如果相对列表中的所有元素进行排序，常见的方式有两种：

1.调用方法sort

调用方法sort后，列表中的所有元素默认按照从小到大的顺序进行排序

L = [5,3,8,1,6]
L.sort()
print(L)

[1, 3, 5, 6, 8]

调用方法sort时，可以指定参数reverse = True,从而按照逆序进行排序。

L.sort(reverse = True)
print(L)

[8, 6, 5, 3, 1]

2.调用内置函数sorted

内置函数sorted的返回值时排序后生成的新列表，且被排序的列表不发生变化。

L = [5,3,8,1,6]
print(sorted(L))
print(L)

[1, 3, 5, 6, 8]
[5, 3, 8, 1, 6]

调用方法sorted时，可以指定参数reverse = True,从而按照逆序进行排序。

print(sorted(L,reverse = True))

[8, 6, 5, 3, 1]

十三.多维列表

当列表中的元素也是列表时，就构成了多维列表。例如：当列表中的元素是一维列表时，就构成了二维列表；当列表中的元素是二维列表时，就构成了三维列表。因此，可以把多维列表看作时特殊的一维列表。

1.一维列表的操作也适应于多维列表

L = [[3,4],[1,5,2],[6,8,9,7]]
from IPython.display import Image
Image(filename = 'F:/Jupyter/Python/liebiao7.jpg', width=300, height=150)

print(L[2][1])

L[1] = 9  #修改列表
print(L)

[[3, 4], 9, [6, 8, 9, 7]]

L.append([2,0])  # 列表末尾增填
print(L)

[[3, 4], 9, [6, 8, 9, 7], [2, 0]]

L.pop(2)    # 索引删除
print(L)

[[3, 4], 9, [2, 0]]

2.多维列表的初始化

print([[0] * 3] * 4)

[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

print([0 for i in range(3)])   # 列表生成式

[0, 0, 0]

print([[0 for i in range(3)] for j in range(4)])

[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

print([[0] * 3 for j in range(4)])   # 两者结合也可以

[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

学习参考：

图解Python: http://e-learning.51cto.com/course/12803
Python菜鸟教程：https://www.runoob.com/python/python-tutorial.html

ZPILOTE

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
1
评论
Learn_Python_列表05

什么是列表为了使程序能方便地存储和操作数据，Python语言提供了一些内置的数据结构，例如：列表，元组，字典和集合等。所谓“内置”，指的是它们是Python语言的一部分，因此在程序中可以直接使用它们。列表的示意图:列表相当于其它编程语言中的数组from IPython.display import ImageImage(filename = 'F:/Jupyter/Python/lieb...
复制链接

扫一扫