ما هو الفرق بين أساليب قائمة Python وتمديده؟
-
05-07-2019 - |
سؤال
ما الفرق بين طرق القائمة append()
و extend()
?
نصائح أخرى
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
يضيف وسيطتها كعنصر واحد إلى نهاية القائمة. سوف يزيد طول القائمة نفسها بمقدار واحد.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
تمدد الطريقة قائمة عن طريق إلحاق العناصر من ithable:
my_list.extend(iterable)
لذلك مع التمديد ، يتم إلحاق كل عنصر من عناصر ITERBLE على القائمة. فمثلا:
>>> 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']
Overload Overload ، __add__
(+
) و __iadd__
(+=
)
كلاهما +
و +=
يتم تعريف المشغلين ل list
. فهي تشبه بشكل دلالي التمديد.
my_list + another_list
ينشئ قائمة ثالثة في الذاكرة ، حتى تتمكن من إرجاع النتيجة ، ولكنه يتطلب أن يكون القائمة الثانية.
my_list += another_list
يعدل القائمة في مكانها ( هو المشغل الداخلي ، والقوائم هي كائنات قابلة للتغيير ، كما رأينا) لذلك لا ينشئ قائمة جديدة. كما أنه يعمل مثل التمديد ، حيث يمكن أن يكون الثاني الجدير بالحيوية.
لا تشعر بالارتباك - my_list = my_list + another_list
لا يعادل +=
- يمنحك قائمة جديدة مخصصة لـ My_List.
تعقيد الوقت
إلحاق تعقيد الوقت المستمر, ، س (1).
تمديد لديه تعقيد الوقت ، o (k).
التكرار من خلال المكالمات المتعددة إلى append
يضيف إلى التعقيد ، مما يجعله يعادل تمديده ، وبما أن تكرار Extens يتم تنفيذه في 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
معالجة تعليق على التوقيت
قال أحد المعلقين:
إجابة مثالية ، أفتقد توقيت مقارنة عنصر واحد فقط
افعل الشيء الصحيح بشكل دلالي. إذا كنت ترغب في إلحاق جميع العناصر في حالة جيدة ، استخدم 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
, عندما تنوي إلحاق كل عنصر في القائمة.
إذا كان لديك عنصر واحد فقط (وليس في أمر غير قابل للإعجاب) لإضافته إلى القائمة ، فاستخدم 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']
من الغوص في بيثون.
يمكنك استخدام "+" لإرجاع التمديد ، بدلاً من التمدد في مكانه.
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
هو عند استخدامه في نطاقات الوظائف ، انظر منشور المدونة هذا.
إلحاق مقابل تمديد
مع إلحاق ، يمكنك إلحاق عنصر واحد من شأنه تمديد القائمة:
>>> 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]
إضافة المزيد من العناصر ... مع نتائج مختلفة
إذا كنت تستخدم أكثر من عنصر واحد ، فيجب عليك تمرير قائمة من العناصر كوسيطات وستحصل على قائمة متداخلة!
>>> 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()
يمكن استخدامها مع حجة Iterator. هنا مثال. ترغب في إعداد قائمة من قائمة القوائم بهذه الطريقة:
من
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()
يمكن استخدامها مع حجة Iterator:
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 لإضافة عنصر واحد.
مثال 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 () ، لدمج قائمتين أو إدراج عناصر متعددة في قائمة واحدة.
مثال 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 تشبه "."
يضيف إلحاق البيانات بأكملها مرة واحدة. سيتم إضافة البيانات بأكملها إلى الفهرس الذي تم إنشاؤه حديثًا. من ناحية أخرى، 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
:
- يقبل أي متوقعة كحجة لها ويجعل القائمة أكبر.
- القائمة الناتجة هي دائمًا قائمة أبعاد واحدة (أي عدم تعشيش) وقد تحتوي على عناصر غير متجانسة فيها (على سبيل المثال الأحرف ، الأعداد الصحيحة ، تعويم) نتيجة للتطبيق
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
الطريقة غير مناسبة: في أ 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" "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,
يعد الإلحاق والتمديد أحد آليات التوسيع في Python.
إلحاق: يضيف عنصرًا إلى نهاية القائمة.
my_list = [1,2,3,4]
لإضافة عنصر جديد إلى القائمة ، يمكننا استخدام طريقة إلحاق بالطريقة التالية.
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]) ، بدلاً من العنصر. للانضمام إلى قائمتين ، سيتعين علينا استخدام الملحق.
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]