python学习笔记05：列表、元组与字典
目录
1 列表和元组的公有部分
1.1 创建
1.1.1 直接创建
1.1.2 使用list()和tuple()函数创建
1.2 利用索引访问
1.3 子序列访问
1.4 数学运算--加法
1.5 数学运算--乘法
1.6 in运算符与常用函数
1.7 序列的封包与解包
2 列表的特性
2.1 追加元素 -- list.append()函数
2.2 删除元素 -- del()
2.3 slice语法修改列表元素的值
3 字典
3.1 创建方法
3.2 通过键操作对应的值
3.3 常用函数说明
3.4 字典格式化字符串
4 完整源码
本节讲述python的三种内置数据结构：列表【list】、元组【tuple】和字典【dict】，这三个数据结构可以满足用户大量的数据保存需求。其中列表和元组类似，都是按照顺序保存元素，并可以通过索引来访问，但是列表的数据可以修改而原则则不可以；字典是以键值对的形式进行数据的保存。
如果固定的保存需要的数据且不需要修改，就使用元组；否则使用列表。
1 列表和元组的公有部分
1.1 创建
1.1.1 直接创建
使用 [...] 创建列表；使用圆括号 (...) 创建元组；
注意：当元组中只有一个元素时，需要在第一个元素的后边加上 【 , 】；否则解释器会将其认为是普通变量。
#创建列表
my_list = ['name', 'age']
print(my_list)
#创建元组【存放PI和自然常数e】
my_tuple = (3.14, 2.71828)
print(my_tuple)
1.1.2 使用list()和tuple()函数创建
使用list()函数，将元组、range【前包后不包，可指定步长】等对象转化为列表
使用tuple()函数，将列表、range【前包后不包，可指定步长】等对象转化为列表
list_to_tuple = list(my_tuple)
tuple_to_list = tuple(my_list)
list_from_range = list(range(1,10,2))
tuple_form_range = tuple(range(2,10,2))
print(list_to_tuple) #[3.14, 2.71828]
print(tuple_to_list) #('name', 'age')
print(list_from_range) #[1, 3, 5, 7, 9]
print(tuple_form_range) #(2, 4, 6, 8)
1.2 利用索引访问
#索引访问列表
print(my_list[-1]) #name
print(my_list[0]) #age
#索引访问元组
print(my_tuple[-1]) #2.71828
print(my_tuple[0]) #3.141.3 子序列访问
在中括号中使用起始索引、终止索引和步长表示要访问的子序列：
[start : end : step]
1.4 数学运算--加法
列表A加上列表B相当于在列表A的尾部追加列表B的内容，返回一个合并后的新列表，原始列表并未发生改变；
#列表相加
my_list2 = ['profession', 'address']
sum_list = my_list + my_list2
print(my_list) #['name', 'age']
print(my_list2) #['profession', 'address']
print(sum_list) #['name', 'age', 'profession', 'address']
元组A加上元组B相当于在元组A的尾部追加元组B的内容，返回一个合并后的新元组，原始元组并未发生改变；
#元组相加【存放重力常数和光速】
my_tuple2 = (9.8, 300000)
sum_tuple = my_tuple + my_tuple2
print(my_tuple) #(3.14, 2.71828)
print(my_tuple2) #(9.8, 300000)
print(sum_tuple) #(3.14, 2.71828, 9.8, 300000)元组不能和列表直接相加
print(my_list + my_tuple)
TypeError: can only concatenate list (not "tuple") to list
print(my_tuple + my_list)
TypeError: can only concatenate tuple (not "list") to tuple
1.5 数学运算--乘法
乘法与小学数学学习的乘法类似，乘以N就相当于N个相加
#乘法
print(my_list * 3) #['name', 'age', 'name', 'age', 'name', 'age']
print(my_tuple * 3) #(3.14, 2.71828, 3.14, 2.71828, 3.14, 2.71828)为一个月的每一天添加后缀
#为一个月的天数加上后缀【123的后缀与其他的不一致，需要单独指定】
order_endings = ('st', 'nd', 'rd') + ('th',) * 17 + ('st', 'nd', 'rd') + ('th',) * 7 + ('st',)
print(order_endings)
#('st', 'nd', 'rd', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'st', 'nd', 'rd', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'st')
day = input('input a date[1-31]:')
day = int(day)
print('your input digit %d is %s' %(day, str(day) + order_endings[day - 1]))
#input a date[1-31]:30
#your input digit 30 is 30th1.6 in运算符与常用函数
in判断指定元素与序列的隶属关系；隶属关系成立返回True，隶属关系不成立则返回False
max、min函数，对于字符串，返回序列的逐元素逐字符比对字母序的字符串结果；对于数值类型，返回最大或最小值
len用于序列返回的是序列的长度，即元素个数
#in
print('sex' in sum_list) #False
print( 9.8 in sum_tuple) #True
#max/min/len
print(max(sum_tuple)) #300000
print(min(sum_tuple)) #2.7828
print(len(sum_tuple)) #4
print(max(sum_list)) #profession
print(min(sum_list)) #address【字母序逐元素排序结果】
print(len(sum_list)) #41.7 序列的封包与解包
将多个数据赋值给一个变量的过程称为封包，会自动生成一个元组
将元组的值赋值给多个变量的过程称为解包，会自动为每个变量赋值
#封包
a = 1,2,3,4
print(type(a)) #
#解包
a1, a2, a3, a4 = a #1 2 3 4 解包时个数必须一致，否者会报错
b1, b2, b3 = a #1 2 3 4
ValueError: too many values to unpack (expected 3)
此时，可以通过加 【 * 】的方式直接获得后边的所有元素，并形成一个列表；
- 用户提供几个解包参数就会根据其位置，将序列解包成对应个数的子部分
- 星号定义列表中的元素个数等于【序列长度 - 定义的解包参数 + 1】
first, second, *rest = range(10)
print(first) #0
print(second)#1
print(rest) #[2, 3, 4, 5, 6, 7, 8, 9]
print(type(first)) #
print(type(second)) #
print(type(rest)) #
header, *middle, tail = range(10)
print(header) #0
print(middle)#[1, 2, 3, 4, 5, 6, 7, 8]
print(tail) #[9]
print(type(header)) #
print(type(middle)) #
print(type(tail)) # 只能有一个【 * 】，代码：
*header, *middle, tail = range(10)会报如下错误：
2 列表的特性
2.1 追加元素 -- list.append()函数
可追加列表构成嵌套列表；也可追加元组构成嵌套元组
sum_list.append(('sex', 'group'))
print(sum_list) #['name', 'age', 'profession', 'address', ('sex', 'group')]
sum_list.append(['zhao', 'qian','sun', 'li', 4])
print(sum_list) #['name', 'age', 'profession', 'address', ('sex', 'group'), ['zhao', 'qian', 'sun', 'li', 4]
注意python中没有像其他语言一样设置push()函数执行列表的入栈操作，append函数代替了push()的功能；但是python定义pop()出栈函数，调用该函数会将列表的最后一个元素移除。
2.2 删除元素 -- del()
既可以删除列表中的元素，也可以删除整个列表变量
del sum_list[-1]
print(sum_list) #['name', 'age', 'profession', 'address', ('sex', 'group')]
del sum_list
print(sum_list) #name 'sum_list' is not defined2.3 slice语法修改列表元素的值
- 只包含一个索引值，修改对应索引位置的列表元素；元素可为空
- 以【start : end】定义的起始和结束索引值，修改对应闭合区间内的列表元素；起始=结束，相当于添加元素
- 【start : end : step】类型，按照指定区间和步长修改闭合区间的元素，指定值必须等于区间长度
sList = list(range(1,10,1))
print(sList) #[1, 2, 3, 4, 5, 6, 7, 8, 9]
sList[1] = []
print(sList) #[1, [], 3, 4, 5, 6, 7, 8, 9]
sList[1] = ['dog']
print(sList) #[1, ['dog'], 3, 4, 5, 6, 7, 8, 9]
sList[1:3] = 'dog'
print(sList) #[1, 'd', 'o', 'g', 4, 5, 6, 7, 8, 9]
sList[3:3] = 'kit'
print(sList) #[1, 'd', 'o', 'k', 'i', 't', 'g', 4, 5, 6, 7, 8,
sList[2:9:2] = [11,12,13,14]
print(sList) #[1, 'd', 11, 'k', 12, 't', 13, 4, 14, 6, 7, 8, 9]
3 字典
由键值对构成，键不可更改；因此，列表不能作为字典的键，元组可以
3.1 创建方法
使用花括号创建
dict1 = {'中国': '亚洲', '美国' : '北美洲'}
print(dict1)
dict2 = {('中国','巴基斯坦'): '亚洲', '美国' : '北美洲'}
print(dict2)
使用dict()函数创建
dList = [['key1', 'value1'],['key2', 'value2']]
dict_from_list = dict(dList)
print(dict_from_list) #{'key1': 'value1', 'key2': 'value2'}
tList = [('key3', 'value3'),('key4', 'value4')]
dict_from_list_tuple = dict(tList)
print(dict_from_list_tuple) #{'key3': 'value3', 'key4': 'value4'}
ltList = (['key5', 'value5'],['key6', 'value6'])
dict_from_tuple_list = dict(ltList)
print(dict_from_tuple_list) #{'key5': 'value5', 'key6': 'value6'}
ttList = (('key7', 'value7'),('key8', 'value8'))
dict_from_tuple_tuple = dict(ttList)
print(dict_from_tuple_tuple) #{'key7': 'value7', 'key8': 'value8'}3.2 通过键操作对应的值
- 如果是未出现的新键，添加新的键值对
- 如果是已出现的旧键，修改键对应的值
- 键结合in/not in语法判断键值对是否存在
- 键结合del删除对应的键值对
#键操作值
newDict = dict1;
print(newDict) # {'中国': '亚洲', '美国': '北美洲'}
#利用键修改值
newDict['美国'] = '北美洲南部'
print(newDict) # {'中国': '亚洲', '美国': '北美洲南部'}
#利用新键添加值
newDict['俄罗斯'] = '亚洲北部'
print(newDict) # {'中国': '亚洲', '美国': '北美洲南部', '俄罗斯': '亚洲北部'}
newDict['日本'] = '亚洲东部'
print(newDict) # {'中国': '亚洲', '美国': '北美洲南部', '俄罗斯': '亚洲北部', '日本': '亚洲东部'}
#利用键删除值
del newDict['日本']
print(newDict) # {'中国': '亚洲', '美国': '北美洲南部', '俄罗斯': '亚洲北部'}
#利用键判断键值对是否存在
print('小鬼子' not in newDict) # True
print('中国' in newDict) # True
3.3 常用函数说明
使用dir(dict)得到如下内容：
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
方法及说明
| clear | 清空字典 |
| get(key) | 根据键获取对应的值，当键不存在时，返回None；当使用方括号语法访问不存在的键时，会出错 |
| items() | 读取字典中的所有键值对，类型为dict_items |
| keys() | 返回字典中所有的键，类型为dict_keys |
| values() | 返回字典中的所有值，类型为dict_values |
| pop(key) | 删除key对应的键值对 |
| popitem() | 随机删除一个键值对；这里的随机是假的，删除的总是字典最后一个键值对，但是由于字典的存储是无序的，故我们不知道哪一个键值对排在最后，也就不知道具体删的是哪一个。 |
| setdefault(key, defaultValue) | 若为旧键，不影响；若为新键，设置默认值 |
| fromkeys(key1,key2) formKeys(kv1,kv2) |
经常使用类名调用，dict.fromkeys()； 若仅指定key，则其value默认为None；也可以直接指定键值对 |
| update(newDict) | 使用一个字典对另外一个字段进行更新；若存在，则修改之；若不存在，则添加之【可以该函数进行字符串合并】 |
3.4 字典格式化字符串
temp = '我是%(name)s朝人，生活在公元%(period)d世纪'
yingzheng = {'name' : '秦', 'period' : -2}
print(temp % yingzheng) #我是秦朝人，生活在公元-2世纪4 完整源码
#创建列表
my_list = ['name', 'age']
print(my_list)
#创建元组【存放PI和自然常数e】
my_tuple = (3.14, 2.71828)
print(my_tuple)
list_to_tuple = list(my_tuple)
tuple_to_list = tuple(my_list)
list_from_range = list(range(1,10,2))
tuple_form_range = tuple(range(2,10,2))
print(list_to_tuple)
print(tuple_to_list)
print(list_from_range)
print(tuple_form_range)
#索引访问列表
print(my_list[-1])
print(my_list[0])
#索引访问元组
print(my_tuple[-1])
print(my_tuple[0])
#列表相加
my_list2 = ['profession', 'address']
sum_list = my_list + my_list2
print(my_list)
print(my_list2)
print(sum_list)
#元组相加【存放重力常数和光速】
my_tuple2 = (9.8, 300000)
sum_tuple = my_tuple + my_tuple2
print(my_tuple)
print(my_tuple2)
print(sum_tuple)
#列表加元组
#print(my_list + my_tuple)
#print(my_tuple + my_list)
#乘法
print(my_list * 3)
print(my_tuple * 3)
#为一个月的天数加上后缀【123的后缀与其他的不一致，需要单独指定】
order_endings = ('st', 'nd', 'rd') + ('th',) * 17 + ('st', 'nd', 'rd') + ('th',) * 7 + ('st',)
print(order_endings)
'''day = input('input a date[1-31]:')
day = int(day)
print('your input digit %d is %s' %(day, str(day) + order_endings[day - 1]))'''
#in
print('sex' in sum_list) #False
print( 9.8 in sum_tuple) #True
#max/min/len
print(max(sum_tuple)) #300000
print(min(sum_tuple)) #2.7828
print(len(sum_tuple)) #4
print(max(sum_list)) #profession
print(min(sum_list)) #address【字母序逐元素排序结果】
print(len(sum_list)) #4
#封包
a = 1,2,3,4
print(type(a)) #
#解包
a1, a2, a3, a4 = a #1 2 3 4
#b1, b2, b3 = a #1 2 3 4
print(a1, a2, a3, a4)
first, second, *rest = range(10)
print(first) #0
print(second)#1
print(rest) #[2, 3, 4, 5, 6, 7, 8, 9]
print(type(first)) #
print(type(second)) #
print(type(rest)) #
header, *middle, tail = range(10)
print(header) #0
print(middle)#[1, 2, 3, 4, 5, 6, 7, 8]
print(tail) #[9]
print(type(header)) #
print(type(middle)) #
print(type(tail)) #
#列表追加
sum_list.append(('sex', 'group'))
print(sum_list)
sum_list.append(['zhao', 'qian','sun', 'li', 4])
print(sum_list)
del sum_list[-1]#此操作与pop函数功能一致
print(sum_list)
#del sum_list
#print(sum_list)
#slice语法
sList = list(range(1,10,1))
print(sList)
sList[1] = [] #将第二个元素设置为空列表
print(sList)
sList[1] = ['dog']
print(sList)
sList[1:3] = 'dog'
print(sList)
sList[3:3] = 'kit'
print(sList)
sList[2:9:2] = [11,12,13,14]
print(sList)
#字典
dict1 = {'中国': '亚洲', '美国' : '北美洲'}
print(dict1)
dict2 = {('中国','巴基斯坦'): '亚洲', '美国' : '北美洲'}
print(dict2)
dList = [['key1', 'value1'],['key2', 'value2']]
dict_from_list = dict(dList)
print(dict_from_list) #{'key1': 'value1', 'key2': 'value2'}
tList = [('key3', 'value3'),('key4', 'value4')]
dict_from_list_tuple = dict(tList)
print(dict_from_list_tuple) #{'key3': 'value3', 'key4': 'value4'}
ltList = (['key5', 'value5'],['key6', 'value6'])
dict_from_tuple_list = dict(ltList)
print(dict_from_tuple_list) #{'key5': 'value5', 'key6': 'value6'}
ttList = (('key7', 'value7'),('key8', 'value8'))
dict_from_tuple_tuple = dict(ttList)
print(dict_from_tuple_tuple) #{'key7': 'value7', 'key8': 'value8'}
#键操作值
newDict = dict1
print(newDict)
#利用键修改值
newDict['美国'] = '北美洲南部'
print(newDict)
#利用新键添加值
newDict['俄罗斯'] = '亚洲北部'
print(newDict)
newDict['日本'] = '亚洲东部'
print(newDict)
#利用键删除值
del newDict['日本']
print(newDict)
#利用键判断键值对是否存在
print('小鬼子' not in newDict)
print('中国' in newDict)
temp = '我是%(name)s朝人，生活在公元%(period)d世纪'
yingzheng = {'name' : '秦', 'period' : -2}
print(temp % yingzheng) #我是秦朝人，生活在公元-2世纪