python - 초기화 - 파이썬 리스트 합치기




파이썬에서 append와 extend리스트 메소드의 차이점 (16)

목록 메소드 append()extend() 의 차이점은 무엇입니까?


추가 대 확장

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

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

하나 이상의 요소를 확장하려면 하나의 엘멘먼트 또는 하나의 요소 목록 만 추가 할 수 있기 때문에 extend를 사용해야합니다.

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

당신이 중첩 된리스트를 얻도록

확장과 함께 이처럼 단일 요소를 확장 할 수 있습니다.

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

또는 append와 달리 목록을 원래 목록에 중첩하지 않고 한 번에 더 많은 요소를 확장합니다 (이름 확장의 이유 임)

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

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

요소 하나 추가

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

하나의 요소를 확장하다

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

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

둘 이상의 요소에 대해 append를 사용하면 인수 목록에 요소 목록을 전달해야하며 중첩 목록을 가져옵니다.

>>> 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를 사용하여 더 많은 항목으로 목록을 가져옵니다. append를 사용하여 더 이상 요소를 목록에 추가하지 않고 코드 결과에서 명확하게 볼 수있는 중첩 목록 인 요소 하나를 사용합니다.


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

  • append 는 인수를 목록의 끝에 단일 요소로 append 합니다. 목록 자체의 길이가 1 씩 증가합니다.
  • 각 요소를 목록에 추가하여 인수를 반복하여 목록을 확장합니다. 많은 요소가 iterable 인수에 포함되어 있기 때문에 목록의 길이가 늘어납니다.

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 대해 정의 list . 그들은 의미 론적으로 확장과 유사합니다.

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

my_list += another_list 는 목록을 현재 위치에서 수정합니다 ( , in-place 연산자이며 목록은 변경 가능한 객체이므로 여기 에서처럼). 그러면 새 목록이 작성되지 않습니다. 그것은 또한 두번째 반복문이 어떤 종류의 반복문이 될 수 있다는 점에서 extend와 같이 작동합니다.

혼동하지 마십시오. - my_list = my_list + another_list+= 와 동일하지 않습니다. my_list에 할당 된 새로운 목록을 제공합니다.

시간 복잡성

Append는 일정한 시간 복잡도 , O (1)을가집니다.

확장 (Extend)은 시간 복잡성, O (k)를 갖는다.

여러 호출을 반복하여 반복하면 복잡도가 늘어나 확장과 같게되며 extend의 ​​반복은 C에서 구현되므로 iterable에서 연속적인 항목을 목록에 추가하려는 경우 항상 빠릅니다.

공연

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

타이밍에 대한 의견 수렴

작성자는 다음과 같이 말했습니다.

완벽한 대답, 나는 단지 하나의 요소를 추가하는 것을 비교할 때의 타이밍을 놓치고있다.

의미 론적으로 올바른 것을하십시오. 모든 요소를 ​​반복 가능하게 추가하려면 extend 사용하십시오. 요소 하나를 추가하는 중이라면 append 사용 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

우리는 이것을 통해 하나의 요소 만 추가 extendextend 를 사용하여 얻을 수있는 것이 아무것도 없다는 것을 알 수 있습니다.

또한 이러한 타이밍은 그다지 중요하지 않습니다. 파이썬에서 의미 상으로는 올바른 일을하는 것이 Right Way ™를하는 것이라고 지적했습니다.

비교 가능한 두 작업에 대한 타이밍을 테스트하고 모호하거나 반전 된 결과가 발생할 수 있습니다. 의미 론적으로 올바른 것을하는 데 집중하십시오.

결론

우리는 extend 이 의미 상으로 명확하다는 것을 보았고 iterable의 각 요소를리스트에 추가하려고 할 때 append 보다 훨씬 빠르게 실행될 수 있음을 알 수 있습니다 .

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


( 하나의 항목만으로 ) 목록을 (그 위치에) " append "하고, 하나의 객체는 (인수로) 전달됩니다.

인수로 전달 된 객체 만큼 많은 항목에 의해 목록을 확장합니다.

이것은 str 객체에 대해 약간 혼란 스러울 수 있습니다.

  1. 문자열을 인수로 전달하면 append 는 끝에 단일 문자열 항목을 추가하지만 extend 은 해당 문자열의 길이만큼 "단일" 'str'항목을 추가합니다.
  2. 인수로 문자열 목록을 전달하면 append 는 끝에 'list'항목 하나를 추가하고 extend 는 전달 된 목록의 길이만큼 'list'항목을 추가합니다.
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,

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

예를 들어

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

append 우리는 얻는다 :

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

extend 동안 우리는 얻는다 :

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

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]

나는이 질문에 도움이 될 수 있기를 바랍니다. 목록에 특정 유형의 객체 (예 : Info )가 저장되어있는 경우 extend 메소드가 적합하지 않은 상황이 extend . for 루프에서 매번 Info 객체를 생성하고 extend 를 사용하여 목록에 저장하면 실패합니다. 예외는 다음과 같습니다.

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

그러나 append 메서드를 사용하면 결과가 정상입니다. extend 메서드를 사용할 때마다 항상 목록 또는 다른 컬렉션 유형으로 처리하고 반복하고 이전 목록 뒤에 배치합니다. 분명히 특정 객체는 반복 될 수 없습니다.


다음 두 코드 조각은 의미 상으로 동일합니다.

for item in iterator:
    a_list.append(item)

a_list.extend(iterator)

후자는 루프가 C로 구현되기 때문에 빠를 수 있습니다.


암시되었지만 설명되지 않은 재미있는 점은 추가가 더 빠릅니다. 내부에 추가 된 루프는 list.extend (processed_elements)로 대체되어야합니다.

새로운 요소를 추가하면 전체 목록이 메모리의 더 나은 위치로 다시 연결될 수 있음을 명심하십시오. 한 번에 1 요소 씩 추가하기 때문에 여러 번 수행하면 전반적인 성능이 저하됩니다. 이러한 의미에서 list.extend는 .join (stringlist)과 유사합니다.


이것은 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 를 사용하고 extend 할 때 실제로 일어나는 일을 이해하는 데 도움이되었습니다 :

a = [[1,2,3],[4,5,6]]
print(a)
>>> [[1, 2, 3], [4, 5, 6]]
a.append([6,7,8])
print(a)
>>> [[1, 2, 3], [4, 5, 6], [6, 7, 8]]
a.extend([0,1,2])
print(a)
>>> [[1, 2, 3], [4, 5, 6], [6, 7, 8], 0, 1, 2]
a=a+[8,9,10]
print(a)
>>> [[1, 2, 3], [4, 5, 6], [6, 7, 8], 0, 1, 2, 8, 9, 10]

추가와 확장은 파이썬에서 확장 성 메커니즘 중 하나입니다.

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

my_list = [1,2,3,4]

목록에 새 요소를 추가하려면 다음과 같이 append 메서드를 사용할 수 있습니다.

my_list.append(5)

새 요소가 추가되는 기본 위치는 항상 (길이 + 1) 위치입니다.

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

insert (index, object)의 메소드 서술자입니다. 여기에는 두 개의 인수가 필요합니다. 첫 번째 요소는 요소를 삽입하려는 인덱스이고 두 번째 요소는 요소입니다.

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

확장 : 두 개 이상의 목록을 단일 목록으로 결합하고자 할 때 매우 유용합니다. extends를 사용하지 않고 두 개의 목록을 결합하려는 경우 결과 객체에는 목록의 목록이 포함됩니다.

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]

확장 기능 대신 확장 기능을 사용하려면 "+"를 사용할 수 있습니다.

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]

비슷하게 += in place 동작이지만 append & extend 와는 약간의 차이가 extend . appendextend 에서 += 의 가장 큰 차이점 중 하나는 기능 범위에서 사용되는 경우입니다. 이 블로그 게시물을 참조하십시오.


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]

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

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

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

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

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

다음은 iterator 인수와 동등하게 extend() 사용할 수있는 방법입니다.

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

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]






extend