Python의 목록 메소드 추가와 확장의 차이점은 무엇입니까?

https://stackoverflow.com/questions/252703

05-07-2019
|

문제

목록 방법의 차이점은 무엇입니까 append() 그리고 extend()?

해결책

append: 끝에 객체가 추가됩니다.

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

당신에게 : [1, 2, 3, [4, 5]]

extend: 반복 가능한 요소를 추가하여 목록을 확장합니다.

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

당신에게 : [1, 2, 3, 4, 5]

다른 팁

append 목록에 요소를 추가합니다 extend 첫 번째 목록을 다른 목록과 연결합니다 (또는 반드시 목록이 아닙니다.)

>>> li = ['a', 'b', 'mpilgrim', 'z', 'example']
>>> li
['a', 'b', 'mpilgrim', 'z', 'example']

>>> li.append("new")
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new']

>>> li.append(["new", 2])
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new', ['new', 2]]

>>> li.insert(2, "new")
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', ['new', 2]]

>>> li.extend(["two", "elements"])
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', ['new', 2], 'two', 'elements']

에서 파이썬으로 뛰어 들었습니다.

목록 메소드 추가와 확장의 차이점은 무엇입니까?

append 인수를 목록 끝에 단일 요소로 추가합니다.목록 자체의 길이가 1씩 늘어납니다.
extend 목록에 각 요소를 추가하여 인수를 반복하여 목록을 확장합니다.목록의 길이는 반복 가능한 인수에 포함된 요소의 수에 따라 늘어납니다.

`append`

그만큼 list.append 메서드는 목록 끝에 개체를 추가합니다.

my_list.append(object)

숫자, 문자열, 다른 목록 등 객체가 무엇이든 관계없이 객체의 끝에 추가됩니다. my_list 목록의 단일 항목으로.

>>> my_list
['foo', 'bar']
>>> my_list.append('baz')
>>> my_list
['foo', 'bar', 'baz']

따라서 목록은 객체라는 점을 명심하세요.목록에 다른 목록을 추가하면 첫 번째 목록은 목록 끝에 있는 단일 개체가 됩니다(원하는 것이 아닐 수도 있음).

>>> another_list = [1, 2, 3]
>>> my_list.append(another_list)
>>> my_list
['foo', 'bar', 'baz', [1, 2, 3]]
                     #^^^^^^^^^--- single item at the end of the list.

`extend`

그만큼 list.extend 메소드는 iterable의 요소를 추가하여 목록을 확장합니다.

my_list.extend(iterable)

따라서 확장을 사용하면 iterable의 각 요소가 목록에 추가됩니다.예를 들어:

>>> my_list
['foo', 'bar']
>>> another_list = [1, 2, 3]
>>> my_list.extend(another_list)
>>> my_list
['foo', 'bar', 1, 2, 3]

문자열은 반복 가능하므로 문자열로 목록을 확장하면 문자열을 반복할 때 각 문자를 추가하게 됩니다(원하는 것이 아닐 수도 있음).

>>> my_list.extend('baz')
>>> my_list
['foo', 'bar', 1, 2, 3, 'b', 'a', 'z']

연산자 과부하, `add` (`+`) 그리고 `iadd` (`+=`)

둘 다 + 그리고 += 연산자는 다음에 대해 정의됩니다. list.의미상 확장과 유사합니다.

my_list + another_list 메모리에 세 번째 목록을 생성하므로 결과를 반환할 수 있지만 두 번째 반복 가능 항목은 목록이어야 합니다.

my_list += another_list 목록을 그 자리에서 수정합니다(그것은 ~이다 내부 연산자와 목록은 우리가 본 것처럼 변경 가능한 개체이므로 새 목록을 생성하지 않습니다.또한 두 번째 반복 가능 항목은 모든 종류의 반복 가능 항목이 될 수 있다는 점에서 확장과 유사하게 작동합니다.

헷갈리지 마세요 - my_list = my_list + another_list 는 다음과 동일하지 않습니다 += - my_list에 할당된 새로운 목록을 제공합니다.

시간 복잡도

추가 내용 일정한 시간 복잡도, 오(1).

확장에는 시간 복잡도 O(k)가 있습니다.

여러 호출을 통해 반복 append 복잡성을 더해 확장과 동일하게 만들고, 확장의 반복은 C로 구현되므로 반복 가능 항목의 연속 항목을 목록에 추가하려는 경우 항상 더 빠릅니다.

성능

추가를 사용하여 확장과 동일한 결과를 얻을 수 있으므로 무엇이 더 성능이 좋은지 궁금할 수 있습니다.다음 함수는 동일한 작업을 수행합니다.

def append(alist, iterable):
    for item in iterable:
        alist.append(item)

def extend(alist, iterable):
    alist.extend(iterable)

그러니 시간을 측정해 봅시다:

import timeit

>>> min(timeit.repeat(lambda: append([], "abcdefghijklmnopqrstuvwxyz")))
2.867846965789795
>>> min(timeit.repeat(lambda: extend([], "abcdefghijklmnopqrstuvwxyz")))
0.8060121536254883

타이밍에 대한 의견 처리

한 논평자는 다음과 같이 말했습니다.

완벽한 답변입니다. 요소 하나만 추가하는 비교 타이밍이 그리워요.

의미상 올바른 일을 하세요.iterable의 모든 요소를 추가하려면 다음을 사용하십시오. extend.요소 하나만 추가하는 경우 다음을 사용하세요. append.

좋습니다. 시간이 지남에 따라 이것이 어떻게 작동하는지 알아보는 실험을 만들어 보겠습니다.

def append_one(a_list, element):
    a_list.append(element)

def extend_one(a_list, element):
    """creating a new list is semantically the most direct
    way to create an iterable to give to extend"""
    a_list.extend([element])

import timeit

그리고 단지 확장을 사용하기 위해 반복 가능한 객체를 생성하려고 애쓰는 것은 (사소한) 시간 낭비라는 것을 알 수 있습니다.

>>> min(timeit.repeat(lambda: append_one([], 0)))
0.2082819009956438
>>> min(timeit.repeat(lambda: extend_one([], 0)))
0.2397019260097295

우리는 이것을 사용하여 얻을 수 있는 것이 없다는 것을 배웁니다. extend 우리만 있을 때 하나 추가할 요소입니다.

또한 이러한 타이밍은 그다지 중요하지 않습니다.나는 단지 파이썬에서 의미상 올바른 일을 하는 것이 오른쪽 웨이™.

두 개의 비교 가능한 작업에서 타이밍을 테스트하고 모호하거나 반대의 결과를 얻을 수도 있습니다.의미상 올바른 일을 하는 데에만 집중하세요.

결론

우리는 그것을 본다 extend 의미상으로 더 명확하고 다음보다 훨씬 빠르게 실행될 수 있습니다. append, iterable의 각 요소를 목록에 추가하려는 경우.

목록에 추가할 요소가 하나만 있는 경우(반복 가능 항목 아님) 다음을 사용하세요. append.

append 단일 요소를 추가합니다. extend 요소 목록을 추가합니다.

추가 할 목록을 전달하면 여전히 하나의 요소가 추가됩니다.

>>> a = [1, 2, 3]
>>> a.append([4, 5, 6])
>>> a
[1, 2, 3, [4, 5, 6]]

다음 두 스 니펫은 의미 적으로 동일합니다.

for item in iterator:
    a_list.append(item)

그리고

a_list.extend(iterator)

후자는 루프가 C에서 구현되면 더 빠를 수 있습니다.

그만큼 append() 메소드 목록 끝에 단일 항목을 추가합니다.

x = [1, 2, 3]
x.append([4, 5])
x.append('abc')
print(x)
# gives you
[1, 2, 3, [4, 5], 'abc']

그만큼 extend() 메소드는 하나의 인수, 목록을 취하고 인수의 각 항목을 원래 목록에 추가합니다. (목록은 클래스로 구현됩니다.“생성”목록은 실제로 클래스를 인스턴스화하는 것입니다. 따라서 목록에는 작동하는 방법이 있습니다.)

x = [1, 2, 3]
x.extend([4, 5])
x.extend('abc')
print(x)
# gives you
[1, 2, 3, 4, 5, 'a', 'b', 'c']

에서 파이썬으로 뛰어 들었습니다.

확장을 확장하는 대신 extend를 반환하는 데 "+"를 사용할 수 있습니다.

l1=range(10)

l1+[11]

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11]

l2=range(10,1,-1)

l1+l2

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2]

비슷하게 += 행동에있어서, 그러나 약간의 차이가 있습니다. append & extend. 가장 큰 차이점 중 하나입니다 += ~에서 append 그리고 extend 기능 범위에 사용되는 경우 이 블로그 게시물.

추가 vs 확장

추가를 사용하면 목록을 확장할 단일 요소를 추가할 수 있습니다.

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

하나 이상의 요소를 확장하려면 하나의 요소 또는 하나의 요소 목록만 추가할 수 있으므로 확장을 사용해야 합니다.

>>> a.append([4,5])
>>> a
>>> [1,2,3,[4,5]]

중첩된 목록을 얻으려면

대신 확장을 사용하면 다음과 같이 단일 요소를 확장할 수 있습니다.

>>> a = [1,2]
>>> a.extend([3])
>>> a
[1,2,3]

또는 추가와는 다르게 목록을 원래 목록에 중첩하지 않고 한 번에 더 많은 요소를 확장합니다(이것이 이름 확장의 이유입니다).

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

두 가지 방법으로 하나의 요소 추가

요소 1개 추가

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

하나의 요소를 확장

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

더 많은 요소를 추가하는 중...다른 결과로

둘 이상의 요소에 추가를 사용하는 경우 요소 목록을 인수로 전달해야 하며 NESTED 목록을 얻게 됩니다!

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

대신 확장을 사용하면 목록을 인수로 전달하지만 이전 요소에 중첩되지 않은 새 요소가 포함된 목록을 얻게 됩니다.

>>> z = [1,2] 
>>> z.extend([3,4])
>>> z
[1,2,3,4]

따라서 요소가 많을수록 확장을 사용하여 더 많은 항목이 포함된 목록을 얻을 수 있습니다.목록에 더 많은 요소를 추가하지 않고 코드 출력에서 명확하게 볼 수 있듯이 중첩된 목록인 하나의 요소를 추가하려면 추가를 사용합니다.

append(object) - 목록에 개체를 추가하여 목록을 업데이트합니다.

x = [20]
# List passed to the append(object) method is treated as a single object.
x.append([21, 22, 23])
# Hence the resultant list length will be 2
print(x)
--> [20, [21, 22, 23]]

extend(list) - 본질적으로 두 목록을 연결합니다.

x = [20]
# The parameter passed to extend(list) method is treated as a list.
# Eventually it is two lists being concatenated.
x.extend([21, 22, 23])
# Here the resultant list's length is 4
print(x)
[20, 21, 22, 23]

extend() 반복자 인수와 함께 사용할 수 있습니다. 여기 예입니다. 이 방법으로 목록에서 목록을 만들고 싶습니다.

에서

list2d = [[1,2,3],[4,5,6], [7], [8,9]]

당신은 원합니다

>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]

당신은 사용할 수 있습니다 itertools.chain.from_iterable() 그렇게하려면. 이 방법의 출력은 반복자입니다. 구현은 동일합니다

def from_iterable(iterables):
    # chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
    for it in iterables:
        for element in it:
            yield element

우리의 예로 돌아갈 수 있습니다

import itertools
list2d = [[1,2,3],[4,5,6], [7], [8,9]]
merged = list(itertools.chain.from_iterable(list2d))

그리고 원하는 목록을 얻으십시오.

여기에 얼마나 동등한 지 있습니다 extend() 반복자 인수와 함께 사용할 수 있습니다.

merged = []
merged.extend(itertools.chain.from_iterable(list2d))
print(merged)
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]

이것은 동등합니다 append 그리고 extend 사용 + 운영자:

>>> x = [1,2,3]
>>> x
[1, 2, 3]
>>> x = x + [4,5,6] # Extend
>>> x
[1, 2, 3, 4, 5, 6]
>>> x = x + [[7,8]] # Append
>>> x
[1, 2, 3, 4, 5, 6, [7, 8]]

부록 (): 기본적으로 Python에서 하나의 요소를 추가하는 데 사용됩니다.

Example 1:

>> a = [1, 2, 3, 4]
>> a.append(5)
>> print(a)
>> a = [1, 2, 3, 4, 5]

Example 2:

>> a = [1, 2, 3, 4]
>> a.append([5, 6])
>> print(a)
>> a = [1, 2, 3, 4, [5, 6]]

연장하다(): 여기서 extend ()는 두 목록을 병합하거나 한 목록에 여러 요소를 삽입하는 데 사용됩니다.

Example 1:

>> a = [1, 2, 3, 4]
>> b = [5, 6, 7, 8]
>> a.extend(b)
>> print(a)
>> a = [1, 2, 3, 4, 5, 6, 7, 8]

Example 2:

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

힌트를 주지만 설명되지 않은 흥미로운 점은 확장이 추가보다 빠릅니다. 내부에 추가 된 루프의 경우 List.extend (Processed_Elements)로 대체되는 것으로 간주해야합니다.

새로운 요소를 승인하면 전체 목록을 메모리의 더 나은 위치로 실현할 수 있습니다. 한 번에 1 요소를 추가하여 여러 번 완료되면 전반적인 성능이 어려워집니다. 이런 의미에서 List.extend는 ".join (StringList)과 유사합니다.

Append는 한 번에 전체 데이터를 추가합니다. 전체 데이터는 새로 생성 된 인덱스에 추가됩니다. 반면에, extend, 이름에서 알 수 있듯이 현재 배열을 확장합니다.

예를 들어

list1 = [123, 456, 678]
list2 = [111, 222]

와 함께 append 우리는 얻는다 :

result = [123, 456, 678, [111, 222]]

계속해서 extend 우리는 얻는다 :

result = [123, 456, 678, 111, 222]

영어 사전은 단어를 정의합니다 append 그리고 extend 처럼:

추가: 서면 문서의 끝에 (무언가) 추가하십시오.
연장하다: 더 크게 만듭니다. 확대 또는 확장

그 지식으로 이제 이해합시다

1) 차이 append 그리고 extend

append:

추가 모든 파이썬 객체 목록의 끝까지 (예 : 목록의 마지막 요소).
결과 목록은 중첩 될 수 있으며 이기종 요소를 포함 할 수 있습니다 (예 : 목록, 문자열, 튜플, 사전, 세트 등).

extend:

어떤 사람도 받아들입니다 반복적 인 논쟁으로서 목록을 만듭니다 더 큰.
결과 목록은 항상 1 차원 목록 (예 : 중첩 없음)이며 적용의 결과로 이종 요소 (예 : 문자, 정수, 플로트)가 포함될 수 있습니다. list(iterable).

2) 사이의 유사성 append 그리고 extend

둘 다 정확히 하나의 주장을합니다.
둘 다 목록을 수정합니다 현장.
결과적으로 두 사람 모두 돌아옵니다 None.

예시

lis = [1, 2, 3]

# 'extend' is equivalent to this
lis = lis + list(iterable)

# 'append' simply appends its argument as the last element to the list
# as long as the argument is a valid Python object
lis.append(object)

이 질문에 유용한 보충을 할 수 있기를 바랍니다. 목록이 특정 유형 객체를 저장하는 경우 (예 : Info, 여기에 상황이 있습니다 extend 방법은 적합하지 않습니다 : a for 루프 및 생성 Info 매번 객체와 사용 extend 목록에 저장하려면 실패합니다. 예외는 다음과 같습니다.

TypeError : '정보'객체는 반복 할 수 없습니다

그러나 당신이 사용하는 경우 append 방법, 결과는 괜찮습니다. 사용할 때마다 extend 방법, 항상 목록 또는 기타 수집 유형으로 취급하여 반복하여 이전 목록에 배치합니다. 특정 객체를 반복 할 수 없습니다.

직관적으로 구별합니다

l1 = ['a', 'b', 'c']
l2 = ['d', 'e', 'f']
l1.append(l2)
l1
['a', 'b', 'c', ['d', 'e', 'f']]

같네요 l1 그녀의 몸 안에 몸을 재현하십시오 (중첩).

# Reset l1 = ['a', 'b', 'c']
l1.extend(l2)
l1
['a', 'b', 'c', 'd', 'e', 'f']

두 명의 분리 된 개인이 결혼하여 연합 가족을 짓는 것과 같습니다.

게다가 나는 당신의 참조를위한 모든 목록의 방법을 철저한 치트 시트를 만듭니다.

list_methods = {'Add': {'extend', 'append', 'insert'},
                'Remove': {'pop', 'remove', 'clear'}
                'Sort': {'reverse', 'sort'},
                'Search': {'count', 'index'},
                'Copy': {'copy'},
                }

extend(L) 주어진 목록의 모든 항목을 추가하여 목록을 확장합니다. L.

>>> a
[1, 2, 3]
a.extend([4])  #is eqivalent of a[len(a):] = [4]
>>> a
[1, 2, 3, 4]
a = [1, 2, 3]
>>> a
[1, 2, 3]
>>> a[len(a):] = [4]
>>> a
[1, 2, 3, 4]

append "확장"목록 (제자리에) 하나의 항목 만, 단일 객체가 통과했습니다 (인수로).

extend "확장"목록 (제자리에) 많은 항목 (인수)가 포함 된 대상에 통과 된 대상.

이것은 약간 혼란 스러울 수 있습니다 str 사물.

문자열을 인수로 전달하는 경우 :append 마지막에 단일 문자열 항목을 추가하지만extend 그 문자열의 길이만큼 많은 "단일" 'str'항목을 추가합니다.
문자열 목록을 인수로 전달하는 경우 :append 끝에 여전히 단일 '목록'항목을 추가하고extend 전달 된 목록의 길이만큼 많은 '목록'항목을 추가합니다.

def append_o(a_list, element):
    a_list.append(element)
    print('append:', end = ' ')
    for item in a_list:
        print(item, end = ',')
    print()

def extend_o(a_list, element):
    a_list.extend(element)
    print('extend:', end = ' ')
    for item in a_list:
        print(item, end = ',')
    print()
append_o(['ab'],'cd')

extend_o(['ab'],'cd')
append_o(['ab'],['cd', 'ef'])
extend_o(['ab'],['cd', 'ef'])
append_o(['ab'],['cd'])
extend_o(['ab'],['cd'])

생산 :

append: ab,cd,
extend: ab,c,d,
append: ab,['cd', 'ef'],
extend: ab,cd,ef,
append: ab,['cd'],
extend: ab,cd,

추가 및 확장은 파이썬의 확장 성 메커니즘 중 하나입니다.

추가 : 목록 끝에 요소를 추가합니다.

my_list = [1,2,3,4]

목록에 새 요소를 추가하기 위해 다음 방법으로 Append 메소드를 사용할 수 있습니다.

my_list.append(5)

새 요소가 추가 될 기본 위치는 항상 (길이+1) 위치에 있습니다.

삽입 : 삽입 방법을 사용하여 부록의 한계를 극복했습니다. 삽입을 사용하면 새 요소를 삽입하려는 정확한 위치를 명시 적으로 정의 할 수 있습니다.

인서트의 메소드 디스크립터 (색인, 객체). 두 가지 인수가 필요합니다. 먼저 요소를 삽입하고 두 번째 요소 자체를 삽입하려는 색인입니다.

Example: my_list = [1,2,3,4]
my_list[4, 'a']
my_list
[1,2,3,4,'a']

확장 : 두 개 이상의 목록에 단일 목록에 가입하려는 경우 매우 유용합니다. 확장없이 두 개의 목록에 가입하려면 결과 객체에 목록 목록이 포함됩니다.

a = [1,2]
b = [3]
a.append(b)
print (a)
[1,2,[3]]

POS 2에서 요소에 액세스하려고하면 요소 대신 목록 ([3])가 나타납니다. 두 목록에 가입하려면 Append를 사용해야합니다.

a = [1,2]
b = [3]
a.extend(b)
print (a)
[1,2,3]

여러 목록에 가입합니다

a = [1]
b = [2]
c = [3]
a.extend(b+c)
print (a)
[1,2,3]

라이센스 : CC-BY-SA ~와 함께 속성

제휴하지 않습니다 StackOverflow