# 创建一个空元组
t1 = ()
t2 = tuple()

# 创建一个具有 3 个元素的元组
t3 = (1, 2, 3)

# 使用 tuple 函数通过列表创建一个元组
t4 = tuple([x for x in range(5)])

# 使用 tuple 函数通过字符串创建一个元组
t5 = tuple("abcdabcd")
# t5 = ('a', 'b', 'c', 'd', 'a', 'b', 'c', 'd')

# 使用 list 函数将元组转换为列表
t6 = list(t5)
# t6 = ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd']

创建只有一个元素的元组

# 创建一个只有一个元素的元组
t1 = (4,)  # 注意有个逗号
t1 = 4,  # 元组
t2 = (1) # t2 不是元组，而是一次赋值，将 1 赋给 t2
print(type(t2), t2)  # <class 'int'> 1

元组解包

在Python中，元组解包是一种将元组中的多个值赋给多个变量的方式。这可以在赋值操作中直接完成，也可以在函数调用中使用来提供参数。

解包可以使用星号表达式来选择性地解包元组中的部分元素。

# -*- coding: utf-8 -*-

# 直接解包
tup = (1, 2, 3)
a, b, c = tup
print(a, b, c)
# a = 1, b = 2, c = 3

# 使用星号表达式解包
tup = (1, 2, 3, 4, 5)
x, y, *rest = tup
print(x, y, rest)
# x = 1, y = 2, rest = [3, 4, 5]


# 函数调用中的解包
def func(v1, v2, v3):
    print(v1, v2, v3)


args = (1, 2, 3)
# func(args)  
# TypeError: func() missing 2 required positional arguments: 'v2' and 'v3'
func(*args)  # 输出: 1 2 3


# 函数返回多个值时的解包
def get_values():
    return 1, 2, 3


a, b, c = get_values()  # a = 1, b = 2, c = 3

可变和不可变元素元组

一个元组包含了一个固定的元素列表。一个元组里的一个个体元素可能是易变的。如果一个元组的元素都是不可变的，那么这个元组被称为元素不可变元组。否则是元素可变元组。

# -*- coding: utf-8 -*-

# 元素不可变元组
data = (1, 2, 3)  # 这里1， 2， 3都是不可变的
data2 = ("abc", "hello", "world")  # 这里字符串"abc"， "hello"， "world"都是不可变的
# data2[0][0] = 'x'  
# 将会报错：TypeError: 'str' object does not support item assignment

# 元素可变元组
data3 = ([1, 2, 3], ["x", "y"])  # [1, 2, 3]是列表，是可变的
data3[0][0] = 100   # 不会报错
print(data3)   # ([100, 2, 3], ['x', 'y'])
# 这里是将元组的第一个元素，是个列表，这个列表的第一个元素的地址进行改变
# 而没有该彼岸元组第一个元素的地址，即还是这个列表

# 元组本身不可变和可变是指在元组内容初始化后，不能更改元组元素的内存地址
value = [99, 99]
# data3[0] = value   
# 将会报错：TypeError: 'tuple' object does not support item assignment
# 这里试图将data3这个元组的第一个元素的地址换成[99, 99]的地址，是非法的
# 因为元组是不可变的

2.集合

集合特点

创建集合

# -*- coding: utf-8 -*-

# 创建一个空集
set1 = set()  # 注意 set2 = {} 是创建了一个字典

# 创建 1 个元素的集合
set2 = {5}

# 创建 3 个元素的集合
set3 = {1, 3, 5}

# 用 set 函数通过元组创建集合
set4 = set((1, 3, 5))

# 用 set 函数通过列表创建集合
set5 = set([x ** 2 for x in range(5)])

# 用 set 函数通过字符串创建集合
set6 = set("helloworld")
print(set6)  # 注意集合是无序的，每次打印可能会不一样

# 用 list 函数通过集合创建一个列表
list1 = list(set5)

# 用 tuple 函数通过集合创建一个元组
t1 = tuple(set5)

集合元素要求

# -*- coding: utf-8 -*-

set1 = {1, 3, 5}  # ok
set2 = {[1, 2], [3]}  # error:TypeError: unhashable type: 'list'

集合方法

访问与修改

# -*- coding: utf-8 -*-

set1 = {1, 2, 3, "a", "b"}
# 对集合添加一个元素
set1.add(4)
print(set1)

# update 方法 # 单个元素用 add，可迭代的对象用 update
set1 = {1, 2, 3}
set1.update("abc")
print(set1)  # {1, 2, 3, 'b', 'c', 'a'}
set1.update({2, 3, 4})
print(set1)  # {1, 2, 3, 'b', 'c', 4, 'a'}
set1.update([4, 5, 6])
print(set1)  # {1, 2, 3, 'b', 'c', 4, 5, 6, 'a'}

# 删除元素
set1.remove(3)  # 删除元素，不存在则抛出一个 KeyError 异常
print(set1.pop())
set1.discard(3)  # 删除元素，不存在不报错

# len 函数、max 函数、min 函数、sum 函数
print(len(set1))

# 可以使用 for 循环遍历一个集合中的所有元素
for x in set1:
    print(x)

# in 和 not in
print(100 in set1)

set1 = {1, 2, 3}
set2 = {1, 3, 2, 4}
print(set1.issubset(set2))  # True
print(set2.issuperset(set1))  # True

相等性判断

set1 = {1, 2, 3}
set2 = {1, 3, 2, 4}
set3 = {3, 1, 2，2}
print(set1 == set2)  # False
print(set1 != set2)  # True
print(set1 == set3)  # True

set1 = {1, 2, 4}
set2 = {1, 3, 5}
print(set1.union(set2)) # {1, 2, 3, 4, 5}
print(set1 | set2) # {1, 2, 3, 4, 5}

print(set1.intersection(set2)) 
print(set1 & set2) # {1}

print(set1.difference(set2))
print(set1 - set2) # {2, 4}

print(set1.symmetric_difference(set2))
print(set1 ^ set2) # {2, 3, 4, 5}

# -*- coding: utf-8 -*-

# 可变集合
set1 = {1, 2, 3, "a", "b"}
set1.add(4)  # ok
print(set1)  # {1, 2, 3, 4, 'b', 'a'}

# 不可变集合
data = [1, 2, 3]
set2 = frozenset(data)  # 转变为不可变集合
# set2.add(4)   # AttributeError: 'frozenset' object has no attribute 'add'

3.字典

字典特点

一个字典是按照关键字存储值的集合，简称存储“键值”的集合。

它通过使用关键字实现快速获取，删除和更新值。这些关键字很像下标运算符。

在一个列表中，下标是整数； 在一个字典中，关键字必须是一个可哈希对象。

一个字典不能包含有重复的关键字 ，每个关键字都对应着一个值。

一个关键字和它对应的值形成存储在字典的一个键值对。这种数据结构被称为“字典”。

字典创建和常见操作

条目 = 关键字(key) : 值(value)

关键字必须是可哈希的，比如字符串和数字，元组。

值可以是任意类型，比如是不可哈希的列表、字典、集合。

在Python中创建字典时，通常不需要显式指定键（key）和值（value）的类型，因为字典是一种动态类型的数据结构，它可以容纳任意类型的键和值。然而，如果你想在字典中指定键和值的类型，可以使用类型提示（Type Hints）来提供额外的信息，这在代码的可读性和维护性方面是有益的。

# -*- coding: utf-8 -*-

from typing import Dict, Any, Union

# 使用类型提示声明字典的键和值的类型
my_dict: Dict[str, Union[int, str]] = {
    "key1": 42,
    "key2": "value2",
    "key3": 3.14  # 这个值将被视为 Union[int, str] 中的任一类型
}

# 打印字典
print(my_dict)

请注意，类型提示仅仅是一种静态分析工具，对于 Python 解释器本身并没有强制约束。它主要用于提高代码的可读性和与其他开发者的交流。

d2 = {'22-23-1827': 'tom', '22-23-1828': 'bob'}
del d2['22-23-1828']
print(d2)  # {'22-23-1827': 'tom'}

# 如果字典中没有这个关键字，将抛出一个 KeyError 异常

d1 = {'22-23-1827': 'tom', '22-23-1828': 'bob'}
d2 = {'22-23-1828': 'bob', '22-23-1827': 'tom'}
print(d1 == d2)  # True
print(d2 != d1)  # False

字典内置方法