Как из списка сделать кортеж в python
Кортеж (tuple) представляет последовательность элементов, которая во многом похожа на список за тем исключением, что кортеж является неизменяемым (immutable) типом. Поэтому мы не можем добавлять или удалять элементы в кортеже, изменять его.
Для создания кортежа используются круглые скобки, в которые помещаются его значения, разделенные запятыми:
tom = ("Tom", 23) print(tom) # ("Tom", 23)
Также для определения кортежа мы можем просто перечислить значения через запятую без применения скобок:
tom = "Tom", 23 print(tom) # ("Tom", 23)
Если вдруг кортеж состоит из одного элемента, то после единственного элемента кортежа необходимо поставить запятую:
tom = ("Tom",)
Для создания кортежа из другого набора элементов, например, из списка, можно передать список в функцию tuple() , которая возвратит кортеж:
data = ["Tom", 37, "Google"] tom = tuple(data) print(tom) # ("Tom", 37, "Google")
С помощью встроенной функции len() можно получить длину кортежа:
tom = ("Tom", 37, "Google") print(len(tom)) # 3
Обращение к элементам кортежа
Обращение к элементам в кортеже происходит также, как и в списке, по индексу. Индексация начинается также с нуля при получении элементов с начала списка и с -1 при получении элементов с конца списка:
tom = ("Tom", 37, "Google", "software developer") print(tom[0]) # Tom print(tom[1]) # 37 print(tom[-1]) # software developer
Но так как кортеж — неизменяемый тип (immutable), то мы не сможем изменить его элементы. То есть следующая запись работать не будет:
tom[1] = "Tim"
При необходимости мы можем разложить кортеж на отдельные переменные:
name, age, company, position = ("Tom", 37, "Google", "software developer") print(name) # Tom print(age) # 37 print(position) # software developer print(company) # Google
Получение подкортежей
Как и в списках, можно получить часть кортежа в виде другого кортежа
tom = ("Tom", 37, "Google", "software developer") # получем подкортеж с 1 по 3 элемента (не включая) print(tom[1:3]) # (37, "Google") # получем подкортеж с 0 по 3 элемента (не включая) print(tom[:3]) # ("Tom", 37, "Google") # получем подкортеж с 1 по послдений элемент print(tom[1:]) # (37, "Google", "software developer")
Кортеж как параметр и результат функций
Особенно удобно использовать кортежи, когда необходимо возвратить из функции сразу несколько значений. Когда функция возвращает несколько значений, фактически она возвращает в кортеж:
def get_user(): name = "Tom" age = 22 company = "Google" return name, age, company user = get_user() print(user) # ("Tom", 37, "Google")
При передаче кортежа в функцию с помощью оператора * его можно разложить на отдельные значения, которые передаются параметрам функции:
def print_person(name, age, company): print(f"Name: Age: Company: ") tom = ("Tom", 22) print_person(*tom, "Microsoft") # Name: Tom Age: 22 Company: Microsoft bob = ("Bob", 41, "Apple") print_person(*bob) # Name: Bob Age: 41 Company: Apple
Перебор кортежей
Для перебора кортежа можно использовать стандартные циклы for и while . С помощью цикла for:
tom = ("Tom", 22, "Google") for item in tom: print(item)
С помощью цикла while:
tom = ("Tom", 22, "Google") i = 0 while i < len(tom): print(tom[i]) i += 1
Проверка наличия значения
Как для списка с помощью выражения элемент in кортеж можно проверить наличие элемента в кортеже:
user = ("Tom", 22, "Google") name = "Tom" if name in user: print("Пользователя зовут Tom") else: print("Пользователь имеет другое имя")
Конвертация списка в кортеж в Python
В Python есть несколько встроенных структур данных, включая списки и кортежи. Они оба используются для хранения коллекции элементов. Однако в отличие от списков, кортежи являются неизменяемыми, что означает, что после их создания их нельзя изменить.
Часто возникает ситуация, когда необходимо преобразовать список в кортеж. Это может быть необходимо по различным причинам, например, для обеспечения защиты данных от изменений или для улучшения производительности, поскольку кортежи обрабатываются быстрее, чем списки.
Вот пример кода, который не работает:
my_list = [1, 2, 3] tuple(my_list)
При попытке выполнения этого кода может возникнуть ошибка «TypeError: ‘tuple’ object is not callable». Это происходит, когда имя «tuple» было ранее использовано в качестве имени переменной и Python пытается вызвать его как функцию.
Решение проблемы
Проблема решается очень просто. Нужно убедиться, что не используется имя «tuple» в качестве имени переменной. Вот исправленный код:
my_list = [1, 2, 3] my_tuple = tuple(my_list)
Теперь, когда мы печатаем my_tuple , мы видим, что это кортеж (1, 2, 3) . Таким образом, переход от списка к кортежу выполняется успешно.
Помимо этого, желательно всегда стараться давать переменным уникальные и осмысленные имена, чтобы избежать подобных конфликтов и ошибок в будущем.
Разбираемся с массивами в Python: кортежи
Недавно мы изучали списки в Python — многофункциональный и удобный вид структуры для работы с данными. Сегодня черёд кортежей. Они во многом похожи на списки, но и отличаются во многом. Рассказываем и показываем на подробных примерах. Приготовьтесь: получилась большая статья.
Что такое кортеж
Кортеж tuple — это упорядоченная и неизменяемая коллекция объектов различных типов. По сути, кортежи — те же списки, только для них недействительны все операции и методы, которые обновляют коллекцию. Кортежи не сортируются сами по себе, не принимают новые элементы и не перезаписывают те, что уже есть.
Чтобы создать кортеж, достаточно перечислить его элементы через запятую: Python автоматически распознает эту последовательность как кортеж. Но обычно рекомендуется использовать круглые скобки — так код получается яснее и читабельнее. Например, мы хотим создать кортеж с чётными числами от 2 до 14:
my_tuple = (2, 4, 6, 8, 10, 12, 14)
Такой же кортеж можно создать при помощи встроенного метода tuple и функции range , которая создаёт последовательность чисел. Укажем через запятую начало, конец последовательности и шаг, с которым нужно генерировать числа. При этом число, обозначающее конец последовательности, не будет включено:
my_tuple = tuple(range(2, 16, 2))
Ещё раз подробно перечислим свойства кортежей:
- Гибкость. Как и списки, кортежи могут содержать элементы разных типов данных: целые числа, числа с плавающей запятой, строки, кортежи, словари и другие объекты Python.
- Неизменяемость. Элементы в кортежах нельзя сортировать, добавлять, изменять и удалять. Но можно преобразовать кортеж в список, внести изменения и снова сделать кортеж.
- Упорядоченность. Порядок элементов имеет значение, благодаря чему элементы кортежа доступны по индексу (индексация начинается с 0).
Операции над кортежами
Кортежам присущи все операции списков, кроме операции удаления элемента командой del . Создадим кортеж из названий шести фруктов и рассмотрим доступные операции на его примере:
my_fruits = ('яблоко', 'апельсин', 'груша', 'грейпфрут', 'айва', 'абрикос')
Получение длины. С помощью функции len() можно узнать, сколько элементов содержится в кортеже:
# присваиваем переменной значение количества элементов length = len(my_fruits) # выводим результат print(f'''my_fruits = Количество фруктов в кортеже: ''')
Доступ по индексу. Как и в списках, индексация ведётся с нуля, поэтому номер последнего элемента всегда будет на единицу меньше длины кортежа. Если индексы отрицательные, обращение к элементам будет производиться с конца кортежа.
Например, мы можем вывести третий, предпоследний и последний элементы из нашего кортежа:
print(f'''my_fruits = Избранные фрукты: , , ''') 
По индексу также можно присвоить элементы кортежа другим переменным для дальнейшей работы с ними:
# присваиваем переменной элемент с индексом 2 my_fruit1 = my_fruits[2] # присваиваем переменной элемент с индексом −2 (предпоследний) my_fruit2 = my_fruits[-2] # присваиваем переменной последний элемент кортежа last_fruit = my_fruits[length - 1] # выводим результаты print(f'''my_fruit1 = my_fruit2 = last_fruit = ''')
Срезы. Срезы выбирают из кортежа подмножества. Синтаксис такой же, как для списков: нужно указать в квадратных скобках начальный и конечный индексы элементов (индексация начинается с 0). Элемент с последним указанным индексом не включается в срез. Срез с диапазоном [::] создаёт копию кортежа.
# выбираем часть кортежа с нулевого по четвёртый элементы my_fruits_part1 = my_fruits[0:5] # выбираем элементы с четвёртого и до конца my_fruits_part2 = my_fruits[4:] # выбираем элементы с третьего по пятый my_fruits_part3 = my_fruits[2:-1] # выбираем элементы с нулевого по второй my_fruits_part4 = my_fruits[:-3] # выбираем элементы с предпоследнего и до конца my_fruits_part5 = my_fruits[-2:] # выбираем элементы с начала, шагая через 2 my_fruits_part6 = my_fruits[::2] # выбираем в обратном порядке, шагая через 1 my_fruits_reversed = my_fruits[::-1] # выводим результаты print(f'''my_fruits_part1 = my_fruits_part2 = my_fruits_part3 = my_fruits_part4 = my_fruits_part5 = my_fruits_part6 = my_fruits_reversed = ''')
Конкатенация. Кортежи можно складывать между собой, тогда Python создаст новый кортеж, а исходные не изменятся:
# новый кортеж фруктов my_fruits_new = ('мандарин', 'гранат', 'киви') # объединённый кортеж my_fruits_concatenated = my_fruits + my_fruits_new # выводим результат print(f'Объединённый кортеж фруктов: ')
Удаление всего кортежа. Кортеж нельзя удалить напрямую, но можно удалить ссылку на него с помощью функции del . Если на кортеж нет других ссылок, сборщик мусора Python автоматически удалит его и освободит память.
Если удалить кортеж, при выводе мы получим ошибку.
del my_fruits_part1 print(f'my_fruits_part1 = ')
Умножение на целое число. Умножив кортеж на N, мы создадим новый кортеж из N исходных кортежей:
multiplied_fruits = my_fruits * 3 print(f'Кортеж фруктов после умножения на 3: ')
Проверка наличия элемента. Оператор in проверяет наличие элемента в кортеже, not in — отсутствие:
# проверяем наличие в кортеже элемента “киви” flag = 'киви' in my_fruits print(f'flag = ')
# проверяем отсутствие в кортеже элемента “киви” flag = 'киви' not in my_fruits print(f'flag = ')
Минимум и максимум. С помощью функций min() и max() можно определять минимальное и максимальное значения. Числовые значения сравниваются по величине, строки — по их числовым значениям в таблице символов Unicode.
# элемент с минимальным значением my_fruits_min = min(my_fruits) # выводим результат print(f'my_fruits_min = ') # элемент с максимальным значением my_fruits_max = max(my_fruits) # выводим результат print(f'my_fruits_max = ')
Сортировка без изменения. Функция sorted() вернёт отсортированный кортеж без его изменения:
# сортируем кортеж my_fruits_sorted = sorted(my_fruits) print(f'''Кортеж фруктов: Отсортированный кортеж фруктов: ''')
Сравнение кортежей. Как и списки, кортежи сравниваются поэлементно, пока не найдётся больший из них. Подмножество элементов кортежа всегда меньше него. При сравнении строк элементы с равными индексами сравниваются по их числовым значениям в таблице символов Unicode.
# выводим результат проверки, что исходный кортеж меньше объединённого print(my_fruits < my_fruits_concatenated)
Методы кортежей
У кортежей в силу неизменяемости только два метода: .index и .count . Действуют так же, как со списками.
Метод .index возвращает индекс элемента:
index_of_pear = my_fruits.index('груша') print(f'Индекс элемента "груша" в кортеже: ')
Метод .count возвращает число вхождений элемента в кортеж:
frequency_of_kiwi = my_fruits.count('киви') print(f'Количество вхождений элемента "киви" в кортеж фруктов: ')
Чем кортеж лучше списка
Кортежи хороши тем, что их нельзя случайно изменить. Они занимают меньше памяти, чем списки. Например, пустой список занимает 56 байт, тогда как пустой кортеж — всего 40 байт:
# подключаем модуль sys для работы с операционной системой import sys # создаём пустой список empty_list = [] # создаём пустой кортеж для сравнения empty_tuple = () # выводим размер пустого списка print(f'Размер пустого списка: ') # выводим размер пустого кортежа print(f'Размер пустого кортежа: ')
Получается, что кортежи полезны, если нужно сэкономить память или защитить от изменений постоянный набор данных.
Что дальше
В следующий раз мы продолжим разбираться с массивами в Python и рассмотрим библиотеки. Подпишитесь, чтобы не пропустить.
Списки и кортежи в Python для начинающих
Предположим, что вы составляете список гостей на свадьбу. Этот список постоянно меняется: добавились друзья семьи Дима и Света, не смогут прийти троюродные сестры со стороны жены Лида с Наташей.
Для представления таких данных из реального мира в Python отлично подходят списки. Списки — это еще один встроенный тип данных Python.
Создать, или другими словами, объявить список в Python можно двумя способами, так:
my_list = list() my_list = [] Вернемся, однако, к гостям на свадьбе. Для создания списка гостей, сразу же при создании помещаем внутрь скобок строки с именами через запятую.
guests = ['Родители', 'Одноклассники', 'Лида и Наташа'] print(guests) Операции с элементами списка ¶
В нашем списке три элемента: «Родители», «Одноклассники», «Лида и Наташа», — которые хранятся внутри списка именно в таком порядке. Если только вы не измените порядок списка, «Родители» всегда будет первым элементом, «Одноклассники» — вторым и «Лида и Наташа» — третьим. Родители представляет собой начало списка, а Лида и Наташа — конец. Мы помним, что Лида и Наташа не смогут прийти, и их нужно удалить из списка.
С помощью метода remove можно удалить последний элемент в списке.
guests = ['Родители', 'Одноклассники', 'Лида и Наташа'] print(guests) # ['Родители', 'Одноклассники', 'Лида и Наташа'] guests.remove("Лида и Наташа") print(guests) # ['Родители', 'Одноклассники', 'Лида и Наташа'] Но не забываем, нужно еще добавить в список двух гостей. Добавление новых элементов в конец списка происходит при помощи метода append .
guests = ['Родители', 'Одноклассники', 'Лида и Наташа'] print(guests) # ['Родители', 'Одноклассники', 'Лида и Наташа'] guests.remove("Лида и Наташа") print(guests) # ['Родители', 'Одноклассники'] guests.append('Дима') guests.append('Света') print(guests) # ['Родители', 'Одноклассники', 'Дима', 'Света'] В список можно не только добавить элемент, но и изменить одно из его значений на другое, согласно индексу элемента.
guests = ['Родители', 'Одноклассники', 'Дима', 'Света'] print(guests) # ['Родители', 'Одноклассники', 'Лида и Наташа'] guests[2] = 'Коллеги' print(guests) # ['Родители', 'Одноклассники', 'Коллеги', 'Света'] И так, список — это контейнер, хранящий объекты в определенном порядке. Обратите внимание, что в отличие от строк, методы списка меняют исходный список. Есть однако у списков кое‑что общее со строками. Это доступ к элементу по индексу и срезы. Все это работает в списках точно так же, как и в строках.
guests = ['Родители', 'Одноклассники', 'Дима', 'Света'] print(guests[0]) # Родители print(guests[-1]) # Света print(guests[:2]) # ['Родители', 'Одноклассники'] Кортежи ¶
Кортежи — это контейнеры, хранящие объекты в определенном порядке. В отличие от списков, кортежи неизменяемы.
Как только вы создали кортеж, значение какого-либо его элемента уже нельзя изменить, как нельзя добавлять и удалять элементы. Кортежи объявляются с помощью круглых скобок. Элементы в кортеже должны быть разделены запятыми.
Для создания кортежей также используют один из двух вариантов синтаксиса. Первый:
my_tuple = tuple() my_tuple = () Чтобы добавить в кортеж новые объекты, создайте его вторым способом, указав через запятую каждый желаемый элемент.
data = ('И. Иванов', 1958, True) print(data) # ('И. Иванов', 1958, True) Даже если кортеж содержит только один элемент, после этого элемента все равно нужно поставить запятую. Таким образом Python отличает кортеж от числа в скобках, определяющих порядок выполнения операций.
Получить элементы кортежа можно так же, как и элементы списка, указывая индекс элемента.
books = ("1984", "О дивный новый мир", "451 градус по Фаренгейту") print(books[2]) # 451 градус по Фаренгейту Ключевое слово in / not in ¶
Проверить, содержится ли элемент в кортеже, можно с помощью ключевого слова in .
books = ("1984", "О дивный новый мир", "451 градус по Фаренгейту") print("1984" in books) # True print("Незнайка на луне" in books) # False Поместите перед in ключевое слово not для проверки отсутствия элемента в кортеже.
books = ("1984", "О дивный новый мир", "451 градус по Фаренгейту") print("Незнайка на луне" not in books) # True Те же операции с ключевыми словами in и not in сработают и со списками.
Сложение кортежей и списков ¶
При помощи оператора сложения можно соединять друг с другом две одинаковые структуры данных. Пример ниже со списками также будет работать и с кортежами:
colors1 = ["синий", "зеленый", "желтый"] colors2 = ["оранжевый", "розовый", "черный"] print(colors1 + colors2) # ['синий', 'зеленый', 'желтый', 'оранжевый', 'розовый', 'черный'] На данном этапе вам может стать интересно, зачем использовать структуры данных, которые кажутся менее гибкими, чем списки? На самом же деле, кортежи удобны, когда вы имеете дело со значениями, которые никогда не изменятся. Примером таких данных для кортежа могут быть географические координаты. Долготу и широту города следует сохранить в кортеже, поскольку эти значения никогда не изменятся, а сохранение в кортеже будет гарантировать, что другие части программы случайно их не изменят.
Итерирование ¶
Строки, списки и кортежи поддерживают итерирование (программа может их перебирать, значение за значением), то есть к каждому их элементу можно получить доступ через цикл — такие объекты называются итерируемыми. Каждый элемент в итерируемом объекте, как мы уже знаем, имеет свой порядковый индекс.
В следующем примере элемент Москва записан в списке с индексом 0, Хельсинки с индексом 1, а 'Анкара' с индексом 2.
cities = ['Москва', 'Хельсинки' ,'Анкара'] for city in cities: print(city) # Москва # Хельсинки # Анкара Вот мы и познакомились с оператором for — циклом, перебирающим итерируемый объект. Цикл for можно использовать, чтобы определять инструкции, которые будут выполняться один раз для каждого элемента в итерируемом объекте, и с помощью таких инструкций вы можете получать доступ ко всем этим элементам и осуществлять операции с ними.
Например, с помощью цикла for , выполняющего перебор списка строк, и метода upper можно сделать символы каждой строки прописными:
cities = ['Москва', 'Хельсинки' ,'Анкара'] for city in cities: print(city.upper()) # МОСКВА # ХЕЛЬСИНКИ # АНКАРА Как показано в примерах выше, цикл for определяется синтаксисом: for имя_переменной in имя_итерируемого_объекта: где имя_переменной — выбранное вами имя переменной, в которую каждую итерацию цикла будет записываться очередное значение из итерируемого объекта.