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', 2]]
>>> li.insert(2, "new")
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new']
>>> li.extend(["two", "elements"])
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']
FromPythonに飛び込む。
リストメソッドの追加と拡張の違いは何ですか？
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メソッドはイテラブルの要素を追加することでリストを拡張します。
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に対して定義されています。それらは意味的にはextendに似ています。
my_list + another_listはメモリ内に3番目のリストを作成するので、その結果を返すことができますが、2番目のイテラブルはリストである必要があります。
my_list += another_listはリストをインプレースで修正します（それはisインプレース演算子です、そして私たちが見たようにリストは可変オブジェクトです）、それは新しいリストを作成しません。 2番目のイテラブルがどんな種類のイテラブルでもよいという点で、それはまた拡張のように働きます。
混乱しないでください - my_list = my_list + another_listは+=と同じではありません - それはあなたにmy_listに割り当てられた真新しいリストを与えます。
時間の複雑さ
Appendには 一定の時間複雑性 、O（1）があります。
Extendは時間の複雑さ、O（k）を持ちます。
appendへの複数の呼び出しを繰り返すことは、それをextendのそれと同等にする複雑さを増します、そして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を使用してください。要素を1つ追加するだけの場合は、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
そして、extendを使うためだけにイテラブルを作成するという私たちのやり方から抜け出すことは、（マイナーな）時間の無駄です。
>>> min(timeit.repeat(lambda: append_one([], 0)))
0.2082819009956438
>>> min(timeit.repeat(lambda: extend_one([], 0)))
0.2397019260097295
このことから、追加するone要素しかない場合、extendを使用しても何も得られないことがわかります。
また、これらのタイミングはそれほど重要ではありません。私はPythonで意味的に正しいことを行うことがRight Way™のことを行うことであることを示すためにそれらを示しています。
2つの同等の操作でタイミングをテストして、あいまいな結果または逆の結果が生じる可能性があります。意味的に正しいことに集中してください。
結論
extendは意味的により明確で、リストの繰り返し可能要素の各要素を追加する場合はappend、よりもはるかに速く実行できることがわかりました。
リストに追加する要素が1つしかない場合（iterableに含まれていない場合）、appendを使用します。
appendは単一の要素を追加します。 extendは要素のリストを追加します。
追加するリストを渡しても、1つの要素が追加されます。
>>> a = [1, 2, 3]
>>> a.append([4, 5, 6])
>>> a
[1, 2, 3, [4, 5, 6]]
次の2つのコードは意味的に同じです。
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（）メソッドは1つの引数、リストを取り、引数の各項目を元のリストに追加します。 （リストはクラスとして実装されています。リストの「作成」は実際にはクラスをインスタンス化することです。したがって、リストにはそれを操作するメソッドがあります。）
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と+=の最大の違いの1つは、それが関数スコープで使用されるときです。 このブログ記事 を参照してください。
追加と拡張
![enter image description here]()
Appendを使うと、リストを拡張する単一の要素を追加することができます。
>>> a = [1,2]
>>> a.append(3)
>>> a
[1,2,3]
複数の要素を拡張したい場合は、extendを使用する必要があります。追加できるのは1つの要素または要素のリストだけです。
>>> a.append([4,5])
>>> a
>>> [1,2,3,[4,5]]
ネストしたリストになるように
Extendではなく、このように単一の要素を拡張することができます
>>> a = [1,2]
>>> a.extend([3])
>>> a
[1,2,3]
または、appendとは異なり、リストを元のリストにネストせずに、一度に複数の要素を拡張する（これがextendという名前の理由です）
>>> a.extend([4,5,6])
>>> a
[1,2,3,4,5,6]
両方の方法で1つの要素を追加する
1つの要素を追加
>>> x = [1,2]
>>> x.append(3)
>>> x
[1,2,3]
1つの要素を拡張
>>> x = [1,2]
>>> x.extend([3])
>>> x
[1,2,3,4]
要素を追加して...さまざまな結果
複数の要素に対して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]
appendを使用して、リストに追加の要素を追加するのではなく、1つの要素をネストされたリストにすることで、明らかにわかります。コードの出力に。
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) - 2つのリストを本質的に連結します。
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（） ：Pythonでは基本的に1つの要素を追加するために使用されます。
例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（）は、2つのリストをマージしたり、1つのリストに複数の要素を挿入するために使用されます。
例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）に置き換えられていると見なす必要があります。
新しい要素を理解すると、リスト全体がメモリ内のより良い場所に再配置される可能性があることに注意してください。一度に1つの要素を追加しているためにこれが複数回行われると、全体的なパフォーマンスが低下します。この意味で、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を次のように定義します。
append ：文書の最後に（何か）を追加する。
extend ：大きくします。拡大または拡大
その知識で、今理解しましょう
1）appendとextendの違い
append：
- 任意のPythonオブジェクトをそのまま としてリストの末尾に追加します（すなわち、リストの最後の要素として）。
- 結果として得られるリストは入れ子になっていてもよく、異種の要素（リスト、文字列、タプル、辞書、集合など）を含んでいてもよい。
extend：
- 引数として任意の iterable を受け入れ、リスト をより大きく にします。
- 結果のリストは常に一次元のリスト（つまりネストなし）であり、
list(iterable)を適用した結果として異種の要素（例：文字、整数、浮動小数点数）が含まれることがあります。
2）appendとextendの類似点
- どちらも厳密に1つの引数を取ります。
- 両方ともリスト インプレース を修正します。
- 結果として、両方とも
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)
メソッド「append」はそのパラメータを 単一要素 としてリストに追加し、「extend」はリストを取得してその内容を追加します。
例えば、
拡張
letters = ['a', 'b']
letters.extend(['c', 'd'])
print(letters) # ['a', 'b', 'c', 'd']
追加
letters.append(['e', 'f'])
print(letters) # ['a', 'b', 'c', 'd', ['e', 'f']]
別の辞書に辞書を追加します。
>>>def foo():
dic = {1:'a', 2:'b', 3:'c', 4:'a'}
newdic = {5:'v', 1:'aa'}
for i in dic.keys():
if not newdic.has_key(dic[i]):
newdic[i] = dic[i]
print "Appended one:", newdic
>>>foo()
Appended one: {1: 'a', 2: 'b', 3: 'c', 4: 'a', 5: 'v'}
私はこの質問に役立つ補足をすることができると思います。リストに特定の型オブジェクト、たとえばInfoが格納されている場合は、extendメソッドが適していない状況になります。forループ内でInfoオブジェクトを生成する毎回extendを使用してリストに保存すると、失敗します。例外は以下のとおりです。
TypeError： 'Info'オブジェクトは反復できません
しかし、appendメソッドを使用すれば、結果はOKです。毎回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']
2人の別々の人が結婚して団結した家族を築くようなものです。
私はあなたの参照のためにすべてのリストの方法の徹底的なチートシートを作ります。
list_methods = {'Add': {'extend', 'append', 'insert'},
'Remove': {'pop', 'remove', 'clear'}
'Sort': {'reverse', 'sort'},
'Search': {'count', 'index'},
'Copy': {'copy'},
}
append： 既存のリストの最後に 'list'または 'single element'を追加します。
a = [1,2]
b = [3]
a.append(b)
print(a) # prints [1,2,[3]]
a.append(4)
print(a) # prints [1,2,[3],4]
extend： 'リストの要素'（引数として渡される）を既存のリストに追加します。
a = [1,2]
b = [3]
a.extend(b)
print(a) # prints [1,2,3]
a.extend(4) # typeError as int cannot be used as argument with extend
Append：その引数を単一の要素としてリストの末尾に追加します。
例えば：-
my_list = ['stack', 'over']
my_list.append('flow')
print my_list
出力：
['stack', 'over', 'flow']
注： - リストに別のリストを追加した場合、最初のリストはリストの最後にある単一のオブジェクトになります。
例えば：-
my_list = ['stack', 'over', 'flow']
another_list = [1,2,3,4] ,
my_list.append(another_list)
print my_list
出力：-
['stack', 'over', 'over', [1,2,3,4]]
extend()： - 引数を繰り返し、各要素をリストに追加してリストを拡張します。リストの長さは、引数内の要素数によって増加します。
例えば：-
my_list = ['stack', 'over']
another_list = [6, 0, 4, 1]
my_list.extend(another_list)
print my_list
出力：
['stack', 'over', 6, 0, 4, 1]
注： - 文字列は反復可能なので、リストを文字列で拡張する場合は、文字列を反復処理するときに各文字を追加します。
例えば：-
my_list = ['stack', 'overflow', 6, 0, 4, 1]
my_list.extend('hello')
print my_list
これは私があなたが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]
append（） methodは、渡された引数を単一の要素として追加します。
extend（） は渡された引数を繰り返し処理し、繰り返し処理された各要素を渡すことでリストを拡張します。基本的に、全体を1つとして加算するのではなく複数の要素を追加します。
list1 = [1,2,3,4,5]
list2 = [6,7,8]
list1.append(list2)
print(list1)
#[1,2,3,4,5,[6,7,8]]
list1.extend(list2)
print(list1)
#[1,2,3,4,5,6,7,8]
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]