متد append پایتون

در پایتون، افزودن «آیتم‌ها» به لیست، کاری رایج است؛ بنابراین این زبان برای کمک به شما، مجموعه‌ای از متدها و فانکشن‌ها را در اختیارتان قرار می‌دهد. یکی از این متدها ".append ()" است. با ".append ()"، می توانید آیتم‌ها را به انتهای یک شی لیست اضافه کنید. همچنین می‌توانید جهت پر کردن لیست‌ها به شکل برنامه‌ریزی شده، در حلقه "for" از ".append ()" استفاده کنید.

 #  اضافه کردن آیتم به لیست با متد append در پایتون

متد ".append()" در پایتون، شیئ را به عنوان متغیر گرفته و آن را به انتهای لیستی از پیش ساخته شده، اضافه می‌کند؛ درست بعد از آخرین عنصر لیست:

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

هر موقع .append() را برای یک لیست فراخوانی کنید، این متد آیتم جدید را به انتهای، سمت راست، لیست اضافه می‌کند. شکل زیر فرآیند را در قالب تصویر نشان می‌دهد:

لیست‌ها در پایتون، در انتهای خود فضایی اضافه جهت آیتم‌های جدید رزرو می‌کنند. فراخوانی .append() منجر به اضافه شدن آیتم جدید در انتهای فضای موجود می‌گردد.

در عمل می‌توانید با استفاده از .append()، هر نوع شئ را به لیست مورد نظرتان اضافه کنید:

>>> mixed = [1, 2]

>>> mixed.append(3)
>>> mixed
[1, 2, 3]

>>> mixed.append("four")
>>> mixed
[1, 2, 3, 'four']

>>> mixed.append(5.0)
>>> mixed
[1, 2, 3, 'four', 5.0]

لیست‌ها دنباله‌هایی هستند که می‌توانند انواع مختلف داده‌ها و اشیا پایتون را در خود جای دهند، بنابراین می‌توانید از (.append) جهت اضافه کردن هر شی به لیست دلخواه خود استفاده کنید. در این مثال، ابتدا عددی صحیح، سپس یک رشته و در آخر عددی اعشاری اضافه می‌کنید. با این حال، می‌توانید لیستی دیگر، دیکشنری، تاپِل، شی تعریف شده توسط کاربر، و غیره را نیز اضافه کنید.

استفاده از .append() معادل عملیات زیر است:

>>> numbers = [1, 2, 3]

>>> # Equivalent to numbers.append(4)
>>> numbers[len(numbers):] = [4]
>>> numbers
[1, 2, 3, 4]

در خط سوم، همزمان دو عملیات را انجام می‌دهید:

۱. با استفاده از این عبارت، می‌توانید برشی از اعداد را داشته باشید: numbers[len(numbers):].

۲. می‌توانید به آن بُرش، یک iterable تخصیص دهید.

عملیات برش، فضای بعد از آخرین آیتم را در اعداد می‌گیرد. در همین حال عمل جایگزینی، آیتم‌های موجود در لیست را در سمت راست اپراتور جایگزینی باز کرده و به اعداد اضافه می‌کند. با این وجود، تفاوت مهمی بین استفاده از این نوع جایگزینی و استفاده از روش .append () وجود دارد. با عملیات جایگزینی، می‌توانید همزمان چندین آیتم را به انتهای لیست خود اضافه کنید:

>>> numbers = [1, 2, 3]

>>> numbers[len(numbers):] = [4, 5, 6]
>>> numbers
[1, 2, 3, 4, 5, 6]

در این مثال، خط دوم کد، برشی از انتهای اعداد گرفته، آیتم‌های موجود در لیست را از سمت راست باز کرده و آن‌ها را به عنوان آیتم‌های جداگانه به برش اولیه اضافه می‌کند.

ویدیو مرتبط: آموزش متدهای مربوط به لیست‌ها در پایتون

 +  دستور .append() فقط یک آیتم را اضافه می‌کند

با .append ()، می‌توانید یک عدد، لیست، تاپل، دیکشنری، شئ تعریف شده توسط کاربر یا هر شی دیگری را به لیست موجود اضافه کنید. با این حال، باید به خاطر داشته باشید که .append () هر بار فقط یک آیتم یا یک شی را اضافه می‌کند:

>>> x = [1, 2, 3, 4]
>>> y = (5, 6)

>>> x.append(y)
>>> x
[1, 2, 3, 4, (5, 6)]

آنچه در اینجا اتفاق می‌افتد این است که .append () شئ تاپل را به انتهای لیست هدف شما، یعنی "x"، اضافه می‌کند. اگر بخواهید هر آیتم موحود در تاپل "y" را به عنوان موردی جداگانه در انتهای "x" اضافه کنید و لیستی معادل با [1، 2، 3، 4، 5، 6] داشته باشید، چه کار می‌کنید؟ در این صورت می‌توانید از .extend () استفاده کنید:

>>> x = [1, 2, 3, 4]
>>> y = (5, 6, 7)
>>> x.extend(y)
>>> x
[1, 2, 3, 4, 5, 6, 7]

>>> x = [1, 2, 3, 4]
>>> y = (5, 6, 7)
>>> # Equivalent to x.extend(y)
>>> x[len(x):] = y
>>> x
[1, 2, 3, 4, 5, 6, 7]

دستور .extend () یک "iterable" را به عنوان متغیر گرفته، آیتم‌های داخلش را باز کرده و آن‌ها را به انتهای لیست هدف شما اضافه می‌کند. این عملیات معادل "x [len (x)] = y" است که در واقع همان تکنیکی است که در قسمت قبل مشاهده‌اش کردید.

دوره پیشنهادی: دوره آموزش پایتون (python)

 +  دستور .append() مقدار None برمیگرداند

در عمل، .append () کار خود را با اصلاح و رشد لیست اصلی انجام می‌دهد. این بدان معنی است که .append () لیست جدیدی با یک مورد تازه‌ی اضافی در انتهایش را بر نمی‌گرداند. بلکه مقدار "None" را باز می‌گرداند:

>>> x = [1, 2, 3, 4]
>>> y = x.append(5)
>>> y is None
True
>>> x
[1, 2, 3, 4, 5]

مانند روش‌های مشابه دیگر، .append () لیست اصلی را در جای خود تغییر می‌دهد. هنگام یادگیری نحوه عملکرد انواع توالی‌های قابل تغییر، تلاش برای استفاده از مقدار بازگشتی حاصل شده از روشِ .append ()، اشتباهی رایج است. به خاطر داشتن این رفتارِ دستور .append () در جلوگیری از وقوع خطا در کدتان، کمک می‌کند.

ویدیو پیشنهادی: ویدیو انواع None در پایتون

 #  پر کردن لیست از ابتدا

مشکلی رایج که هنگام کار با لیست‌ها در پایتون، ممکن است با آن روبه‌رو شوید این است که چگونه آن‌ها را با چندین آیتم جهت پردازش بیشتر پر کنید. دو راه برای انجام این کار وجود دارد:

1. استفاده از متد .append() و حلقه‌ی "for"

2. استفاده از مفهوم لیست

در چند بخش بعدی، خواهید آموخت که چگونه و چه وقت از این تکنیک‌ها برای ایجاد و پر کردن لیست‌های پایتون از پایه، استفاده کنید.

 +  استفاده از append

یکی از رایج‌ترین استفاده‌های .append()، پرکردن کاملِ لیستی خالی با استفاده از حلقه‌ی for است. در داخل حلقه، می‌توانید داده‌ها را دستکاری کرده و از .append () جهت افزودن نتایج متوالی به لیست استفاده کنید. فرض کنیم نیاز به ایجاد تابعی دارید که دنباله‌ای از اعداد را گرفته و لیستی متشکل از ریشه مربع هر عدد را برگرداند:

>>> import math

>>> def square_root(numbers):
...     result = []
...     for number in numbers:
...         result.append(math.sqrt(number))
...     return result
...

>>> numbers = [1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> square_root(numbers)
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]

در اینجا، شما Square_root را تعریف می‌کنید، که لیستی از اعداد را به عنوان متغیر دریافت می‌کند. داخل ریشه‌ی دوم، لیستی خالی به نام result ایجاد کرده و یک حلقه for را شروع می‌کنید که به تعداد آیتم‌های داخل «لیست اعداد» تکرار می‌شود. در هر تکرار، از math.sqrt () برای محاسبه ریشه مربع عدد فعلی استفاده می‌کنید و سپس از .append () استفاده کرده تا حاصل را به «result» اضافه کنید. پس از اتمام حلقه، لیست حاصل را برمی‌گردانید.

نکته: در مثال بالا، از دستور sqrt موجود در ماژول "math" استفاده می‌کنید. ماژول "math" پایتون در کتابخانه استاندارد وجود دارد و امکان استفاده از عملیات‌های ریاضیاتی را فراهم می‌کند.

این روش پرکردن لیست‌ها در پایتون، نسبتاً رایج است. با این حال، این زبان ساختارهای مناسبی را ارائه می‌دهد که می‌توانند روند کار را بسیار کارآمدتر و "Pythonic" کنند. یکی از این سازه‌ها list comprehension است که در بخش بعدی مشاهده خواهید کرد.

ویدیو پیشنهادی: ویدیو آموزش list comprehension در پایتون

 +  استفاده از list comprehension

در عمل، هنگام ایجاد لیست از ابتدا و پرکردن آن، اغلب .append () را با list comprehension جایگزین می‌کنید. با list comprehension، می‌توانید دستور "square_root ()" را دوباره به این شکل اجرا کنید:

>>> import math

>>> def square_root(numbers):
...     return [math.sqrt(number) for number in numbers]
...

>>> numbers = [1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> square_root(numbers)
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]

list comprehension داخل square_root لیستی ایجاد می‌کند که شامل ریشه مربع عدد برای هر "number" موجود در لیست "numbers" است. این کد تقریباً شبیه انگلیسی روان خوانده می‌شود. همچنین، این پیاده‌سازی جدید از نظر زمان پردازش بسیار کارآمدتر از پیاده‌سازی است که از .append () همراه با حلقه for استفاده می‌کند.

نکته: پایتون انواع دیگری از مفهومات، مانند مفهوم مجموعه، مفهوم دیکشنری و عبارات مولد را نیز ارائه می‌دهد.

مقاله پیشنهادی: importهای مطلق و نسبی در پایتون

 +  بازگشت به append()

گرچه list comprehension می‌تواند برای پرکردن لیست خواناتر و کارآمدتر از متد .append () باشد، اما ممکن است در شرایطی .append () انتخاب بهتری باشد.

فرض کنید جهت ارائه اطلاعات جزئی‌تر در مورد فرآیند محاسبه ریشه مربع لیست ورودی اعداد به کاربران، به "square_root()" نیاز دارید. برای گزارش فرآیند عملیات، می‌توانید از دستور "print ()" استفاده کنید:

>>> import math

>>> def square_root(numbers):
...     result = []
...     n = len(numbers)
...     for i, number in enumerate(numbers):
...         print(f"Processing number: {number}")
...         result.append(math.sqrt(number))
...         print(f"Completed: {int((i + 1) / n * 100)}%")
...     return result
...

>>> numbers = [1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> square_root(numbers)
Processing number: 1
Completed: 11%
...
Processing number: 81
Completed: 100%
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]

حال به این فکر کنید که چگونه می‌توانید بدنه "square_root ()" را به list comprehension تبدیل کنید. استفاده از دستور "print ()" داخل list comprehension به نظر منسجم یا حتی غیرممکن می‌آید مگر اینکه بخشی از کد را در یک تابع "helper" قرار دهید. بنابراین، در این مثال، استفاده از ".append ()" انتخاب صحیحی است.

پندی که در پشت مثال فوق وجود دارد این است که نمی‌توانید در برخی شرایط دستورِ ".append ()" را با list comprehension یا با ساختار دیگری جایگزین کنید.

مقاله پیشنهادی: 10 مشکل امنیتی برای پایتونی‌ها

 #  ایجاد کردن stack و queue با متد append در پایتون

شما تا الآن یاد گرفته‌اید که چگونه از ".append ()" برای افزودن آیتمی به لیست، یا ساخت و پر کردن لیست‌ها از ابتدا، استفاده کنید. اکنون زمان مثالی متفاوت و دقیق‌تر است. در این بخش، یاد خواهید گرفت که چگونه با استفاده از ".append ()" و ".pop ()" در یک لیستِ پایتون، ساختارهای داده stack و queue با حداقل عملکرد مورد نیاز را بسازید.

 +  پیاده سازی stack

پشته یک ساختار داده است که آیتم‌ها را روی هم ذخیره می‌کند. آیتم‌ها به صورت Last In / First Out (LIFO) به پشته وارد و از آن خارج می‌شوند. یک پشته معمولاً دو عملیات اصلی را اجرا می‌کند:

1. یک شئ را به بالا یا انتهای پشته اضافه می‌کند.

2. دستور "pop" آیتم موجود در بالای پشته را برداشته و آن را برمی‌گرداند.

>>> numbers = [1, 2, 3]
>>> numbers.pop(1)
2
>>> numbers
[1, 3]

>>> numbers.pop()
3
>>> numbers
[1]

>>> numbers.pop()
1
>>> numbers
[]

>>> numbers.pop()
Traceback (most recent call last):
  File "<input>", line 1, in <module>
    numbers.pop()
IndexError: pop from empty list

اگر index صحیح را به عنوان متغیر به ".pop ()" بدهید، این متد آیتم موجود در آن شاخص عددی مد نظر شما را از لیست برداشته و آن را برمی‌گرداند. فراخوانی ".pop ()" بدون هیچ متغیری، آخرین آیتمِ لیست را برمی‌گرداند. توجه داشته باشید که ".pop ()" آیتم را از لیست مورد نظر حذف می‌کند. سرانجام، اگر فرمان .pop () را برای لیستی خالی فراخوانی کنید، یک "IndexError" دریافت خواهید کرد.

با چیزهایی که یاد گرفتید، آماده استفاده از پشته با استفاده از ".append () و .pop ()" هستید. در اینجا یک کلاس، پشته را تعریف می‌کند. کلاس عملگر‌های ".push () و .pop ()" را فراهم می‌کند.

class Stack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        try:
            return self._items.pop()
        except IndexError:
            print("Empty stack")

    def __len__(self):
        return len(self._items)

    def __repr__(self):
        return f"Stack({self._items})"

در پشته، ابتدا نماد نمونه‌ی "._items" را مقدار دهی می‌کنید. این نماد لیستی خالی را در خود جای داده که از آن برای ذخیره موارد در پشته، استفاده خواهید کرد. سپس کد .push() را می‌نویسید، که عملیات push را با استفاده از ".append ()" در "._items" پیاده‌سازی می‌کند.

همچنین با فراخوانی ".pop ()" در لیست مذکور، "._items"، عمل "pop" را پیاده‌سازی می‌کنید. در این حالت، از یک بلوک "try & except" برای مدیریت "IndexError"، که هنگام فراخوانیِ ".pop ()" در لیستی خالی رخ می‌دهد، استفاده می‌کنید.

نکته: در پایتون، استفاده از استثناها برای کنترل جریان برنامه، الگویی رایج است. توسعه‌دهندگان پایتون این سبک کدگذاری که به عنوان "EAFP" (درخواست آسان‌تر از اجازه است) شناخته می‌شود را به سبک کدگذاری معروف به "LBYL" (قبل از جهش، بررسی کنید) ترجیح می دهند. "EAFP" می‌تواند در جلوگیری از وقوع شرایط مسابقه‌ای، بهبود عملکرد کلی یک برنامه یا قطعه کد کمکتان کند و از عبور بی‌صدا از کنار خطاها، جلوگیری کند.

متد خاصِ ".__ len __ ()" قابلیت مورد نیاز برای بازیابی طول داخلی آیتم‌های لیست را فراهم می‌کند. متد ویژه‌ی ".__ repr __ ()" به شما امکان می‌دهد در هنگام چاپ ساختار داده روی صفحه، نمایش رشته‌ی کاربرپسندی از پشته ارائه دهید.

در اینجا چند نمونه‌ی عملی از نحوه استفاده از پشته آورده شده‌است:

>>> stack = Stack()

>>> # Push items onto the top of the stack
>>> stack.push(1)
>>> stack.push(2)

>>> # User-friendly printing format
>>> stack
Stack([1, 2])
>>> print(stack)
Stack([1, 2])

>>> # Retrieve the length of the stack
>>> len(stack)
2

>>> # Pop items from the top of the stack
>>> stack.pop()
2
>>> stack.pop()
1
>>> stack.pop()
Empty stack
>>> stack
Stack([])

خودشه! یک ساختار داده پشته را کدگذاری کرده‌اید که عملیات push و pop را اجرا می‌کند. همچنین این کد، عملکردی برای بدست آوردن طول لیست اصلی و چاپ کل پشته به روشی کاربرپسند فراهم می‌کند.

ویدیو مرتبط: ویدیو آموزش ماژول queue در پایتون

 +  پیاده سازی queue

صف‌ها ساختارهای داده‌ای هستند که معمولاً آیتم‌های خود را به روش "First In / First Out (FIFO)" مدیریت می‌کنند. صف‌ها مانند یک لوله کار می کنند که در آن از یک سر موارد جدید را به داخل هول می‌دهید و آیتم‌های قدیمی از انتهای دیگر بیرون می‌زنند.

افزودن یک آیتم به انتهای صف، به عنوان عملیات به صف کردن شناخته شده، و برداشتن یک آیتم از قسمت جلو یا ابتدای صف به عنوان عملیات به صف کردن شناخته می‌شود.

می‌توانید آیتم‌ها را با استفاده از ".append ()" به صف کرده و آن‌ها را با استفاده از ".pop ()" کم کنید. این بار، فقط باید «صفر» را به عنوان متغیر برای ".pop ()" ارائه دهید تا بتواند به جای آخرین مورد، اولین مورد را در لیست بازیابی کند. در اینجا کلاسی وجود دارد که با استفاده از لیستی برای ذخیره آیتم‌های خود، یک ساختار داده صف را پیاده سازی می‌کند:

class Queue:
    def __init__(self):
        self._items = []

    def enqueue(self, item):
        self._items.append(item)

    def dequeue(self):
        try:
            return self._items.pop(0)
        except IndexError:
            print("Empty queue")

    def __len__(self):
        return len(self._items)

    def __repr__(self):
        return f"Queue({self._items})"

این کلاس کاملاً شبیه پشته‌ی شماست. تفاوت اصلی در این است که ".pop ()" مقدار ۰ را به عنوان متغیر برای بازگشت گرفته و اولین مورد در لیست اصلی، ._items، را به جای آخرین مورد حذف می‌کند.

نکته: استفاده از .pop (0) در لیست پایتون کارآمدترین روش استفاده از آیتم‌های لیست نیست. خوشبختانه، ماژول مجموعه‌های پایتون یک ساختار داده به نام "deque ()" را فراهم می‌کند.

در طی این آموزش، بیشتر در مورد استفاده از "deque"ها خواهید آموخت.

بقیه فرآیند پیاده‌سازی تقریباً مشابه است، فقط از نام‌های مناسب مانند ".enqueue ()" برای افزودن موارد و ".dequeue ()" برای حذف آنها استفاده می‌شود. می‌توانید از صف به همان روش بخش پشته، استفاده کنید: برای افزودن آیتم‌ها ".enqueue ()" و برای بازیابی و حذفشان، فقط ".dequeue ()" را فراخوانی کنید.

دوره پیشنهادی: دوره آموزش الگوریتم‌نویسی در پایتون

 #  استفاده متد append در سایر ساختارها

سایر ساختارهای داده‌ی پایتون نیز متد ".append ()" را اجرا می‌کنند. قاعده‌ی کلی عملیات مانند روش‌کارِ متد ".append ()" در لیست است. این متد یک آیتم را به انتهای ساختار داده‌های مورد نظر اضافه می‌کند. با این حال، تفاوت‌های ظریفی وجود دارد.

در دو بخش بعدی، خواهید آموخت که ".append ()" در سایر ساختارهای داده مانند "array.array ()" و "collections.deque ()" چگونه کار می‌کند.

 +  array.append

دستور "array.array ()" پایتون، ساختار داده‌ای توالی‌سان را ارائه داده که می‌تواند به صورت فشرده آرایه‌ای از مقادیر را نشان دهد. این مقادیر باید هم‌نوع باشند که به انواع داده "C-Style"، مانند کاراکترها، اعداد صحیح و اعداد اعشاری، محدود می‌شوند. "array.array ()" دو متغیر زیر را می‌گیرد:

مستند آرایه، اطلاعات کاملی در مورد همه کدهای نوع مجاز را فراهم می‌کند که می‌توانید هنگام ایجاد آرایه‌ها استفاده کنید. مثال زیر از کد نوع "i" برای ایجاد آرایه‌ای از اعداد صحیح استفاده می‌کند: 

>>> from array import array

>>> # Array of integer numbers
>>> int_array = array("i", [1, 2, 3])
>>> int_array
array('i', [1, 2, 3])
>>> int_array[0]
1
>>> int_array[:2]
array('i', [1, 2])
>>> int_array[2] = 4
>>> int_array
array('i', [1, 2, 4])

برای ایجاد یک آرایه، باید کدی تک‌ کاراکتری برای تعریف نوع داده مقادیرِ آرایه را فراهم کنید. همچنین می‌توانید لیستی اختیاری از مقادیر با نوع مناسب، جهت مقداردهی اولیه‌ی آرایه فراهم کنید.

آرایه ها از اکثر عملیات لیست مانند برش و نمایه‌سازی/شاخص‌گذاری پشتیبانی می‌کنند. مانند لیست‌ها، "array.array ()" متدی به نام ".append ()" را نیز ارائه می‌دهد. این متد همانند نمونه‌ی مشابه خود در لیست‌ها کار کرده و مقداری واحد به انتهای آرایه اصلی اضافه می‌کند. با این حال، نوع داده‌ی این مقدار باید با با مقادیر موجود در آرایه سازگار باشد. در غیر این صورت، یک "TypeError" دریافت خواهید کرد.

به عنوان مثال، اگر آرایه‌ای متشکل از اعداد صحیح دارید، نمی‌توانید از ".append ()" جهت افزودن یک عدد اعشاری به آن آرایه استفاده کنید:

>>> from array import array

>>> a = array("i", [1, 2, 3])
>>> a
array('i', [1, 2, 3])

>>> # Add a floating-point number
>>> a.append(1.5)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
    a.append(1.5)
TypeError: integer argument expected, got float

اگر بخواهید عددی اعشاری به "a" اضافه کنید، متد .append () ناموفق بوده و یک TypeError برمی‌گرداند. این اتفاق به این دلیل رخ می‌دهد که پایتون نمی‌تواند بدون از دست دادن اطلاعات، عدد اعشاری را به عددی صحیح تبدیل کند.

در مقابل، اگر آرایه‌ای با اعداد اعشاری داشته باشید و سعی کنید به آن اعداد صحیح اضافه کنید، عملیات شما موفقیت آمیز خواهد بود:

>>> from array import array

>>> float_array = array("f", [1.0, 2.0, 3.0])
>>> float_array
array('f', [1.0, 2.0, 3.0])

>>> # Add and integer number
>>> float_array.append(4)
>>> float_array
array('f', [1.0, 2.0, 3.0, 4.0])

در اینجا، از .append() برای افزودن عدد صحیح به آرایه‌ای از اعداد اعشاری استفاده می‌کنید. این ممکن است زیرا پایتون می‌تواند به طور خودکار اعداد صحیح را به اعداد اعشاری تبدیل کند، بدون اینکه در طول فرآیند اطلاعاتی را از دست بدهد.

ویدیو پیشنهادی: ویدیو آموزش deque در پایتون

 +  deque.append و deque.appendleft

دستور "Collections.deque ()" ساختارداده‌ی دیگری است که گستره‌ای از دستورات ".append ()" را پیاده‌سازی می‌کند. "deque" تعمیم پشته و صف است که بطور ویژه برای پشتیبانی سریع و با حافظه کارآمد از عملیات «ضمیمه» و «پاپ»، به‌شکلی دوطرفه طراحی شده‌است. بنابراین اگر نیاز به ایجاد ساختار داده با این ویژگی‌ها دارید، استفاده از "deque" را به جای لیست مد نظر قرار دهید.

دستور "Collections.deque ()" دو مقدار اختیاری زیر را می‌گیرد:

اگر مقداری برای "maxlen" ارائه دهید، در این صورت صفِ شما فقط آیتم‌هایی با حداکثر طول معادل با "maxlen" را ذخیره می‌کند. هنگامی که صف پر شد، افزودن آیتم جدید به طور خودکار باعث بیرون ریختن آیتم موجود در انتهای مخالف صف می‌شود. از طرف دیگر، اگر مقداری برای maxlen تعیین نکنید، صف می‌تواند به تعداد دلخواه آیتم داشته باشد.

در "deque" نیز دستورِ ".append ()" یک آیتم را به انتها یا سمت راستِ ساختار‌داده‌ی اصلی اضافه می‌کند:

>>> from collections import deque

>>> d = deque([1, "a", 3.0])
>>> d
deque([1, 'a', 3.0])

>>> d.append("b")
>>> d
deque([1, 'a', 3.0, 'b'])

مانند لیست‌ها، "deque"ها می‌توانند انواع مختلفی از آیتم‌ها را در خود جای دهند، بنابراین متد ".append ()" آیتم‌های دلخواه را به انتهای "deque" اضافه می‌کند. به عبارت دیگر، با دستور ".append ()" می‌توانید هر شئ را به "deque" اضافه کنید.

علاوه بر متد فوق؛ "deque"ها همچنین ".appendleft ()" را ارائه می‌دهند که یک آیتم را به ابتدا یا سمت چپ "deque" اضافه می‌کند. به طور مشابه، "deque" دستوراتِ ".pop ()" و ".popleft ()" را به ترتیب برای برداشتن آیتم‌ها از سمت راست و چپِ "deque" فراهم می‌کنند:

>>> from collections import deque

>>> d = deque([1, "a", 3.0])
>>> d.appendleft(-1.0)
>>> d
deque([-1.0, 1, 'a', 3.0])

>>> d.pop()
3.0

>>> d.popleft()
-1.0

>>> d
deque([1, 'a'])

فراخوانیِ ".appendleft ()" یک -۱ به سمت چپ "d" اضافه می‌کند. از طرف دیگر، ".pop ()" آخرین آیتم و ".popleft ()" اولین آیتم در "d" را برگردانده و حذف می‌کند. به عنوان تمرین، می‌توانید با استفاده از "deque" به جای لیست، پشته یا صف خود را پیاده‌سازی کنید. برای این کار می.توانید از نمونه‌هایی که در بخش ایجاد پشته‌ها و صف با استفاده از متد".append ()" پایتون مشاهده کرده‌اید بهره ببرید.

 #  نتیجه گیری

پایتون متد/روشی به نام ".append ()" ارائه می‌دهد که می‌توانید از آن برای افزودن آیتم‌ها به انتهای لیستِ داده‌شده، استفاده کنید. این روش به طور گسترده‌ای برای افزودن یک آیتم به انتهای لیست، یا پرکردن لیست با استفاده از حلقه "for"، استفاده می‌شود. یادگیری نحوه استفاده از ".append ()" به شما کمک می‌کند تا لیست‌ها را در برنامه‌های خود پردازش کنید.