row用法 - python建立list




Python中追加與擴展列表方法的區別 (16)

追加與擴展

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

使用兩種方法添加一個元素

附加1個元素

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

延伸一個元素

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

因此,使用更多元素,您將使用extend來獲取包含更多項的列表。 您將使用append,將更多元素附加到列表中,但是一個元素是嵌套列表,您可以在代碼的輸出中清楚地看到。

列表方法append()extend()之間有什麼區別?


列表方法append和extend之間有什麼區別?

  • append將其參數作為單個元素添加到列表的末尾。 列表本身的長度將增加一個。
  • extends迭代遍歷其參數,將每個元素添加到列表中,擴展列表。 但是,可迭代參數中的許多元素會增加列表的長度。

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定義的。 它們在語義上類似於extend。

my_list + another_list在內存中創建第三個列表,因此您可以返回它的結果,但它要求第二個iterable是一個列表。

my_list += another_list就地修改列表(它就地運算符,列表是可變對象,正如我們所見),因此它不會創建新列表。 它也像extend一樣工作,因為第二個iterable可以是任何類型的iterable。

不要混淆 - my_list = my_list + another_list不等於+= - 它為您提供了一個分配給my_list的全新列表。

時間複雜性

追加具有恆定的時間複雜度 ,O(1)。

擴展具有時間複雜度O(k)。

迭代多次調用append會增加複雜性,使其等同於extend,並且由於extend的迭代是用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

而且我們看到,為了使用擴展而創建一個可迭代的方法是一種(輕微的)浪費時間:

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

我們從中了解到,當我們只有一個要追加的元素時,使用extend沒有任何好處。

而且,這些時間並不重要。 我只是向他們展示一點,在Python中,做語義正確的事情就是做Right Way™。

可以想像,您可以測試兩個類似操作的時序並獲得模糊或反向結果。 只關注做語義正確的事情。

結論

我們看到extend在語義上更清晰,並且當你打算將迭代中的每個元素追加到列表中時 ,它可以比append運行得快得多

如果您只有一個元素(不是可迭代的)要添加到列表中,請使用append


Append和extend是python中的可擴展性機制之一。

附加:將元素添加到列表的末尾。

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

擴展:當我們想要將兩個或多個列表連接到一個列表中時,這非常有用。 如果我們想要連接兩個列表,則不使用extend,結果對象將包含列表列表。

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]

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

Dive Into Python


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(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將一個元素添加到列表中,並將第一個列表與另一個列表(或另一個可列表,不一定是列表)連接起來。

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

Dive到Python


append附加一個元素。 extend附加元素列表。

請注意,如果您傳遞列表以追加,它仍會添加一個元素:

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

append() :它基本上用於Python中添加一個元素。

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

append()方法將添加傳遞給它的參數作為單個元素。

extend()將迭代傳遞的參數並通過傳遞迭代的每個元素來擴展列表,基本上它將添加多個元素而不是將整體添加為一個。

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]

以下兩個片段在語義上是等效的:

for item in iterator:
    a_list.append(item)

a_list.extend(iterator)

後者可能更快,因為循環在C中實現。


將字典附加到另一個字典:

>>>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方法,結果就可以了。 因為每次使用extend方法時,它總是將其視為列表或任何其他集合類型,迭代它,並將其放在上一個列表之後。 顯然,特定對象無法迭代。


方法“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']]

英語詞典定義詞語appendextend為:

追加 :將(某物)添加到書面文件的末尾。
延伸 :做大。 放大或擴大

有了這些知識,現在讓我們理解

1) appendextend之間的區別

append

  • 任何Python對象按原樣附加到列表的末尾(即作為列表中的最後一個元素)。
  • 結果列表可以嵌套並包含異構元素(即列表,字符串,元組,字典,集等)

extend

  • 接受任何iterable作為其參數並使列表更大
  • 結果列表總是一維列表(即沒有嵌套),並且它可能包含異構元素(例如字符,整數,浮點數)作為應用list(iterable)

2) appendextend之間的相似性

  • 兩者都只有一個參數。
  • 兩者都就地修改列表。
  • 結果,兩者都返回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)

這有助於我了解使用appendextend時發生的事情:

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]




extend