Введение
В этой лабораторной работе вы получите всестороннее представление о кортежах (tuples) в Python. Вы узнаете, как создавать кортежи, получать доступ к их элементам с помощью индексации и срезов, а также изучите их неизменяемую природу. Вы также попрактикуетесь в использовании операторов для кортежей, распаковки и распространенных встроенных функций для эффективной работы с данными кортежей.
Создание и доступ к кортежам (Tuples)
На этом шаге вы научитесь создавать кортежи и получать доступ к их элементам. Кортежи — это упорядоченные, неизменяемые (immutable) коллекции элементов, что означает, что их содержимое нельзя изменить после создания.
Сначала найдите проводник файлов (file explorer) в левой части WebIDE. Найдите и откройте файл с именем tuple_basics.py. Мы будем писать наш код в этом файле.
Давайте начнем с создания нескольких различных типов кортежей. Добавьте следующий код в tuple_basics.py:
## Create an empty tuple
empty_tuple = ()
print("Empty tuple:", empty_tuple)
print("Type of empty_tuple:", type(empty_tuple))
## Create a tuple with a single element (note the trailing comma)
single_element_tuple = (50,)
print("\nSingle element tuple:", single_element_tuple)
print("Type of single_element_tuple:", type(single_element_tuple))
## Create a tuple with multiple elements
fruits = ("apple", "banana", "cherry")
print("\nFruits tuple:", fruits)
## Create a tuple from a list using the tuple() constructor
numbers_list = [1, 2, 3, 4]
numbers_tuple = tuple(numbers_list)
print("\nTuple from list:", numbers_tuple)
После добавления кода сохраните файл (вы можете использовать сочетание клавиш Ctrl+S). Затем откройте терминал в нижней части WebIDE и запустите скрипт следующей командой:
python tuple_basics.py
Вы должны увидеть следующий вывод, который подтверждает создание и типы ваших кортежей:
Empty tuple: ()
Type of empty_tuple: <class 'tuple'>
Single element tuple: (50,)
Type of single_element_tuple: <class 'tuple'>
Fruits tuple: ('apple', 'banana', 'cherry')
Tuple from list: (1, 2, 3, 4)
Теперь давайте научимся получать доступ к элементам внутри кортежа. Вы можете использовать индексацию (начиная с 0) для получения одного элемента и срезы (slicing) для получения подпоследовательности элементов.
Добавьте следующий код в конец вашего файла tuple_basics.py:
## Define a sample tuple for accessing elements
my_tuple = ('p', 'y', 't', 'h', 'o', 'n')
print("\nOriginal tuple:", my_tuple)
## Access elements using indexing
print("First element (index 0):", my_tuple[0])
print("Last element (index -1):", my_tuple[-1])
## Access elements using slicing
print("Elements from index 1 to 3:", my_tuple[1:4])
print("Elements from index 2 to the end:", my_tuple[2:])
print("Reverse the tuple:", my_tuple[::-1])
Снова сохраните файл и запустите скрипт из терминала:
python tuple_basics.py
Полный вывод теперь будет включать результаты доступа к элементам кортежа:
Empty tuple: ()
Type of empty_tuple: <class 'tuple'>
Single element tuple: (50,)
Type of single_element_tuple: <class 'tuple'>
Fruits tuple: ('apple', 'banana', 'cherry')
Tuple from list: (1, 2, 3, 4)
Original tuple: ('p', 'y', 't', 'h', 'o', 'n')
First element (index 0): p
Last element (index -1): n
Elements from index 1 to 3: ('y', 't', 'h')
Elements from index 2 to the end: ('t', 'h', 'o', 'n')
Reverse the tuple: ('n', 'o', 'h', 't', 'y', 'p')
Теперь вы успешно создали кортежи и получили доступ к их элементам.
Понимание неизменяемости кортежей (Tuple Immutability)
Ключевая характеристика кортежей — их неизменяемость (immutability). Это означает, что после создания кортежа вы не можете изменять, добавлять или удалять его элементы. На этом шаге вы увидите, что произойдет, если вы попытаетесь изменить кортеж, и узнаете правильный способ добиться "изменения" путем создания нового кортежа.
Откройте файл tuple_modification.py в проводнике файлов.
Сначала давайте попробуем изменить элемент в кортеже напрямую. Добавьте следующий код в tuple_modification.py. Строка, которая пытается выполнить изменение, закомментирована.
my_tuple = ('a', 'b', 'c', 'd', 'e')
print("Original tuple:", my_tuple)
## The following line will cause a TypeError because tuples are immutable.
## You can uncomment it to see the error for yourself.
## my_tuple[0] = 'f'
Если бы вы запустили код с раскомментированной предпоследней строкой, Python остановился бы и выдал бы ошибку TypeError: 'tuple' object does not support item assignment.
Поскольку мы не можем изменить кортеж на месте, решением является создание нового кортежа с желаемыми изменениями. Мы можем сделать это, используя срезы (slicing) и конкатенацию (+).
Добавьте следующий код в конец tuple_modification.py, чтобы увидеть, как "заменить" элемент:
## "Modify" a tuple by creating a new one
## Concatenate a new single-element tuple ('f',) with a slice of the original tuple
modified_tuple = ('f',) + my_tuple[1:]
print("New 'modified' tuple:", modified_tuple)
print("Original tuple is unchanged:", my_tuple)
Аналогично, вы можете "удалить" элемент, создав новый кортеж, который его не содержит. Добавьте этот код в свой файл:
## "Delete" an element by creating a new tuple
## Concatenate the slice before the element with the slice after the element
tuple_after_deletion = my_tuple[:2] + my_tuple[3:] ## Excludes element at index 2 ('c')
print("\nNew tuple after 'deletion':", tuple_after_deletion)
Сохраните файл и запустите его из терминала:
python tuple_modification.py
Вывод продемонстрирует, что мы создали новые кортежи, в то время как исходный остался без изменений:
Original tuple: ('a', 'b', 'c', 'd', 'e')
New 'modified' tuple: ('f', 'b', 'c', 'd', 'e')
Original tuple is unchanged: ('a', 'b', 'c', 'd', 'e')
New tuple after 'deletion': ('a', 'b', 'd', 'e')
Этот шаг подчеркивает неизменяемую природу кортежей и стандартную практику обхода этого ограничения.
Использование операторов кортежей и распаковки (Tuple Operators and Unpacking)
Python предоставляет несколько полезных операторов для работы с кортежами. Вы также узнаете о распаковке кортежей (tuple unpacking) — мощной функции для присваивания элементов кортежа переменным.
Откройте файл tuple_operators.py в проводнике файлов.
Давайте рассмотрим операторы конкатенации (+), повторения (*) и проверки на вхождение (in). Добавьте следующий код в tuple_operators.py:
tuple1 = (1, 2, 3)
tuple2 = ('a', 'b', 'c')
## Concatenation (+)
concatenated_tuple = tuple1 + tuple2
print("Concatenated:", concatenated_tuple)
## Repetition (*)
repeated_tuple = tuple1 * 3
print("Repeated:", repeated_tuple)
## Membership (in)
is_present = 'b' in tuple2
print("\nIs 'b' in tuple2?", is_present)
is_absent = 5 in tuple1
print("Is 5 in tuple1?", is_absent)
Сохраните файл и запустите его из терминала:
python tuple_operators.py
Вы увидите результаты этих операций:
Concatenated: (1, 2, 3, 'a', 'b', 'c')
Repeated: (1, 2, 3, 1, 2, 3, 1, 2, 3)
Is 'b' in tuple2? True
Is 5 in tuple1? False
Далее давайте изучим распаковку кортежей. Это позволяет присвоить элементы кортежа нескольким переменным в одной читаемой строке. Количество переменных должно соответствовать количеству элементов в кортеже.
Добавьте следующий код в конец tuple_operators.py:
## Tuple unpacking
person_info = ("Alice", 30, "Engineer")
name, age, profession = person_info
print("\nOriginal info tuple:", person_info)
print("Unpacked Name:", name)
print("Unpacked Age:", age)
print("Unpacked Profession:", profession)
Снова сохраните файл и запустите скрипт:
python tuple_operators.py
Теперь вывод будет включать распакованные переменные:
Concatenated: (1, 2, 3, 'a', 'b', 'c')
Repeated: (1, 2, 3, 1, 2, 3, 1, 2, 3)
Is 'b' in tuple2? True
Is 5 in tuple1? False
Original info tuple: ('Alice', 30, 'Engineer')
Unpacked Name: Alice
Unpacked Age: 30
Unpacked Profession: Engineer
Распаковка кортежей особенно полезна для функций, возвращающих несколько значений, поскольку они часто возвращают их в виде кортежа.
Применение встроенных функций и методов (Built-in Functions and Methods)
На этом заключительном шаге вы узнаете, как использовать общие встроенные функции (built-in functions) и методы, применяемые к кортежам. Кортежи имеют два основных метода: count() и index(), и могут использоваться со многими функциями общего назначения.
Откройте файл tuple_functions.py в проводнике файлов.
Начнем с методов кортежей. Метод count() возвращает количество вхождений элемента, а метод index() возвращает индекс первого вхождения элемента.
Добавьте следующий код в tuple_functions.py:
my_tuple = (1, 5, 2, 8, 5, 3, 5, 9)
print("Tuple:", my_tuple)
## count() method
count_of_5 = my_tuple.count(5)
print("Count of 5:", count_of_5)
## index() method
index_of_8 = my_tuple.index(8)
print("Index of 8:", index_of_8)
Теперь давайте используем некоторые встроенные функции, которые очень полезны для кортежей, такие как len(), max(), min(), sum() и sorted().
Добавьте следующий код в конец tuple_functions.py:
number_tuple = (10, 5, 20, 15, 30, 5)
print("\nNumber tuple:", number_tuple)
## len() function
print("Length:", len(number_tuple))
## max() and min() functions
print("Maximum value:", max(number_tuple))
print("Minimum value:", min(number_tuple))
## sum() function (for numeric tuples)
print("Sum of elements:", sum(number_tuple))
## sorted() function (returns a new sorted list)
sorted_list = sorted(number_tuple)
print("Sorted list from tuple:", sorted_list)
Обратите внимание, что функция sorted() возвращает новый список (list), а не кортеж. Если вам нужен отсортированный кортеж, вы можете преобразовать результат обратно, используя tuple(sorted_list).
Сохраните файл и запустите его из терминала:
python tuple_functions.py
Ваш вывод должен выглядеть следующим образом:
Tuple: (1, 5, 2, 8, 5, 3, 5, 9)
Count of 5: 3
Index of 8: 3
Number tuple: (10, 5, 20, 15, 30, 5)
Length: 6
Maximum value: 30
Minimum value: 5
Sum of elements: 85
Sorted list from tuple: [5, 5, 10, 15, 20, 30]
Теперь вы научились использовать важные методы и функции для проверки и анализа кортежей.
Резюме
В этой лабораторной работе вы заложили прочную основу для использования кортежей (tuples) в Python. Вы узнали, как создавать кортежи различными способами и как получать доступ к их элементам с помощью индексации и срезов (slicing). Вы изучили основную концепцию неизменяемости кортежей (immutability) и практиковались в создании новых кортежей для выполнения "изменений". Вы также познакомились с общими операторами для кортежей, такими как + и *, удобством распаковки кортежей (tuple unpacking), а также с полезностью встроенных методов (count(), index()) и функций (len(), max(), sorted()) для работы с данными кортежей.
