index - write a python program to select an item randomly from a list.




الفرق بين إلحاق مقابل طرق القائمة تمديد في بيثون (16)

إلحاق مقابل تمديد

مع إلحاقك ، يمكنك إلحاق عنصر واحد من شأنه توسيع القائمة:

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

إضافة المزيد من العناصر ... بنتائج مختلفة

إذا كنت تستخدم إلحاق أكثر من عنصر واحد ، فيجب عليك تمرير قائمة بالعناصر كوسيطة وستحصل على قائمة NESTED!

>>> 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() extend() ؟


ما هو الفرق بين طرق القائمة إلحاق وتمديد؟

  • تضيف 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 قائمة بإلحاق عناصر من iterable:

my_list.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 بإنشاء قائمة ثالثة في الذاكرة ، حتى تتمكن من إرجاع النتيجة ، ولكنها تتطلب أن تكون القائمة الثانية قابلة للتكرار.

my_list += another_list بتعديل القائمة في المكان (فهي عامل التشغيل في الموقع ، والقوائم هي كائنات قابلة للتغيير ، كما رأينا) لذلك لا تقوم بإنشاء قائمة جديدة. كما أنه يعمل مثل الامتداد ، حيث يمكن أن يكون التكرار الثاني أي نوع من التكرار.

لا تربك - my_list = my_list + another_list لا يساوي += - فهو يمنحك قائمة جديدة تمامًا يتم تعيينها إلى my_list.

تعقيد الوقت

الإلحاق له تعقيد زمني ثابت ، O (1).

تمديد لديه تعقيد الوقت ، O (ك).

ويضيف التكرار من خلال المكالمات المتعددة append إلى التعقيد ، مما يجعله مكافئًا لمدى التوسيع ، وبما أن تكرار التكرار يتم تنفيذه في 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 .


إلحاق قاموس إلى آخر:

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

إلحاق وتمديد واحدة من آليات القابلية للتوسعة في بيثون.

إلحاق: يضيف عنصرًا إلى نهاية القائمة.

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]

النقطة المثيرة للاهتمام التي تم التلميح إليها ، ولكن لم يتم شرحها ، هي أن التمديد أسرع من الإلحاق. يجب اعتبار أي حلقة ملحقة بالداخل محلها list.extend (process_elements).

ضع في اعتبارك أن إدراج عناصر جديدة قد يؤدي إلى إعادة تخصيص القائمة بأكملها إلى موقع أفضل في الذاكرة. إذا تم ذلك عدة مرات لأننا نقوم بإلحاق عنصر واحد في كل مرة ، فإن الأداء الكلي سيعاني. في هذا المعنى ، list.extend يماثل "" .join (stringlist).


تضيف إضافة عنصر إلى قائمة ، وتوسيط القائمة الأولى مع قائمة أخرى (أو أخرى قابلة للتكرار ، وليس بالضرورة قائمة.)

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

من الغوص في بايثون .


ساعدني ذلك في فهم ما يحدث حقاً عند استخدامك append :

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]

سيضيف أسلوب اللاحقة () الوسيطة التي تم تمريرها إليه كعنصر واحد.

وسيركّد امتداد () على الحجج التي تم تمريرها ويمدّ القائمة بتمرير كل العناصر المتكرّرة ، بشكل أساسي سيضيف عناصر متعددة لا تضيف كاملًا كواحد.

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]

هذا هو ما يعادل append باستخدام المشغل + :

>>> 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 كـ:

إلحاق : إضافة (شيء) إلى نهاية مستند مكتوب.
تمديد : جعل أكبر. تكبير أو توسيع

بهذه المعرفة ، دعونا نفهم الآن

1) الفرق بين append extend

append :

  • يلحق أي كائن بايثون كما هو في نهاية القائمة (أي كآخر عنصر في القائمة).
  • قد تكون قائمة النتائج متداخلة وتحتوي على عناصر غير متجانسة (مثل قائمة ، سلسلة ، مجموعة حروف ، قاموس ، مجموعة ، إلخ.)

extend :

  • يقبل أي تكراري كوسيطة ويجعل القائمة أكبر .
  • وتكون القائمة الناتجة دائمًا قائمة أحادية البعد (أي بدون تداخل) وقد تحتوي على عناصر غير متجانسة فيها (على سبيل المثال ، أحرف ، أعداد صحيحة ، طفو) كنتيجة لتطبيق list(iterable) .

2) التشابه بين append extend

  • كلاهما يأخذ حجة واحدة بالضبط.
  • كل من تعديل القائمة في المكان .
  • نتيجة لذلك ، كلاهما إرجاع بلا.

مثال

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)

يضيف إلحاق البيانات بأكملها دفعة واحدة. ستتم إضافة البيانات بأكملها إلى الفهرس الذي تم إنشاؤه حديثًا. من ناحية أخرى ، فإن extend ، كما يوحي اسمه ، يمدد الصفيف الحالي.

فمثلا

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

مع append نحصل:

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

أثناء extend نحصل على:

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

يمتد الامتداد (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]

يمكنك استخدام "+" لعرض توسيع ، بدلا من تمديد في المكان.

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 : إلحاق كائن في النهاية.

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

يمنحك: [1, 2, 3, [4, 5]]

expand: يوسع القائمة عن طريق إلحاق عناصر من iterable.

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

يمنحك: [1, 2, 3, 4, 5]


append "يمتد" القائمة (في المكان) من قبل عنصر واحد فقط ، تم تمرير كائن واحد (كوسيطة).

extend "يمتد" القائمة (في المكان) بواسطة العديد من العناصر كما يحتوي على الكائن الذي تم تمريره (كوسيطة).

قد يكون هذا مربكًا بعض الشيء لكائنات str .

  1. إذا قمت بتمرير سلسلة كوسيطة: سيضيف append عنصرًا مفردًا في النهاية ، ولكن سيضيف extend أكبر عدد من عناصر "single" '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,

append إلحاق عنصر واحد. extend يضيف قائمة من العناصر.

لاحظ أنه في حالة تمرير قائمة لإلحاقها ، فسيظل يضيف عنصرًا واحدًا:

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




extend