Python：元组、字典、集合

1. 元组

1.1 元组的概念与声明

什么是元组

列表非常适合用于存储在程序运行期间可能变化的数据集，并且列表是可以修改的。

然而，有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。

元组看起来犹如列表，但使用圆括号而不是方括号来标识。

元组的创建

dimensions = (200, 50) 
print(dimensions[0]) #200 
print(dimensions[1]) #50

将试图修改元素时，程序将会报错。

1.2 遍历元组中的所有值

像列表一样，也可以使用for 循环来遍历元组中的所有值：

dimensions = (200, 50) 
for dimension in dimensions: 
print(dimension) 
"""
200 
50 
"""

1.3 元组中常用函数

系统函数

max()、min()、sum()、len()、sorted()、tuple()

# max()
print(max(tuple1)) #9
# min()
print(min(tuple1)) #1
# sum()
print(sum(tuple1)) #25
# len()
print(len(tuple1)) #5
# sorted()：排序完成后返回的结果是列表
print(sorted(tuple1)) #[1, 3, 5, 7, 9]
# tuple()：元组类型的强制转化
print(tuple(sorted(tuple1))) #(1, 3, 5, 7, 9)

自带函数

index()、count()

tuple1 = (7,5,3,9,1,1)
# index()：返回实参所对应的下标
print(tuple1.index(3)) #2
# count()：返回实参出现次数
print(tuple1.count(1)) #2

1.4 拆包与装包

x,*y = (1,3,6,2,7)
print(x) #1
print(y) #[3, 6, 2, 7]
print(*y) #3 6 2 7

2. 字典

2.1 字典的概念与声明

在Python中，字典是一系列键—值对。每个键都与一个值相关联，你可以使用键来访问与之相关联的值。

与键相关联的值可以是数字、字符串、列表乃至字典。事实上，可将任何Python对象用作字典中的值。

在Python中，字典用放在花括号{} 中的一系列键—值对表示。

键—值对是两个相关联的值。指定键时，Python将返回与之相关联的值。键和值之间用冒号分隔，而键—值对之间用逗号分隔。

下面是一个简单的字典：

alien_0 = {'color': 'green', 'points': 5}
print(alien_0['color']) #green 
print(alien_0['points']) #5

2.2 添加键值对

字典是一种动态结构，可随时在其中添加键值对。

要添加键—值对，可依次指定字典名、用方括号括起的键和相关联的值。

alien_0 = {'color': 'green', 'points': 5} 
print(alien_0) #{'color': 'green', 'points': 5} 
alien_0['x_position'] = 0 
alien_0['y_position'] = 25 
print(alien_0) #{'color': 'green', 'points': 5, 'x_position': 0, 'y_position': 25}

2.3 修改键值对

要修改键值对，可以使用添加键值对的方法进行修改，重新赋值。

alien_0 = {'color': 'green', 'points': 5} 
print(alien_0) #{'color': 'green', 'points': 5} 
alien_0['color'] = 'black' 
print(alien_0) #{'color': 'black', 'points': 5} 

2.4 删除键值对

使用del语句

对于字典中不再需要的信息，可使用del语句将相应的键值对彻底删除。

使用del语句时，必须指定字典名和要删除的键。

dict = {'张三':100,'李四':56.,'王五':98,'赵六':77}
del dict['张三']
print(dict) #{'李四': 56.0, '王五': 98, '赵六': 77}

删除的键—值对永远消失了。

使用pop()方法

找到键，则删除改键，返回值为该键的值

找不到，返回默认值

dict = {'张三':100,'李四':56.,'王五':98,'赵六':77}
result = dict.pop('张三')
result1 = dict.pop('张大彪','字典中没有此键')
print(dict) #{'李四': 56.0, '王五': 98, '赵六': 77}
print(result) #100
print(result1) #字典中没有此键

使用popitem()方法

随机删除字典中的键值对（一般是从末尾删除元素），返回值为该键值对

dict = {'张三':100,'李四':56.,'王五':98,'赵六':77}
result = dict.popitem()
print(dict) #{'张三': 100, '李四': 56.0, '王五': 98}
print(result) #('赵六', 77)

使用clear()方法

删除所有键值对，返回None，字典变为空字典

dict = {'张三':100,'李四':56.,'王五':98,'赵六':77}
result = dict.clear()
print(dict) #{}
print(result) #None

2.5 查找键值对

按照key查找键值对时，只能找到value的值。

alien_0 = {'color': 'green', 'points': 5} 
print(alien_0['color']) #green

可以使用get()函数去查找

有键就返回值；无键返回None，不报错；有其它参数且无键返回其他参数

alien_0 = {'color': 'green', 'points': 5} 
print(alien_0.get('color')) #green
print(alien_0.get('name')) #None
print(alien_0.get('name','张三')) #张三

2.6 遍历字典

遍历所有键

在默认情况下，字典遍历的是key

user_0 = { 
    'username': 'efermi', 
    'first': 'enrico', 
    'last': 'fermi', } 
for key in user_0:
    print(key)
"""
username
first
last
"""

遍历所有键——值对：items()

该方法将字典键值对转化成列表保存的形式

user_0 = { 
    'username': 'efermi', 
    'first': 'enrico', 
    'last': 'fermi', } 
for key, value in user_0.items(): 
    print("\nKey: " + key) 
    print("Value: " + value)
print(user_0.items())
"""
Key: last 
Value: fermi     
Key: first 
Value: enrico 
Key: username 
Value: efermi
dict_items([('username', 'efermi'), ('first', 'enrico'), ('last', 'fermi')])
"""

遍历字典中的所有键：keys()

在不需要使用字典中的值时，方法keys() 很有用。

favorite_languages = { 
    'jen': 'python', 
    'sarah': 'c', 
    'edward': 'ruby',
    'phil': 'python', } 
for name in favorite_languages.keys(): 
    print(name.title())
"""
Jen 
Sarah 
Phil 
Edward
"""

遍历字典时，会默认遍历所有的键，因此，如果将上述代码中的for name in favorite_languages.keys(): 替换为for name in favorite_languages: ，输出将不变。

如果显式地使用方法keys() 可让代码更容易理解，你可以选择这样做，但如果你愿意，也可省略它。

遍历字典中的所有值：values()

如果你感兴趣的主要是字典包含的值，可使用方法values() ，它返回一个值列表，而不包含任何键。

favorite_languages = { 
    'jen': 'python', 
    'sarah': 'c', 
    'edward': 'ruby', 
    'phil': 'python', }
for language in favorite_languages.values(): 
    print(language.title())
""" 
Python 
C
Python
Ruby
"""

3. 集合

3.1 集合的概念与声明

集合是无序且不重复的元素集，集合的表达方式是{元素1,元素2,元素3,…}

其声明方式有两种：

• 通过使用set()方法进行集合的声明
• 通过{}进行集合的声明

list = [1,5,3,2,1,6,4,3,2]
set1 = {}
# 用{}方式声明时必须添加元素，否则为字典
set2 = {1,2,3}
# 可以用set()来生成空集合
set3 = set()
# set()可以进行去重、排序操作
set4 = set(list)
print(type(set1)) #<class 'dict'>
print(type(set2)) #<class 'set'>
print(type(set3)) #<class 'set'>
print(set4) #{1, 2, 3, 4, 5, 6}

3.2 添加元素

add()：添加单个元素

使用add()方法添加元素时，会进行无序添加，还可以在()内添加元组，但是是作为一个元素添加的，不能添加列表。

set1 = set()
set1.add("hello")
set1.add(123)
set1.add("张三")
print(set1) #{123, '张三', 'hello'}
tup = ("元","组")
set1.add(tup) 
print(set1) #{123, '张三', 'hello', ('元', '组')}

update()：添加多个元素

使用方法update()方法添加元素时，会进行多个元素的无序添加，可以在()内传入元组，元组中有多少元素就添加多少元素。

set1 = set()
tup = ("元","组")
set1.update(tup)
print(set1) #{'组', '元'}
set1.update("张三",'李四')
print(set1) #{'元', '四', '三', '组', '李', '张'}

3.3 删除元素

remove()：删除指定元素，不存在该元素则报错

set1 = {1,2,3,4,5,6}
set1.remove(1)
print(set1) #{2, 3, 4, 5, 6}

dicard()：类型remove()，移除不存在元素不会报错

set1 = {1,2,3,4,5,6}
set1.discard(3)
print(set1) #{1, 2, 4, 5, 6}
set1.discard(0) #不会报错

pop()：一般删除第一个元素

set1 = {1,2,3,4,5,6}
set1.pop()
print(set1) #{2, 3, 4, 5, 6}

clear()：清空所有元素

set1 = {1,2,3,4,5,6}
set1.clear()
print(set1) #set()

3.4 差集、交集、并集和对称差集

差集

实现交集有两种方式，一种是使用" - "，一种是使用differerce()方法

set1 = {1,2,3,4,5,6}
set2 = {4,5,6,7,8}
set3 = set1 - set2
print(set3) #{1, 2, 3}
set4 = set3.difference(set2)
print(set4) #{1, 2, 3}

交集

实现交集有两种方式，一种是使用" & "，一种是使用intersection()方法

set1 = {1,2,3,4,5,6}
set2 = {4,5,6,7,8}
set3 = set1 & set2
print(set3) #{4, 5, 6}
set4 = set3.intersection(set2)
print(set4) #{4, 5, 6}

并集

实现并集有两种方式，一种是使用" | "，一种是使用union()方法

set1 = {1,2,3,4,5,6}
set2 = {4,5,6,7,8}
set3 = set1 | set2
print(set3) #{1, 2, 3, 4, 5, 6, 7, 8}
set4 = set3.union(set2)
print(set4) #{1, 2, 3, 4, 5, 6, 7, 8}

对称差集

实现对称差集有两种方式，一种是使用" ^ "，一种是使用symmetric_difference()方法

set1 = {1,2,3,4,5,6}
set2 = {4,5,6,7,8}
set3 = set1 ^ set2
print(set3) #{1, 2, 3, 7, 8}
set4 = set1.symmetric_difference(set2)
print(set4) #{1, 2, 3, 7, 8}