목록 방법 append()과 차이점은 무엇입니까 extend()?

append: 끝에 오브젝트를 추가합니다.

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

당신에게 제공합니다 : [1, 2, 3, [4, 5]]

extend: iterable에서 요소를 추가하여 목록을 확장합니다.

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)

따라서 extend와 함께 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 메모리에 세 번째 목록을 작성하므로 결과를 리턴 할 수 있지만 두 번째 iterable은 목록이어야합니다.

my_list += another_list수정 목록에 장소 (그것은 이다 인플레 이스 (in-place) 운영자, 그리고 우리가 보았 듯이 목록, 변경 가능한 객체)는 새로운 목록을 작성하지 않도록. 두 번째 iterable은 모든 종류의 iterable이 될 수 있다는 점에서 extend처럼 작동합니다.

혼동하지 마십시오. my_list = my_list + another_list이에 해당 하지 않습니다 +=. my_list에 지정된 새 목록을 제공합니다.

시간 복잡성

Append는 일정한 시간 복잡도를 갖습니다 (O (1)).

Extend에는 시간이 복잡합니다 (O (k)).

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

공연

append를 사용하여 extend와 동일한 결과를 얻을 수 있으므로 성능이 더 뛰어난 것이 궁금 할 수 있습니다. 다음과 같은 기능이 동일합니다.

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

그리고 우리는 확장을 사용하기 위해 iterable을 만드는 길을 벗어나는 것이 (소액의) 시간 낭비라는 것을 알았습니다.

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

우리는 이것으로부터 추가 할 요소가 하나extend 밖에 없을 때 사용 하면 얻을 수있는 것이 없다는 것을 배웁니다 .

또한 이러한 타이밍은 그다지 중요하지 않습니다. 파이썬에서 의미 론적으로 올바른 일을하는 것이 Right Way ™를 하는 것임을 지적하기 위해 그것들을 보여주고 있습니다 .

두 개의 비교 가능한 작업에서 타이밍을 테스트하고 모호하거나 역의 결과를 얻을 수 있습니다. 의미 적으로 올바른 일에 집중하십시오.

결론

우리는 볼 extend훨씬보다 더 빨리 실행할 수 있습니다 의미 명확하고 있음을 append, 당신이 목록에 반복자의 각 요소를 추가하고자 할 때.

목록에 추가 할 단일 요소 (반복 가능하지 않은 요소) 만있는 경우을 사용하십시오 append.

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

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

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

추가 대 확장

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

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

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

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

중첩 목록을 얻을 수 있도록

대신 extend를 사용하면 이와 같은 단일 요소를 확장 할 수 있습니다

>>> 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]

더 많은 요소 추가 ... 다른 결과

둘 이상의 요소에 append를 사용하면 요소 목록을 인수로 전달해야하며 NESTED 목록을 얻을 수 있습니다!

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

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

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

따라서 더 많은 요소가 있으면 extend를 사용하여 더 많은 항목이있는 목록을 얻습니다. 그러나 목록을 추가하면 목록에 더 많은 요소가 추가되지 않지만 코드 출력에서 ​​명확하게 볼 수 있듯이 중첩 목록 인 요소 하나가 추가됩니다.

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

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

파이썬 에서 다이빙으로 .

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

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이 기능 범위에 사용하는 경우, 참조 인 이 블로그 게시물을 .

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]]

append () : 기본적으로 파이썬에서 하나의 요소를 추가하는 데 사용됩니다.

예 1 :

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

예 2 :

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

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

예 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]

예 2 :

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

암시되었지만 설명되지 않은 흥미로운 점은 확장이 추가보다 빠르다는 것입니다. 내부에 추가 된 루프의 경우 list.extend (processed_elements)로 대체되어야합니다.

새 요소를 추가하면 전체 목록이 메모리의 더 나은 위치에 다시 할당 될 수 있습니다. 한 번에 하나의 요소를 추가하여 여러 번 수행하면 전체 성능이 저하됩니다. 이런 의미에서 list.extend는 "".join (stringlist)와 유사합니다.

추가는 전체 데이터를 한 번에 추가합니다. 전체 데이터가 새로 생성 된 인덱스에 추가됩니다. 반면에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:

• iterable 을 인수로 허용 하고 목록을 더 크게 만듭니다. .
• 결과 목록은 항상 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
list.append(object)

이 질문에 유용한 보충 자료를 만들 수 있기를 바랍니다. 목록은 특정 유형의 객체를 저장하는 경우, 예를 들어 Info, 여기에있는 상황 extend에있어서 적합하지 않다 : (A)에 for루프 및 및 생성 Info물체마다 및 사용 extend하여리스트에 저장하는 것이 실패 할 것이다. 예외는 다음과 같습니다.

TypeError : 'Info'객체를 반복 할 수 없습니다

그러나 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객체에 약간 혼란 스러울 수 있습니다 .

1. 문자열을 인수로 전달 append하면 끝에 단일 문자열 항목을 extend추가 하지만 해당 문자열의 길이만큼 "단일" 'str'항목을 추가합니다.
2. 문자열 목록을 인수로 전달하는 경우 : 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) 위치입니다.

삽입 : 삽입의 한계를 극복하기 위해 삽입 방법이 사용되었습니다. insert를 사용하면 새 요소를 삽입 할 정확한 위치를 명시 적으로 정의 할 수 있습니다.

insert (index, object)의 메소드 디스크립터. 두 개의 인수가 필요합니다. 첫 번째는 요소를 삽입하려는 인덱스이고 두 번째는 요소 자체입니다.

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]