《疯狂Python讲义》读书笔记——第3章 列表、元组和字典

目录

 

3.1 序列简介

3.1.1 Python的序列

3.1.2 创建列表和元组

3.2 列表和元组的通用用法（不涉及改变元组的操作）

3.2.1 通过索引使用元组

3.2.2 子序列（slice切片）——使用索引获取中间的一段

3.2.3 加法

3.2.4 乘法

3.2.5 in运算符

3.2.6 长度、最大值和最小值（len()、max()、min()三个全局函数）

3.2.7 序列封包和序列解包

3.3 使用列表

3.3.1 创建列表

3.3.2 增加列表元素

3.3.3 删除列表元素

3.3.4 修改列表元素

3.3.5 列表的其他常用方法

3.4 使用字典

3.4.1 字典入门

3.4.2 创建字典

3.4.3 字典的基本用法（对字典的操作都是基于key的）

3.4.4 字典的常用方法

3.4.5 使用字典格式化字符串

---

3.1 序列简介

序列——是一种包含多项数据的数据结构。

3.1.1 Python的序列

常见类型：字符串、列表、元组等。

3.1.2 创建列表和元组

语法：

1. 创建列表：[元素1,元素2,.....]
2. 创建元组：(元素1,元素2,.....)

例如：

#使用方括号定义列表
my_list = ['春眠不觉晓，','处处闻啼鸟。','夜来风雨声，','花落知多少。']
print(my_list)
#使用圆括号定义元组
my_tuple = ('春眠不觉晓，','处处闻啼鸟。','夜来风雨声，','花落知多少。')
print(my_tuple)

3.2 列表和元组的通用用法（不涉及改变元组的操作）

3.2.1 通过索引使用元组

它们的索引都是从0开始，并支持负数索引。列表的索引相当于一个变量，元组的元素相当于一个常量。

例如：

#*****************************
#***程序名称：index_test.py
#***程序功能：使用列表和元组的元素
#***编写日期：2019-2-12
#*****************************
a_tuple = ('crazyit',20,5.6,'fkit',-17)
print(a_tuple)
#访问第1个元素
print(a_tuple[0])
#访问第2个元素
print(a_tuple[1])
#访问倒数第1个元素
print(a_tuple[-1])
#访问倒数第2个元素
print(a_tuple[-2])

3.2.2 子序列（slice切片）——使用索引获取中间的一段

语法格式：[start:end:step]

例如：

#*****************************
#***程序名称：slice_test.py
#***程序功能：使用start、end获取元组中间一段的用法(叫切片或分片)
#***编写日期：2019-2-12
#*****************************
a_tuple = ('crazyit',20,5.6,'fkit',-17)
#访问从第2个到第4个（不包含）的所有元素
print(a_tuple[1:3])
#访问从倒数第3个到倒数第1个（不包含）的所有元素
print(a_tuple[-3:-1])
#访问从第2个到倒数第2个（不包含）的所有元素
print(a_tuple[1:-2])
#访问从倒数第3个到第5个（不包含）的所有元素
print(a_tuple[-3:4])
b_tuple = (1,2,3,4,5,6,7,8,9)
#访问从第3个到第9个（不包含）、间隔为2的所有元素
print(b_tuple[2:8:2])
#访问从第3个到第9个（不包含）、间隔为3的所有元素
print(b_tuple[2:8:3])
#访问从第3个到倒数第2个（不包含）、间隔为2的所有元素
print(b_tuple[2:-2:2])

3.2.3 加法

注意：列表只能和列表相加；元组只能和元组相加；元组不能直接和列表相加。

例如：

#*****************************
#***程序名称：plus_test.py
#***程序功能：元组和列表的加法运算
#***编写日期：2019-2-12
#*****************************
a_tuple = ('crazyit',20,-1.2)
b_tuple = (127,'crazyit','fkit',3.33)
#计算元组相加
sum_tuple = a_tuple + b_tuple
print(sum_tuple)	#('crazyit',20,-1.2,127,'crazyit','fkit',3.33)
print(a_tuple)	#a_tuple并没有改变
print(b_tuple)	#b_tuple并没有改变
#两个元组相加
print(a_tuple + (-20,-30))
#下面代码报错：元组和列表不能直接相加
#print(a_tuple + [-20,-30])
a_list = [20,30,50,100]
b_list = ['a','b','c']
#计算列表相加
sum_list = a_list + b_list
print(sum_list)	#[20,30,50,100,'a','b','c']
print(a_list + ['fkit'])	#[20,30,50,100,'fkit']

3.2.4 乘法

列表和元组的乘法：把它们所包含的元素重复N次。

例如：

#*****************************
#***程序名称：multiple_test.py
#***程序功能：元组和列表的乘法运算
#***编写日期：2019-2-13
#*****************************
role_Hp = ('生命',20)
#执行元组乘法
mul_Hp = role_Hp * 3
print(mul_Hp)
#执行列表乘法
role_Hit = ['攻击',2]
mul_Hit = role_Hit * 3
print(mul_Hit)

另：

#*****************************
#***程序名称：translate.py
#***程序功能：对元组和列表同时进行加法、乘法运算。
#例如：把用户输入的日期翻译成英文表示的形式——就是添加英文的'第'后缀。
#***编写日期：2019-2-13
#*****************************
#同时对元组使用加法、乘法
order_endings = ('st','nd','rd')+('th',)*17+('st','nd','rd')+('th',)*7+('st',)
#将会看到st、nd、rd、17个th、st、nd、rd、7个th、st
#为了表示只有一个元素的元组，必须在唯一的元组元素之后添加英文逗号。
print(order_endings)
day = input("输入日期（1-31）:")
#将字符串转成整数
day_int = int(day)
print(day + order_endings[day_int - 1])

3.2.5 in运算符

——用于判断列表或元组是否包含某个元素。

例如：

a_tuple = ('两个黄鹂鸣翠柳','一行白鹭上青天',100)
print(100 in a_tuple)    #True
print(2 in a_tuple)    #False
print('门泊东吴万里船' not in a_tuple)    #True

3.2.6 长度、最大值和最小值（len()、max()、min()三个全局函数）

例如：

#*****************************
#***程序名称：func_test.py
#***程序功能：Python提供了内置的len()、max()、min()全局函数
#来获取元组或列表的长度、最大值和最小值。
#要求：传递给max()、min()函数的元组、列表的元素必须是相同类型且可以比较大小。
#***编写日期：2019-2-13
#*****************************
#元素都是数值的元组
a_tuple = (20,10,-2,15.2,102,50)
#计算最大值
print('a_tuple的最大值:',max(a_tuple))
#计算最小值
print('a_tuple的最小值:',min(a_tuple))
#计算长度
print('a_tuple的长度:',len(a_tuple))
#元素都是字符串的列表
b_list = ['crazyit','fkit','Python','Kotlin']
#计算最大值(依次比较每个字符的ASCII码值，先比较第一个字符，再比较第一个字符，若相同，再比较第二个，以此类推)
print('b_list的最大值:',max(b_list))
#计算最小值
print('b_list的最小值:',min(b_list))
#计算长度
print('b_list的长度:',len(b_list))

3.2.7 序列封包和序列解包

——序列封包：程序把多个值赋给一个变量时，Python会自动将多个值封装成元组。这种功能被称为序列封包。（多对一）

——序列解包：程序允许将序列（元组或列表等）直接赋值给多个变量，序列的各元素会被依次赋值给每个变量（要求序列的元素个数和变量个数相等）。这种功能被称为解包。（一对多）

上代码看的明白：

#*****************************
#***程序名称：seq_packing.py
#***程序功能：示范序列封包和序列解包的功能
#***编写日期：2019-2-13
#*****************************
#序列封包：将10,20,30封装成元组后赋值给vals
vals = 10,20,30
print(vals)
print(type(vals))
#输出元组vals的第2个元素的值
print(vals[1])
a_tuple = tuple(range(1,10,2))
#序列解包：将a_tuple元组的各元素依次赋值给a,b,c,d,e变量
a,b,c,d,e = a_tuple
print(a,b,c,d,e)
a_list = ['fkit','crazyit']
#序列解包：将a_list序列的各元素依次赋值给a_str、b_str变量
a_str,b_str =a_list
print(a_str,b_str)
#将10,20,30依次赋值给x,y,z（多对多）
x,y,z = 10,20,30
print(x,y,z) 
#将y,z,x依次赋值给x,y,z（交换变量的值）
x,y,z = y,z,x
print(x,y,z)
#first、second保存前两个元素，rest列表包含剩余的元素
first,second,*rest = range(10)
print(first)
print(second)
print(rest)
#last保存最后一个元素，begin保存前面剩下的元素
*begin,last = range(10)
print(begin)
print(last)
#first保存第一个元素，last保存最后一个元素，middle保存中间剩下的元素
first,*middle,last = range(10)
print(first)
print(middle)
print(last)

3.3 使用列表

3.3.1 创建列表

（1）list()函数：用于将元组、区间（range）等对象转换为列表。

（2）tuple()函数：用于将列表、区间等对象转换为元组。

例如：

#*****************************
#***程序名称：list_test.py
#***程序功能：list()函数可用于将元组、区间(range)等对象转换为列表
#***编写日期：2019-2-13
#*****************************
a_tuple = ('crazyit',20,-1.2)
#将元组转换成列表
a_list = list(a_tuple)
print(a_list)
#使用range()函数创建区间(range)对象
a_range = range(1,5)
print(a_range)		#rang(1,5)
#将区间转换成列表
b_list = list(a_range)
print(b_list)		#[1,2,3,4]
#创建区间时还指定了步长
c_list = list(range(4,20,3))
print(c_list)			#[4,7,10,13,16,19]

#*****************************
#***程序名称：tuple_test.py
#***程序功能：tuple()函数可用于将列表、区间(range)等对象转换为元组。
#***编写日期：2019-2-13
#*****************************
a_list = ['crazyit',20,-1.2]
#将列表转换成元组
a_tuple = tuple(a_list)
print(a_tuple)
#使用range()函数创建区间(range)对象
a_range = range(1,5)
print(a_range)
#将区间转换成元组
b_tuple = tuple(a_range)
print(b_tuple)
#创建区间时还指定了步长
c_tuple = tuple(range(4,20,3))
print(c_tuple)	#[4,7,10,13,16,19]

3.3.2 增加列表元素

（1）append()方法：把传入的参数追加到列表的最后面。即可接受单个值，也可接受元组、列表等，但该方法只是把元组、列表当成当个元素，形成在列表中嵌套列表、嵌套元组的情形。

（2）extend()方法：不将被追加的列表当成一个整体，只是追加列表中的元素。

（3）insert()方法：在列表中间增加元素，要指定将元素插入到列表的哪个位置。

例如：

#*****************************
#***程序名称：append_test.py
#***程序功能：append()方法把传入的参数追加到列表的最后面
#***         extend()方法只追加列表中的元素不将被追加的列表当成一个整体。
#***         insert()方法将元素插入指定的位置。
#***编写日期：2019-2-13
#*****************************
a_list = ['crazyit',20,-2]
#追加元素
a_list.append('fkit')
print(a_list)		#['crazyit',20,-2,'fkit']
a_tuple = (3.4,5.6)
#追加元组，元组被当成一个元素
a_list.append(a_tuple)
print(a_list)		#['crazyit',20,-2,'fkit',(3.4,5.6)]
#追加列表，列表被当成一个元素
a_list.append(['a','b'])
#使用extend()方法
b_list = ['a',30]
#追加元组中的所有元素
b_list.extend((-2,3.1))
print(b_list)		#['a',30,-2,3.1]
#追加列表中的所有元素
b_list.extend(['C','R','A'])
print(b_list)		#['a',30,-2,3.1,'C','R','A']
#追加区间中的所有元素
b_list.extend(range(97,100))
print(b_list)	#['a',30,-2,3.1,'C','R','A',97,98,99]
#使用列表的insert()方法，将元素插入列表的指定位置
c_list = list(range(1,6))
print(c_list)
#在索引3处插入字符串
c_list.insert(3,'CRAZY')
print(c_list)		#[1,2,3,'CRAZY',4,5]
#在索引3处插入元组，元组被当成一个元素
c_list.insert(3,tuple('CRAZY'))
print(c_list)		#[1,2,3,('C','R','A','Z','Y'),'CRAZY',4,5]

3.3.3 删除列表元素

（1）del语句：删除列表的元素、变量。

（2）remove方法：根据元素本身来执行删除列表元素的操作。该方法只删除第一个找到的元素，如果找不到该元素，该方法将会引发ValueError错误。

（3）clear()方法：用于清空列表的所有元素。

例如：

#*****************************
#***程序名称：delete_test.py
#***程序功能：delete语句删除列表元素
#***编写日期：2019-2-14
#*****************************
a_list = ['crazyit',20,-2.4,(3,4),'fkit']
#删除第3个元素
del a_list[2]
print(a_list)
#删除第2个到第4个（不包含）元素
del a_list[1:3]
print(a_list)
b_list = list(range(1,10))
#删除第3个到倒数第2个（不包含）元素，间隔为2
del b_list[2:-2:2]
print(b_list)	#[[1, 2, 4, 6, 8, 9]
#删除第3个到第5个(不包含)元素，间隔为2
del b_list[2:4]		
print(b_list)	#[1, 2, 8, 9]
name = 'crazyit'
print(name)        #NameError
#删除name变量
del name
#print(name)
#remove()方法删除列表元素
c_list = [20,'crazyit',30,-4,'crazyit',3.4]
#删除第一次找到的30
c_list.remove(30)
print(c_list)
#删除第一次找到的'crazyit'
c_list.remove('crazyit')
print(c_list)
#clear()方法清空列表的所有元素
c_list.clear()
print(c_list)

3.3.4 修改列表元素

（1）通过索引对列表赋值，既可以使用正数索引，也可以使用负数索引。

（2）对列表中空的slice赋值，变为列表插入元素。

（3）将列表其中一段赋值为空列表，变为了从列表中删除元素。

（4）使用字符串赋值，Python自动把字符串当成列表处理，其中每个字符都是一个元素。

（5）如果使用slice语法赋值，并指定step参数，则要求所赋值的列表元素个数与所替换的列表元素个数相等。

例如：

#*****************************
#***程序名称：update_test.py
#***程序功能：修改列表元素
#***编写日期：2019-2-14
#*****************************
a_list=[2,4,-3.4,'crazyit',23]
#对第三个元素赋值
a_list[2]='fkit'
print(a_list)	#输出[2,4,'fkit','crazyit',23]
#对倒数第2个元素赋值
a_list[-2]=9527
print(a_list)	#输出[2,4,'fkit',9527,23]
b_list=list(range(1,5))
print(b_list)
#将第2个到第4个(不包含)元素赋值为新列表的元素
b_list[1:3]=['a','b']
print(b_list)
#如果对列表中空的slice赋值，就变成为列表插入元素
#将第3个到第3个(不包含)元素赋值为新列表的元素，就是插入元素
b_list[2:2]=['x','y']
print(b_list)	#将输出[1, 'a','x','y','b', 4]
#将第3个到第6个(不包含)元素赋值为空列表，就是删除元素
b_list[2:5]=[]
print(b_list)	#将输出[1, 'a', 4]
#Python会自动将str分解成序列
b_list[1:3]='Charlie'
print(b_list)	#将输出[1, 'C','h','a','r','l','i','e']
c_list=list(range(1,10))
#指定step为2，被赋值的元素有4个，因此用于赋值的列表也必须有4个元素
c_list[2:9:2]=['a','b','c','d']
print(c_list)	#将输出[1, 2, 'a', 4, 'b', 6, 'c', 8, 'd']

3.3.5 列表的其他常用方法

（1）count()：用于统计列表中某个元素出现的次数。

（2）index()：用于判断某个元素在列表中出现的位置。

（3）pop()：用于将列表当成“栈”使用，实现元素出栈功能。

（4）reverse()：用于将列表中的元素反向存放。

（5）sort(key,reverse)：用于对列表元素排序。

例如：

#*****************************
#***程序名称：count_test.py
#***程序功能：count()统计列表中某个元素出现的次数
#***编写日期：2019-2-14
#*****************************
a_list = [2,30,'a',[5,30],30]
#计算列表中30出现的次数
print(a_list.count(30))
#计算列表中[5,30]出现的次数
print(a_list.count([5,30]))

#*****************************
#***程序名称：index_test.py
#***程序功能：index()定位列表中某个元素出现的位置
#***编写日期：2019-2-14
#*****************************
a_list = [2,30,'a','b','crazyit',30]
#定位元素30出现的位置
print(a_list.index(30))
#从索引2开始，定位元素30出现的位置
print(a_list.index(30,2))
#在索引1到索引4之间定位元素30出现的位置，若找不到该元素，出现ValueError错误
print(a_list.index(30,1,4))

#*****************************
#***程序名称：stack_test.py
#***程序功能：pop()实现元素的出栈功能——先入后出（FILO）
#***编写日期：2019-2-14
#*****************************
stack = []
#向栈中入栈3个元素
stack.append('fkit')
stack.append('crazyit')
stack.append('Charlie')
print(stack)	#输出['fkit', 'crazyit', 'Charlie']
#第一次出栈：最后入栈的元素被移出栈
print(stack.pop())		#返回出栈的元素Charlie
print(stack)	#['fkit', 'crazyit']
#再次出栈
print(stack.pop())	#返回出栈的元素crazyit
print(stack)	#['fkit']

#*****************************
#***程序名称：reverse_test.py
#***程序功能：reverse()方法会将列表中的所有元素的顺序反转
#***编写日期：2019-2-14
#*****************************
a_list = list(range(1,8))
#将a_list列表元素反转
a_list.reverse()
print(a_list)	#[7, 6, 5, 4, 3, 2, 1]

#*****************************
#***程序名称：sort_test.py
#***程序功能：sort()方法对列表中的所有元素的进行排序
#***编写日期：2019-2-14
#*****************************
a_list = [3,4,-2,-30,14,9.3,3.4]
#对列表元素排序
a_list.sort()
print(a_list)	#[-30, -2, 3, 3.4, 4, 9.3, 14]
b_list = ['Python','Swift','Ruby','Go','Kotlin','Erlang']
#对列表元素排序，默认按字符串包含的字符的编码来比较大小
b_list.sort()
print(b_list)	#['Erlang', 'Go', 'Kotlin', 'Python', 'Ruby', 'Swift']
#指定key为len，指定使用len函数对集合元素生成比较大小的键
#也就是按字符串的长度比较大小
b_list.sort(key=len)
print(b_list)	#['Go', 'Ruby', 'Swift', 'Erlang', 'Kotlin', 'Python']
#指定反向排序
b_list.sort(key=len,reverse=True)	#reverse参数用于执行是否需要反转排序
print(b_list)	#['Erlang', 'Kotlin', 'Python', 'Swift', 'Ruby', 'Go']

3.4 使用字典

——字典是Python提供的一种常用的数据结构，用于存放具有映射关系的数据。

3.4.1 字典入门

 

由于字典中的key是非常关键的数据，而且程序需要通过key来访问value，因此字典中的key不允许重复。

3.4.2 创建字典

（1）使用花括号（{}）语法来创建字典；

（2）使用dict()函数创建字典。

3.4.3 字典的基本用法（对字典的操作都是基于key的）

（1）通过key访问value；

（2）通过key添加key-value对；

（3）通过key删除key-value对；

（4）通过key修改key-value对；

（5）通过key判断指定key-value对是否存在。（使用in或not in 运算符）

3.4.4 字典的常用方法

（1）clear()：清空字典中的所有键值对，字典变为空字典。

#*****************************
#***程序名称：clear_basic.py
#***程序功能：clear()用于清空字典中所有的key-value对
#***编写日期：2019-2-14
#*****************************
cars = {'BMW':8.5,'BENS':8.3,'AUDI':7.9}
print(cars)
#清空cars的所有key-value对
cars.clear()
print(cars)

（2）get()：根据key获取value，相当于方括号的增强版。

#*****************************
#***程序名称：get_basic.py
#***程序功能：get()根据key来获取value
#***编写日期：2019-2-14
#*****************************
cars = {'BMW':8.5,'BENS':8.3,'AUDI':7.9}
#获取BMW对应的value
print(cars.get('BMW'))
print(cars.get('PORSCHE'))
#print(cars['PORSCHE'])	#KeyError

（3）update()：使用一个字典所包含的键值对来更新已有的字典。

cars = {'BMW':8.5,'BENS':8.3,'AUDI':7.9}
cars.update({'BMW':4.5,'PORSCHE':9.3})
print(cars)	#输出{'BMW': 4.5, 'BENS': 8.3, 'AUDI': 7.9, 'PORSCHE': 9.3}

（4）items()、keys()、values()分别用于获取字典中的所有key-value对、所有key、所有value。Python不希望用户直接操作这几个方法，但可通过list()函数吧它们转换成列表。

cars = {'BMW':8.5,'BENS':8.3,'AUDI':7.9}
#获取字典中的所有key-value对，返回一个dict_items对象
ims = cars.items()	
print(type(ims))	#
#将dict_items转换成列表
print(list(ims))	#[('BMW', 8.5), ('BENS', 8.3), ('AUDI', 7.9)]
#访问第2个key-value对
print(list(ims)[1])	#('BENS', 8.3)
#获取字典中所有的key，返回一个dict_keys对象
kys = cars.keys()
print(type(kys))	#
#将dict_keys转换成列表
print(list(kys))	#['BMW', 'BENS', 'AUDI']
#访问第2个key
print(list(kys)[1])	#BENS
#获取字典中的所有的value，返回一个dict_values对象
vals = cars.values()
#将dict_values转换成列表
print(type(vals))	#
print(list(vals))	#[8.5, 8.3, 7.9]
#访问第2个value
print(list(vals)[1])	#8.3

（5）pop()：该方法用于获取指定key对应的value，并删除这个key-value对。

cars = {'BMW':8.5,'BENS':8.3,'AUDI':7.9}
print(cars.pop('AUDI'))		#7.9
print(cars)		#{'BMW': 8.5, 'BENS': 8.3}

（6）popitem()：该方法用于随机弹出字典中的一个key-value对。

#*****************************
#***程序名称：popitem_test.py
#***程序功能：随机弹出字典中的一个key-value对
#实际上popitem()方法总是弹出底层存储的最后一个key-value
#***编写日期：2019-2-15
#*****************************
cars = {'BMW':8.5,'BENS':8.3,'AUDI':7.9}
print(cars)
#弹出字典底层存储的最后一个key-value对
print(cars.popitem())			#('AUDI', 7.9)
print(cars)	#{'BMW': 8.5, 'BENS': 8.3}
#将弹出项的key赋值给k,value赋值给v
k,v=cars.popitem()
print(k,v)	#BENS 8.3

（7）setdefault()：该方法用于根据key来获取对应的value的值。

cars = {'BMW':8.5,'BENS':8.3,'AUDI':7.9}
#设置默认值，该key在dict中不存在，新增key-value对
print(cars.setdefault('PORSCHE',9.2))		#9.2
print(cars)
#设置默认值，该key在dict中存在，不会修改dict内容
print(cars.setdefault('BMW',3.4))		#8.5
print(cars)

（8）fromkeys()：该方法使用给定的多个key创建字典，这些key对应的value默认都是None；也可以额外传入一个参数作为默认的value。

#使用列表创建包含两个key的字典
a_dict=dict.fromkeys(['a','b'])
print(a_dict)		#{'a': None, 'b': None}
#使用元组创建包含两个key的字典
b_dict=dict.fromkeys((13,17))
print(b_dict)		#{13: None, 17: None}
#使用元组创建包含两个key的字典，指定默认值的valuec
c_dict=dict.fromkeys((13,17),'good')
print(c_dict)			#{13: 'good', 17: 'good'}

3.4.5 使用字典格式化字符串

#在字符串模板中使用key
temp = '书名是:%(name)s,价格是:%(price)010.2f,出版社是:%(publish)s'
book = {'name':'疯狂Python讲义','price':88.9,'publish':'电子社'}
#使用字典为字符串模板中的key传入值
print(temp % book)
book = {'name':'疯狂Kotlin讲义','price':78.9,'publish':'电子社'}
#使用字典为字符串模板中的key传入值
print(temp % book)