튜플에서 값을 변경하는 방법은 무엇입니까?

튜플에서 값을 변경하는 방법은 무엇입니까?

나는 이라는 튜플을 가지고 있습니다.values다음을 포함합니다.

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

번째 값 첫번값즉째)을 .275 이합니다.values[0] = 200작동하지 않습니다.어떻게 하면 이를 달성할 수 있을까요?

다음을 통해 가능합니다.

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

그래서: 만약 튜플이 짧다면, 얇게 썰어서 연결하세요.길면 목록 변환!

하나의 라이너로 가능합니다.

values = ('275', '54000', '0.0', '5000.0', '0.0')
values = ('300', *values[1:])

저는 이것이 기술적으로 질문에 대한 답이라고 믿지만, 집에서 이것을 하지 마세요.튜플을 것을 하지만, 은 현재모답는새만것드포사이수있다용습니할만지함되를 사용할 수 .ctypes튜플 인 메모리를 수정합니다.의 다양한 가지 방법은 다음과 . 64비트 시스템에서 CPython을 실행할 수 있습니다.

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 now (10, 50, 30)
modify_tuple(t, -1, 50)  # Will probably crash your Python runtime

헌터 맥밀런이 언급했듯이 튜플은 불변이므로 이를 달성하려면 새 튜플을 만들어야 합니다.예를 들어:

>>> 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')

이것이 우수하다는 것은 아니지만, 궁금한 사람이 있다면 다음과 같이 한 줄로 수행할 수 있습니다.

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

튜플에서 항목을 수정할 수는 없지만 튜플에서 변수 개체의 속성은 수정할 수 있습니다(예: 해당 개체가 목록 또는 실제 클래스 개체인 경우).

예를들면

my_list = [1,2]
tuple_of_lists = (my_list,'hello')
print(tuple_of_lists) # ([1, 2], 'hello')
my_list[0] = 0
print(tuple_of_lists) # ([0, 2], 'hello')

편집: 중복 항목이 있는 튜플에서는 아직 작동하지 않습니다!!

Pooya의 아이디어에 기초하여:

이 작업을 자주 수행할 계획이라면(튜플은 이유가 있어 불변이므로 수행하면 안 됩니다) 다음과 같은 작업을 수행해야 합니다.

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")

Jon's Idea와 친애하는 Trufa를 기반으로 합니다.

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")

그것은 당신의 모든 오래된 가치 발생을 변화시킵니다.

그럴수는 없어요.변경하려면 튜플 대신 목록을 사용해야 합니다.

대신 새 값을 첫 번째 요소로 사용하는 새 튜플을 만들 수 있습니다.

먼저, 왜 당신이 돌연변이를 하고 싶은지 스스로에게 물어보십시오.tuplePtyhon에서 문자열과 튜플이 불변하는 이유가 있습니다, 만약 당신이 당신의 것을 변형시키고 싶다면.tuple그렇다면 아마도 그것은list대신.

둘째, 만약 당신이 여전히 당신의 튜플을 변형시키고 싶다면, 당신은 당신의 튜플을 변환할 수 있습니다.tuplelist그런 다음 다시 변환하고 새 튜플을 동일한 변수로 재할당합니다.튜플을 한 번만 변형시킬 경우에는 이 방법이 좋습니다.그렇지 않다면, 저는 개인적으로 그것이 직관에 어긋난다고 생각합니다.기본적으로 새 튜플을 만드는 것이기 때문에 매번 튜플을 변형하려면 변환을 수행해야 합니다.또한 만약 당신이 코드를 읽는다면 왜 그냥 만들지 않는지 생각하는 것은 혼란스러울 것입니다.list하지만 도서관이 필요하지 않기 때문에 좋습니다.

를 사용하는 것이 좋습니다.mutabletuple(typename, field_names, default=MtNoDefault)가변 튜플 0.2부터.저는 개인적으로 이 방법이 더 직관적이고 읽기 쉽다고 생각합니다.개인적으로 코드를 읽는 사람은 작가가 미래에 이 튜플을 변형시킬 의도가 있다는 것을 알 것입니다.부정적인 면은 다음과 비교됩니다.list위의 변환 방법은 추가 py 파일을 가져와야 한다는 것입니다.

from mutabletuple import mutabletuple

myTuple = mutabletuple('myTuple', 'v w x y z')
p = myTuple('275', '54000', '0.0', '5000.0', '0.0')
print(p.v) #print 275
p.v = '200' #mutate myTuple
print(p.v) #print 200

TL;DR: 돌연변이를 시도하지 마십시오.tuple, 이 1회용 변환인 것입니다.tuple나열하고, 변형하고, 회전합니다.list 것으로로.tuple오래된 상태로 유지되는 변수에 다시 재할당합니다.tuple원하신다면tuple그리고 어떻게든 피하고 싶어합니다.list그리고 한 번 이상 돌연변이를 일으킨 다음 생성하기를 원합니다.mutabletuple.

튜플을 편집하는 가장 좋은 방법은 이전 버전을 기본으로 사용하여 튜플을 다시 만드는 것입니다.

다음은 밝은 색을 만들기 위해 사용한 예입니다(당시 이미 열어 두었습니다).

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)

튜플 = 튜플을 통해 반복, 필요에 따라 각 항목 변경

그게 컨셉입니다.

게임에 늦었지만 (상황에 따라) 가장 간단하고, 자원 친화적이며, 가장 빠른 방법은 튜플 자체를 덮어쓰는 것이라고 생각합니다.이렇게 하면 목록과 변수를 만들 필요가 없으므로 한 줄로 보관됩니다.

new = 24
t = (1, 2, 3)
t = (t[0],t[1],new)

>>> (1, 2, 24)

그러나: 이것은 다소 작은 튜플에만 유용하며 고정 튜플 값으로 제한하기도 합니다. 그럼에도 불구하고 대부분의 경우 튜플에 해당됩니다.

이 경우에는 다음과 같이 나타납니다.

new = '200'
t = ('275', '54000', '0.0', '5000.0', '0.0')
t = (new, t[1], t[2], t[3], t[4])

>>> ('200', '54000', '0.0', '5000.0', '0.0')

만약 여러분이 이것을 하고 싶다면, 여러분은 아마도 이상한 기능들을 여기저기에 던져놓고 그렇게 할 수 없는 특정한 것들의 가치를 바꾸고 싶어하는 여러분에게 주의를 환기시키고 싶지 않을 것입니다.또한 효율적이지 않다고 가정할 수도 있습니다.

t = tuple([new_value if p == old_value else p for p in t])

@fuglede에서 영감을 받은 NumPy는 실제로 튜플을 수정하는 것이 매우 쉽습니다.버퍼 a의 값을 버퍼 b에 복사하기만 하면 됩니다.튜플은 수정 후 사용 가능하지만, 하지 않는 것이 확실히 안전합니다. (집에서 이것을 시도하지 마세요)

import ctypes
import sys
import numpy as np


def changetuples(v, new, ind):
    # tuple value to buffer
    buff = (ctypes.c_uint8 * (sys.getsizeof(v[ind]))).from_address(id(v[ind]))
    ax = np.frombuffer(buff, dtype=np.uint8)

    # new value to buffer
    buff2 = (ctypes.c_uint8 * (sys.getsizeof(new))).from_address(id(new))
    ax2 = np.frombuffer(buff2, dtype=np.uint8)

    # copying each byte from one buffer to another
    for i in range(len(ax2)):
        try:
            ax[i] = ax2[i]
        except Exception:
            return False
    return True


t = ("275", 54000, "0.0", "5000.0", "0.0")
newvar = "200"  # the new string needs to be  <=  the old string
index = 0
print(id(t), t)
changetuples(v=t, new=newvar, ind=index)
print(id(t), t)
index = 1
newvar = 20.1
changetuples(v=t, new=newvar, ind=index)
print(id(t), t)
2424588439760 ('275', 54000, '0.0', '5000.0', '0.0')
2424588439760 ('200', 54000, '0.0', '5000.0', '0.0')
2424588439760 ('200', 20.1, '0.0', '5000.0', '0.0')

저는 이렇게 했습니다.

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

그리고 변화하려면, 그냥 하라.

list[0]=6

튜플을 변경할 수 있습니다.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]

참조별 복사를 사용하여 튜플 값을 변경할 수 있습니다.

>>> tuple1=[20,30,40]

>>> tuple2=tuple1

>>> tuple2
    [20, 30, 40]

>>> tuple2[1]=10

>>> print(tuple2)
    [20, 10, 40]

>>> print(tuple1)
    [20, 10, 40]

언급URL : https://stackoverflow.com/questions/11458239/how-to-change-values-in-a-tuple