Chapter 03 复合数据类型-2

1.元组 tuple

元组（tuple）是Python中的一种数据结构，它与列表（list）类似，但有一个重要的区别：元组是不可变的，即一旦创建，其元素就不能被修改。

元组的定义：

元组是由圆括号()括起来的、由逗号分隔的多个元素组成的序列。这些元素可以是不同类型的数据，如整数、浮点数、字符串、列表、甚至是另一个元组。

元组的创建：

直接赋值=

使用圆括号()将多个元素括起来，元素之间用逗号分隔。

注意：即使只有一个元素，也需要加上逗号来区分它是一个元组还是一个普通的括号表达式。

python">>>>t1 = ()#创建一个空元组变量t1
>>>t2 = （1,2,3,4,5）]#创建一个元素为整数的元组变量t2
>>>t3 = ('Python','BigData','AI') #创建元素为字符串的元组变量t3；
>>>t4 = ('乔峰', [1997,7,7],(90,1.83)) #元素的数据类型可以各不相同

注意：即使只有一个元素，也需要加上逗号来区分它是一个元组还是一个普通的括号表达式。

正确的元组定义：
当你使用逗号来分隔元素，并且整个表达式被括号包围时，Python 会将其视为一个元组。

python">t = (1,)
print(t)  # 输出: (1,)
print(type(t))  # 输出: <class 'tuple'>

错误的元组定义（实际上是整数）：
当你只写 (1) 而不加逗号时，Python 不会将其视为元组，而是将其视为一个整数表达式，括号在这里没有作用（除了在某些数学运算中改变优先级）

python">t = (1)
print(t)  # 输出: 1
print(type(t))  # 输出: <class 'int'>

这里，Python 抛出了一个 TypeError，因为整数 1 不能被迭代来生成元组。

尝试将整数转换为元组：
当你尝试使用 tuple() 函数将一个整数转换为元组时，你会遇到错误，因为 tuple() 函数期望一个可迭代对象（如列表、字符串、集合等），而整数不是可迭代的：

python">t = tuple(1)
# TypeError: 'int' object is not iterable

tuple()函数

tuple()函数可以将一个可迭代对象（如列表、字符串、集合等）转换为一个元组。

python">tuple()函数可将其他序列转换为元组
>>> x = tuple() # 创建一个空元组
>>> y = [0,1,2,3,4] # 创建列表y
>>> z = tuple(y) #把列表y转换为元组, z的值为(0, 1, 2, 3, 4)
>>> t1= tuple(range(5)) # t1的值为 (0, 1, 2, 3, 4)
>>> t2= tuple('Python')  # t2的结果为('P', 'y', 't', 'h', 'o', 'n')

元组的主要操作：元素的增、删、改、查

元组一旦定义就不允许更改其元素。

无法向元组中添加元素；
不能从元组中删除元素；
使用del可以删除元组对象，不能删除元组中的元素。

tuple( )冻结列表，而list( )融化元组

+,*运算符，in关键字，len(),max(),min()等内置函数，切片的用法与列表一致。

元组的优势：

元组的速度比列表更快

元组在性能上通常比列表更快，尤其是在创建和访问元素方面。这是因为元组是不可变的（immutable），一旦创建，其内容和结构就不能被改变。这种不可变性允许Python在内部对元组进行优化，例如通过减少内存分配和复制操作，以及可能利用更高效的数据结构来实现元组。相比之下，列表是可变的（mutable），允许在创建后添加、删除或修改元素，这些操作通常需要更多的内存和计算资源。

定义了一系列常量值时，使用元组而不是列表

当您有一系列不需要改变的常量值时，使用元组而不是列表是一个更好的选择。这是因为元组的不可变性可以防止代码意外地修改这些值，从而增加代码的健壮性和可读性。此外，由于元组在性能上通常更优，使用它们还可以提高程序的运行效率。

元组对不需要改变的数据进行“写保护”将使得代码更加安全

元组的不可变性提供了一种自然的“写保护”机制，可以防止代码中的错误或恶意行为修改数据。这种保护对于维护代码的正确性和稳定性至关重要。例如，在函数参数中使用元组可以确保传递给函数的值在函数执行期间不会被修改，从而避免了潜在的副作用和错误。

元组可用作字典键（特别是包含字符串、数值和其它元组这样的不可变数据的元组）。列表不能当做字典键使用，因为列表不是不可变的。

由于元组是不可变的，因此它们可以用作字典（dictionary）的键。字典是一种基于键值对的数据结构，其中键必须是不可变的，以便能够在内部通过哈希函数进行快速查找。元组作为键时，可以包含字符串、数值和其他不可变的元组等数据类型。这使得元组在需要基于多个值进行快速查找和检索的场景中非常有用。

相比之下，列表由于是可变的，因此不能用作字典的键。如果尝试将列表用作键，Python将抛出一个TypeError异常，指出列表不是不可变的类型。

字典dict

字典是无序、可变序列

无序性：字典中的元素（键值对）没有固定的顺序。这意味着你不能通过索引来访问字典中的元素，而只能通过键来访问。
可变性：与元组不同，字典是可变的。这意味着你可以在创建后添加、删除或修改字典中的键值对。

字典的定义

字典的定义使用大括号 {} 来包含所有的键值对。每个键值对由键和值组成，它们之间用冒号 : 分隔。不同的键值对之间用逗号 , 分隔。(所有的元素放在大括号｛｝中，每个元素由键和值用冒号分隔，元素之间用逗号分隔。)

python">d = {'key1': 'value1', 'key2': 'value2'}

键的唯一性和不可变性

键的唯一性：在字典中，每个键都是唯一的。如果尝试向字典中添加一个已经存在的键，其对应的值将被新值覆盖。
键的不可变性：字典的键必须是不可变的数据类型，如整数、实数、复数、字符串或元组。这是因为字典在内部通过哈希函数来存储和查找键值对，而哈希函数要求输入是不可变的。

字典的创建：

字典可以通过多种方式创建：

1.直接赋值：
你可以直接通过赋值语句来创建一个字典。这是最常见和最简单的方法。

python">>>> d1 = {} #空字典
>>> d2 = {'name':'乔峰','age':40,('birth','height'):(1997,1.83)}#d2为 {'name': '乔峰', 'age': 40, ('birth', 'height'): (1997, 1.83)}

2.使用 dict() 函数：
dict() 函数可以用来创建一个新的空字典，或者从其他可迭代对象（如列表、元组的列表等）中创建字典。

python">dict()可利用已有数据（键数据、值数据）创建字典：
>>> d1 = dict() #空字典
>>> keys = ['Python','C','mz']
>>> values = [100,80,60] 
>>> d3 = dict(zip(keys, values))#{'Python': 100, 'C': 80, 'mz': 60}
>>> dx = dict(name=‘乔峰’, age=40)# {'name': '乔峰', 'age': 40}

3.以给定内容为键，创建值为空的字典

python">>>> d2 = dict.fromkeys(['name', 'age’])
>>> d4 = dict.fromkeys([1,2,3])
>>> d4
{1: None, 2: None, 3: None}

zip() 函数: 内置函数，将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象。

python">>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [7,8,9,10,11]
>>> z1 = zip(a,b)  # 返回一个对象
>>> z1
<zip object at 0x103abc288>
>>> list(z1)  # list() 将z1转换为列表后可输出
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c)) # 元素个数与最短的列表一致
[(1, 7), (2, 8), (3, 9)]

字典的主要操作：

增（增加）：
向字典中添加新的键值对，或者修改现有键的值。
以键为下标赋值：
如果键已经存在，则更新该键的值；如果键不存在，则添加新的键值对。

python">d['address'] = '123 Main St'  # 添加新的键值对
d['age'] = 31  # 修改现有键的值

python">>>> sc={'Python': 100, 'C': 80, 'mz': 60}
>>> sc[‘Java’] = 90 #不存在键’Java’
>>> sc
{'Python': 100, 'C': 80, 'mz': 60, 'Java': 90}
>>> sc[‘C’] = 90  #存在键’C’
>>> sc
{'Python': 100, 'C': 90, 'mz': 60, 'Java': 90}

使用update()方法：
将另一个字典的键值对添加到当前字典中。如果键已经存在，则更新该键的值；如果键不存在，则添加新的键值对。

python">new_data = {'email': 'alice@example.com', 'phone': '123-456-7890'}
d.update(new_data)  # 将new_data中的键值对添加到d中

删（删除）：
1.del删除整个字典或某个元素；
删除整个字典：

python">d = {'name': 'Alice', 'age': 30}
del d  # 删除整个字典d
# 此时，尝试访问d将引发NameError，因为d已经被删除

删除字典中的某个元素：

python">d = {'name': 'Alice', 'age': 30}
del d['name']  # 删除键为'name'的键值对
# 此时，d中只剩下{'age': 30}

2.clear()方法来删除字典中所有元素；
clear() 方法用于删除字典中的所有元素，使其变为一个空字典。

python">d = {'name': 'Alice', 'age': 30}
d.clear()  # 删除d中的所有元素
# 此时，d变为{}

3.pop()方法删除并返回指定键的元素；
pop() 方法用于删除并返回字典中指定键的元素。如果指定的键不存在，将引发KeyError异常。不过，可以通过为pop()方法提供一个默认值来避免这个异常。

python">d = {'name': 'Alice', 'age': 30}
removed_value = d.pop('name')  # 删除并返回键为'name'的元素的值
# 此时，removed_value为'Alice'，d变为{'age': 30}# 如果键不存在，提供默认值避免KeyError
# removed_value = d.pop('gender', 'default_value')  # 返回'default_value'

4.popitem()方法删除并返回字典中的一个元素；
popitem() 方法用于删除并返回字典中的一个元素（键值对）。需要注意的是，popitem() 方法在Python 3.7+版本中返回的是字典中的一个任意元素（因为字典在Python 3.7+中是有序的），而在更早的版本中，它返回的是最后插入的元素（但这并不总是可靠的，因为字典在Python 3.6及更早版本中是无序的）。

python">d = {'name': 'Alice', 'age': 30}
removed_item = d.popitem()  # 删除并返回一个元素（键值对）
# 在Python 3.7+中，removed_item可能是('name', 'Alice')或('age', 30），具体取决于字典的内部实现和元素插入顺序
# 此时，d将少一个元素

查（查询）：
字典元素的访问：
使用键作为下标来访问字典中的值。如果键存在，则返回对应的值；如果键不存在，则抛出KeyError异常（除非使用get()方法，它会返回None或指定的默认值）。

python">d = {'name': 'Alice', 'age': 30}
print(d['name'])  # 输出: Alice
print(d.get('age'))  # 输出: 30
print(d.get('gender', 'unknown'))  # 输出: unknown（因为'gender'键不存在

python">>>> sc={'Python': 100, 'C': 80, 'mz': 60}
>>> sc['C']
80
>>> sc[‘Java’] #不存在Java键，抛出异常
Traceback (most recent call last):File "<pyshell#3>", line 1, in <module>sc['Java']
KeyError: 'Java'

python">for item in sc.items(): #输出字典元素    print(item)
for key, value in sc.items(): #序列解包print(key, value)
for key in sc:  #默认输出字典的键print(key)

改（修改）：
实际上，修改操作可以通过上述的“增加”操作中的以键为下标赋值来实现。当键已经存在时，为其赋予新值即视为修改。
赋值= 可直接修改对应元素的值；

python">d = {'name': 'Alice', 'age': 30}
# 修改'age'键对应的值
d['age'] = 31
# 此时，d变为{'name': 'Alice', 'age': 31}

字典元素也是对象，支持相关类型操作：

可哈希性：虽然字典本身是不可哈希的（因此不能作为另一个字典的键），但字典中的键必须是可哈希的。这通常是因为键需要支持哈希函数来计算其哈希值，以便在字典内部进行高效的存储和查找。
动态属性：虽然字典的键值对没有像类实例那样明确的“属性”概念，但你可以通过键来动态地访问和修改字典中的内容，这在某种程度上类似于对象的属性访问。
方法调用：字典对象本身支持一系列方法，如keys()、values()、items()等，用于返回字典的键、值或键值对视图。此外，字典还支持get()、pop()、update()等方法来执行特定的操作。
迭代：字典支持迭代操作，你可以使用for循环来遍历字典的键、值或键值对。
比较操作：虽然字典本身不支持直接的比较操作（如==、<、>等用于比较两个字典是否相等或大小关系），但你可以通过比较它们的元素（即键值对）来间接地实现这一点。通常，这需要你编写自定义的比较逻辑或使用Python内置的==运算符来比较两个字典是否包含相同的键值对。