元组与字典的有关知识

元组与字典

元组与列表的区别

元组（tuple）和列表（list）是Python中两种常用的数据结构，它们有以下几点区别：

1. 可变性：
   • 元组是不可变的（immutable），一旦创建后就无法对其进行增删改操作。
   • 列表是可变的（mutable），可以随意添加、删除或修改其中的元素。
2. 语法表示：
   • 元组使用圆括号()来表示，例如：(1, 2, 3)
   • 列表使用方括号[]来表示，例如：[1, 2, 3]

因为元组具有不可变的特性，所以在能用元组代替列表的地方最好都使用元组，这样代码更安全。

元组的创建与访问

创建元组的话有两种方式

1.元组创建很简单，使用逗号或者在括号()中添加元素，元素之间用逗号隔开。元组中只包含单个元素时，需要在该元素后面添加逗号。

# 使用逗号创建元组
my_tuple = 1, 2, 3
print(my_tuple)  # 输出 (1, 2, 3)

# 单个元素的元组
single_tuple = (1,)  # 在单个元素后面加上逗号
print(single_tuple)  # 输出 (1,)

# 空元组
empty_tuple = ()
print(empty_tuple)  # 输出 ()

访问元组的很简单，和列表一样，可以使用下标索引来访问元组中的值。

我这里列出三种访问方式：

my_tuple = (1, 2, 3, 4, 5)

# 访问单个元素
print(my_tuple[0])  # 输出 1，第一个元素
print(my_tuple[2])  # 输出 3，第三个元素

# 使用负数索引访问元素（从末尾开始）
print(my_tuple[-1])  # 输出 5，最后一个元素
print(my_tuple[-2])  # 输出 4，倒数第二个元素

# 切片操作访问多个元素
print(my_tuple[1:4])  # 输出 (2, 3, 4)，索引1到3的元素

这里面也包括了使用切片进行元组的访问。

元组的修改

元组中的元素值是不可以修改的，如果强行修改会报错。

    menu = ('meat','fish','chicken','carrot')
    menu[0] = 'pizza'
    print(menu[0])
    #  报错：  TypeError: 'tuple' object does not support item assignment

元组内置函数：

和列表差不多，都有一些内置函数方便编程的。例如：

len(tuple)：计算元组中元素个数；

max(tuple)：返回元组中元素的最大值；

min(tuple)：返回元组中元素的最小值；

tuple(seq)：将列表转换为元组

这里面比较有趣的是tuple函数，我这里着重讲一下。

函数的话其实不仅可以把列表转换成元组，还可以把字符串转换成元组。只是把字符串转换成元组的话比较鸡肋，这里的话我还是讲一下把。

三种情况：

1. 从列表到元组的转换：

   pythonCopy Codemy_list = [1, 2, 3]
   my_tuple = tuple(my_list)
   print(my_tuple)  # 输出 (1, 2, 3)
   

2. 从字符串到元组的转换：

   pythonCopy Codemy_string = "hello"
   string_tuple = tuple(my_string)
   print(string_tuple)  # 输出 ('h', 'e', 'l', 'l', 'o')
   

3. 空元组的创建：

   pythonCopy Codeempty_tuple = tuple()
   print(empty_tuple)  # 输出 ()
   

最后一种其实可以归到元组的创建上的。

字典的创建

字典和列表一样，都是 Python 中十分重要的可变容器模型，都可以存储任意类型元素。

与列表之间的联系：

• 在某种程度上，列表和字典都是用来存储数据的容器。它们都允许存储多个元素，并且可以进行遍历、访问和修改。
• 在某些情况下，列表中的元素也可以是字典，或者字典的值可以是列表，这样可以建立更复杂的数据结构。

字典的创建有两种方式：

1.使用大括号{}进行字典的创建。

# 创建一个空字典
my_dict = {}

# 创建一个非空字典
my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

2.使用字典内置函数dict()进行字典的创建

# 创建一个空字典
my_dict = dict()

# 创建一个非空字典
my_dict = dict(key1='value1', key2='value2', key3='value3')
# 创建一个非空字典，通过键值对列表
key_value_pairs = [('key1', 'value1'), ('key2', 'value2'), ('key3', 'value3')]
my_dict = dict(key_value_pairs)

# 使用 zip 函数创建字典
keys = ['key1', 'key2', 'key3']
values = ['value1', 'value2', 'value3']
my_dict = dict(zip(keys, values))

相关知识

字典是 Python 最强大的数据类型之一，通过键-值对的方式建立数据对象之间的映射关系。字典的每个键-值对用冒号:分割，每个键-值对间用逗号,分隔开，字典则包含在{}中。列表格式如下：

d = { key1 : value1, key2 : value2 }

每个键都与一个值相关联，我们可以使用键来访问与之相关联的值。与键相关联的值可以是数字、字符串、列表乃至字典。事实上，可将任何 Python 对象用作字典中的值。

访问字典中的值

要获取与键相关联的值，可依次指定字典名和放在方括号内的键

# 创建并初始化menu字典
menu = {'fish':40, 'pork':30, 'potato':15, 'noodles':10}
# 获取并返回menu字典中键'fish'键对应的值
print(menu['fish'])
#输出	40

还有一种是用get函数进行访问：

# 使用 get() 方法来访问值
name = my_dict.get('name')
age = my_dict.get('age')
city = my_dict.get('city')

print(name)  # 输出 'Alice'
print(age)   # 输出 30
print(city)  # 输出 'New York'

注意事项：

• 如果使用方括号 [ ] 来访问字典中不存在的键，会引发 KeyError 异常。而使用 get() 方法访问不存在的键会返回 None，可以避免异常。
• 可以通过指定默认值来避免 get() 方法返回 None 的情况：my_dict.get('key', default_value)。

字典的修改与插入

添加键—值对

字典是一种动态数据结构，可随时在字典中添加键-值对。要添加键-值对时，可依次指定字典名、键和键对应的值。

# 创建并初始化menu字典
menu = {'fish':40, 'pork':30, 'potato':15, 'noodles':10}
# 向menu字典中添加菜名和价格
menu['juice'] = 12
menu['egg'] = 5
# 输出新的menu
print(menu)
#输出结果：{'fish': 40,'pork': 30,'potato': 15,'noodles': 10, 'juice': 12,'egg': 5}

注意：字典中键-值对的排列顺序和添加顺序没有必然联系。Python 不关心字典中键-值对的排列顺序，而只关心键与值的对应关系。 同理，字典和列表一样，可以先创建一个空字典，然后可以不断向里面添加新的键-值对。

修改字典中的值

在Python中，可以通过指定字典的键来修改字典中对应键的值。字典是可变的数据结构，因此可以直接对键对应的值进行赋值操作来进行修改。

# 创建一个字典
my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 修改 'age' 键对应的值
my_dict['age'] = 31

# 修改 'city' 键对应的值
my_dict['city'] = 'Los Angeles'

print(my_dict)

运行以上代码后，字典 my_dict 的 ‘age’ 对应的值从 30 被修改为 31，‘city’ 对应的值从 ‘New York’ 被修改为 ‘Los Angeles’。

注意：如果指定的键在字典中不存在，直接赋值会创建一个新的键值对。因此，在修改字典中的值时，确保键存在，或者根据实际情况做好键的检查处理。

字典的删除

字典的删除有两种方法：

1.使用 del 关键字删除键值对：

# 创建一个字典
my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 删除指定键值对
del my_dict['age']

print(my_dict)  # 输出 {'name': 'Alice', 'city': 'New York'}

2.使用 pop() 方法删除键值对

# 创建一个字典
my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 删除指定键值对并返回对应的值
removed_value = my_dict.pop('age')

print(my_dict)        # 输出 {'name': 'Alice', 'city': 'New York'}
print(removed_value)  # 输出 30

字典的遍历

字典首先分为键和值，遍历分为几种情况。

遍历字典中的键-值对

Python 为字典类型提供了items()方法，items()方法会将字典里的所有的键与值一起返回。

# 创建一个字典
my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 使用items()方法遍历键值对
for key, value in my_dict.items():
    print(key, ": ", value)

遍历字典中的键

# 创建一个字典
my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 遍历字典的键
for key in my_dict:
    print(key)
#输出
name
age
city

讲到这个我得讲一下字典的一个内置函数：keys()这个是用来提取字典中的键；所以上面那种情况还有一种写法；

# 创建一个字典
my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
# 利用keys()方法遍历输出键
for key in my_dict.keys():
    print('键:'+key)
    
#输出结果：
键:name
键:age
键:city

字典与列表的嵌套

Python 的列表和字典可以存储任意类型的元素，所以我们可以将字典存储在列表中，也可以将列表存储在字典中，这种操作称为嵌套。

字典中嵌套列表

# 创建一个字典，其中值为列表
my_dict = {
    'name': 'Alice',
    'grades': [85, 90, 88, 92]
}

# 访问字典中的嵌套列表元素
print(my_dict['name'])        # 输出 'Alice'
print(my_dict['grades'][0])   # 输出 85

列表中嵌套字典：

# 创建一个列表，其中元素为字典
my_list = [
    {'name': 'Alice', 'age': 30},
    {'name': 'Bob', 'age': 25}
]

# 访问列表中的嵌套字典元素
print(my_list[0]['name'])     # 输出 'Alice'
print(my_list[1]['age'])      # 输出 25

复杂的嵌套结构：

# 创建一个包含多层嵌套的数据结构
nested_data = {
    'key1': [1, 2, 3],
    'key2': {'subkey1': 'value1', 'subkey2': 'value2'},
    'key3': [{'name': 'Alice', 'age': 30}, {'name': 'Bob', 'age': 25}]
}

# 访问复杂嵌套结构中的元素
print(nested_data['key2']['subkey1'])                 # 输出 'value1'
print(nested_data['key3'][0]['name'])                 # 输出 'Alice'