목록에서 요소 찾기 및 바꾸기

목록을 검색하고 한 요소의 모든 항목을 다른 요소로 바꿔야합니다. 지금까지 코드를 시도했지만 아무데도 도움이되지 않습니다.이 작업을 수행하는 가장 좋은 방법은 무엇입니까?

예를 들어, 내 목록에 다음 정수가 있다고 가정하십시오.

>>> a = [1,2,3,4,5,1,2,3,4,5,1]

숫자 1의 모든 항목을 값 10으로 바꿔야하므로 필요한 출력이

>>> a = [10, 2, 3, 4, 5, 10, 2, 3, 4, 5, 10]

따라서 내 목표는 숫자 1의 모든 인스턴스를 숫자 10으로 바꾸는 것입니다.

>>> a= [1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1]
>>> for n, i in enumerate(a):
...   if i == 1:
...      a[n] = 10
...
>>> a
[10, 2, 3, 4, 5, 10, 2, 3, 4, 5, 10]

목록 이해 와 삼항 연산자를 사용해보십시오 .

>>> a=[1,2,3,1,3,2,1,1]
>>> [4 if x==1 else x for x in a]
[4, 2, 3, 4, 3, 2, 4, 4]

목록 이해가 잘 작동하고 열거를 통해 반복하면 메모리가 절약 될 수 있습니다 (b / c 작업이 본질적으로 수행되고 있음).

기능적 프로그래밍도 있습니다. 지도 사용법을 참조하십시오 .

>>> a = [1,2,3,2,3,4,3,5,6,6,5,4,5,4,3,4,3,2,1]
>>> map(lambda x: x if x != 4 else 'sss', a)
[1, 2, 3, 2, 3, 'sss', 3, 5, 6, 6, 5, 'sss', 5, 'sss', 3, 'sss', 3, 2, 1]

대체 할 값이 여러 개인 경우 사전을 사용할 수도 있습니다.

a = [1, 2, 3, 4, 1, 5, 3, 2, 6, 1, 1]
dic = {1:10, 2:20, 3:'foo'}

print([dic.get(n, n) for n in a])

> [10, 20, 'foo', 4, 10, 5, 'foo', 20, 6, 10, 10]

>>> a=[1,2,3,4,5,1,2,3,4,5,1]
>>> item_to_replace = 1
>>> replacement_value = 6
>>> indices_to_replace = [i for i,x in enumerate(a) if x==item_to_replace]
>>> indices_to_replace
[0, 5, 10]
>>> for i in indices_to_replace:
...     a[i] = replacement_value
... 
>>> a
[6, 2, 3, 4, 5, 6, 2, 3, 4, 5, 6]
>>> 

a = [1,2,3,4,5,1,2,3,4,5,1,12]
for i in range (len(a)):
    if a[i]==2:
        a[i]=123

for 및 or while 루프를 사용할 수 있습니다. 그러나 내장 Enumerate 함수를 알고 있다면 Enumerate를 사용하는 것이 좋습니다. 1

모두 쉽게 교체하기 1로 10에 a = [1,2,3,4,5,1,2,3,4,5,1]'봐, 엄마, 아니 IF를 또는 FORS를!'하나 다음과 같은 한 줄 람다 + 맵의 조합을 사용할 수 있으며, :

# This substitutes all '1' with '10' in list 'a' and places result in list 'c':

c = list(map(lambda b: b.replace("1","10"), a))

다음은 Python 2.x에서 매우 직접적인 방법입니다.

 a = [1,2,3,4,5,1,2,3,4,5,1]        #Replacing every 1 with 10
 for i in xrange(len(a)):
   if a[i] == 1:
     a[i] = 10  
 print a

이 방법이 작동합니다. 의견을 환영합니다. 그것이 도움이되기를 바랍니다 :)

또한 outis 및 damzam 솔루션의 작동 방식을 이해하십시오 . 리스트 압축과 람다 기능은 유용한 도구입니다.

나는 이것이 매우 오래된 질문이라는 것을 알고 있으며 그것을 할 수있는 많은 방법이 있습니다. 내가 찾은 가장 간단한 것은 numpy패키지를 사용하는 것 입니다.

import numpy

arr = numpy.asarray([1, 6, 1, 9, 8])
arr[ arr == 8 ] = 0 # change all occurrences of 8 by 0
print(arr)

내 유스 케이스가 None일부 기본값 으로 바뀌 었습니다 .

@kxr-using을 포함하여 여기에 제시된이 문제에 대한 접근 방식을 시간을 정했습니다 str.count.

Python 3.8.1을 사용하여 ipython에서 테스트 코드 :

def rep1(lst, replacer = 0):
    ''' List comprehension, new list '''

    return [item if item is not None else replacer for item in lst]


def rep2(lst, replacer = 0):
    ''' List comprehension, in-place '''    
    lst[:] =  [item if item is not None else replacer for item in lst]

    return lst


def rep3(lst, replacer = 0):
    ''' enumerate() with comparison - in-place '''
    for idx, item in enumerate(lst):
        if item is None:
            lst[idx] = replacer

    return lst


def rep4(lst, replacer = 0):
    ''' Using str.index + Exception, in-place '''

    idx = -1
    # none_amount = lst.count(None)
    while True:
        try:
            idx = lst.index(None, idx+1)
        except ValueError:
            break
        else:
            lst[idx] = replacer

    return lst


def rep5(lst, replacer = 0):
    ''' Using str.index + str.count, in-place '''

    idx = -1
    for _ in range(lst.count(None)):
        idx = lst.index(None, idx+1)
        lst[idx] = replacer

    return lst


def rep6(lst, replacer = 0):
    ''' Using map, return map iterator '''

    return map(lambda item: item if item is not None else replacer, lst)


def rep7(lst, replacer = 0):
    ''' Using map, return new list '''

    return list(map(lambda item: item if item is not None else replacer, lst))


lst = [5]*10**6
# lst = [None]*10**6

%timeit rep1(lst)    
%timeit rep2(lst)    
%timeit rep3(lst)    
%timeit rep4(lst)    
%timeit rep5(lst)    
%timeit rep6(lst)    
%timeit rep7(lst)    

나는 얻다:

26.3 ms ± 163 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
29.3 ms ± 206 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
33.8 ms ± 191 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
11.9 ms ± 37.8 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
11.9 ms ± 60.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
260 ns ± 1.84 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
56.5 ms ± 204 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

내부를 사용하는 str.index것이 실제로 수동 비교보다 빠릅니다.

테스트 4의 예외가을 사용 str.count하는 것 보다 더 힘들지 여부는 몰랐습니다 . 차이는 무시할 만합니다.

참고 map()7 테스트 따라서 (실험 6) 반복자 아닌 실제의리스트를 반환한다.

긴 목록과 드문 경우 list.index()에는 다른 답변에 제시된 단일 단계 반복 방법과 비교 하여 약 3 배 빠릅니다 .

def list_replace(lst, old=1, new=10):
    """replace list elements (inplace)"""
    i = -1
    try:
        while 1:
            i = lst.index(old, i + 1)
            lst[i] = new
    except ValueError:
        pass

파이썬에서 간단히 목록 이해를 사용할 수 있습니다.

def replace_element(YOUR_LIST, set_to=NEW_VALUE):
    return [i
            if SOME_CONDITION
            else NEW_VALUE
            for i in YOUR_LIST]

귀하의 경우, 1의 모든 발생을 10으로 바꾸려는 경우 코드 스 니펫은 다음과 같습니다.

def replace_element(YOUR_LIST, set_to=10):
    return [i
            if i != 1  # keeps all elements not equal to one
            else set_to  # replaces 1 with 10
            for i in YOUR_LIST]

하나의 항목 만 찾아서 교체

ur_list = [1,2,1]     # replace the first 1 wiz 11

loc = ur_list.index(1)
ur_list.remove(1)
ur_list.insert(loc, 11)

----------
[11,2,1]