JAYのpython学习笔记——数据结构之元组、集合和字典

元组可以存储一个固定元素的列表；
使用集合存储和快速访问不重复的元素；
使用字典存储键值对并使用这些关键字来快速访问元素

元组

与列表类似，但是元组中的元素是固定的，即一旦元组被创建，那么元组就不能被添加、删除、替换或重新排序元素。元组是静态的，相较于列表，元组的效率更高，占用的内存空间更小。

t1 = ()
t2 = (1, 3, 5)
t3 = tuple([2 * x for x in range(1,5)])
t4 = tuple("abcd") #t4 is ['a', 'b', 'c', 'd']

元组是一个序列，针对序列的操作也可以用在元组上，例如len、min、max、sum、for、in、not in这些操作都可以用。

tuple1 = ("green", "red", "blue") #用括号创建
print(tuple1)

tuple2 = tuple([7, 1, 2, 23, 4, 5])
print(tuple2)

print("length is", len(tuple2))
print("min is", min(tuple2))
print("max is", max(tuple2))
print(sum is", sum(tuple2))

print("the first element is", tuple2[0])
tuple3 = tuple1 + tuple2
print(tuple3)

tuple3 = 2 * tuple1 
print(tuple3)
#没有错误，因为重新分配了一个新元组给tuple3了
#“元组的元素是固定的”，是指不能给一个元组添加、删除、替换元素以及打乱元组中的元素

print(tuple2[2:4])
print(tuple1[-1])

print(2 in tuple2)

for v in tuple1:
	print(v, end = ' ')
print()

list1 = list(tuple2)
list1.sort()
tuple4 = tuple(list1)
tuple5 = tuple(list1)
print(tuple4)
print(tuple4 == tuple5)

集合

集合与列表类似，可以使用他们存储一个元素集合，但是，不同于列表，集合中的元素是不重复的且不按任何特定顺序放置的。和数学的集合概念完全一致，集合占用的内存也比列表小，列表需要指针来标明元素顺序。
集合可以包含类型相同或不同的元素。

创建集合

s1 = set() #创建空集合
s2 = {1, 3, 5} #花括号创建集合
s3 = set((1, 3, 5)) #从元组创建集合
s4 = set([x * 2 for x in range(1,10)]) #从列表创建集合
#也可以用list(set)或者tuple(set)从集合创建一个列表或者元组
s5 = set("abac") #从字符串创建集合 s5 is {'a', 'b', 'c'}
#集合中不存储重复的元素
s6 = {1, 2, 3, "one", "two", "three"}
#集合中每个元素必须是哈希的，即在对象的生命周期中，对象的哈希值不变化，那么即是哈希的

目前所介绍的所有类型对象除了列表之外都是哈希的

操作和访问集合

>>> s1 = {1, 2, 4}
>>> s1.add(6)
>>> s1
{1, 2, 4, 6}
>>> len(s1)
4
>>> max(s1)
6
>>> min(s1)
1
>>> sum(s1)
13
>>> 3 in s1
False
>>> s1.remove(4)
>>> s1
{1, 2, 6}
#如果删除一个不存在的元素，那么会返回KeyError的错误

子集和超集

>>> s1 = {1, 2, 4}
>>> s2 = {1, 4, 5, 2, 6}
>>> s1.issubset(s2)
True
>>> s2.issuperset(s1)
True

相等性测试

>>> s1 = {1, 2, 4}
>>> s2 = {1, 4, 2}
>>> s1 == s2
True

**
如果s1是s2的一个真子集，那么s1<s2返回True
如果s1是s2的一个子集，那么s1<=s2返回True
如果s1是s2的一个真超集，那么s1>s2返回True
如果s1是s2的一个超集，那么s1>=s2返回True

集合运算

#求并集
>>> s1 = {1, 2, 4}
>>> s2 = {1, 3, 5}
>>> s1.union(s2)
{1, 2, 3, 4, 5}
>>> s1 | s2
{1, 2, 3, 4, 5}
#求交集
>>> s1 = {1, 2, 4}
>>> s2 = {1, 3, 5}
>>> s1.intersection(s2)
{1}
>>> s1 & s2
{1}
#求差集
>>> s1 = {1, 2, 4}
>>> s2 = {1, 3, 5}
>>> s1.difference(s2)
{2, 4}
>>> s1 - s2
{2, 4}
#求对称差或称为异或
>>> s1 = {1, 2, 4}
>>> s2 = {1, 3, 5}
>>> s1.symmetric_difference(s2)
{2, 3, 4, 5}
>>> s1 ^ s2
{2, 3, 4, 5}

不能使用下标运算符来访问集合中的元素，因为这些元素没有固定的顺序

比较集合和列表的性能

对于in和not in运算符和remove方法来说，集合比列表的效率更高
至于原理，需要学习算法、链表和哈希等相关知识，此处不详细讨论

字典

一个字典是一个存储键值对集合的容器对象，通过使用关键字快速获取、删除和更新值。
字典是由很多条目构成的，其中各个条目又是由关键字和其对应值组成的，一个字典不能包含有重复的关键字。

创建一个字典

关键字必须是哈希类型，例如数字和字符串
值可以是任何类型

>>> students = {}
>>> students = {"111-34-3434":"John", "132-56-6290":"Peter"}

添加、修改和获取值

>>> students = {"111-34-3434":"John", "132-56-6290":"Peter"}
>>> students["234-56-9010"] = "Susan" #add a new item
>>> students["234-56-9010"]
"Susan"
# 如果一个关键字没有，那么就返回KeyError

删除条目

#del dictionaryName[key]
del students["234-56-9020"]

循环条目

>>> students = {"111-34-3434":"John", "132-56-6290":"Peter"}
>>> for key in students:
... 	print(key + ":" + str(sutdents[key]))
...
"111-34-3434":"John"
"132-56-6290":"Peter"
>>>

len函数

>>> students = {"111-34-3434":"John", "132-56-6290":"Peter"}
>>> len(students)
2

检测一个关键字是否在字典中

>>> students = {"111-34-3434":"John", "132-56-6290":"Peter"}
>>> "111-34-3434" in students
True

相等性检测

不考虑顺序

>>> d1 = {"red":41, "blue":3}
>>> d2 = {"blue":3, "red":41}
>>> d1 = d2
True

不能使用比较运算符（> >= < <=）对字典进行比较，因为字典中的条目是没有顺序的

字典方法

dict	说明
keys() :tuple	返回一个关键字序列
values():tuple	返回一个值序列
items():tuple	返回一个元组序列，每个元组都是一个条目的（键，值）
clear():None	删除所有条目
get(key):value	返回这个关键字对应的值
pop(key):value	删除这个关键字对应的条目并返回他的值
popitem(): tuple	返回一个随机选择的键值对作为元组并删除这个被选择的条目

>>> students = {"111-34-3434":"John", "132-56-6290":"Peter"}
>>> tuple(students.keys())
("111-34-3434", "132-56-6290")
>>> tuple(students.values())
("John", "Peter")
>>> tuple(students.items())
(("111-34-3434":"John"), ("132-56-6290":"Peter"))
>>> students.get("111-34-3434")
"John"
>>> print(students.get("999-34-3434"))
None
>>> students.pop("111-34-3434")
"John"
>>> students
{"132-56-6290":"Peter"}
>>> students.clear()
>>> students
{}