Python: изменение значения в кортеже

Я новичок в python, поэтому этот вопрос может быть немного базовым. У меня есть кортеж, называемый values который содержит следующее:

 ('275', '54000', '0.0', '5000.0', '0.0') 

Я хочу изменить первое значение (т. 275 ) в этом кортеже, но я понимаю, что кортежи неизменяемы, поэтому values[0] = 200 не будут работать. Как я могу это достичь?

  • Как документировать атрибуты класса в Python?
  • gdata-python-api + Аналитика с простым auth
  • Создание бинномозговых гистограмм в Spark
  • Python - разделительный список, содержащий строки и целые числа
  • Прослушивание Socket Python
  • Обновление Mountain Lion и библиотек python
  • Дочерние даты в Python
  • Python csv: UnicodeDecodeError
  • 12 Solutions collect form web for “Python: изменение значения в кортеже”

    Сначала вам нужно спросить, почему вы хотите это сделать?

    Но это возможно через:

     t = ('275', '54000', '0.0', '5000.0', '0.0') lst = list(t) lst[0] = '300' t = tuple(lst) 

    Но если вам нужно что-то изменить, вам, вероятно, лучше держать его в list

    В зависимости от вашей проблемы нарезка может быть действительно опрятным решением:

     >>> b = (1, 2, 3, 4, 5) >>> b[:2] + (8,9) + b[3:] (1, 2, 8, 9, 4, 5) >>> b[:2] + (8,) + b[3:] (1, 2, 8, 4, 5) 

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

    Ну, как уже показало Trufa, существует два способа замены элемента кортежа на данный индекс. Либо преобразовать кортеж в список, заменить элемент и преобразовать обратно, либо построить новый кортеж путем конкатенации.

     In [1]: def replace_at_index1(tup, ix, val): ...: lst = list(tup) ...: lst[ix] = val ...: return tuple(lst) ...: In [2]: def replace_at_index2(tup, ix, val): ...: return tup[:ix] + (val,) + tup[ix+1:] ...: 

    Итак, какой метод лучше, то есть быстрее?

    Оказывается, что для коротких кортежей (на Python 3.3) конкатенация на самом деле быстрее!

     In [3]: d = tuple(range(10)) In [4]: %timeit replace_at_index1(d, 5, 99) 1000000 loops, best of 3: 872 ns per loop In [5]: %timeit replace_at_index2(d, 5, 99) 1000000 loops, best of 3: 642 ns per loop 

    Но если мы посмотрим на более длинные кортежи, конвертирование списков – это путь:

     In [6]: k = tuple(range(1000)) In [7]: %timeit replace_at_index1(k, 500, 99) 100000 loops, best of 3: 9.08 µs per loop In [8]: %timeit replace_at_index2(k, 500, 99) 100000 loops, best of 3: 10.1 µs per loop 

    Для очень длинных кортежей преобразование списков значительно лучше!

     In [9]: m = tuple(range(1000000)) In [10]: %timeit replace_at_index1(m, 500000, 99) 10 loops, best of 3: 26.6 ms per loop In [11]: %timeit replace_at_index2(m, 500000, 99) 10 loops, best of 3: 35.9 ms per loop 

    Кроме того, производительность метода конкатенации зависит от индекса, в котором мы заменяем элемент. Для метода списка индекс не имеет значения.

     In [12]: %timeit replace_at_index1(m, 900000, 99) 10 loops, best of 3: 26.6 ms per loop In [13]: %timeit replace_at_index2(m, 900000, 99) 10 loops, best of 3: 49.2 ms per loop 

    Итак: если ваш кортеж короток, нарежьте и соедините. Если это долго, сделайте преобразование списка!

    Не то, чтобы это было лучше, но если кому-то интересно, это можно сделать на одной линии:

     tuple = tuple([200 if i == 0 else _ for i, _ in enumerate(tuple)]) 

    EDIT: Это не работает с кортежами с повторяющимися записями!

    Основываясь на идее Пойи :

    Если вы планируете делать это часто (что вам не нужно, так как кортежи не поддаются обработке по какой-либо причине), вы должны сделать что-то вроде этого:

     def modTupByIndex(tup, index, ins): return tuple(tup[0:index]) + (ins,) + tuple(tup[index+1:]) print modTupByIndex((1,2,3),2,"a") 

    Или на основе идеи Джона :

     def modTupByIndex(tup, index, ins): lst = list(tup) lst[index] = ins return tuple(lst) print modTupByIndex((1,2,3),1,"a") 

    основанный на идее Джона и дорогой Труфе

     def modifyTuple(tup, oldval, newval): lst=list(tup) for i in range(tup.count(oldval)): index = lst.index(oldval) lst[index]=newval return tuple(lst) print modTupByIndex((1, 1, 3), 1, "a") 

    он изменяет все ваши старые значения

    Как писал Хантер Макмиллен в комментариях, кортежи неизменяемы, для этого нужно создать новый кортеж. Например:

     >>> tpl = ('275', '54000', '0.0', '5000.0', '0.0') >>> change_value = 200 >>> tpl = (change_value,) + tpl[1:] >>> tpl (200, '54000', '0.0', '5000.0', '0.0') 

    Вы не можете. Если вы хотите изменить его, вам нужно использовать список вместо кортежа.

    Обратите внимание, что вместо этого вы можете создать новый кортеж, который имеет новое значение в качестве своего первого элемента.

    Я считаю, что это технически отвечает на вопрос, но не делайте этого дома. На данный момент все ответы связаны с созданием нового кортежа, но вы можете использовать ctypes для изменения кортежа в памяти. Опираясь на различные детали реализации CPython в 64-битной системе, один из способов сделать это:

     def modify_tuple(t, idx, new_value): # `id` happens to give the memory address in CPython; you may # want to use `ctypes.addressof` instead. element_ptr = (ctypes.c_longlong).from_address(id(t) + (3 + idx)*8) element_ptr.value = id(new_value) # Manually increment the reference count to `new_value` to pretend that # this is not a terrible idea. ref_count = (ctypes.c_longlong).from_address(id(new_value)) ref_count.value += 1 t = (10, 20, 30) modify_tuple(t, 1, 50) # t is then (10, 50, 30) modify_tuple(t, -1, 50) # Probably crash Python to ensure that noone uses this 

    Я нашел лучший способ редактировать кортежи, чтобы воссоздать кортеж, используя предыдущую версию в качестве базы.

    Вот пример, который я использовал для создания более светлой версии цвета (у меня он был открыт уже в то время):

     colour = tuple([c+50 for c in colour]) 

    Что он делает, это проходит через «цвет» кортежа и читает каждый элемент, что-то делает с ним и, наконец, добавляет его в новый кортеж.

    Итак, что бы вы хотели, было бы что-то вроде:

     values = ('275', '54000', '0.0', '5000.0', '0.0') values = (tuple(for i in values: if i = 0: i = 200 else i = values[i]) 

    Этот конкретный не работает, но концепция – это то, что вам нужно.

     tuple = (0, 1, 2) 

    tuple = итерация через кортеж, изменение каждого элемента по мере необходимости

    это концепция.

    Фрист, спросите себя, почему вы хотите мутировать ваш tuple . Существует причина, по которой строки и кортежи являются неизменяемыми в Ptyhon , если вы хотите изменить свой tuple тогда, вероятно, это скорее list .

    Во-вторых, если вы все еще хотите изменить свой кортеж, вы можете преобразовать свой tuple в list затем преобразовать его и переназначить новый кортеж в одну и ту же переменную. Это здорово, если вы только однажды будете мутировать ваш кортеж . В противном случае, я лично считаю, что это нелогично. Поскольку он по существу создает новый кортеж и каждый раз, если вы хотите изменить кортеж, вам придется выполнить преобразование. Также, если вы читаете код, было бы странно думать, почему бы просто не создать list ? Но это хорошо, потому что она не требует никакой библиотеки.

    Я предлагаю использовать mutabletuple(typename, field_names, default=MtNoDefault) из mutabletuple 0.2 . Я лично считаю, что этот путь более интуитивно понятен и читабельен. Личное чтение кода было бы известно, что писатель намерен мутировать этот кортеж в будущем. Недостаток сравнения с list выше методом преобразования list заключается в том, что для этого требуется импортировать дополнительный файл py.

     from mutabletuple import mutabletuple myTuple = mutabletuple('myTuple', 'vwxy z') p = myTuple('275', '54000', '0.0', '5000.0', '0.0') print(pv) #print 275 pv = '200' #mutate myTuple print(pv) #print 200 

    TL; DR : не пытайтесь мутировать tuple . если вы это сделаете, и это одноразовая операция конвертирования tuple в список, его мутацию, переверните list в новый tuple и переназначьте обратно переменную, содержащую старый tuple . Если вы хотите tuple и как-то хотите избежать list и хотите мутировать более одного раза, создайте mutabletuple .

    я сделал это:

     list = [1,2,3,4,5] tuple = (list) 

    и изменить, просто сделайте

     list[0]=6 

    и u может изменить кортеж: D

    здесь он копируется точно из IDLE

     >>> list=[1,2,3,4,5,6,7,8,9] >>> tuple=(list) >>> print(tuple) [1, 2, 3, 4, 5, 6, 7, 8, 9] >>> list[0]=6 >>> print(tuple) [6, 2, 3, 4, 5, 6, 7, 8, 9] 
    Interesting Posts

    Невозможно установить атрибуты класса объектов

    Tkinter: Как использовать потоки для предотвращения цикла основного события от «замораживания»

    Можно ли добавить пару <ключ, значение> в конец словаря в python

    TypeError – Translate принимает один аргумент. (2 данный) Python

    Запуск пользовательского класса Java в PySpark

    Почему точка с запятой разрешена в этом фрагменте питона?

    Конкатенация разреженных матриц в Python с использованием SciPy / Numpy

    Вызов rm из подпроцесса с использованием подстановочных знаков не удаляет файлы

    регулярное выражение python: получить конечные цифры из строки

    Обрезать изображение с помощью PIL в python

    Каковы хорошие возможности для классификации фотографий одежды?

    Python: создание экземпляра класса без вызова инициализатора

    Определение нескольких графиков для анимации с помощью цикла for в matplotlib

    Python – способ перезапуска цикла for, аналогичный «продолжить» для циклов while?

    Преобразование SVG в PNG в Python

    Python - лучший язык программирования в мире.