我们准备利用17天时间,将 Python 基础的刻意练习分为如下任务:
Task01:变量、运算符与数据类型(1day)
Task02:条件与循环(1day)
Task03:列表与元组(2day)
Task04:字符串与序列(1day)
Task05:函数与Lambda表达式(2day)
Task06:字典与集合(1day)
Task07:文件与文件系统(2day)
Task08:异常处理(1day)
Task09:else 与 with 语句(1day)
Task10:类与对象(2day)
Task11:魔法方法(2day)
Task12:模块(1day)
Task03:列表与元组(2day)
1. 列表
「列表」定义语法为 [元素1, 元素2, …, 元素n]
关键点是「中括号 []」和「逗号 ,」
- 中括号 把所有元素绑在一起
- 逗号 将每个元素一一分开
- 列表是有序集合,没有固定大小,能够保存任意数量任意类型的 Python 对象。
1.创建列表
创建一个普通列表
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week, type(week))
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'] <class 'list'>
number = [2, 3, 4, 5, 6, 7]
print(number, type(number))
# [2, 3, 4, 5, 6, 7] <class 'list'>
创建一个混合列表
mix = [1, 'lsgo', 3.14, [1, 2, 3]]
print(mix) # [1, 'lsgo', 3.14, [1, 2, 3]]
创建一个空列表
empty = []
print(empty) # []
列表不像元组,列表内容可更改 (mutable),因此附加 (append, extend)、插入 (insert)、删除 (remove, pop) 这些操作都可以用在它身上。
2. 向列表添加元素
append(obj) 在列表末尾添加新的对象,只接受一个参数,参数可以是任何数据类型,被追加的元素在 list 中保持着原结构类型。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
week.append('Thursday')
print(week)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday']
print(len(week)) # 6
此元素如果是一个 list,那么这个 list 将作为一个整体进行追加,注意append()和extend()的区别。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
week.append(['Thursday', 'Sunday'])
print(week)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', ['Thursday', 'Sunday']]
print(len(week)) # 6
extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
week.extend(['Thursday', 'Sunday'])
print(week)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday', 'Sunday']
严格来说 append 是追加,把一个东西整体添加在列表后,而 extend 是扩展,把一个东西里的所有元素添加在列表后。
insert(index, obj) 在编号 index 位置前插入 obj。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
week.insert(0, 'Sunday')
print(week)
# ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
3. 从列表中获取元素
跟数组一样,我们可以通过元素的索引值,从列表获取单个元素,注意,列表索引值是从0开始的。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[0]) # Monday
4. 从列表中删除元素
remove(obj) 移除列表中某个值的第一个匹配项
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
week.remove('Monday')
print(week) # ['Tuesday', 'Wednesday', 'Thursday', 'Friday']
pop([index=-1]) 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
day = week.pop()
print(day) # Friday
day = week.pop(0)
print(day) # Monday
day = week.pop(-2)
print(day) # Wednesday
remove 和 pop 都可以删除元素,前者是指定具体要删除的元素,后者是指定一个编号位置。
del var1[, var2 ……]语句:删除单个或多个对象
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
del week[0], week[1]
print(week) # ['Tuesday', 'Thursday', 'Friday']
5. 列表分片
切片的通用写法是 start : stop : step
情况 1 - “start :”
以 step 为 1 (默认) 从编号 start 往列表尾部切片。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[3:]) # ['Thursday', 'Friday']
print(week[-3:]) # ['Wednesday', 'Thursday', 'Friday']
情况 2 - “: stop”
以 step 为 1 (默认) 从列表头部往编号 stop 切片。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:3]) # ['Monday', 'Tuesday', 'Wednesday']
print(week[:-3]) # ['Monday', 'Tuesday']
情况 3 - “start : stop”
以 step 为 1 (默认) 从编号 start 往编号 stop 切片。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[1:3]) # ['Tuesday', 'Wednesday']
print(week[-3:-1]) # ['Wednesday', 'Thursday']
情况 4 - “start : stop : step”
以具体的 step 从编号 start 往编号 stop 切片。注意最后把 step 设为 -1,相当于将列表反向排列。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[1:4:2])
# ['Tuesday', 'Thursday']
print(week[:4:2])
# ['Monday', 'Wednesday']
print(week[1::2])
# ['Tuesday', 'Thursday']
print(week[::-1])
# ['Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']
6. 拷贝
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:])
# week的拷贝 ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
list1 = [123, 456, 789, 213]
list2 = list1
list3 = list1[:]
print(list2) # [123, 456, 789, 213]
print(list3) # [123, 456, 789, 213]
list1.sort()
print(list2) # [123, 213, 456, 789]
print(list3) # [123, 456, 789, 213]
7. 列表的常用操作符
比较操作符
逻辑操作符
连接操作符 +
重复操作符 *
成员关系操作符 in、not in
和元组拼接一样, 列表拼接也有两种方式,用「加号 +」和「乘号 *」,前者首尾拼接,后者复制拼接。
list1 = [123, 456]
list2 = [234, 123]
print(list1 > list2) # False
list3 = [123, 456]
print((list1 < list2) and (list1 == list3)) # True
list4 = list1 + list2 # extend()
print(list4) # [123, 456, 234, 123]
list5 = list3 * 3
print(list5) # [123, 456, 123, 456, 123, 456]
list3 *= 3
print(list3) # [123, 456, 123, 456, 123, 456]
print(123 in list3) # True
print(456 not in list3) # False
前面三种方法(append, extend, insert)可对列表增加元素,它们没有返回值,是直接修改了原数据对象。
将两个list相加,需要创建新的 list 对象,从而需要消耗额外的内存,特别是当 list 较大时,尽量不要使用 “+” 来添加list。
8. 列表的其它方法
count(obj)方法:统计某个元素在列表中出现的次数
list1 = [123, 456] * 3
print(list1) # [123, 456, 123, 456, 123, 456]
num = list1.count(123)
print(num) # 3
index(obj[, start[, end]])方法:从列表中找出某个值第一个匹配项的索引位置
list1 = [123, 456] * 5
print(list1.index(123)) # 0
print(list1.index(123, 1)) # 2
print(list1.index(123, 3, 7)) # 4
reverse()方法:反向列表中元素
list1 = [123, 456, 789]
list1.reverse()
print(list1) # [789, 456, 123]
sort(key=None, reverse=False)方法:对原列表进行排序
list1 = [123, 456, 789, 213]
list1.sort()
print(list1) # [123, 213, 456, 789]
list1.sort(reverse=True)
print(list1) # [789, 456, 213, 123]
元组
「元组」定义语法为:(元素1, 元素2, …, 元素n)
小括号把所有元素绑在一起
逗号将每个元素一一分开
1. 创建和访问一个元组
Python 的元组与列表类似,不同之处在于tuple被创建后就不能对其进行修改,类似字符串。
元组使用小括号,列表使用方括号。
t1 = (1, 10.31, 'python')
t2 = 1, 10.31, 'python'
print(t1, type(t1))
# (1, 10.31, 'python') <class 'tuple'>
print(t2, type(t2))
# (1, 10.31, 'python') <class 'tuple'>
tuple1 = (1, 2, 3, 4, 5, 6, 7, 8)
print(tuple1[1]) # 2
print(tuple1[5:]) # (6, 7, 8)
print(tuple1[:5]) # (1, 2, 3, 4, 5)
tuple2 = tuple1[:]
print(tuple2) # (1, 2, 3, 4, 5, 6, 7, 8)
- 创建元组可以用小括号 (),也可以什么都不用,为了可读性,建议还是用 ()。
- 元组中只包含一个元素时,需要在元素后面添加逗号,否则括号会被当作运算符使用:
temp = (1)
print(type(temp)) # <class 'int'>
temp = 2, 3, 4, 5
print(type(temp)) # <class 'tuple'>
temp = []
print(type(temp)) # <class 'list'>
temp = ()
print(type(temp)) # <class 'tuple'>
temp = (1,)
print(type(temp)) # <class 'tuple'>
例子2:
print(8 * (8)) # 64
print(8 * (8,)) # (8, 8, 8, 8, 8, 8, 8, 8)
当然也可以创建二维元组:
nested = (1, 10.31, 'python'), ('data', 11)
print(nested)
# ((1, 10.31, 'python'), ('data', 11))
元组中可以用整数来对它进行索引 (indexing) 和切片 (slicing),不严谨的讲,前者是获取单个元素,后者是获取一组元素。接着上面二维元组的例子,先看看索引的代码:
print(nested[0])
# (1, 10.31, 'python')
print(nested[0][0], nested[0][1], nested[0][2])
# 1 10.31 python
再看看切片的代码:
print(nested[0][0:2])
# (1, 10.31)
2.更新和删除一个元组
例子1:
week = ('Monday', 'Tuesday', 'Thursday', 'Friday')
week = week[:2] + ('Wednesday',) + week[2:]
print(week) # ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')
例子2:
t1 = (1, 2, 3, [4, 5, 6])
print(t1) # (1, 2, 3, [4, 5, 6])
t1[3][0] = 9
print(t1) # (1, 2, 3, [9, 5, 6])
元组有不可更改 (immutable) 的性质,因此不能直接给元组的元素赋值,但是只要元组中的元素可更改 (mutable),那么我们可以直接更改其元素,注意这跟赋值其元素不同。
3. 元组相关的操作符
比较操作符
逻辑操作符
连接操作符 +
重复操作符 *
成员关系操作符 in、not in
元组拼接 (concatenate) 有两种方式,用「加号 +」和「乘号 *」,前者首尾拼接,后者复制拼接。
t1 = (2, 3, 4, 5)
t2 = ('老马的程序人生', '小马的程序人生')
t3 = t1 + t2
print(t3) # (2, 3, 4, 5, '老马的程序人生', '小马的程序人生')
t4 = t2 * 2
print(t4) # ('老马的程序人生', '小马的程序人生', '老马的程序人生', '小马的程序人生')
4. 内置方法
元组大小和内容都不可更改,因此只有 count 和 index 两种方法。
t = (1, 10.31, 'python')
print(t.count('python')) # 1
print(t.index(10.31)) # 1
count(‘python’) 是记录在元组 t 中该元素出现几次,显然是 1 次
index(10.31) 是找到该元素在元组 t 的索引,显然是 1
5. 解压元组
解压(unpack)一维元组(有几个元素左边括号定义几个变量)
t = (1, 10.31, 'python')
(a, b, c) = t
print(a, b, c)
# 1 10.31 python
解压二维元组(按照元组里的元组结构来定义变量)
t = (1, 10.31, ('OK', 'python'))
(a, b, (c, d)) = t
print(a, b, c, d)
# 1 10.31 OK python
如果你只想要元组其中几个元素,用通配符「*」,英文叫 wildcard,在计算机语言中代表一个或多个元素。下例就是把多个元素丢给了 rest 变量。
t = 1, 2, 3, 4, 5
a, b, *rest, c = t
print(a, b, c) # 1 2 5
print(rest) # [3, 4]
如果你根本不在乎 rest 变量,那么就用通配符「*」加上下划线「_」,例子如下:
a, b, *_ = t
print(a, b) # 1 2