Python 列表與元組轉(zhuǎn)換的必備技能
作者：手把手PythonAI編程
今天我們來聊一聊Python中非常常用的數(shù)據(jù)結(jié)構(gòu)——列表和元組。這兩個(gè)數(shù)據(jù)結(jié)構(gòu)在很多場景下都非常有用，但有時(shí)候我們需要在它們之間進(jìn)行轉(zhuǎn)換。
大家好，歡迎來到今天的Python編程教程!今天我們來聊一聊Python中非常常用的數(shù)據(jù)結(jié)構(gòu)——列表和元組。這兩個(gè)數(shù)據(jù)結(jié)構(gòu)在很多場景下都非常有用，但有時(shí)候我們需要在它們之間進(jìn)行轉(zhuǎn)換。掌握這些轉(zhuǎn)換技巧，可以讓你的代碼更加靈活和高效。
1. 基本概念
首先，讓我們快速回顧一下列表和元組的基本概念：
- 列表(List)：列表是可變的，可以用方括號(hào) [] 來表示。列表中的元素可以被修改、添加或刪除。
- 元組(Tuple)：元組是不可變的，可以用圓括號(hào) () 來表示。元組中的元素一旦創(chuàng)建就不能被修改。
2. 將列表轉(zhuǎn)換為元組
將列表轉(zhuǎn)換為元組非常簡單，只需要使用 tuple() 函數(shù)即可。
# 定義一個(gè)列表
my_list = [1, 2, 3, 4, 5]
# 將列表轉(zhuǎn)換為元組
my_tuple = tuple(my_list)
print(my_tuple) # 輸出: (1, 2, 3, 4, 5)3. 將元組轉(zhuǎn)換為列表
同樣地，將元組轉(zhuǎn)換為列表也非常簡單，只需要使用 list() 函數(shù)。
# 定義一個(gè)元組
my_tuple = (1, 2, 3, 4, 5)
# 將元組轉(zhuǎn)換為列表
my_list = list(my_tuple)
print(my_list) # 輸出: [1, 2, 3, 4, 5]4. 轉(zhuǎn)換嵌套列表和元組
有時(shí)候，我們可能會(huì)遇到嵌套的列表或元組。這時(shí)候，我們可以使用嵌套的 tuple() 和 list() 函數(shù)來進(jìn)行轉(zhuǎn)換。
# 嵌套列表
nested_list = [[1, 2], [3, 4]]
# 將嵌套列表轉(zhuǎn)換為嵌套元組
nested_tuple = tuple(tuple(sublist) for sublist in nested_list)
print(nested_tuple) # 輸出: ((1, 2), (3, 4))
# 嵌套元組
nested_tuple = ((1, 2), (3, 4))
# 將嵌套元組轉(zhuǎn)換為嵌套列表
nested_list = list(list(subtuple) for subtuple in nested_tuple)
print(nested_list) # 輸出: [[1, 2], [3, 4]]5. 使用列表推導(dǎo)式和生成器表達(dá)式
列表推導(dǎo)式和生成器表達(dá)式是Python中非常強(qiáng)大的工具，可以用來簡化轉(zhuǎn)換過程。
# 使用列表推導(dǎo)式將元組轉(zhuǎn)換為列表
my_tuple = (1, 2, 3, 4, 5)
my_list = [x for x in my_tuple]
print(my_list) # 輸出: [1, 2, 3, 4, 5]
# 使用生成器表達(dá)式將列表轉(zhuǎn)換為元組
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. 轉(zhuǎn)換包含不同數(shù)據(jù)類型的列表和元組
列表和元組可以包含不同數(shù)據(jù)類型的元素。在轉(zhuǎn)換時(shí)，這一點(diǎn)需要注意。
# 包含不同數(shù)據(jù)類型的列表
mixed_list = [1, 'two', 3.0, True]
# 將混合列表轉(zhuǎn)換為元組
mixed_tuple = tuple(mixed_list)
print(mixed_tuple) # 輸出: (1, 'two', 3.0, True)
# 包含不同數(shù)據(jù)類型的元組
mixed_tuple = (1, 'two', 3.0, True)
# 將混合元組轉(zhuǎn)換為列表
mixed_list = list(mixed_tuple)
print(mixed_list) # 輸出: [1, 'two', 3.0, True]7. 轉(zhuǎn)換包含字典的列表和元組
如果列表或元組中包含字典，我們也可以進(jìn)行轉(zhuǎn)換。
# 包含字典的列表
dict_list = [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}]
# 將包含字典的列表轉(zhuǎn)換為元組
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})
# 將包含字典的元組轉(zhuǎn)換為列表
dict_list = list(dict_tuple)
print(dict_list) # 輸出: [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}]8. 轉(zhuǎn)換包含集合的列表和元組
如果列表或元組中包含集合，我們也可以進(jìn)行轉(zhuǎn)換。
# 包含集合的列表
set_list = [{1, 2, 3}, {4, 5, 6}]
# 將包含集合的列表轉(zhuǎn)換為元組
set_tuple = tuple(set_list)
print(set_tuple) # 輸出: ({1, 2, 3}, {4, 5, 6})
# 包含集合的元組
set_tuple = ({1, 2, 3}, {4, 5, 6})
# 將包含集合的元組轉(zhuǎn)換為列表
set_list = list(set_tuple)
print(set_list) # 輸出: [{1, 2, 3}, {4, 5, 6}]9. 轉(zhuǎn)換包含自定義對(duì)象的列表和元組
如果你有一個(gè)自定義類的對(duì)象，也可以進(jìn)行轉(zhuǎn)換。
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})"
# 包含自定義對(duì)象的列表
person_list = [Person('Alice', 25), Person('Bob', 30)]
# 將包含自定義對(duì)象的列表轉(zhuǎn)換為元組
person_tuple = tuple(person_list)
print(person_tuple) # 輸出: (Person(name=Alice, age=25), Person(name=Bob, age=30))
# 包含自定義對(duì)象的元組
person_tuple = (Person('Alice', 25), Person('Bob', 30))
# 將包含自定義對(duì)象的元組轉(zhuǎn)換為列表
person_list = list(person_tuple)
print(person_list) # 輸出: [Person(name=Alice, age=25), Person(name=Bob, age=30)]10. 轉(zhuǎn)換包含嵌套字典的列表和元組
如果列表或元組中包含嵌套字典，我們也可以進(jìn)行轉(zhuǎn)換。
# 包含嵌套字典的列表
nested_dict_list = [{'name': 'Alice', 'details': {'age': 25, 'city': 'New York'}},
{'name': 'Bob', 'details': {'age': 30, 'city': 'Los Angeles'}}]
# 將包含嵌套字典的列表轉(zhuǎn)換為元組
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'}})
# 將包含嵌套字典的元組轉(zhuǎn)換為列表
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. 轉(zhuǎn)換包含嵌套列表的元組
如果元組中包含嵌套列表，我們也可以進(jìn)行轉(zhuǎn)換。
# 包含嵌套列表的元組
nested_list_tuple = ([1, 2, 3], [4, 5, 6])
# 將包含嵌套列表的元組轉(zhuǎn)換為列表
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]]
# 將包含嵌套列表的列表轉(zhuǎn)換為元組
nested_list_tuple = tuple(list(sublist) for sublist in nested_list_list)
print(nested_list_tuple) # 輸出: ([1, 2, 3], [4, 5, 6])12. 轉(zhuǎn)換包含嵌套元組的列表
如果列表中包含嵌套元組，我們也可以進(jìn)行轉(zhuǎn)換。
# 包含嵌套元組的列表
nested_tuple_list = [(1, 2, 3), (4, 5, 6)]
# 將包含嵌套元組的列表轉(zhuǎn)換為元組
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))
# 將包含嵌套元組的元組轉(zhuǎn)換為列表
nested_tuple_list = [list(subtuple) for subtuple in nested_tuple_tuple]
************************************************### 繼續(xù) Python 列表與元組轉(zhuǎn)換的13個(gè)必備技能
## 14. 轉(zhuǎn)換包含多個(gè)數(shù)據(jù)類型混合的復(fù)雜結(jié)構(gòu)
有時(shí)候，我們會(huì)遇到包含多種數(shù)據(jù)類型的復(fù)雜結(jié)構(gòu)，例如列表中包含元組、字典和集合。這種情況下，我們?nèi)匀豢梢允褂?`tuple()` 和 `list()` 函數(shù)進(jìn)行轉(zhuǎn)換。
```python
# 復(fù)雜的列表結(jié)構(gòu)
complex_list = [1, ('Alice', 25), {'name': 'Bob', 'age': 30}, {1, 2, 3}]
# 將復(fù)雜的列表轉(zhuǎn)換為元組
complex_tuple = tuple(complex_list)
print(complex_tuple) # 輸出: (1, ('Alice', 25), {'name': 'Bob', 'age': 30}, {1, 2, 3})
# 復(fù)雜的元組結(jié)構(gòu)
complex_tuple = (1, ('Alice', 25), {'name': 'Bob', 'age': 30}, {1, 2, 3})
# 將復(fù)雜的元組轉(zhuǎn)換為列表
complex_list = list(complex_tuple)
print(complex_list) # 輸出: [1, ('Alice', 25), {'name': 'Bob', 'age': 30}, {1, 2, 3}]13. 轉(zhuǎn)換包含嵌套字典和列表的復(fù)雜結(jié)構(gòu)
如果列表或元組中包含嵌套的字典和列表，我們可以通過嵌套的 tuple() 和 list() 函數(shù)進(jìn)行轉(zhuǎn)換。
# 復(fù)雜的列表結(jié)構(gòu)
complex_list = [
{'name': 'Alice', 'details': {'age': 25, 'courses': ['Math', 'Science']}},
{'name': 'Bob', 'details': {'age': 30, 'courses': ['History', 'English']}}
]
# 將復(fù)雜的列表轉(zhuǎn)換為元組
complex_tuple = tuple(complex_list)
print(complex_tuple) # 輸出: ({'name': 'Alice', 'details': {'age': 25, 'courses': ['Math', 'Science']}}, {'name': 'Bob', 'details': {'age': 30, 'courses': ['History', 'English']}})
# 復(fù)雜的元組結(jié)構(gòu)
complex_tuple = (
{'name': 'Alice', 'details': {'age': 25, 'courses': ['Math', 'Science']}},
{'name': 'Bob', 'details': {'age': 30, 'courses': ['History', 'English']}}
)
# 將復(fù)雜的元組轉(zhuǎn)換為列表
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. 轉(zhuǎn)換包含自定義類對(duì)象的復(fù)雜結(jié)構(gòu)
如果列表或元組中包含自定義類的對(duì)象，我們可以通過嵌套的 tuple() 和 list() 函數(shù)進(jìn)行轉(zhuǎn)換。
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})"
# 復(fù)雜的列表結(jié)構(gòu)
complex_list = [
Student('Alice', 25, ['Math', 'Science']),
Student('Bob', 30, ['History', 'English'])
]
# 將復(fù)雜的列表轉(zhuǎn)換為元組
complex_tuple = tuple(complex_list)
print(complex_tuple) # 輸出: (Student(name=Alice, age=25, courses=['Math', 'Science']), Student(name=Bob, age=30, courses=['History', 'English']))
# 復(fù)雜的元組結(jié)構(gòu)
complex_tuple = (
Student('Alice', 25, ['Math', 'Science']),
Student('Bob', 30, ['History', 'English'])
)
# 將復(fù)雜的元組轉(zhuǎn)換為列表
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. 轉(zhuǎn)換包含嵌套元組和列表的復(fù)雜結(jié)構(gòu)
如果列表或元組中包含嵌套的元組和列表，我們可以通過嵌套的 tuple() 和 list() 函數(shù)進(jìn)行轉(zhuǎn)換。
# 復(fù)雜的列表結(jié)構(gòu)
complex_list = [
(1, 2, 3),
[4, 5, 6],
{'name': 'Alice', 'age': 25}
]
# 將復(fù)雜的列表轉(zhuǎn)換為元組
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})
# 復(fù)雜的元組結(jié)構(gòu)
complex_tuple = (
(1, 2, 3),
[4, 5, 6],
{'name': 'Alice', 'age': 25}
)
# 將復(fù)雜的元組轉(zhuǎn)換為列表
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. 轉(zhuǎn)換包含嵌套字典和集合的復(fù)雜結(jié)構(gòu)
如果列表或元組中包含嵌套的字典和集合，我們可以通過嵌套的 tuple() 和 list() 函數(shù)進(jìn)行轉(zhuǎn)換。
# 復(fù)雜的列表結(jié)構(gòu)
complex_list = [
{'name': 'Alice', 'details': {'age': 25, 'courses': {'Math', 'Science'}}},
{'name': 'Bob', 'details': {'age': 30, 'courses': {'History', 'English'}}}
]
# 將復(fù)雜的列表轉(zhuǎn)換為元組
complex_tuple = tuple(complex_list)
print(complex_tuple) # 輸出: ({'name': 'Alice', 'details': {'age': 25, 'courses': {'Math', 'Science'}}}, {'name': 'Bob', 'details': {'age': 30, 'courses': {'History', 'English'}}})
# 復(fù)雜的元組結(jié)構(gòu)
complex_tuple = (
{'name': 'Alice', 'details': {'age': 25, 'courses': {'Math', 'Science'}}},
{'name': 'Bob', 'details': {'age': 30, 'courses': {'History', 'English'}}}
)
# 將復(fù)雜的元組轉(zhuǎn)換為列表
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. 轉(zhuǎn)換包含嵌套自定義類對(duì)象的復(fù)雜結(jié)構(gòu)
如果列表或元組中包含嵌套的自定義類對(duì)象，我們可以通過嵌套的 tuple() 和 list() 函數(shù)進(jìn)行轉(zhuǎn)換。
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})"
# 復(fù)雜的列表結(jié)構(gòu)
complex_list = [
Student('Alice', 25, [Course('Math', 4), Course('Science', 3)]),
Student('Bob', 30, [Course('History', 3), Course('English', 4)])
]
# 將復(fù)雜的列表轉(zhuǎn)換為元組
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)]))
# 復(fù)雜的元組結(jié)構(gòu)
complex_tuple = (
Student('Alice', 25, [Course('Math', 4), Course('Science', 3)]),
Student('Bob', 30, [Course('History', 3), Course('English', 4)])
)
# 將復(fù)雜的元組轉(zhuǎn)換為列表
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)])]實(shí)戰(zhàn)案例：處理學(xué)生成績數(shù)據(jù)
假設(shè)我們有一個(gè)包含學(xué)生成績的列表，每個(gè)學(xué)生成績是一個(gè)字典，包含姓名、科目和成績。我們需要將這個(gè)列表轉(zhuǎn)換為元組，并計(jì)算每個(gè)學(xué)生的平均成績。
# 學(xué)生成績數(shù)據(jù)列表
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}
]
# 將學(xué)生成績數(shù)據(jù)列表轉(zhuǎn)換為元組
grades_tuple = tuple(grades_list)
# 計(jì)算每個(gè)學(xué)生的平均成績
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("每個(gè)學(xué)生的平均成績是:")
for name, average in average_grades.items():
print(f"{name}: {average:.2f}")
# 輸出:
# 每個(gè)學(xué)生的平均成績是:
# Alice: 87.50
# Bob: 83.00責(zé)任編輯：趙寧寧
來源：
手把手PythonAI編程
