Python 列表與元組轉換的必備技能

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

開發

今天我們來聊一聊Python中非常常用的數據結構——列表和元組。這兩個數據結構在很多場景下都非常有用，但有時候我們需要在它們之間進行轉換。

大家好，歡迎來到今天的Python編程教程!今天我們來聊一聊Python中非常常用的數據結構——列表和元組。這兩個數據結構在很多場景下都非常有用，但有時候我們需要在它們之間進行轉換。掌握這些轉換技巧，可以讓你的代碼更加靈活和高效。

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

責任編輯：趙寧寧來源：手把手PythonAI編程

Python 列表元組

成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看