راهنمای رابط ها در پایتون

معرفی

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

با وجود این، پایتون ابزارهای قدرتمندی را برای تقلید از رفتار رابط‌ها در اختیار ما قرار می‌دهد و تضمین می‌کند که کد ما تا حد امکان تمیز، کارآمد و قابل فهم باقی می‌ماند. این راهنما به بررسی آن ابزارها می پردازد، به ویژه تمرکز روی تایپ اردک و کلاس های پایه چکیده (ABC).

ما با درک این که رابط ها چیست و چرا اهمیت دارند شروع می کنیم. سپس، بررسی خواهیم کرد که چگونه پایتون از اصول Duck Typing و ABC برای شبیه سازی رابط ها استفاده می کند. در ادامه، ما شما را راهنمایی خواهیم کرد روی چگونه از ABC های داخلی پایتون برای تعریف رابط های سفارشی استفاده کنید و حتی در ساخت رابط های شخصی خود با استفاده از ABC های پایتون تحقیق کنید.

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

درک رابط ها: تعاریف و تفاوت ها

قبل از اینکه پایتون چگونه رابط‌ها را مدیریت می‌کند، بیایید ابتدا درک کاملی از اینکه رابط‌ها چیست و چرا در برنامه‌نویسی حیاتی هستند، ایجاد کنیم.

در هسته خود، یک رابط، طرحی از یک کلاس است. این قراردادی است که مجموعه ای از متدها را تعریف می کند که یک کلاس باید پیاده سازی کند.

یک رابط مانند توافق بین یک کلاس و دنیای خارج را در نظر بگیرید. هنگامی که یک کلاس یک رابط را پیاده سازی می کند، قول می دهد که رفتار خاصی را ارائه دهد. به عنوان مثال، اگر یک رابط به نام داشته باشیم Sortable، هر کلاسی که این رابط را پیاده سازی می کند قول ارائه یک روش مرتب سازی را می دهد. با این حال، این روش می تواند به روش های مختلف پیاده سازی شود، تا زمانی که وعده ارائه یک قابلیت مرتب سازی حفظ شود.

در زبان های تایپ ایستا مانند جاوا یا سی شارپ، رابط ها یک بلوک ساختمانی اساسی هستند. آنها به حفظ سطح بالایی از سازماندهی، خوانایی و مقیاس پذیری در پایگاه های کد بزرگ با اطمینان از اینکه کلاس های خاصی به رفتارهای خاص پایبند هستند کمک می کنند. با این حال، درک این نکته مهم است که خود اینترفیس ها حاوی جزئیات پیاده سازی نیستند. آنها صرفاً روش هایی را تعریف می کنند که باید اجرا شوند.

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

پایتون به جای اعمال تعاریف روش در زمان کامپایل (همانطور که در زبان های تایپ ایستا انجام می شود) تمرکز می کند. روی رفتار شی در زمان اجرا این رویکرد در محاوره به عنوان “اگر شبیه یک اردک به نظر می رسد، مانند یک اردک شنا می کند، و مانند یک اردک شنا می کند، پس احتمالا یک اردک است” یا، به طور خلاصه، تایپ اردک شناخته می شود.

علاوه بر این، پایتون کلاس‌های پایه انتزاعی را ارائه می‌کند، که شکلی از ارائه رفتار رابط‌مانند، با قابلیت اضافه‌شده برای اعمال تعاریف متدهای خاص در کلاس‌های فرعی است.

در بخش‌های بعدی، روش استفاده Python از Duck Typing و Abstract Base Classs را برای ارائه عملکردی شبیه به رابط آشنا خواهیم کرد. ما این مفاهیم را با جزئیات بررسی خواهیم کرد و نشان خواهیم داد که چگونه به انعطاف پذیری و قدرت پایتون کمک می کنند.

قدرت رابط ها در برنامه نویسی پایتون

اگرچه پایتون به طور واضح از رابط ها مانند برخی از زبان های دیگر پشتیبانی نمی کند، اما نقشی اساسی در ساختار و سازماندهی موثر برنامه های پایتون ایفا می کند. در اینجا، رابط‌ها صرفاً یک ساختار زبان نیستند، بلکه یک اصل طراحی هستند که به بهبود خوانایی کد، قابلیت نگهداری، قابلیت استفاده مجدد و آزمایش کمک می‌کنند.

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

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

رابط ها نیز فوق العاده هستند مفید در تست. هنگام نوشتن تست های واحد، اغلب لازم است که اشیاء واقعی را با اشیاء ساختگی جایگزین کنید. اگر این اشیا به یک رابط بچسبند، process ایجاد اشیاء ساختگی بسیار ساده تر و کمتر مستعد خطا می شود. با اجرای قرارداد رفتارها، رابط‌ها استدلال در مورد سیستم مورد آزمایش را آسان‌تر می‌کنند و احتمال منفی یا مثبت کاذب را در مجموعه آزمایشی شما کاهش می‌دهند.

در پایتون، این مزایا از طریق دو اصل اصلی تحقق می یابد – تایپ اردک و کلاس های پایه چکیده (ABCs). هر دوی این مکانیسم ها به ما امکان دستیابی را می دهند رفتار رابط مانند، هر کدام نقاط قوت و کاربرد منحصر به فرد خود را دارند.

رویکرد پایتون: رابط‌ها، تایپ اردک، و کلاس‌های پایه انتزاعی

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

در پایتون، این امر عمدتاً از طریق اصول به دست می آید تایپ اردک و کلاس های پایه چکیده (ABC).

در پایتون، این رفتار شی است که واقعاً مهم است، نه نوع یا کلاس آن. این مفهوم، به نام تایپ اردک، نام خود را از این ضرب المثل گرفته است: “اگر شبیه یک اردک است، مانند یک اردک شنا می کند، و مانند یک اردک کوک می کند، پس احتمالا یک اردک است.”

این چه ارتباطی با رابط ها دارد؟ خوب، در حالی که پایتون اعلان‌های واسط صریح ندارد، هر شیئی که مجموعه‌ای از روش‌ها را پیاده‌سازی می‌کند، می‌تواند به عنوان پیاده‌سازی یک “رابط” خاص تلقی شود. این انعطاف‌پذیری به ما اجازه می‌دهد تا اشیایی را ایجاد کنیم که می‌توانند به جای یکدیگر مورد استفاده قرار گیرند، تا زمانی که آنها به یک رفتار پایبند باشند، یعنی روش‌های یکسانی را اجرا کنند.

هر شیئی که مجموعه خاصی از روش ها را پیاده سازی می کند، می تواند به عنوان پیاده سازی یک “رابط” خاص تلقی شود.

در حالی که Duck Typing ارائه می دهد روش ضمنی برای تقلید پایتون یک رفتار شبیه به رابط را نیز ارائه می دهد راه صریح از طریق کلاس های پایه چکیده. ABC کلاسی است که شامل یک یا چند کلاس است روش های انتزاعی.

یک روش انتزاعی روشی است که در ABC اعلام شده است اما هیچ پیاده سازی ندارد. به طور کلی انتظار می رود که زیر کلاس های ABC یک پیاده سازی برای این روش ها ارائه دهند.

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

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

رمزگشایی از تایپ اردک در پایتون

مفهومی از تایپ اردک برای انعطاف پذیری و قدرت پایتون مفید است. Duck Typing یک اصل است که می گوید نوع یا کلاس یک شی از روش هایی که تعریف می کند اهمیت کمتری دارد. وقتی از یک شی استفاده می کنید، شما به آنچه که شی می تواند انجام دهد، علاقه مند هستید، نه آنچه که هست.

برای تکرار استعاره پشت نام: “اگر شبیه یک اردک است، مانند یک اردک شنا می کند، و مانند یک اردک شنا می کند، پس احتمالا یک اردک است.”. این بدان معناست که اگر یک شی مانند یک اردک رفتار کند (روش هایی شبیه اردک ارائه می دهد)، پایتون آن را یک اردک در نظر می گیرد و اجازه می دهد تا در هر جایی که یک اردک انتظار می رود از آن استفاده شود.

بیایید این موضوع را با یک مثال ساده توضیح دهیم:

class Duck:
    def quack(self):
        print("Quack!")

class Person:
    def quack(self):
        print("I'm quacking like a duck!")

def make_it_quack(creature):
    creature.quack()

duck = Duck()
person = Person()

make_it_quack(duck)  
make_it_quack(person)  

این make_it_quack() تابع انتظار دارد که آرگومان خود a داشته باشد quack روش. مهم نیست که استدلال الف باشد Duck یا الف Person یا هر کلاس دیگری – تا زمانی که بتواند لات، قابل قبول است این اردک تایپ در عمل است!

Duck Typing روش ضمنی پایتون برای ارائه رفتار رابط مانند است. ما نیازی به تعریف صریح یک رابط یا استفاده از کلمات کلیدی مانند “Implements” نداریم. اگر یک شی متدهای لازم را ارائه دهد (به واسط پایبند باشد)، می توان آن را به جای هر شی دیگری که همان روش ها را ارائه می دهد استفاده کرد.

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

کلاس های پایه چکیده (ABC) روشی صریح برای تعریف رابط ها در پایتون ارائه می دهد. آنها به عنوان یک طرح اولیه برای کلاس های دیگر عمل می کنند و می توانند یک API مشترک برای کلاس های مشتق شده آن، مشابه رابط های زبان های دیگر، تعریف کنند.

یک ABC می‌تواند روش‌ها و ویژگی‌هایی را تعریف کند که باید توسط هر کلاس مشخص (به عنوان مثال، غیرانتزاعی) که از ABC به ارث می‌برند، پیاده‌سازی شوند. در پایتون، یک روش انتزاعی متدی است که در ABC اعلام شده است، اما شامل هیچ پیاده سازی نمی شود. انتظار می رود که زیر کلاس های این ABC یک پیاده سازی برای این روش ارائه دهند:

from abc import ABC, abstractmethod


class AbstractBird(ABC):
    @abstractmethod
    def fly(self):
        pass


class Sparrow(AbstractBird):
    def fly(self):
        print("Sparrow flying")


class Ostrich(AbstractBird):
    def fly(self):
        print("Ostrich trying to fly")

sparrow = Sparrow()
ostrich = Ostrich()

sparrow.fly()  
ostrich.fly()  

در این مثال، AbstractBird یک کلاس پایه Abstract است که یک متد انتزاعی را تعریف می کند fly. Sparrow و Ostrich کلاس های مشخصی هستند که از آنها به ارث می برند AbstractBird و پیاده سازی را برای fly روش.

در حالی که Duck Typing یک روش ضمنی تر برای برخورد با رابط ها در پایتون است، ABC ها یک راه صریح را ارائه می دهند. ABC ها به ما اجازه می دهند که متدهای خاصی را در یک زیر کلاس پیاده سازی کنیم. این می‌تواند به شناسایی خطاها در مراحل اولیه کمک کند، خوانایی کد را افزایش دهد و یک قرارداد واضح برای آنچه یک کلاس باید پیاده‌سازی کند فراهم کند.

با وجود تفاوت‌هایشان، کلاس‌های Duck Typing و Abstract Base راهی برای تعریف رابط‌ها در پایتون در اختیار ما قرار می‌دهند.

استفاده از کلاس های پایه انتزاعی داخلی پایتون

پایتون چندین کلاس پایه انتزاعی (ABC) داخلی را در این برنامه ارائه می کند collections.abc ماژولی که می تواند به عنوان رابط های مفید برای بسیاری از ساختارهای داده رایج عمل کند. آنها نمایانگر رابط های کلیدی در پایتون هستند، مانند Iterable، Iterator، Sequence، MutableSequence، و خیلی بیشتر.

این ABC های داخلی راهی آسان برای اطمینان از اینکه کلاس های سفارشی شما به رفتارهای مورد انتظار انواع داخلی پایتون پایبند هستند، ارائه می دهند. بیایید به چند نمونه نگاهی بیندازیم!

مثال 1: تکرار پذیر رابط

در این مثال، ما را ایجاد خواهیم کرد Fibonacci کلاسی که داخلی را پیاده سازی می کند Iterable رابط، بنابراین می توان از آن در یک استفاده کرد for حلقه:

from collections.abc import Iterable


class Fibonacci(Iterable):
    def __init__(self, stop):
        self.stop = stop
        self.a = 0
        self.b = 1

    def __iter__(self):
        return self

    def __next__(self):
        if self.a > self.stop:
            raise StopIteration
        value_to_return = self.a
        self.a, self.b = self.b, self.a + self.b
        return value_to_return


fib = Fibonacci(10)
for num in fib:
    print(num)

که به ما می دهد:

0
1
1
2
3
5
8

مثال 2: توالی رابط

اگر بخواهیم اجرا کنیم Sequence رابط با کلاس خود، ما باید پیاده سازی برای را فراهم کنیم __len__ و __getitem__ مواد و روش ها. این به ما امکان می دهد از داخلی استفاده کنیم len عملگر تابع و شاخص روی نمونه هایی از کلاس تازه ایجاد شده ما. بگویید ما می خواهیم ایجاد کنیم Range کلاس به عنوان یک پیاده سازی از Sequence رابط:

from collections.abc import Sequence


class Range(Sequence):
    def __init__(self, start, end):
        self.start = start
        self.end = end
        self.values = list(range(start, end))

    def __len__(self):
        return self.end - self.start

    def __getitem__(self, index):
        return self.values(index)


r = Range(1, 10)
print(len(r))  
print(r(5))  

با استفاده از این ABC های داخلی از collections.abc می تواند به کلاس های پایتون سفارشی شما ظاهر و احساس انواع داخلی را بدهد. این نه تنها استفاده از کلاس‌های شما را آسان‌تر می‌کند، بلکه کمک می‌کند تا اطمینان حاصل شود که در زمینه‌های مختلف همانطور که انتظار می‌رود رفتار می‌کنند. با این حال، گاهی اوقات باید رابط های خود را تعریف کنید، جایی که ABC های سفارشی وارد می شوند، همانطور که در بخش بعدی بررسی خواهیم کرد.

ایجاد رابط های سفارشی با ABC های پایتون

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

پایتون به ما قدرت ایجاد می دهد ABC های سفارشی که مجموعه منحصر به فرد خود از روش های انتزاعی را تعریف می کنند.

بیایید مثالی را در نظر بگیریم که در آن می خواهیم سیستمی از حیوانات ایجاد کنیم و هر حیوان می تواند صدای منحصر به فردی تولید کند. می توانیم یک روش انتزاعی تعریف کنیم make_sound در ما Animal ABC و مستلزم آن است که هر کلاس حیوانی پیاده سازی خود را از این روش ارائه دهد:

from abc import ABC, abstractmethod


class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        return "Woof!"

class Cat(Animal):
    def make_sound(self):
        return "Meow!"

dog = Dog()
cat = Cat()

print(dog.make_sound())  
print(cat.make_sound())  

در مثال بالا، Animal ABC سفارشی است که تعریف می کند make_sound روش انتزاعی Dog و Cat کلاس های مشخصی هستند که از آنها به ارث می برند Animal و پیاده سازی برای make_sound. به همین سادگی!

پیاده سازی چند شکلی با رابط های پایتون

پلی مورفیسمیک مفهوم کلیدی در برنامه نویسی شی گرا، یک رابط واحد را قادر می سازد تا انواع مختلف اشیاء را نشان دهد. این به ما امکان می دهد کدهای عمومی و انعطاف پذیرتری بنویسیم.

رابط‌ها، چه از طریق Duck Typing یا ABC پیاده‌سازی شوند، نقشی اساسی در دستیابی به چندشکلی در پایتون دارند.

شرایطی را در نظر بگیرید که در آن ما یک برنامه کاربردی داریم که از چندین پایگاه داده پشتیبانی می کند. هر نوع پایگاه داده (به عنوان مثال، MySQL، PostgreSQL، SQLite) می تواند یک رابط را پیاده سازی کند (به عنوان مثال، connect، disconnect، query). سپس برنامه می‌تواند با هر نوع پایگاه داده از طریق این رابط مشترک، بدون نیاز به دانستن نوع پایگاه داده خاصی که با آن تعامل دارد، تعامل داشته باشد. این چند شکلی در عمل است!

در اینجا یک مثال ساده از روش پیاده سازی این مورد با استفاده از ABC آورده شده است:

from abc import ABC, abstractmethod


class Database(ABC):
    @abstractmethod
    def connect(self):
        pass

    @abstractmethod
    def disconnect(self):
        pass

    @abstractmethod
    def query(self, sql):
        pass


class MySQL(Database):
    def connect(self):
        return "MySQL connection established"

    def disconnect(self):
        return "MySQL connection closed"

    def query(self, sql):
        return f"Running '{sql}' روی MySQL"


class PostgreSQL(Database):
    def connect(self):
        return "PostgreSQL connection established"

    def disconnect(self):
        return "PostgreSQL connection closed"

    def query(self, sql):
        return f"Running '{sql}' روی PostgreSQL"

def database_operations(database, sql):
    print(database.connect())
    print(database.query(sql))
    print(database.disconnect())

mysql = MySQL()
postgresql = PostgreSQL()

database_operations(mysql, "SELECT * FROM users")
database_operations(postgresql, "SELECT * FROM products")

اجرای این کد منجر به موارد زیر می شود:

MySQL connection established
Running 'SELECT * FROM users' روی MySQL
MySQL connection closed

PostgreSQL connection established
Running 'SELECT * FROM products' روی PostgreSQL
PostgreSQL connection closed

اینجا Database یک ABC است که یک رابط مشترک برای کلاس های مختلف پایگاه داده تعریف می کند. هر دو MySQL و PostgreSQL این رابط را پیاده سازی کنید، به این معنی که آنها می توانند به جای یکدیگر در آن استفاده شوند database_operations تابع. این تابع یک نمونه ای از پلی مورفیسم – می تواند عملیات را انجام دهد روی هر شی که اجرا می کند Database رابط، بدون نیاز به دانستن نوع خاصی از پایگاه داده که با آن تعامل دارد.

بهبود تست با رابط ها در پایتون

رابط ها در پایتون نقش مهمی در نوشتن کدهای قابل آزمایش دارند. آنها به ما اجازه می دهند با استفاده از تست های انعطاف پذیر بنویسیم اشیاء مسخره که به همان رابطی که اشیایی که در حال جایگزینی هستند می چسبند. این امر به ویژه زمانی مفید است که استفاده از اشیاء واقعی در آزمایش ها به دلیل عواملی مانند الزامات تنظیم پیچیده یا عملکرد کند دشوار باشد.

سیستمی را در نظر بگیرید که متکی است روی یک پایگاه داده برای آزمایش این سیستم، ما می توانیم یک MockDatabase کلاسی که رابط کاربری واقعی ما را پیاده سازی می کند Database کلاس این MockDatabase به جای اتصال به یک پایگاه داده واقعی، داده های رمزگذاری شده را برمی گرداند و تست ها را سریع تر و آسان تر تنظیم می کند:

class MockDatabase(Database):
    def connect(self):
        return "Mock connection established"

    def disconnect(self):
        return "Mock connection closed"

    def query(self, sql):
        return f"Running '{sql}' روی mock database, returning hard-coded data"


mock_database = MockDatabase()
database_operations(mock_database, "SELECT * FROM users")

این MockDatabase کلاس همان متدهای را ارائه می دهد Database ABC، به این معنی که می توان آن را در هر کدی که انتظار دارد a استفاده کرد Database هدف – شی. تست‌ها می‌توانند بدون پایگاه داده واقعی اجرا شوند و نوشتن آن‌ها را آسان‌تر و اجرا را سریع‌تر می‌کند.

این هست فقط یک مثال این که چگونه رابط ها می توانند تست را در پایتون بهبود بخشند. با طراحی سیستم خود پیرامون رابط ها، می توانید کد خود را ماژولارتر، انعطاف پذیرتر و قابل آزمایش تر کنید. این کمک می کند تا اطمینان حاصل شود که هر قسمت از سیستم شما می تواند به طور مستقل آزمایش شود، که منجر به کد قابل اعتمادتر و قابل نگهداری می شود.

استفاده از رابط پایتون: نکات و ترفندها

در حالی که رویکرد پایتون به رابط‌ها انعطاف‌پذیری زیادی را فراهم می‌کند، پیروی از بهترین روش‌ها و آگاهی از مشکلات احتمالی مهم است. بیایید چند نکته کلیدی را که باید هنگام کار با رابط‌ها در پایتون در نظر داشته باشید مرور می‌کنیم.

1. از رابط ها برای تعریف نقش ها استفاده کنید نه پیاده سازی ها
   • رابط ها باید تمرکز کنند روی آنچه که یک کلاس باید انجام دهد، نه چگونه آن را انجام می دهد. این کار کپسوله سازی را تشویق می کند و کد شما را انعطاف پذیرتر می کند.
2. به اصل جایگزینی لیسکوف (LSP) پایبند باشید
   • LSP، یک اصل کلیدی در طراحی شی گرا، بیان می کند که اگر برنامه ای از یک کلاس پایه استفاده می کند، باید بتواند از هر یک از زیر کلاس های خود بدون اطلاع برنامه استفاده کند. به عبارت دیگر، یک زیر کلاس باید بتواند هر کاری را که سوپرکلاسش می تواند انجام دهد.
3. در صورت امکان از ارث بردن چندگانه خودداری کنید
   • پایتون به یک کلاس اجازه می دهد تا از چندین سوپرکلاس به ارث ببرد، اما این اغلب می تواند منجر به کدهای پیچیده و سخت شود. به طور کلی، ترکیب را بر ارث، به ویژه ارث چندگانه ترجیح دهید.
4. از رابط ها بیش از حد استفاده نکنید
   • در حالی که رابط‌ها می‌توانند ابزار قدرتمندی باشند، استفاده بیش از حد از آن‌ها می‌تواند به کدهای بیش از حد مهندسی شده و بیش از حد پیچیده منجر شود. همیشه قبل از ایجاد یک اینترفیس سوال کنید که آیا یک رابط مورد نیاز است یا خیر.
5. سعی کنید زیاد تکیه نکنید روی تایپ اردک
   • در حالی که Duck Typing انعطاف‌پذیری زیادی را فراهم می‌کند، اما اگر یک شی تمام روش‌هایی را که انتظار می‌رود پیاده‌سازی نکند، می‌تواند منجر به خطاهای سخت در زمان اجرا شود. استفاده از کلاس های پایه انتزاعی را برای سیستم های بزرگتر یا کدهای مهم در نظر بگیرید که این خطاها می توانند تأثیر قابل توجهی داشته باشند.
6. اصل مسئولیت واحد (SRP) را نقض نکنید
   • یک رابط باید تنها یک مسئولیت داشته باشد. اگر متوجه شدید که یک رابط دارای چندین مسئولیت است، معمولاً بهتر است آن را به چندین رابط کوچکتر تقسیم کنید.

نتیجه

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

پایتون یک رویکرد منعطف و عملی برای رابط‌ها اتخاذ می‌کند، و هم رابط‌های صریح از طریق کلاس‌های پایه انتزاعی و هم رابط‌های ضمنی از طریق Duck Typing را در بر می‌گیرد. این انعطاف‌پذیری به شما اجازه می‌دهد تا ابزار مناسب را برای نیازهای خاص خود انتخاب کنید، تشویق شیوه های برنامه نویسی موثر بدون تحمیل قوانین سفت و سخت.

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