Как преобразовать кортеж в список python

Преобразовать список кортежей в список списков [закрыт]

Закрыт. Этот вопрос не по теме. Ответы на него в данный момент не принимаются.

Вопросы с просьбами помочь с отладкой («почему этот код не работает?») должны включать желаемое поведение, конкретную проблему или ошибку и минимальный код для её воспроизведения прямо в вопросе. Вопросы без явного описания проблемы бесполезны для остальных посетителей. См. Как создать минимальный, самодостаточный и воспроизводимый пример.

Закрыт 2 года назад .

сверху мой вывод. снизу правильный, каким образом я могу изменить список в массив?

Кортежи

Кортежи (tuple) в Python – это те же списки за одним исключением. Кортежи неизменяемые структуры данных. Так же как списки они могут состоять из элементов разных типов, перечисленных через запятую. Кортежи заключаются в круглые, а не квадратные скобки.

>>> a = (10, 2.13, "square", 89, 'C') >>> a (10, 2.13, 'square', 89, 'C')

Из кортежа можно извлекать элементы и брать срезы:

>>> a[3] 89 >>> a[1:3] (2.13, 'square')

Однако изменять его элементы нельзя:

>>> a[0] = 11 Traceback (most recent call last): File "", line 1, in TypeError: 'tuple' object does not support item assignment

Также у типа tuple нет методов для добавления и удаления элементов.

Возникает резонный вопрос. Зачем в язык программирования был введен этот тип данных, по-сути представляющий собой неизменяемый список? Дело в том, что иногда надо защитить список от изменений. Преобразовать же кортеж в список, если это потребуется, как и выполнить обратную операцию легко с помощью встроенных в Python функций list() и tuple() :

>>> a = (10, 2.13, "square", 89, 'C') >>> b = [1, 2, 3] >>> c = list(a) >>> d = tuple(b) >>> c [10, 2.13, 'square', 89, 'C'] >>> d (1, 2, 3)

Рассмотрим случай, когда уместно использовать кортежи. В Python изменяемые объекты передаются в функцию по ссылке. Это значит, что не создается копия объекта, а переменной-параметру присваивается ссылка на уже существующий объект. В итоге, если в теле функции объект изменяется, то эти изменения касаются глобального объекта.

def add_num(seq, num): for i in range(len(seq)): seq[i] += num return seq origin = [3, 6, 2, 6] changed = add_num(origin, 3) print(origin) print(changed)

Данная программа неправильная. Хотя никаких выбросов исключений не произойдет, она содержит логическую ошибку. На выводе получаем:

[6, 9, 5, 9] [6, 9, 5, 9]

То есть исходный список был также изменен. Параметр seq содержал ссылку не на свой локальный список, а на список-оригинал. Таким образом, в операторе return здесь нет смыла. Если функция замысливалась как изменяющая глобальный список, то программа должна выглядеть так:

def add_num(seq, num): for i in range(len(seq)): seq[i] += num origin = [3, 6, 2, 6] add_num(origin, 3) print(origin)

Что делать, если все же требуется не изменять исходный список, а сформировать по нему новый. Задачу можно решить несколькими способами. Во первых, в функции можно создать локальный список, после чего возвращать его:

def add_num(seq, num): new_seq = [] for i in seq: new_seq.append(i + num) return new_seq origin = [3, 6, 2, 6] changed = add_num(origin, 3) print(origin) print(changed)

[3, 6, 2, 6] [6, 9, 5, 9]

Исходный список в функции не меняется. Его элементы лишь перебираются.

Второй способ защитить список-оригинал – использовать кортеж. Этот способ более надежный, так как в больших программах трудно отследить, что ни одна функция не содержит команд изменения глобальных данных.

Хотя преобразовывать к кортежу можно как при передаче в функцию, так и в самой функции, лучше сразу делать глобальный список кортежем. Поскольку неизменяемые объекты передаются по значению, а не по ссылке, то в функцию будет поступать копия структуры, а не оригинал. Даже если туда передается оригинал, изменить его невозможно. Можно лишь, как вариант, скопировать его и/или изменить тип, создав тем самым локальную структуру, и делать с ней все, что заблагорассудится.

def add_num(seq, num): seq = list(seq) for i in range(len(seq)): seq[i] += num return seq origin = (3, 6, 2, 6) changed = add_num(origin, 3) print(origin) print(changed)

Списки в кортежах

Кортежи могут содержать списки, также как списки быть вложенными в другие списки.

>>> nested = (1, "do", ["param", 10, 20])

Как вы думаете, можем ли мы изменить список [«param», 10, 20] вложенный в кортеж nested ? Список изменяем, кортеж – нет. Если вам кажется, что нельзя, то вам кажется неправильно. На самом деле можно:

>>> nested[2][1] = 15 >>> nested (1, 'do', ['param', 15, 20])

Примечание. Выражения типа nested[2][1] используются для обращения к вложенным объектам. Первый индекс указывает на позицию вложенного объекта, второй – индекс элемента внутри вложенного объекта. Так в данном случае сам список внутри кортежа имеет индекс 2, а элемент списка 10 – индекс 1 в списке.

Странная ситуация. Кортеж неизменяем, но мы все-таки можем изменить его. На самом деле кортеж остается неизменяемым. Просто в нем содержится не сам список, а ссылка на него. Ее изменить нельзя. Но менять сам список можно.

Чтобы было проще понять, перепишем кортеж так:

>>> l = ["param", 10, 20] >>> t = (1, "do", l) >>> t (1, 'do', ['param', 10, 20])

Кортеж содержит переменную-ссылку. Поменять ее на другую ссылку нельзя. Но кортеж не содержит самого списка. Поэтому его можно менять как угодно:

>>> l.pop(0) 'param' >>> t (1, 'do', [10, 20])

Однако такой номер не проходит с неизменяемыми типами:

>>> a = "Kat" >>> t = (a, l) >>> t ('Kat', [10, 20]) >>> a = "Bat" >>> t ('Kat', [10, 20])

Они передаются в кортеж как и в функцию – по значению. То есть их значение копируется в момент передачи.

Практическая работа

1. Чтобы избежать изменения исходного списка, не обязательно использовать кортеж. Можно создать его копию с помощью метода списка copy() или взять срез от начала до конца [:] . Скопируйте список первым и вторым способом и убедитесь, что изменение копий никак не отражается на оригинале.
2. Заполните один кортеж десятью случайными целыми числами от 0 до 5 включительно. Также заполните второй кортеж числами от -5 до 0. Для заполнения кортежей числами напишите одну функцию. Объедините два кортежа с помощью оператора +, создав тем самым третий кортеж. С помощью метода кортежа count() определите в нем количество нулей. Выведите на экран третий кортеж и количество нулей в нем.

Примеры решения и дополнительные уроки в pdf-версии курса

X Скрыть Наверх

Python. Введение в программирование

Основы работы со списками и кортежами¶

Список — упорядоченная изменяемая последовательность объектов произвольного типа. В языке Python списки представлены типом list .

Кортеж — неизменяемый аналог списков, которому соответствует тип данных tuple .

Изменяемая последовательность — последвательность, в которой после ее создания возможно изменение количества элементов или присваивание им объектов.

Создание списков и кортежей¶

>>> s = [] >>> type(s) >>> s = [1, 2, 3] >>> type(s) >>> s = list('iterable_obj') >>> type(s) >>> s ['i', 't', 'e', 'r', 'a', 'b', 'l', 'e', '_', 'o', 'b', 'j'] 

>>> s = () >>> type(s) >>> s = 1, >>> type(s) >>> s = tuple('iterable_obj') >>> type(s) >>> s ('i', 't', 'e', 'r', 'a', 'b', 'l', 'e', '_', 'o', 'b', 'j') 

Используя конструкторы list() и tuple() , можно выполнять преобразование последовательностей в список либо кортеж.

Операции со списками и кортежами¶

Списки и кортежи поддерживают общий для последовательностей набор операций. В примерах будет использован список:

>>> lst = [1, 2, 3] 

Проверка на принадлежность элемента x последовательности s :

>>> 3 in lst True >>> 4 in lst False 

Наименьший элемент последовательности:

>>> min(lst) 1 

Наибольший элемент последовательности:

>>> max(lst) 3 

Методы списков и кортежей¶

Подобно строкам, списки и кортежи поддерживают различные методы. Ниже будут приведены методы списков. Для кортежей реализованы только операции, которые не меняют исходный объект.

Вставка элемента в конец списка:

>>> x = [1, 2, 3] >>> x.append(5) >>> x [1, 2, 3, 5] 

s. extend ( L ) ¶

Добавление элементов списка L в конец списка:

>>> x = [1, 2, 3] >>> x.extend([4, 5, 6]) >>> x [1, 2, 3, 4, 5, 6] 

s. insert ( i, x ) ¶

Вставка элемента x по индексу i:

>>> x = [1, 2, 3] >>> x.insert(1, 5) >>> x [1, 5, 2, 3] 

s. remove ( x ) ¶

Удаление первого вхождения x из списка:

>>> x = [1, 2, 3, 3, 2, 1] >>> x.remove(2) >>> x [1, 3, 3, 2, 1] 

Извлечение элемента из списка:

>>> x = [1, 2, 3, 3, 2, 1] >>> x.pop(1) 2 >>> x [1, 3, 3, 2, 1] >>> x.pop() 1 >>> x [1, 3, 3, 2] 

Удаление всех элементов из списка:

>>> x = [1, 2, 3] >>> x.clear() >>> x [] 

>>> x = [1, 2, 3, 3, 2, 1] >>> x.sort() >>> x [1, 1, 2, 2, 3, 3] 

Изменение порядка элементов на обратный:

>>> x = [1, 2, 3] >>> x.reverse() >>> x [3, 2, 1] 

s. index ( x ) ¶

Поиск индекса первого вхождения элемента:

>>> x = [1, 2, 3, 3, 2, 1] >>> x.index(2) 1 

Задачи¶

1. Пользователь вводит числа a и b . Создать список, содержащий квадраты целых чисел расположенных между ними.
2. Пользователь вводит числа до тех пор, пока не введет слово end . Поместите введенные числа в список. Выведите на экран только нечетные элементы списка.
3. Пользователь вводит числа до тех пор, пока не введет слово ‘end’. Поместите введенные числа в список. Подсчитайте количество четных и нечетных элементов в списке.
4. Дан список чисел. Выведите все элементы списка, которые больше предыдущего элемента.
5. Дан список чисел. Поменяйте местами минимальный и максимальный элемент этого списка.
6. Дан список чисел. Определите, сколько в нем различных элементов.
7. Петя перешёл в другую школу. На уроке физкультуры ему понадобилось определить своё место в строю. Помогите ему это сделать. Программа получает на вход последовательность чисел, означающих рост каждого человека в строю. После этого вводится число X – рост Пети. Все числа во входных данных натуральные и не превышают 200. Выведите номер, под которым Петя должен встать в строй. Если в строю есть люди с одинаковым ростом, таким же, как у Пети, то он должен встать после них.
8. Дан список чисел. Циклически сдвиньте элементы списка вправо (A[0] переходит на место A[1], A[1] на место A[2], …, последний элемент переходит на место A[0]).

© Copyright Revision d00c0df4 .

Built with Sphinx using a theme provided by Read the Docs.
Read the Docs v: latest

Versions latest Downloads html On Read the Docs Project Home Builds Free document hosting provided by Read the Docs.

Python. Урок 8. Кортежи (tuple)

Данный урок посвящен кортежам (tuple) в Python. Основное внимание уделено вопросу использования кортежей, почему иногда лучше применять их, а не списки, рассмотрены способы создания и основные приемы работы с кортежами. Также затронем тему преобразования кортежа в список и обратно.

Что такое кортеж (tuple) в Python?

Кортеж (tuple) – это неизменяемая структура данных, которая по своему подобию очень похожа на список. Как вы наверное знаете, а если нет, то, пожалуйста, ознакомьтесь с седьмым уроком, список – это изменяемый тип данных. Т.е. если у нас есть список a = [1, 2, 3] и мы хотим заменить второй элемент с 2 на 15, то мы может это сделать, напрямую обратившись к элементу списка.

>>> a = [1, 2, 3] >>> print(a) [1, 2, 3] >>> a[1] = 15 >>> print(a) [1, 15, 3]

С кортежем мы не можем производить такие операции, т.к. элементы его изменять нельзя.

>>> b = (1, 2, 3) >>> print(b) (1, 2, 3) >>> b[1] = 15 Traceback (most recent call last): File "", line 1, in module> b[1] = 15 TypeError: 'tuple' object does not support item assignment

Зачем нужны кортежи в Python?

Существует несколько причин, по которым стоит использовать кортежи вместо списков. Одна из них – это обезопасить данные от случайного изменения. Если мы получили откуда-то массив данных, и у нас есть желание поработать с ним, но при этом непосредственно менять данные мы не собираемся, тогда, это как раз тот случай, когда кортежи придутся как нельзя кстати. Используя их в данной задаче, мы дополнительно получаем сразу несколько бонусов – во-первых, это экономия места. Дело в том, что кортежи в памяти занимают меньший объем по сравнению со списками.

>>> lst = [10, 20, 30] >>> tpl = (10, 20, 30) >>> print(lst.__sizeof__()) 32 >>> print(tpl.__sizeof__()) 24 

Во-вторых – прирост производительности, который связан с тем, что кортежи работают быстрее, чем списки (т.е. на операции перебора элементов и т.п. будет тратиться меньше времени). Важно также отметить, что кортежи можно использовать в качестве ключа у словаря.

Создание, удаление кортежей и работа с его элементами

Создание кортежей

Для создания пустого кортежа можно воспользоваться одной из следующих команд.

>>> a = () >>> print(type(a)) 'tuple'> >>> b = tuple() >>> print(type(b)) 'tuple'>

Кортеж с заданным содержанием создается также как список, только вместо квадратных скобок используются круглые.

>>> a = (1, 2, 3, 4, 5) >>> print(type(a)) class 'tuple'> >>> print(a) (1, 2, 3, 4, 5)

При желании можно воспользоваться функцией tuple().

>>> a = tuple((1, 2, 3, 4)) >>> print(a) (1, 2, 3, 4)

Доступ к элементам кортежа

Доступ к элементам кортежа осуществляется также как к элементам списка – через указание индекса. Но, как уже было сказано – изменять элементы кортежа нельзя!

>>> a = (1, 2, 3, 4, 5) >>> print(a[0]) 1 >>> print(a[1:3]) (2, 3) >>> a[1] = 3 Traceback (most recent call last): File "", line 1, in module> a[1] = 3 TypeError: 'tuple' object does not support item assignment

Удаление кортежей

Удалить отдельные элементы из кортежа невозможно.

>>> a = (1, 2, 3, 4, 5) >>> del a[0] Traceback (most recent call last): File "", line 1, in module> del a[0] TypeError: 'tuple' object doesn't support item deletion 

Но можно удалить кортеж целиком.

>>> del a >>> print(a) Traceback (most recent call last): File "", line 1, in module> print(a) NameError: name 'a' is not defined

Преобразование кортежа в список и обратно

На базе кортежа можно создать список, верно и обратное утверждение. Для превращения списка в кортеж достаточно передать его в качестве аргумента функции tuple().

>>> lst = [1, 2, 3, 4, 5] >>> print(type(lst)) 'list'> >>> print(lst) [1, 2, 3, 4, 5] >>> tpl = tuple(lst) >>> print(type(tpl)) 'tuple'> >>> print(tpl) (1, 2, 3, 4, 5)

Обратная операция также является корректной.

>>> tpl = (2, 4, 6, 8, 10) >>> print(type(tpl)) 'tuple'> >>> print(tpl) (2, 4, 6, 8, 10) >>> lst = list(tpl) >>> print(type(lst)) 'list'> >>> print(lst) [2, 4, 6, 8, 10]

P.S.

Если вам интересна тема анализа данных, то мы рекомендуем ознакомиться с библиотекой Pandas. На нашем сайте вы можете найти вводные уроки по этой теме. Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”.

Раздел: Python Уроки по Python Метки: Python, Уроки Python

Python. Урок 8. Кортежи (tuple) : 5 комментариев

1. Владимир 15.01.2019 Сорян за глупый вопрос, но я только начинаю изучать Python.
   И так, есть два или более кортежей и нужно найти элементы, общие для этих кортежей, т е. взять пересечение множеств. Существует ли в питоне для этого оператор (функция, метод, …) или нужно самому “городить” такую функцию? Или может есть какая-нибудь подключаемая библиотека с такой функцией?

1. writer 09.02.2019 Добрый день!
   Если вы хотите выполнять операции пересечения и т.п. лучше для этих целей использовать тип данных не кортеж (tuple), а множество (set)

1. Андрей 24.10.2020 f(*opt)