1. 基本概念
首先，让我们快速回顾一下列表和元组的基本概念：
- 列表(List)：列表是可变的，可以用方括号 [] 来表示。列表中的元素可以被修改、添加或删除。
- 元组(Tuple)：元组是不可变的，可以用圆括号 () 来表示。元组中的元素一旦创建就不能被修改。
2. 将列表转换为元组
将列表转换为元组非常简单，只需要使用 tuple() 函数即可。
# 定义一个列表
my_list = [1, 2, 3, 4, 5]
# 将列表转换为元组
my_tuple = tuple(my_list)
print(my_tuple) # 输出: (1, 2, 3, 4, 5)3. 将元组转换为列表
同样地，将元组转换为列表也非常简单，只需要使用 list() 函数。
# 定义一个元组
my_tuple = (1, 2, 3, 4, 5)
# 将元组转换为列表
my_list = list(my_tuple)
print(my_list) # 输出: [1, 2, 3, 4, 5]4. 转换嵌套列表和元组
有时候，我们可能会遇到嵌套的列表或元组。这时候，我们可以使用嵌套的 tuple() 和 list() 函数来进行转换。
# 嵌套列表
nested_list = [[1, 2], [3, 4]]
# 将嵌套列表转换为嵌套元组
nested_tuple = tuple(tuple(sublist) for sublist in nested_list)
print(nested_tuple) # 输出: ((1, 2), (3, 4))
# 嵌套元组
nested_tuple = ((1, 2), (3, 4))
# 将嵌套元组转换为嵌套列表
nested_list = list(list(subtuple) for subtuple in nested_tuple)
print(nested_list) # 输出: [[1, 2], [3, 4]]5. 使用列表推导式和生成器表达式
列表推导式和生成器表达式是Python中非常强大的工具，可以用来简化转换过程。
# 使用列表推导式将元组转换为列表
my_tuple = (1, 2, 3, 4, 5)
my_list = [x for x in my_tuple]
print(my_list) # 输出: [1, 2, 3, 4, 5]
# 使用生成器表达式将列表转换为元组
my_list = [1, 2, 3, 4, 5]
my_tuple = tuple(x for x in my_list)
print(my_tuple) # 输出: (1, 2, 3, 4, 5)6. 转换包含不同数据类型的列表和元组
列表和元组可以包含不同数据类型的元素。在转换时，这一点需要注意。
# 包含不同数据类型的列表
mixed_list = [1, 'two', 3.0, True]
# 将混合列表转换为元组
mixed_tuple = tuple(mixed_list)
print(mixed_tuple) # 输出: (1, 'two', 3.0, True)
# 包含不同数据类型的元组
mixed_tuple = (1, 'two', 3.0, True)
# 将混合元组转换为列表
mixed_list = list(mixed_tuple)
print(mixed_list) # 输出: [1, 'two', 3.0, True]7. 转换包含字典的列表和元组
如果列表或元组中包含字典，我们也可以进行转换。
# 包含字典的列表
dict_list = [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}]
# 将包含字典的列表转换为元组
dict_tuple = tuple(dict_list)
print(dict_tuple) # 输出: ({'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30})
# 包含字典的元组
dict_tuple = ({'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30})
# 将包含字典的元组转换为列表
dict_list = list(dict_tuple)
print(dict_list) # 输出: [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}]8. 转换包含集合的列表和元组
如果列表或元组中包含集合，我们也可以进行转换。
# 包含集合的列表
set_list = [{1, 2, 3}, {4, 5, 6}]
# 将包含集合的列表转换为元组
set_tuple = tuple(set_list)
print(set_tuple) # 输出: ({1, 2, 3}, {4, 5, 6})
# 包含集合的元组
set_tuple = ({1, 2, 3}, {4, 5, 6})
# 将包含集合的元组转换为列表
set_list = list(set_tuple)
print(set_list) # 输出: [{1, 2, 3}, {4, 5, 6}]9. 转换包含自定义对象的列表和元组
如果你有一个自定义类的对象，也可以进行转换。
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def __repr__(self):
return f"Person(name={self.name}, age={self.age})"
# 包含自定义对象的列表
person_list = [Person('Alice', 25), Person('Bob', 30)]
# 将包含自定义对象的列表转换为元组
person_tuple = tuple(person_list)
print(person_tuple) # 输出: (Person(name=Alice, age=25), Person(name=Bob, age=30))
# 包含自定义对象的元组
person_tuple = (Person('Alice', 25), Person('Bob', 30))
# 将包含自定义对象的元组转换为列表
person_list = list(person_tuple)
print(person_list) # 输出: [Person(name=Alice, age=25), Person(name=Bob, age=30)]10. 转换包含嵌套字典的列表和元组
如果列表或元组中包含嵌套字典，我们也可以进行转换。
# 包含嵌套字典的列表
nested_dict_list = [{'name': 'Alice', 'details': {'age': 25, 'city': 'New York'}},
{'name': 'Bob', 'details': {'age': 30, 'city': 'Los Angeles'}}]
# 将包含嵌套字典的列表转换为元组
nested_dict_tuple = tuple(nested_dict_list)
print(nested_dict_tuple) # 输出: ({'name': 'Alice', 'details': {'age': 25, 'city': 'New York'}}, {'name': 'Bob', 'details': {'age': 30, 'city': 'Los Angeles'}})
# 包含嵌套字典的元组
nested_dict_tuple = ({'name': 'Alice', 'details': {'age': 25, 'city': 'New York'}},
{'name': 'Bob', 'details': {'age': 30, 'city': 'Los Angeles'}})
# 将包含嵌套字典的元组转换为列表
nested_dict_list = list(nested_dict_tuple)
print(nested_dict_list) # 输出: [{'name': 'Alice', 'details': {'age': 25, 'city': 'New York'}}, {'name': 'Bob', 'details': {'age': 30, 'city': 'Los Angeles'}}]11. 转换包含嵌套列表的元组
如果元组中包含嵌套列表，我们也可以进行转换。
# 包含嵌套列表的元组
nested_list_tuple = ([1, 2, 3], [4, 5, 6])
# 将包含嵌套列表的元组转换为列表
nested_list_list = [list(sublist) for sublist in nested_list_tuple]
print(nested_list_list) # 输出: [[1, 2, 3], [4, 5, 6]]
# 包含嵌套列表的列表
nested_list_list = [[1, 2, 3], [4, 5, 6]]
# 将包含嵌套列表的列表转换为元组
nested_list_tuple = tuple(list(sublist) for sublist in nested_list_list)
print(nested_list_tuple) # 输出: ([1, 2, 3], [4, 5, 6])12. 转换包含嵌套元组的列表
如果列表中包含嵌套元组，我们也可以进行转换。
# 包含嵌套元组的列表
nested_tuple_list = [(1, 2, 3), (4, 5, 6)]
# 将包含嵌套元组的列表转换为元组
nested_tuple_tuple = tuple(tuple(subtuple) for subtuple in nested_tuple_list)
print(nested_tuple_tuple) # 输出: ((1, 2, 3), (4, 5, 6))
# 包含嵌套元组的元组
nested_tuple_tuple = ((1, 2, 3), (4, 5, 6))
# 将包含嵌套元组的元组转换为列表
nested_tuple_list = [list(subtuple) for subtuple in nested_tuple_tuple]
************************************************### 继续 Python 列表与元组转换的13个必备技能
## 14. 转换包含多个数据类型混合的复杂结构
有时候，我们会遇到包含多种数据类型的复杂结构，例如列表中包含元组、字典和集合。这种情况下，我们仍然可以使用 `tuple()` 和 `list()` 函数进行转换。
```python
# 复杂的列表结构
complex_list = [1, ('Alice', 25), {'name': 'Bob', 'age': 30}, {1, 2, 3}]
# 将复杂的列表转换为元组
complex_tuple = tuple(complex_list)
print(complex_tuple) # 输出: (1, ('Alice', 25), {'name': 'Bob', 'age': 30}, {1, 2, 3})
# 复杂的元组结构
complex_tuple = (1, ('Alice', 25), {'name': 'Bob', 'age': 30}, {1, 2, 3})
# 将复杂的元组转换为列表
complex_list = list(complex_tuple)
print(complex_list) # 输出: [1, ('Alice', 25), {'name': 'Bob', 'age': 30}, {1, 2, 3}]13. 转换包含嵌套字典和列表的复杂结构
如果列表或元组中包含嵌套的字典和列表，我们可以通过嵌套的 tuple() 和 list() 函数进行转换。
# 复杂的列表结构
complex_list = [
{'name': 'Alice', 'details': {'age': 25, 'courses': ['Math', 'Science']}},
{'name': 'Bob', 'details': {'age': 30, 'courses': ['History', 'English']}}
]
# 将复杂的列表转换为元组
complex_tuple = tuple(complex_list)
print(complex_tuple) # 输出: ({'name': 'Alice', 'details': {'age': 25, 'courses': ['Math', 'Science']}}, {'name': 'Bob', 'details': {'age': 30, 'courses': ['History', 'English']}})
# 复杂的元组结构
complex_tuple = (
{'name': 'Alice', 'details': {'age': 25, 'courses': ['Math', 'Science']}},
{'name': 'Bob', 'details': {'age': 30, 'courses': ['History', 'English']}}
)
# 将复杂的元组转换为列表
complex_list = list(complex_tuple)
print(complex_list) # 输出: [{'name': 'Alice', 'details': {'age': 25, 'courses': ['Math', 'Science']}}, {'name': 'Bob', 'details': {'age': 30, 'courses': ['History', 'English']}}]14. 转换包含自定义类对象的复杂结构
如果列表或元组中包含自定义类的对象，我们可以通过嵌套的 tuple() 和 list() 函数进行转换。
class Student:
def __init__(self, name, age, courses):
self.name = name
self.age = age
self.courses = courses
def __repr__(self):
return f"Student(name={self.name}, age={self.age}, courses={self.courses})"
# 复杂的列表结构
complex_list = [
Student('Alice', 25, ['Math', 'Science']),
Student('Bob', 30, ['History', 'English'])
]
# 将复杂的列表转换为元组
complex_tuple = tuple(complex_list)
print(complex_tuple) # 输出: (Student(name=Alice, age=25, courses=['Math', 'Science']), Student(name=Bob, age=30, courses=['History', 'English']))
# 复杂的元组结构
complex_tuple = (
Student('Alice', 25, ['Math', 'Science']),
Student('Bob', 30, ['History', 'English'])
)
# 将复杂的元组转换为列表
complex_list = list(complex_tuple)
print(complex_list) # 输出: [Student(name=Alice, age=25, courses=['Math', 'Science']), Student(name=Bob, age=30, courses=['History', 'English'])]15. 转换包含嵌套元组和列表的复杂结构
如果列表或元组中包含嵌套的元组和列表，我们可以通过嵌套的 tuple() 和 list() 函数进行转换。
# 复杂的列表结构
complex_list = [
(1, 2, 3),
[4, 5, 6],
{'name': 'Alice', 'age': 25}
]
# 将复杂的列表转换为元组
complex_tuple = tuple(
tuple(item) if isinstance(item, list) else item for item in complex_list
)
print(complex_tuple) # 输出: ((1, 2, 3), (4, 5, 6), {'name': 'Alice', 'age': 25})
# 复杂的元组结构
complex_tuple = (
(1, 2, 3),
[4, 5, 6],
{'name': 'Alice', 'age': 25}
)
# 将复杂的元组转换为列表
complex_list = [
list(item) if isinstance(item, tuple) else item for item in complex_tuple
]
print(complex_list) # 输出: [[1, 2, 3], [4, 5, 6], {'name': 'Alice', 'age': 25}]16. 转换包含嵌套字典和集合的复杂结构
如果列表或元组中包含嵌套的字典和集合，我们可以通过嵌套的 tuple() 和 list() 函数进行转换。
# 复杂的列表结构
complex_list = [
{'name': 'Alice', 'details': {'age': 25, 'courses': {'Math', 'Science'}}},
{'name': 'Bob', 'details': {'age': 30, 'courses': {'History', 'English'}}}
]
# 将复杂的列表转换为元组
complex_tuple = tuple(complex_list)
print(complex_tuple) # 输出: ({'name': 'Alice', 'details': {'age': 25, 'courses': {'Math', 'Science'}}}, {'name': 'Bob', 'details': {'age': 30, 'courses': {'History', 'English'}}})
# 复杂的元组结构
complex_tuple = (
{'name': 'Alice', 'details': {'age': 25, 'courses': {'Math', 'Science'}}},
{'name': 'Bob', 'details': {'age': 30, 'courses': {'History', 'English'}}}
)
# 将复杂的元组转换为列表
complex_list = list(complex_tuple)
print(complex_list) # 输出: [{'name': 'Alice', 'details': {'age': 25, 'courses': {'Math', 'Science'}}}, {'name': 'Bob', 'details': {'age': 30, 'courses': {'History', 'English'}}}]17. 转换包含嵌套自定义类对象的复杂结构
如果列表或元组中包含嵌套的自定义类对象，我们可以通过嵌套的 tuple() 和 list() 函数进行转换。
class Course:
def __init__(self, name, credits):
self.name = name
self.credits = credits
def __repr__(self):
return f"Course(name={self.name}, credits={self.credits})"
class Student:
def __init__(self, name, age, courses):
self.name = name
self.age = age
self.courses = courses
def __repr__(self):
return f"Student(name={self.name}, age={self.age}, courses={self.courses})"
# 复杂的列表结构
complex_list = [
Student('Alice', 25, [Course('Math', 4), Course('Science', 3)]),
Student('Bob', 30, [Course('History', 3), Course('English', 4)])
]
# 将复杂的列表转换为元组
complex_tuple = tuple(complex_list)
print(complex_tuple) # 输出: (Student(name=Alice, age=25, courses=[Course(name=Math, credits=4), Course(name=Science, credits=3)]), Student(name=Bob, age=30, courses=[Course(name=History, credits=3), Course(name=English, credits=4)]))
# 复杂的元组结构
complex_tuple = (
Student('Alice', 25, [Course('Math', 4), Course('Science', 3)]),
Student('Bob', 30, [Course('History', 3), Course('English', 4)])
)
# 将复杂的元组转换为列表
complex_list = list(complex_tuple)
print(complex_list) # 输出: [Student(name=Alice, age=25, courses=[Course(name=Math, credits=4), Course(name=Science, credits=3)]), Student(name=Bob, age=30, courses=[Course(name=History, credits=3), Course(name=English, credits=4)])]实战案例：处理学生成绩数据
假设我们有一个包含学生成绩的列表，每个学生成绩是一个字典，包含姓名、科目和成绩。我们需要将这个列表转换为元组，并计算每个学生的平均成绩。
# 学生成绩数据列表
grades_list = [
{'name': 'Alice', 'subject': 'Math', 'grade': 85},
{'name': 'Alice', 'subject': 'Science', 'grade': 90},
{'name': 'Bob', 'subject': 'History', 'grade': 78},
{'name': 'Bob', 'subject': 'English', 'grade': 88}
]
# 将学生成绩数据列表转换为元组
grades_tuple = tuple(grades_list)
# 计算每个学生的平均成绩
from collections import defaultdict
student_grades = defaultdict(list)
for grade in grades_tuple:
student_grades[grade['name']].append(grade['grade'])
average_grades = {name: sum(grades) / len(grades) for name, grades in student_grades.items()}
print("每个学生的平均成绩是:")
for name, average in average_grades.items():
print(f"{name}: {average:.2f}")
# 输出:
# 每个学生的平均成绩是:
# Alice: 87.50
# Bob: 83.00
