درس ۱۷: شی گرایی (OOP) در پایتون: تعریف کلاس و ایجاد شی¶

سازنده (Constructor)¶

در مبحث شی‌گرایی، هنگام ساخت یک شی (ایجاد یک نمونه جدید)، به صورت خودکار یک متد از داخل کلاس مورد نظر فراخوانی می‌شود. به این متد، سازنده (Constructor) گفته می‌شود. فراخوانی خودکار این متد به برنامه‌نویس این امکان را می‌دهد که در صورت تمایل بتواند چگونگی ایجاد شی جدید را مدیریت یا در همان هنگام ساخت، شخصی‌سازی نماید.

از طرفی هر کلاس در زبان برنامه‌نویسی پایتون شامل یک سری متد خاص می‌باشد که نام تمام آن‌ها با دو کاراکتر خط‌زیرین (Underscore or Underline _) شروع و نیز پایان می‌یابد همانند: __init__ - در کامیونیتی پایتون به دو کاراکتر خط‌زیرین در کنار هم به اصطلاح Dunder (Double underscores) گفته می‌شود - به این متدهای خاص در پایتون به اصطلاح Special Methods ،Dunder Methods یا Magic Methods گفته می‌شود. [اسناد پایتون] باید توجه داشت که تمام این متدها یک پیاده‌سازی پیش‌فرض در پایتون دارند و الزامی برای پیاده‌سازی از طرف برنامه‌نویس وجود ندارد.

در فرآیند نمونه‌سازی از یک کلاس پایتون، به ترتیب دو متد خاص درگیر هستند: __new__ [اسناد پایتون] و __init__ [اسناد پایتون]

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

متد __init__ بلافاصله پس از اینکه شی جدید توسط متد __new__ ایجاد گردید و درست قبل از اینکه شی جدید از متد __new__ بازگردانده شود (returned)، فراخوانی می‌گردد. این متد از نوع Instance Method است - در بخش بعدی شرح داده خواهد شد - و بنابراین نخستین پارامتر این متد شی جاری است (همان شی‌ای که توسط __new__ ایجاد گردیده است) و پارامترهای دیگر که برنامه‌نویس در زمان نمونه‌سازی ��هت مقدار دهی در شی ارسال می‌کند - توجه داشته باشید که این متد خروجی ندارد (بدون دستور return یا بهتر بگوییم خروجی آن None است) و شی جدید حاصل خروجی متد __new__ خواهد بود.

متاسفانه برخی افراد تازه وارد در زبان پایتون و همینطور برخی آموزش‌ها متد __init__ را به عنوان Constructor کلاس‌های پایتون می‌دانند اما درست این است که در فرآیند نمونه‌سازی در زبان برنامه‌نویسی پایتون، دو متد __new__ و __init__ با یکدیگر کار می‌کنند و نقش سازنده (Constructor) را ایفا می‌کنند. متد __new__ شی را ایجاد (create) و متد __init__ آن را شحصی‌سازی (customize) می‌کند:

 1class Sample:
 2
 3    def __new__(cls, *args, **kwargs):
 4        print("__new__(), Has been called")
 5        print('cls: ', cls)
 6        print('args: ', args)
 7        print('kwargs: ', kwargs)
 8
 9        # create new object
10        obj = super().__new__(cls, *args, **kwargs)
11
12        # return object
13        return obj
14
15    def __init__(self, x=0, y=0):
16        print("__init__(), Has been called")
17        print('self: ', self)
18        self.x = x
19        self.y = y
20
21
22sample_1 = Sample()
23print('-' * 30)
24sample_2 = Sample(3, 6)
25print('-' * 30)
26sample_3 = Sample(x=3, y=6)

__new__(), Has been called
cls:  <class '__main__.Sample'>
args:  ()
kwargs:  {}
__init__(), Has been called
self:  <__main__.Sample object at 0x7fb4580a6470>
------------------------------
__new__(), Has been called
cls:  <class '__main__.Sample'>
args:  (3, 6)
kwargs:  {}
__init__(), Has been called
self:  <__main__.Sample object at 0x7fb4580a64e0>
------------------------------
__new__(), Has been called
cls:  <class '__main__.Sample'>
args:  ()
kwargs:  {'x': 3, 'y': 6}
__init__(), Has been called
self:  <__main__.Sample object at 0x7fb005453438>

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

اشیا با قابلیت فراخوانی (Callable Objects)¶

پیش‌تر دیدیم که می‌توان توابع را فراخوانی نمود (درس دروازدهم)، با این کار بدنه تابع اجرا و خروجی متناسب دریافت می‌گردید. در این درس نیز مشاهده کردیم کلاس‌ها نیز در پایتون توانایی فراخوانی دارند که با فراخوانی کلاس، یک شی از آن ایجاد می‌گردد. با استفاده از تابع callable در پایتون می‌توان تشخیص داد که آیا یک شی قابلیت فراخوانی دارد یا خیر [اسناد پایتون]، این تابع در صورتی که شی دریافتی قابلیت فراخوانی (callable) داشته باشد مقدار True و در غیر این صورت False برمی‌گرداند:

>>> def function():
...     pass
...
>>> callable(function)
True

>>> class SampleClass:
...     pass
...
>>> callable(SampleClass)
True

>>> obj = SampleClass()
>>> callable(obj)
False

>>> obj()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'SampleClass' object is not callable

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

همانطور که اشاره شد، کلاس در پایتون چندین متد خاص همانند __new__ و __init__ دارد که به تدریج به آنها آشنا خواهیم شد. یکی دیگر از این متدها __call__ می‌باشد [اسناد پایتون]. این متد نیز همانند متد __init__ از نوع Instance Method (بخش بعدی شرح داده شده است) می‌باشد که با پیاده‌سازی آن در کلاس، اشیای آن کلاس قابلیت فراخوانی پیدا خواهند کرد:

 1class Sample:
 2
 3    def __init__(self, x=0, y=0):
 4        print('------------------- Called __init__()')
 5        self.x = x
 6        self.y = y
 7
 8    def __call__(self, x, y):
 9        print('------------------- Called __call__()')
10        self.x = x
11        self.y = y
12
13
14obj = Sample()
15print('object is callable:', callable(obj))
16print('x =', obj.x)
17
18obj(5, 6)
19print('x =', obj.x)

------------------- Called __init__()
object is callable: True
x = 0
------------------- Called __call__()
x = 5

سطر ۱۸ نمایش فراخوانی یک شی از کلاس Sample می‌باشد - درست به مانند یک تابع!

با فراخوانی یکی شی، به صورت خودکار متد __call__ فراخوانی و آرگومان‌های نظیر ارسال می‌گردند.

از کاربردهای پیاده‌سازی متد __call__ و افزودن قابلیت فراخوانی به یک شی می‌توان به ایجاد کلاس به عنوان دکوراتور (decorator) اشاره کرد (دروس آتی شرح داده خواهد شد) و همچنین کاربردهایی که نیاز می‌شود شی در زمان اجرا initialize یا مقداردهی دوباره داشته باشد، چرا که متد __init__ تنها یکبار در زمان نمونه‌سازی فراخوانی می‌گردد.

Instance Attribute¶

به Attributeهای خاص یک شی گفته می‌شود. به هر شی در زبان برنامه‌نویسی پایتون می‌توان با استفاده از سینتکس زیر یک Attribute انتساب داد:

object.attribute_name = value

1class Sample: pass
2
3sample = Sample()
4
5sample.a_new_attribute = 'A New Attribute!'
6
7print(sample.a_new_attribute)

A New Attribute!

هر چیزی در پایتون یک شی است ولی ممکن است مفسر پایتون برای برخی اشیا محدودیت‌هایی در نظر گرفته باشد و شما نتوانید به هر شی‌ای در پایتون Attribute اضافه نمایید. در این لحظه جا دارد اشاره شود به درس چهاردهم (ب��ش Function Attributes) که در واقع کاری جز افزودن Attribute به شی تابع نبود.

برگردیم به مثال قبل که در آن ما یک کلاس به اسم Sample ایجاد (سطر ۱) و به یک شی از آن - پس از نمونه‌سازی (سطر ۳) - یک Attribute به نام a_new_attribute اضافه کردیم (سطر ۵). این شیوه افزودن Attribute به اشیای کلاس‌هایی که خودمان آن‌ها را تعریف می‌کنیم چندان جالب نیست و ممکن است باعث بروز خطاهایی منطقی در برنامه گردد، بهتر است این کار توسط متد __init__ که در واقع initializer اشیا پایتون است، انجام پذیرد - به نمونه کدهای زیر توجه نمایید:

1class Sample:
2
3        def __init__(self, attribute_value):
4                self.a_new_attribute = attribute_value
5
6sample = Sample()
7
8print(sample.a_new_attribute)

A New Attribute!

 1class Person:
 2
 3        def __init__(self, first_name, last_name, age, gender):
 4                self.first_name = first_name
 5                self.last_name = last_name
 6                self.age = age
 7                self.gender = gender
 8
 9person_1 = Person('Kaneki', 'Ken', 18, 'male')
10person_2 = Person('Haise', 'Sasaki', 19, 'male')
11
12print(person_1.first_name)
13print(person_2.last_name)

Kaneki
Sasaki

در ادامه شرح داده خواهد شد که پارامتر self به شی جاری اشاره دارد و به صورت خودکار توسط مفسر پایتون مقداردهی می‌شود.

Class Attribute¶

به Attributeهای خاص یک کلاس گفته می‌شود و در واقع متغیرهایی است که درون کلاس و خارج از متدها تعریف می‌گردند. کاربرد این Attributeها به اشتراک گذاشتن یک یا چند مقدار یکسان در بین تمام اشیاست.

تمام اشیای یک کلاس به Class Attributeهای آن کلاس دسترسی دارند:

 1class Sample:
 2    class_attribute = 0
 3
 4print('#' * 10, 'STEP#A')
 5print('LINE 05:', Sample.class_attribute)
 6
 7# Instantiation
 8sample_1 = Sample()
 9sample_2 = Sample()
10
11print('#' * 10, 'STEP#B')
12print('LINE 12:', sample_1.class_attribute)
13print('LINE 13:', sample_2.class_attribute)
14
15print('#' * 10, 'STEP#C')
16
17# Change class_attribute for all objects
18Sample.class_attribute = 1
19
20print('LINE 20:', sample_1.class_attribute)  # Changed!
21print('LINE 21:', sample_2.class_attribute)  # Changed!
22
23print('#' * 10, 'STEP#D')
24
25# WARNING!!! Create a new instance attribute
26sample_2.class_attribute = 2
27
28print('LINE 28:', sample_1.class_attribute)
29print('LINE 29:', sample_2.class_attribute)  # instance attribute!!!

########## STEP#A
LINE 05: 0
########## STEP#B
LINE 12: 0
LINE 13: 0
########## STEP#C
LINE 20: 1
LINE 21: 1
########## STEP#D
LINE 28: 1
LINE 29: 2

ClassName.class_attribute = new_value

متد شی (Instance Method)¶

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

این نوع متد همواره می‌بایست حداقل یک پارامتر داشته باشد. پارامتر نخست که معمولا self نام‌گذاری می‌شود حاوی شی جاری از کلاس است - در واقع همان شی ای که این متد را فراخوانی کرده است. این مقدار همواره از سوی مفسر پایتون ارسال می‌گردد و نیازی به ارسال از سوی برنامه‌نویس ندارد:

 1class Sample:
 2
 3    def __init__(self, char='*'):
 4        self.character = char
 5
 6    def multiply_print(self, count=1):
 7        print(self.character * count)
 8
 9
10sample_1 = Sample()  # Instantiating a new Object
11
12sample_1.multiply_print()
13sample_1.multiply_print(10)
14
15print('-' * 30)
16
17sample_2 = Sample('#')  # Instantiating a new Object
18
19sample_2.multiply_print()
20sample_2.multiply_print(10)

*
**********
------------------------------
#
##########

گفته شده که متد __init__ جزیی از مفهوم Constructor کلاس‌های پایتون بوده و برای شخصی‌سازی یک شی در زمان ایجاد آن به کار می‌رود و کاربرد معمول آن افزودن Attribute به شی است. در نمونه کد بالا، این متد یک پارامتر char دریافت می‌کند - این پارامتر مقدار پیش‌فرض * را دارد، بنابراین ارسال آرگومان متناظر برای آن اجباری نیست (تابع در پایتون - درس دوازدهم). با این کار می‌توانیم در زمان نمونه‌سازی شی، یک Attribute با نام character در آن تعریف نماییم (سطر ۴). ما می‌خواهیم مقدار Attribute یا صفت character از هر شی را به تعداد دلخواه چاپ نماییم، از آنجا که این مقدار یک صفتِ متعلق به شی است و در ازای هر شی این مقدار می‌تواند متفاوت باشد پس ما برای این کار می‌بایست که یک Instance Method در بدنه کلاس تعریف کنیم (متد multiply_print ) - چرا که تنها در این صورت است که می‌توانیم به self دسترسی داشته باشیم و مقدار صفت character را از آن دستیابی کنیم.

متد کلاس (Class Method)¶

این نوع متد همواره می‌بایست حداقل یک پارامتر داشته باشد. پارامتر نخست که معمولا cls نام‌گذاری می‌شود حاوی کلاس جاری است - در واقع این متد هیچ اطلاعاتی از اشیا کلاس ندارد و تنها کلاس را می‌شنا��د و Class Attributeها را دستیابی و دستکاری می‌کند. مقدار cls نیز همانند self همواره از سوی مفسر پایتون ارسال می‌گردد و نیازی به ارسال از سوی برنامه‌نویس ندارد. این متد با استفاده از دکوراتور (Decorator‌ - درس سیزدهم) classmethod@ ایجاد می‌شود [اسناد پایتون]:

 1class Student:
 2    school_name = 'My School'
 3
 4    def __init__(self, name, family):
 5        self.name = name
 6        self.family = family
 7
 8    @classmethod
 9    def school_info(cls):
10        print(cls)
11        return f'name: {cls.school_name}'
12
13print(Student.school_info())
14print('-' * 30)
15print(Student('My Name', 'My Family').school_info())

<class '__main__.Student'>
name: My School
------------------------------
<class '__main__.Student'>
name: My School

متد ایستا (Static Method)¶

این نوع متد با استفاده از دکوراتور (Decorator‌ - درس سیزدهم) staticmethod@ ایجاد می‌شود [اسناد پایتون]. این نوع متد پایتون، نه از اشیا اطلاعاتی دارد و نه حتی از کلاس. در واقع به این نوع متد، نه مقدار self ارسال می‌شود و نه cls:

 1class Student:
 2    school_name = 'My School'
 3
 4    def __init__(self, name, family):
 5        self.name = name
 6        self.family = family
 7
 8    @classmethod
 9    def school_info(cls):
10        print(cls)
11        return f'name: {cls.school_name}'
12
13    @staticmethod
14    def info():
15        return "This is a student class"
16
17print(Student.info())
18print('-' * 30)
19print(Student('My Name', 'My Family').info())

This is a student class
------------------------------
This is a student class

شی hashable¶

گفتیم ورودی تابع hash پایتون می‌بایست یک شی hashable باید. کدام اشیا در پایتون hashable هستند؟ تمامی اشیای که از نوع immutable (تغییرناپذیر - مراجعه شود به بخش دسته‌بندی از درس هشتم) هستند و همچنین اشیایی که متد خاص __hash__ [اسناد پایتون] را پیاده‌سازی کرده باشند:

>>> class Sample:
...     pass
...
>>> obj = Sample()
>>> hash(obj)
-9223363243335467036
>>> obj.__hash__()
-9223363243335467036

متد __hash__ جزو متدهای خاص در پایتون می‌باشد و هر کلاسی که در پایتون ایجاد می‌کنید به صورت ضمنی یک پیاده‌سازی پیش‌فرض از این متد را شامل می‌شود.

کاربرد hash در پایتون¶

۱) ساختار Hash table [ویکی‌پدیا]

ساختمان داده دو نوع دیکشنری (dict) و مجموعه (set) در زبان برنامه‌نویسی پایتون بر پایه Hash table ایجاد شده است. در نتیجه سرعت دستیابی عناصر در آن‌ها بسیار بیشتر از دستیابی در شی لیست (List) می‌باشد. در نوع داده دیکشنری، hash کلیدها محاسبه و از آن برای دستیابی مقدار مربوطه استفاده می‌شود، برای همین است که کلیدها در دیکشنری حتما می‌بایست از نوع hashable باشند ولی برای مقادیر هیچ محدودیتی وجود ندارد. نوع داده مجموعه نیز تنها می‌تواند شامل تعدادی شی hashable و یکتا (غیر تکراری) باشد.

۲) مقایسه دو شی

طی دروس آینده با مبحث Operator Overloading آشنا خواهید شد ولی در اینجا تنها کافی است بدانید که هرگاه دو شی توسط عملگر == مقایسه گردند، متد __eq__ [اسناد پایتون] به صورت خودکار فراخوانی خواهد شد. البته این متد نیز مانند باقی متدهای خاص پایتون، به صورت ضمنی یک پیاده‌سازی پیش‌فرض از خود دارد. در واقع خروجی این متد نتیجه مقایسه برابر بودن دو شی را برمی‌گرداند.

بین دو متد __eq__ و __hash__ روابطی حاکم است که باید بدانیم:

• اگر متد __eq__ را پیاده‌سازی کنید ولی متد __hash__ را خیر، آنگاه اشیای کلاس مذکور hashable نخواهند بود.

• اگر متد __hash__ را پیاده‌سازی کرده‌اید، آنگاه بهتر است متد __eq__ را هم پیاده‌سازی نمایید. در غیر این صورت ممکن است در هنگام مقایسه اشیا خود دچار نتایج نامطلوب گردید.

• در حالت پیش‌فرض پایتون، True بودن خروجی متد __eq__ برای دو شی x و y یعنی x == y به معنی برقرار بودن دو شرط:‌ x is y و hash(x) == hash(y) می‌باشد.

• در حالت پیش‌فرض پایتون، تمام اشیای یک کلاس نابرابر و دارای مقدار hash متفاوت هستند، مگر اینکه ملاک مقایسه یک شی، خودش باشد.

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

مقایسه شی در حالت پیش‌فرض:

 1class Student:
 2    def __init__(self, name, score):
 3        self.name = name
 4        self.score = score
 5
 6obj_1 = Student('Saeid', 70)
 7obj_2 = Student('Saeid', 90)
 8
 9print('Single Object     :', obj_1 == obj_1)
10print('Same Objects      :', obj_1 == Student('Saeid', 70))
11print('Different Objects :', obj_1 == obj_2)

Single Object     : True
Same Objects      : False
Different Objects : False

مقایسه شی به همراه شخصی‌سازی دو متد مذکور:

 1class Student:
 2    def __init__(self, name, score):
 3        self.name = name
 4        self.score = score
 5
 6    def __eq__(self, other):
 7        return self.name == other.name and self.score == other.score
 8
 9    def __hash__(self):
10        return hash((self.name, self.score))
11
12obj_1 = Student('Saeid', 70)
13obj_2 = Student('Saeid', 90)
14
15print('Single Object     :', obj_1 == obj_1)
16print('Same Objects      :', obj_1 == Student('Saeid', 70))
17print('Different Objects :', obj_1 == obj_2)

Single Object     : True
Same Objects      : True
Different Objects : False

در این مثال هر دو Attribute کلاس Student از نوع immutable بودند، بنابراین از خود آن‌ها برای مقایسه و محاسبه مقدار hash استفاده کردیم. به هر حال منطق پیاده‌سازی این دو متد بر اساس مسئله مطرح شده، بر عهده برنامه‌نویس می‌باشد. حتی می‌توانید از مقدار تابع ()id یا همان id(self) بهره بگیرید.

😊 امیدوارم مفید بوده باشه