Summary  
This chapter shows how to delete an entire tuple using the del statement and how to remove specific elements by converting the tuple to a list, removing items, and converting it back to a tuple.

General domain of usage  
Data structure manipulation

A tuple in Python is immutable, meaning once it's created, you cannot change, add, or remove its elements. However, you can delete the entire tuple using the `del` statement.

movies = ("Inception", "Interstellar", "Tenet", "Dunkirk", "Memento")

# Deleting the tuple
del movies

# Attempting to print the deleted tuple will raise an error
print(movies)

Since tuples are immutable, you cannot directly remove items from them. However, you can work around this by converting the tuple into a list, modifying the list, and then converting it back into a tuple.

Note

movies = ("Inception", "Interstellar", "Tenet", "Dunkirk", "Memento")

# Convert the tuple to a list
movies_list = list(movies)

# Remove specific items
movies_list.remove("Tenet")
movies_list.remove("Dunkirk")

# Convert the list back to a tuple
movies = tuple(movies_list)

print(movies)

import unittest
import importlib
import re

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestUserCode(unittest.TestCase):

    def test_movie_poster_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'movie_poster'),
            "The `movie_poster` variable is declared.",
            "Expected `movie_poster` to be declared."
        )

    def test_movie_poster_is_tuple(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.movie_poster, tuple),
            "The `movie_poster` is of type `tuple`.",
            "Expected `movie_poster` to be of type `tuple`."
        )

    def test_movie_poster_contains_correct_values(self):
        import user_code
        expected_values = ('Finding Nemo', '2001: A Space Odyssey', 'Interstellar', 'Gravity', 'The Martian')
        _dynamic_test(
            self,
            set(user_code.movie_poster) == set(expected_values),
            f"The `movie_poster` contains `{expected_values}`.",
            f"Expected `movie_poster` to contain `{expected_values}`, but got `{user_code.movie_poster}`."
        )

    def test_temp_list_deleted(self):
        import user_code
        _dynamic_test(
            self,
            not hasattr(user_code, 'temp_list'),
            "The `temp_list` variable was deleted.",
            "Expected `temp_list` to be deleted."
        )

    def test_list_function_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'list\s*\(', user_code_source),
            "The `list()` function is used for tuple conversion.",
            "Expected the `list()` function to be used for tuple conversion."
        )

    def test_remove_method_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'\.remove\s*\(', user_code_source),
            "The `remove()` method is used to remove elements.",
            "Expected the `remove()` method to be used to remove elements."
        )

    def test_tuple_function_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'tuple\s*\(', user_code_source),
            "The `tuple()` function is used for conversion back to a tuple.",
            "Expected the `tuple()` function to be used for conversion back to a tuple."
        )

    def test_del_statement_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'del\s+temp_list', user_code_source),
            "The `del` statement is used to delete `temp_list`.",
            "Expected the `del` statement to be used to delete `temp_list`."
        )

if __name__ == '__main__':
    unittest.main()

test_main.py

Explore the fundamental data structures of the Python programming language, including lists, dictionaries, tuples, and sets, and learn how to apply them effectively to solve real-world programming challenges.

What is a list? A list is an ordered collection that can be modified. It also allows for duplicate elements.

Deleting Tuples in Python

Removing Items

解答