Python 列表與元組轉(zhuǎn)換的必備技能

作者：手把手PythonAI編程 2024-10-30 08:00:00

今天我們來聊一聊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)：列表是可變的，可以用方括號 [] 來表示。列表中的元素可以被修改、添加或刪除。
元組(Tuple)：元組是不可變的，可以用圓括號 () 來表示。元組中的元素一旦創(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í)候，我們可能會遇到嵌套的列表或元組。這時(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)換包含自定義對象的列表和元組

如果你有一個(gè)自定義類的對象，也可以進(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})"

# 包含自定義對象的列表
person_list = [Person('Alice', 25), Person('Bob', 30)]

# 將包含自定義對象的列表轉(zhuǎn)換為元組
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))

# 將包含自定義對象的元組轉(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í)候，我們會遇到包含多種數(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)換包含自定義類對象的復(fù)雜結(jié)構(gòu)

如果列表或元組中包含自定義類的對象，我們可以通過嵌套的 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)換包含嵌套自定義類對象的復(fù)雜結(jié)構(gòu)

如果列表或元組中包含嵌套的自定義類對象，我們可以通過嵌套的 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編程

Python 列表元組