Python3.*(第十二课——Python三种常用数据结构：列表、元组、字典)

（本章笔记以总分的结构进行记录学习的，总表示通用部分）

Python中常见的序列类型包括：列表、元组、字典，前面学习的字符串也是一种常用的序列。

字典用于存放具有映射关系的数据。

如果只是固定的保存多个数据项，则不需要修改它们，可以使用元组

如果需要修改它们，可以使用列表

（字符串也是不可变的字符序列）

创建列表和元组

       语法格式：

              列表：[ele1,ele2,ele3,…… ]

              元组：(ele1,ele2,ele3,……)

              例如：

# 使用方括号定义列表
my_list = ['crazyit', 20, 'Python']
print(my_list)
# 使用圆括号定义元组
my_tuple = ('crazyit', 20, 'Python')
print(my_tuple)

只要不涉及改变元素的操作，列表和元组的用法是通用的，

通过索引使用元素

       ①索引都是从0 开始的，第1个元素的索引为0,第2 个元素的索引为1，… 依此类推

       ②倒数第1个元素的索引为-1，倒数第2 个元素的索引为-2 …… 依此类推

       ③列表的元素相当于一个变量，程序既可使用它的值，也可对元素赋值。

       ④元组的元素则相当于一个常量，程序只能使用它的值，不能对它重新赋值。

              例如：（通用用法）

a_tuple = ('crazyit', 20, 5.6, 'fkit', -17)
print(a_tuple)
# 访问第1个元素
print(a_tuple[0]) # crazyit
# 访问第2个元素
print(a_tuple[1]) # 20
# 访问倒数第1个元素
print(a_tuple[-1]) # -17
# 访问倒数第2个元素
print(a_tuple[-2]) # -fkit

子序列

       列表和元组同样也可使用索引获取中间一段，这种用法被称为slice（分片或切片）

              语法：[start: end: step]

                       ①从start 索引的元素开始（包含），到end 索引的元素结束（不包含）

                       ② step表示步长，使用负数没有意义。

                       ③如果指定step参数，则可以隔step个元素再取元素。

                            例如：

a_tuple = ('crazyit', 20, 5.6, 'fkit', -17)
# 访问从第2个到倒数第4个（不包含）所有元素
print(a_tuple[1: 3]) # (20, 5.6)
# 访问从倒数第3个到倒数第1个（不包含）所有元素
print(a_tuple[-3: -1]) # (5.6, 'fkit')
# 访问从第2个到倒数第2个（不包含）所有元素
print(a_tuple[1: -2]) # (20, 5.6)
# 访问从倒数第3个到第5个（不包含）所有元素
print(a_tuple[-3: 4]) # (5.6, 'fkit')

b_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9)
# 访问从第3个到第9个（不包含）、间隔为2的所有元素
print(b_tuple[2: 8: 2]) # (3, 5, 7)
# 访问从第3个到第9个（不包含）、间隔为3的所有元素
print(b_tuple[2: 8: 3]) # (3, 6)
# 访问从第3个到倒数第2个（不包含）、间隔为3的所有元素
print(b_tuple[2: -2: 2]) # (3, 5, 7)

加法

       ①加法的和就是两个列表或元组所包含的元素的总和。

       ②列表只能和列表相加；元组只能和元组相加；

       ③元组不能直接和列表相加。

              例如：

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)) # ('crazyit', 20, -1.2, -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']

乘法

       ①列表和元组乘法的意义就是把它们包含的元素重复N次——N 就是被乘的倍数。

       ②用户可以以对列表、元组同时进行加法、乘法运算

              例如：

a_tuple = ('crazyit' , 20)
# 执行乘法
mul_tuple = a_tuple * 3
print(mul_tuple) # ('crazyit', 20, 'crazyit', 20, 'crazyit', 20)
a_list = [30, 'Python', 2]
mul_list = a_list * 3
print(mul_list) # [30, 'Python', 2, 30, 'Python', 2, 30, 'Python', 2]

# 同时对元组使用加法、乘法
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])

③为了表示只有一个元素的元组，必须在唯一的元组元素之后添加英文逗号。

in运算符

       in运算符用于判断列表或元组是否包含某个元素。

              例如：

s=(23,34,56,7,8,90,12)
print(3 not in s) # true
print(34 in s) # true

a_tuple = ('crazyit' , 20, -1.2)
print(20 in a_tuple) # True
print(1.2 in a_tuple) # False
print('fkit' not in a_tuple) # True

长度、最大值和最小值

       ①len（）、max（）、min（）全局函数来获取元组或列表的长度、最大值和最小值。

       ②在使用以上三个函数时，元组、列表的元素必须是相同类型且可以比较大小。

       ③Python依次按字符串中每个字符对应的编码来比较字符串的大小。（字符串比较大小）

              例如：

# 元素都是数值的元组
a_tuple = (20, 10, -2, 15.2, 102, 50)
# 计算最大值
print(max(a_tuple)) # 102
# 计算最小值
print(min(a_tuple)) # -2
# 计算长度
print(len(a_tuple)) # 6
# 元素都是字符串的列表
b_list = ['crazyit', 'fkit', 'Python', 'Kotlin']
# 计算最大值（依次比较每个字符的ASCII码值，先比较第一个字符，若相同，继续比较第二个字符，以此类推）
print(max(b_list)) # fkit（26个小写字母的ASCII码为97~122）
# 计算最小值
print(min(b_list)) # Kotlin （26个大写字母的ASCII码为65~90）
# 计算长度
print(len(b_list)) # 4

序列封包和序列解包

       ①程序把多个值赋给一个变量时，Python会自动将多个值封装成元组。

       这种功能被称为序列封包。

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

例如：

# 序列封包：将10、20、30封装成元组后赋值给vals
vals = 10, 20, 30
print(vals) # (10, 20, 30)
print(type(vals)) # <class 'tuple'>
print(vals[1]) # 20
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) # 1 3 5 7 9
a_list = ['fkit', 'crazyit']
# 序列解包: 将a_list序列的各元素依次赋值给a_str、b_str变量
a_str, b_str = a_list
print(a_str, b_str) # fkit crazyit

③赋值中同时运用了序列封包和序列解包机制，就可以让赋值运算符支持同时将多个值赋给多个变量。

# 将10、20、30依次赋值给x、y、z
x, y, z = 10, 20, 30
print(x, y, z) # 10 20 30
# 将y,z, x依次赋值给x、y、z
x, y, z = y, z, x
print(x, y, z) # 20 30 10

（上）使用这种机制可以实现交换变量

④在序列解包时也可以只解出部分变量，剩下的依然使用列表变量保存。被赋值的变量之前添加“＊”，那么该变量就代表一个列表

# first、second保存前2个元素，rest列表包含剩下的元素
first, second, *rest = range(10)
print(first) # 0
print(second) # 1
print(rest) # [2, 3, 4, 5, 6, 7, 8, 9]
# last保存最后一个元素，begin保存前面剩下的元素
*begin, last = range(10)
print(begin) # [0, 1, 2, 3, 4, 5, 6, 7, 8]
print(last) # 9
# first保存第一个元素，last保存最后一个元素，middle保存中间剩下的元素
first, *middle, last = range(10)
print(first) # 0
print(middle) # [1, 2, 3, 4, 5, 6, 7, 8]
print(last) # 9