总述

2020年7月21日。今天主要讲了一些Python比之其他编程语言特有的一些数据结构。
有列表元组字典集合。

他们之中有共同点，也有差异。重点把握列表和字典即可。

列表

定义：一个有序的，可修改的，元素以逗号分割的，以中括号包裹的，元素可以是任何数据类型的序列。

创建一个列表，只要把逗号分隔的各个数据项使用方括号括起来即可。

1 2	thislist = ['Zorua', 'Blog', 2000, 2020] emptylist = [ ] #空列表

除此以外，也可以使用list函数来创建列表。

1	thislist = list(("apple", "banana", 123)) #参数是元组

list函数中的参数应是一个可迭代的对象，例如字符串、元组等等。list函数将可迭代对象的元素重新返回为列表。

将字典类型的数据作为参数时，返回的是字典的键（后文会提及）。
将range()函数作为参数，返回的是一个整数元素的列表。
无参数时，返回的是一个空列表。

访问列表中的值

列表同样也可以像字符串一样使用索引/切片来访问其中的值。规则大致相同，可以参考前章内容。
以下是示例。

thislist = ['Zorua','Blog',2000,2020]
print(thislist[0])     #输出结果为 Zorua
print(thislist[0:1])   #输出结果为 ['Zorua']，这是仅有一个元素的列表
print(thislist[0:2])   #输出结果为 ['Zorua','Blog']

上图的示例是创建了一个0-39整数的列表，然后以step=2来切分出了其中的偶数。

更新列表

列表的数据项可以被修改，或添加删除。

更新列表项

接续前文的0-39整数列表示例。

thislist[0:9:2]=[1,1,1,1,1] #thislist[0:9:2]原来是[0,2,4,6,8]
print(thislist)
#输出结果为[1, 1, 1, 3, 1, 5, 1, 7, 1, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39]
#注意到里面仅修改了其中的五个位置。
thislist[39]=1000
print(thislist)
#输出结果为[1, 1, 1, 3, 1, 5, 1, 7, 1, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 1000]

添加列表项

append

作用在列表的尾端加入一个新的元素。
使用方法 listname.append(elem)

thislist = [1,2,3]
thislist.append([1,2,3,4,5,6])
print(thislist)
#注意这里的列表变成了 [1,2,3,[1,2,3,4,5,6]]实际上是列表中嵌套了一个作为元素的列表
#而不是加入了多个元素
#append还是只能加入一个元素
thislist.append(1123)
print(thislist)
#在最末尾又添加了一个新的元素，1123。
#输出结果为[1,2,3,[1,2,3,4,5,6],1123]

insert

作用在列表的指定位置后加入一个新的元素。
使用方法 listname.insert(position,elem)

thislist = [1,2,3]
thislist.insert(1,123)
print(thislist)
#输出结果为[1,2,123,3]

extend

之前在append尝试加入多个元素失败后，其实加入多个元素应该使用extend。
作用在列表的尾端拼接一个列表。
使用方法 listname.extend(listname2)

thislist = [1,2,3]
thislist.extend([1,2,3,4])
print(thislist)
#输出结果为[1,2,3,1,2,3,4]

除了可以使用extend来拼接列表以外，使用语句thislist = thislist + [1,2,3,4]同样也能达到上述代码的效果。

删除列表项

可以使用del函数来删除列表项。
如下示例：

thislist = [1,2,3]
del thislist[1]
print(thislist)
#输出结果为 [1,3]

此外，也可以使用list对象的方法pop(index=-1)来删除。

1 2	thislist.pop() #参数缺省值为-1，因此会删除列表最后一个元素 thislist.pop(1) #和上面的del示例代码一样，删除第二个元素

列表推导式

这是Python中很棒的一个语法糖。^[1]

语法结构：out_list = [out_express for out_express in input_list if out_express_condition]

例如要生成一个偶数的list。由于至此为止，我的实训日志还没有讲解到Python的循环，因此下面我们试着用C语言来实现**外面的循环结构**。

for(int i = 0;i <= 10;i++){
    if(i % 2 == 0){
         thislist.append(i)
    }
}

这样一来，总是需要一个多行的结构。
而使用列表推导式的话：[i for i in range(10) if i % 2 == 0]，只需要一行。
当然，为了增加代码可读性，可以为上式断行。(Python允许在中括号、花括号之间断行)

result = [
    i
    for i in range(10)
    if i % 2 == 0
]

其他示例：

#交换字典的value和key。
changed = {value: key for key, value in input_dict.items()}
#用一个列表的所有单词的首字母生成一个集合。
chars = {w[0] for w in words_list}

列表常见函数与方法

以下内容援引自菜鸟教程。

列表常见函数与方法

序号	函数
1	len(list) 列表元素个数
2	max(list) 返回列表元素最大值
3	min(list) 返回列表元素最小值
4	list(seq) 将元组转换为列表

序号	方法
1	list.append(obj) 在列表末尾添加新的对象
2	list.count(obj) 统计某个元素在列表中出现的次数
3	list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj) 将对象插入列表
6	list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj) 移除列表中某个值的第一个匹配项
8	list.reverse() 反向列表中元素
9	list.sort( key=None, reverse=False) 对原列表进行排序
10	list.clear() 清空列表
11	list.copy() 复制列表

元组

定义：一个有序的，不可修改的，元素以逗号分割的，以小括号包裹，元素可以是任何数据类型的序列。

创建一个元组，和创建一个列表差不多。只要把逗号分隔的各个数据项使用小括号括起来即可。

thistuple = ('Zorua', 'Blog', 2000, 2020)
thistuple = 'Zorua', 'Blog', 2000, 2020 #其实不需要括号也是可以的哦
emptytuple = () #创建空元组
tup1 = (1)   #注意，这样写的话，tup1是整数型变量。
tup2 = (1,)  #而加了一个逗号，编译器才会认为tup2是只有一个元素的元组

除此以外，也可以使用tuple函数来创建元组。

1	thistuple = tuple(("apple", "banana", 123)) #参数是元组

tuple函数中的参数应是一个可迭代的对象，例如字符串、元组等等。tuple函数将可迭代对象的元素重新返回为元组。
~~类似的话前面说过一次了……~~

将字典类型的数据作为参数时，返回的是字典的键（后文会提及）。
将range()函数作为参数，返回的是一个整数元素的元组。
无参数时，返回的是一个空元组。

访问元组中的值

这块内容和上面列表的差不多。不再赘述。

修改元组

前面的定义说了，元组不给改的嗷。
但是可以通过类似于列表的+来扩展元组。

tup1 = (1,2,3)
tup2 = ('1','2','3')
tup3 = tup1 + tup2
print(tup3)
#输出内容为 (1,2,3,'1','2','3')

元组常见函数

以下内容援引自菜鸟教程。

元组常见函数

序号	方法及描述
1	len(tuple) 计算元组元素个数。
2	max(tuple) 返回元组中元素最大值。
3	min(tuple) 返回元组中元素最小值。
4	tuple(iterable) 将可迭代系列转换为元组。

字典

定义：一个无序的，可修改的，元素以键值对呈现，以花括号包裹，键和值可以是任何数据类型的序列。

键：就是存的值的编号
值：就是要存放的数据
由上可知，键肯定是唯一的，且不可变的。
创建一个字典时，字典的每个键值(key=>value)对用冒号:分割，每个对之间用逗号,分割，整个字典包括在花括号{ }中。

1
2
3

dict = { 'name':'Zorua',
         'class':5,
         'hobby':'game'}

访问字典里的值

把相应的键放入到方括号中即可访问字典里的值，如下示例：

dict = { 'name':'Zorua',
         'class':5,
         'hobby':'game'}
print (dict['name'])  #输出 Zorua
print (dict['class']) #输出 5

更新字典

更新字典项

在上面访问字典里的值的基础上，加一个赋值即可。
即：

dict = { 'name':'Zorua',
         'class':5,
         'hobby':'game'}
dict['hobby'] = 'manga'
print (dict['hobby'])  #输出 manga

新增字典项

虽然说，在访问字典里的值里，如果填写的键是不存在的键，则会出错。
但是在新增字典项里，在刚刚的基础上，加一个赋值即可。示例如下：

dict = { 'name':'Zorua',
         'class':5,
         'hobby':'game'}
dict['age'] = 20
print (dict)  #输出 { 'name':'Zorua','class':5,'hobby':'game','age':20}

删除字典项

删除字典中的一个键值对，可以用del dict[key]来实现。例如：

dict = { 'name':'Zorua',
         'class':5,
         'hobby':'game'}
del dict['class']
print (dict)  #输出 { 'name':'Zorua','hobby':'game'}

如果要删除整个字典，可以用del dict。
如果要清空字典，可以用dict.clear()。

dict = { 'name':'Zorua',
         'class':5,
         'hobby':'game'}
dict.clear()
print (dict)  #输出 { }

字典常见函数与方法

以下内容援引自菜鸟教程。

字典常见函数与方法

序号	函数及描述
1	len(dict) 计算字典元素个数，即键的总数。
2	str(dict) 输出字典，以可打印的字符串表示。
3	type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。

序号	函数及描述
1	radiansdict.clear() 删除字典内所有元素
2	radiansdict.copy() 返回一个字典的浅复制
3	radiansdict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4	radiansdict.get(key, default=None) 返回指定键的值，如果键不在字典中返回 default 设置的默认值
5	key in dict 如果键在字典dict里返回true，否则返回false
6	radiansdict.items() 以列表返回可遍历的(键, 值) 元组数组
7	radiansdict.keys() 返回一个迭代器，可以使用 list() 来转换为列表
8	radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里
10	radiansdict.values() 返回一个迭代器，可以使用 list() 来转换为列表
11	pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值。
12	popitem() 随机返回并删除字典中的最后一对键和值。

集合

定义：一个无序的，可修改的，无重复的，以花括号包裹，元素可以是任何数据类型的序列。

但是集合中的元素须是可哈希的类型。前面说的列表、字典还有集合本身不能作为元素(元组可以)。

这个定义和数学上对集合的定义差不多，但是Python中当然没有无限集合。
可以使用大括号 { } 或者 set() 函数创建集合。

注意：创建一个空集合必须用set()而不是{ }，因为{ } 是用来创建一个空字典。

例如下面的例子：

thisset = {1,2,3,4,1,2}
print(thisset) #输出结果为 {1,2,3,4} 由此可见，集合里的元素不能重复
#或者
thisset = set((1,2,3,4))

set函数中的参数应是一个可迭代的对象，例如字符串、元组等等。set函数将可迭代对象的元素重新返回为元组。
~~类似的话前面说过两次了……~~

集合中还可以分为可变集合和不可变集合(frozenset)。使用frozenset函数来创建时，会返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

集合的运算

数学上定义的集合可以进行并集、交集、差集等等运算，Python中的集合也可以。

a = {1,2,3,4,5}
b = {4,5,6,7}
print(a | b)  #a或b都包含的元素, 即a并b, 结果为{1,2,3,4,5,6,7}
print(a & b)  #a和b都包含的元素, 即a交b, 结果为{4,5}
print(a ^ b)  #不同时包含于a和b的元素, 即对称差集, 结果为{1,2,3,6,7}
print(a - b)  #在a中但不在b中的元素, 即a对b的差集, 结果为{1,2,3}

更新集合

添加元素

语法格式为：setname.add(elem)
例如下面这个例子：

lang = {'java','python','ruby'}
lang.add('c/c++')
print(lang)
# 输出结果为 {'java','python','ruby','c/c++'}

除了用add()以外，也可以用update()。
语法格式为：setname.update(elem)。update的参数可以为列表，元组，字典等。

lang = {'java','python','ruby'}
lang.update(['c','c++'])
print(lang)
# 输出结果为 {'java','python','ruby','c','c++'}
# 注意, 这里的结果并不是 {'java','python','ruby',['c','c++']}

删除元素

语法格式为：setname.remove(elem)，使用这个方法时，如果元素不存在，将发生错误。如果想避免这种情况，可以使用setname.discard(elem)。

lang = {'java','python','ruby'}
lang.remove('python')
print(lang)
# 输出结果为 {'java','ruby'}

随机删除一个集合中的元素，可以使用setname.pop()

集合常见方法

以下内容援引自菜鸟教程。

元组常见函数

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集
difference_update()	移除集合中的元素，该元素在指定的集合也存在。
discard()	删除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	返回集合的交集。
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	判断指定集合是否为该方法参数集合的子集。
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	返回两个集合的并集
update()	给集合添加元素