【Python】4.底子语法（4）列表和元组
1. 列表是什么, 元组是什么
编程中, 经常必要使用变量, 来生存/表现数据。
假如代码中必要表现的数据个数比力少, 我们直接创建多个变量即可。
num1
=
; 1
0
num2 =
; 20
num3
=
; 3
0
......
但是有的时间, 代码中必要表现的数据特殊多, 乃至也不知道要表现多少个数据。这个时间, 就必要用到列表。
列表是一种让步调员在代码中批量表现/生存数据的方式
[*]列表类似于一个口袋，可以往内里装东西和拿东西，数目可变。
元组和列表相比, 黑白常相似的, 只是列表中放哪些元素可以修改调解, 元组中放的元素是创建元组的时间就设定好的, 不能修改调解。
[*]元组类似于真空包装的一个口袋，内里东西是固定的，数目稳固的。
2. 创建列表
创建列表紧张有两种方式。 [ ] 表现一个空的列表。
alist =
; [ ]# 方法1
alist =
; list()# 方法2
print(type(alist))
假如必要往内里设置初始值, 可以直接写在 [ ] 当中。
可以直接使用 print 来打印 list 中的元素内容。
alist =
; [1
, 2, 3
, 4
]
print(alist)
列表中存放的元素允许是差别的范例。(这一点和 C
3
;
3
;/Java 差别较大)。
alist =
; [1
, 
9;hello
9;, True, [4
, 5, 6]]
print(alist)
打印࿱
a;
[1
, 
9;hello
9;, True, [4
, 5, 6]]
由于 list 自己是 Python 中的内建函数, 不宜再使用 list 作为变量名, 因此定名为 alist 。
3
. 访问下标
[list=1
]
[*]可以通过下标访问使用符 [ ] 来获取到列表中的恣意元素。
把[]
放到一个列表变量的反面，同时[]
写上一个整数，此时他就是下标访问运算符。
我们把 [ ] 中填写的数字, 称为下标大概索引。
alist =
; [1
, 2, 3
, 4
]
print(alist)
打印࿱
a;
3
留意: 下标是从 0 开始计数的, 因此下标为 2 , 则对应着 3
这个元素。
[list=1
]
[*]通过下标不但能读取元素内容, 还能修改元素的值。
alist =
; [1
, 2, 3
, 4
]alist =
; 1
00print(alist) 打印࿱
a;
[1
, 2, 1
00, 4
]
[list=1
]
[*]假如下标超出列表的有用范围, 会抛出非常。
alist =
; [1
, 2, 3
, 4
]print(alist[1
00])# IndexError: list index out of range [list=1
]
[*]由于下标是从 0 开始的, 因此下标的有用范围是 [0, 列表长度 - 1
]。 使用 len 函数可以获取到列表元素个数。
alist =
; [1
, 2, 3
, 4
]print(len(alist)) 打印࿱
a;
4
[list=1
]
[*]下标可以取负数，表现 “倒数第几个元素”
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pbWctYmxvZy5jc2RuaW1nLmNuL2ltZ19jb252ZXJ0LzMKMwo3ZDBmNmFhNmY3NmQwMwowMDkwYzIyMQoxCjljMGQ2OGIucG5n
alist =
; [1
, 2, 3
, 4
]print(alist[3
])print(alist[-1
]) 打印࿱
a;
4
4
alist[-1
] 相称于 alist[len(alist) - 1
]
4
. 切片使用
通过下标使用是一次取出内里第一个元素。
通过切片, 则是一次取出一组一连的元素, 相称于得到一个子列表。
[list=1
]
[*]使用 [ : ] 的方式举行切片使用。
alist =
; [1
, 2, 3
, 4
]print(alist[1
:3
]) 打印࿱
a;
[2, 3
] alist[1
:3
] 中的 1
:3
表现的是 [1
, 3
) 如许的由下标构成的前闭后开区间。
也就是从下标为 1
的元素开始(2), 到下标为 3
的元素竣事(4
), 但是不包罗下标为 3
的元素。以是最闭幕果只有 2, 3
[list=1
]
[*]切片使用中可以省略前后界限
alist =
; [1
, 2, 3
, 4
]print(alist[1
:])# 省略后界限, 表现获取到列表末端print(alist[:-1
])# 省略前界限, 表现从列表开头获取print(alist[:])# 省略两个界限, 表现获取到整个列表 打印࿱
a;
[2, 3
, 4
][1
, 2, 3
][1
, 2, 3
, 4
] [list=1
]
[*]切片使用还可以指定 “步长” , 也就是 “每访问一个元素后, 下标自增几步”
alist =
; [1
, 2, 3
, 4
, 5, 6, 7, 8, 9, 1
0]print(alist[::1
])print(alist[::2])print(alist[::3
])print(alist[::5])print(alist[1
:-1
:2]) 打印࿱
a;
[1
, 2, 3
, 4
, 5, 6, 7, 8, 9, 1
0][1
, 3
, 5, 7, 9][1
, 4
, 7, 1
0][1
, 6][2, 4
, 6, 8] [list=1
]
[*]切片使用指定的步长还可以是负数, 此时是从后往前举行取元素。表现 “每访问一个元素之后, 下标自减几步”
alist =
; [1
, 2, 3
, 4
, 5, 6, 7, 8, 9, 1
0]print(alist[::-1
])print(alist[::-2])print(alist[::-3
])print(alist[::-5]) 打印࿱
a;
[1
0, 9, 8, 7, 6, 5, 4
, 3
, 2, 1
][1
0, 8, 6, 4
, 2][1
0, 7, 4
, 1
][1
0, 5] [list=1
]
[*]假如切片中填写的数字越界了, 不会有负面结果。只会尽大概的把满足条件的元素已往到。
alist =
; [1
, 2, 3
, 4
]print(alist[1
00:200]) 打印࿱
a;
[]
alist =
; [1
, 2, 3
, 4
]print(alist[3
:200]) 打印࿱
a;
[4
] 5. 遍历列表元素
“遍历” 指的是把元素一个一个的取出来, 再分别举行处置惩罚。
[list=1
]
[*] 最简单的办法就是使用 for 循环
elem就代表了列表里的每个元素
alist =
; [1
, 2, 3
, 4
]for elem in alist: print(elem) 打印࿱
a;
1
23
4
关于elem࿱
a;
代码1
࿱
a;
alist =
; [1
, 2, 3
, 4
]for elem in alist: elem =
; elem 
3
; 1
0 print(elem)打印࿱
a;
1
1
1
21
3
1
4
为什么会如许呢࿱
f;
由于elem就代表了列表里的每个元素， elem =
; elem 
3
; 1
0相称于1

3
;1
0࿱
b;2
3
;1
0࿱
b;3

3
;1
0࿱
b;4

3
;1
0。
改变的是elem，不会改变列表元素。
代码2࿱
a;
alist =
; [1
, 2, 3
, 4
]for i in range(0, len(alist)): alist =
; alist 
3
; 1
0 print(alist)打印࿱
a;
1
1
1
21
3
1
4
代码2固然和代码1
打印内容一样，现实上有很大的区别࿱
a;
代码1
改变的是elem，不会改变列表元素。
代码2改变的是alist，也就是列表元素，会改变列表元素。
[list=1
]
[*]也可以使用 for 按照范围天生下标, 按下标访问
alist =
; [1
, 2, 3
, 4
]for i in range(0, len(alist)): print(alist) 打印࿱
a;
1
23
4
[list=1
]
[*]还可以使用 while 循环。手动控制下标的厘革
alist =
; [1
, 2, 3
, 4
]i =
; 0while i < len(alist): print(alist) i 
3
;=
; 1
打印࿱
a;
1
23
4
6. 新增元素
[list=1
]
[*]使用 append 方法, 向列表末端插入一个元素(尾插)。
alist =
; [1
, 2, 3
, 4
]alist.append(
9;hello
9;)print(alist) 打印࿱
a;
[1
, 2, 3
, 4
, 
9;hello
9;] [list=1
]
[*]使用 insert 方法, 向恣意位置插入一个元素
insert 第一个参数表现要插入元素的下标。
alist =
; [1
, 2, 3
, 4
]alist.insert(1
, 
9;hello
9;)print(alist) 打印࿱
a;
[1
, 
9;hello
9;, 2, 3
, 4
] 什么是 “方法” (method)
方法着实就是函数。只不外函数是独立存在的, 而方法每每要依附于某个 “对象”。
像上述代码 alist.append , append 就是依附于 alist, 相称于是 “针对 alist 这个列表, 举行尾插使用”。
alist =
; [1
, 2, 3
, 4
]alist.insert(1
00, 
9;hello
9;)alist.insert(-1
00, 
9;hello
9;)print(alist) 打印࿱
a;
[
9;hello
9;, 1
, 2, 3
, 4
, 
9;hello
9;] 7. 查找元素
[list=1
]
[*]使用 in 使用符, 判断元素是否在列表中存在，返回值是布尔范例。
alist =
; [1
, 2, 3
, 4
]print(2 in alist)print(1
0 in alist)print(1
0 not in alist) 打印࿱
a;
True
False
True
[list=1
]
[*]使用 index 方法, 查找元素在列表中的下标，返回值是一个整数。
alist =
; [1
, 2, 3
, 4
]print(alist.index(2)) 打印࿱
a;
1
假如元素不存在, 则会抛出非常。
alist =
; [1
, 2, 3
, 4
]print(alist.index(2))print(alist.index(1
0)) 打印࿱
a;
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pbWctYmxvZy5jc2RuaW1nLmNuL2ltZ19jb252ZXJ0LzMKMQowNAo2YmI4MQowZmU2MwpjNzMKOGRhNzc5NjJmNApjZjkyZS5wbmc=
8. 删除元素
[list=1
]
[*]使用 pop 方法删除最末端元素
alist =
; [1
, 2, 3
, 4
]alist.pop()print(alist) 打印࿱
a;
[1
, 2, 3
] [list=1
]
[*]pop 也能按照下标来删除恣意位置的元素
alist =
; [1
, 2, 3
, 4
]alist.pop(2)print(alist) 打印࿱
a;
[1
, 2, 4
] [list=1
]
[*]使用 remove 方法, 按照值删除元素.
alist =
; [1
, 2, 3
, 4
]alist.remove(2)print(alist) 打印࿱
a;
[1
, 3
, 4
] 9. 毗连列表
[list=1
]
[*] 使用 
3
; 可以或许把两个列表拼接在一起。
此处的 
3
; 结果会天生一个新的列表。而不会影响到旧列表的内容。
alist =
; [1
, 2, 3
, 4
]blist =
; print(alist 
3
; blist) 打印࿱
a;
[1
, 2, 3
, 4
, 5, 6, 7] [list=1
]
[*]使用 extend 方法, 相称于把一个列表拼接到另一个列表的反面。
a.extend(b) , 是把 b 中的内容拼接到 a 的末端。不会修改 b, 但是会修改 a。
alist =
; [1
, 2, 3
, 4
]blist =
; c =
; alist.extend(blist)# extend是没有返回值的。# 拿一个变量来吸收一个没有返回值的方法的返回值就会返回None。类似于C里的NULL（空指针 ），大概Java内里的null（空引用）print(alist)print(blist)print(c) 打印࿱
a;
[1
, 2, 3
, 4
, 5, 6, 7]# alist# blistNone# 这是Python内里一个特殊变量的值，表现什么都没有 [list=1
]
[*]使用
3
;=
;来举行拼接
a =
; [1
, 2, 3
, 4
]b =
; a 
3
;=
; bprint(a)print(b) 打印࿱
a;
[1
, 2, 3
, 4
, 5, 6, 7, 8] 固然这里的
3
;=
;使用和上面的extend使用有点像，但是本质上是差别的。
a
3
;=
;b等价于a=
;a
3
;b，a
3
;b会产生一个大的新的暂时列表c，然后把c的值赋值给a，再去烧毁c，相称于a的旧的值就不要了。
a.extend(b)则是直接把b的内容拼到了a的反面，更加高效，省去了数据拷贝和数据开释的过程。
1
0. 关于元组
元组的功能和列表相比, 根本是划一的。
[list=1
]
[*]元组使用 ( ) 来表现。
a =
; ()# 方法1
b =
; tuple()# 方法2print(type(a))print(type(b)) 打印࿱
a;
<class 
9;tuple
9;><class 
9;tuple
9;> [list=1
]
[*]创建元组的时间，指定初始值
a =
; (1
, 2, 3
, 4
)print(a) 打印࿱
a;
(1
, 2, 3
, 4
) [list=1
]
[*]元组中的元素也可以是恣意范例的
b =
; (1
, 2, 
9;hello
9;, True, []
)print(b) 打印࿱
a;
(1
, 2, 
9;hello
9;, True, []
) [list=1
]
[*]通过下标来访问元组中的元素。下标也是从0开始到 len - 1
竣事。
a =
; (1
, 2, 3
, 4
)print(a[1
])print(a[-1
]) 打印࿱
a;
2
4
a =
; (1
, 2, 3
, 4
)print(a[1
])print(a[-1
]) 打印࿱
a;
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pbWctYmxvZy5jc2RuaW1nLmNuL2ltZ19jb252ZXJ0LzhkNAoyMwoxCjEKNmY3ZjEKY2ZjZmVlZjcwNAozCjAwMwpiMmFmOGUucG5n
[list=1
]
[*]通过切片来获取元组中的一个部门
a =
; (1
, 2, 3
, 4
)print(a[1
:3
]) 打印࿱
a;
(2, 3
) [list=1
]
[*]元组也同样可以使用for循环等方式来举行遍历元素
a =
; (1
, 2, 3
, 4
)for elem in a: print(elem) 打印࿱
a;
1
23
4
[list=1
]
[*]可以使用in来判断元素是否存在，使用index来查找元素的下标
a =
; (1
, 2, 3
, 4
)print(3
in a)print(a.index(3
)) 打印࿱
a;
True
2
[list=1
]
[*]可以使用
3
;来拼接两个元组（本质上是创建一个新的大元组）
a =
; (1
, 2, 3
, 4
)b =
; (5, 6, 7, 8)print(a 
3
; b) 打印࿱
a;
(1
, 2, 3
, 4
, 5, 6, 7, 8) 元组不能修改内里的元素, 列表则可以修改内里的元素
因此, 像读使用,比如访问下标, 切片, 遍历, in, index, 
3
; 等, 元组也是一样支持的。
但是, 像写使用, 比如修改元素, 新增元素, 删除元素, extend 等, 元组则不能支持。
别的, 元组在 Python 中很多时间是默认的聚集范例。
[list=1
]
[*]当举行多元函数赋值的时间，着实本质上就是按照元组的方式来举行工作的 。
比方, 当一个函数返回多个值的时间࿱
a;
def getPoint(): return 1
0, 20result =
; getPoint()# 界说result本质上就是创建一个元组print(type(result)) 打印࿱
a;
<class 
9;tuple
9;> 此处的 result 的范例tuple, 着实是元组。
标题来了, 既然已经有了列表, 为啥还必要有元组࿱
f;
元组相比于列表来说, 上风有两方面࿱
a;
你有一个列表, 如今必要调用一个函数举行一些处置惩罚。但是你有不是特殊确认这个函数是否会把你的列表数据弄乱。那么这时间传一个元组就安全很多。
元组不能被修改->不可变对象。而不可变对象是可以哈希的。
立刻要讲的字典, 是一个键值对结构。要求字典的键必须是 “可hash对象” (字典本质上也是一个hash表)。
而一个可hash对象的条件就是不可变，因此元组可以作为字典的键, 但是列表不可。
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！qidao1
23
.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金
页:
[1]