SIMPLE 2D LUDO GAME IN PYTHON

بادئ ذي بدء ، ما هي بايثون؟ وفقًا لمنشئها ، Guido van Rossum ، فإن Python هي:

"لغة البرمجة عالية المستوى ، وفلسفتها الأساسية في التصميم تدور حول قابلية قراءة الكود والبنية التي تسمح للمبرمجين بالتعبير عن المفاهيم في بضعة أسطر من التعليمات البرمجية."

بالنسبة لي ، السبب الأول لتعلم Python هو أنها ، في الواقع ، لغة برمجة جميلة . كان من الطبيعي حقًا ترميزها والتعبير عن أفكاري.

سبب آخر هو أنه يمكننا استخدام الترميز في Python بطرق متعددة: علم البيانات ، وتطوير الويب ، والتعلم الآلي ، كل ذلك يتألق هنا. يستخدم كل من Quora و Pinterest و Spotify لغة Python لتطوير الويب الخلفي. لذلك دعونا نتعلم قليلا عن ذلك.

أساسيات

1. المتغيرات

يمكنك التفكير في المتغيرات على أنها كلمات تخزن قيمة. سهل هكذا.

في Python ، من السهل حقًا تحديد متغير وتعيين قيمة له. تخيل أنك تريد تخزين الرقم 1 في متغير يسمى "واحد". دعنا نقوم به:

one = 1

ما مدى بساطة ذلك؟ لقد عيّنت للتو القيمة 1 للمتغير "واحد".

two = 2
some_number = 10000

ويمكنك تعيين أي قيمة أخرى لأي متغيرات أخرى تريدها. كما ترى في الجدول أعلاه ، يخزن المتغير " two " العدد الصحيح 2 ، بينما يخزن " some_number " 10000 .

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

# booleans
true_boolean = True
false_boolean = False

# string
my_name = "Leandro Tk"

# float
book_price = 15.80

2. تدفق التحكم: عبارات شرطية

" إذا " يستخدم تعبير لتقييم ما إذا كان البيان هو صحيح أم خطأ. إذا كان صحيحًا ، فإنه ينفذ ما يوجد داخل عبارة "if". على سبيل المثال:

if True:
  print("Hello Python If")

if 2 > 1:
  print("2 is greater than 1")

2 أكبر من 1 ، لذلك يتم تنفيذ كود " الطباعة ".

و" آخر سيتم تنفيذ بيان" إذا " إذا " التعبير كاذبة .

if 1 > 2:
  print("1 is greater than 2")
else:
  print("1 is not greater than 2")

1 ليس أكبر من 2 ، لذلك سيتم تنفيذ الكود الموجود داخل عبارة " else ".

يمكنك أيضًا استخدام عبارة " elif ":

if 1 > 2:
  print("1 is greater than 2")
elif 2 > 1:
  print("1 is not greater than 2")
else:
  print("1 is equal to 2")

3. التكرار الحلقي / التكرار

في بايثون ، يمكننا التكرار بأشكال مختلفة. سأتحدث عن اثنين: بينما ومن أجل .

أثناء Looping: بينما تكون العبارة صحيحة ، سيتم تنفيذ الكود داخل الكتلة. لذلك ، سوف يقوم هذا الرمز بطباعة الرقم من 1 إلى 10 .

num = 1

while num <= 10:
    print(num)
    num += 1

في حين حلقة يحتاج إلى " شرط حلقة. "إذا ظل صحيحًا ، فسيستمر في التكرار. في هذا المثال، عندما numهو 11في حالة حلقة متساوين False.

جزء أساسي آخر من الكود لفهمه بشكل أفضل:

loop_condition = True

while loop_condition:
    print("Loop Condition keeps: %s" %(loop_condition))
    loop_condition = False

في حالة حلقة هي Trueذلك فإنه يحتفظ بالتكرار - حتى وضعناها ل False.

بالنسبة إلى Looping : يمكنك تطبيق المتغير " num " على الكتلة ، وستقوم عبارة " for " بتكرارها نيابةً عنك. وهذا الرمز طباعة نفس الوقت كود: من 1 إلى 10 .

for i in range(1, 11):
  print(i)

نرى؟ انها بسيطة جدا. يبدأ النطاق بـ 1ويستمر حتى 11العنصر التاسع ( 10هو 10العنصر التاسع).

القائمة: مجموعة | صفيف | هيكل البيانات

تخيل أنك تريد تخزين العدد الصحيح 1 في متغير. ولكن ربما تريد الآن تخزين 2. و 3 ، 4 ، 5 ...

هل لدي طريقة أخرى لتخزين جميع الأعداد الصحيحة التي أريدها ، ولكن ليس بملايين المتغيرات ؟ لقد خمنت ذلك - هناك بالفعل طريقة أخرى لتخزينها.

Listهي مجموعة يمكن استخدامها لتخزين قائمة من القيم (مثل هذه الأعداد الصحيحة التي تريدها). فلنستخدمه:

my_integers = [1, 2, 3, 4, 5]

انها حقا بسيطة. أنشأنا مصفوفة وقمنا بتخزينها في my_integer .

لكن ربما تسأل: "كيف يمكنني الحصول على قيمة من هذه المجموعة؟"

سؤال رائع. Listلديه مفهوم يسمى الفهرس . يحصل العنصر الأول على الفهرس 0 (صفر). الثاني يحصل على 1 ، وهكذا. انت وجدت الفكرة.

لتوضيح الأمر ، يمكننا تمثيل المصفوفة وكل عنصر بفهرسها. يمكنني رسمها:

باستخدام صيغة Python ، من السهل أيضًا فهم:

my_integers = [5, 7, 1, 3, 4]
print(my_integers[0]) # 5
print(my_integers[1]) # 7
print(my_integers[4]) # 4

تخيل أنك لا تريد تخزين أعداد صحيحة. أنت فقط تريد تخزين الخيوط ، مثل قائمة بأسماء أقاربك. سيبدو لي شيئًا مثل هذا:

relatives_names = [
  "Toshiaki",
  "Juliana",
  "Yuji",
  "Bruno",
  "Kaio"
]

print(relatives_names[4]) # Kaio

يعمل بنفس طريقة الأعداد الصحيحة. لطيف.

لقد تعلمنا للتو كيف Listsتعمل المؤشرات. لكن ما زلت بحاجة إلى أن أوضح لك كيف يمكننا إضافة عنصر إلى Listبنية البيانات (عنصر إلى قائمة).

الطريقة الأكثر شيوعًا لإضافة قيمة جديدة إلى a Listهي append. دعونا نرى كيف يعمل:

bookshelf = []
bookshelf.append("The Effective Engineer")
bookshelf.append("The 4 Hour Work Week")
print(bookshelf[0]) # The Effective Engineer
print(bookshelf[1]) # The 4 Hour Work Week

appendبسيط للغاية. تحتاج فقط إلى تطبيق العنصر (على سبيل المثال ، " المهندس الفعال ") appendكمعامل.

حسنًا ، يكفي Lists. دعنا نتحدث عن هيكل بيانات آخر.

القاموس: بنية بيانات القيمة الأساسية

الآن نحن نعلم أنه Listsمفهرس بأرقام صحيحة. ولكن ماذا لو لم نرغب في استخدام الأعداد الصحيحة كمؤشرات؟ بعض هياكل البيانات التي يمكننا استخدامها هي مؤشرات رقمية أو سلسلة أو أنواع أخرى من الفهارس.

دعنا نتعرف على Dictionaryبنية البيانات. Dictionaryعبارة عن مجموعة من أزواج مفتاح القيمة. هذا ما يبدو عليه:

dictionary_example = {
  "key1": "value1",
  "key2": "value2",
  "key3": "value3"
}

و المفتاح هو مؤشر لافتا إلى قيمة . كيف نصل إلى Dictionary القيمة ؟ لقد خمنت ذلك - باستخدام المفتاح . فلنجربها:

dictionary_tk = {
  "name": "Leandro",
  "nickname": "Tk",
  "nationality": "Brazilian"
}

print("My name is %s" %(dictionary_tk["name"])) # My name is Leandro
print("But you can call me %s" %(dictionary_tk["nickname"])) # But you can call me Tk
print("And by the way I'm %s" %(dictionary_tk["nationality"])) # And by the way I'm Brazilian

لقد خلقت Dictionaryعني. اسمي والكنية والجنسية. تلك الصفات هي Dictionary المفاتيح .

نظرًا لأننا تعلمنا كيفية الوصول إلى Listالفهرس المستخدم ، فإننا نستخدم أيضًا المؤشرات ( المفاتيح في Dictionaryالسياق) للوصول إلى القيمة المخزنة في ملف Dictionary.

في المثال ، قمت بطباعة عبارة عني باستخدام جميع القيم المخزنة في ملف Dictionary. بسيط جدا ، أليس كذلك؟

شيء رائع آخر Dictionaryهو أنه يمكننا استخدام أي شيء كقيمة. في ما Dictionary قمت بإنشائه ، أريد إضافة مفتاح "العمر" والعمر الحقيقي الخاص بي فيه:

dictionary_tk = {
  "name": "Leandro",
  "nickname": "Tk",
  "nationality": "Brazilian",
  "age": 24
}

print("My name is %s" %(dictionary_tk["name"])) # My name is Leandro
print("But you can call me %s" %(dictionary_tk["nickname"])) # But you can call me Tk
print("And by the way I'm %i and %s" %(dictionary_tk["age"], dictionary_tk["nationality"])) # And by the way I'm Brazilian

هنا لدينا زوج مفتاح (عمر) بقيمة (24) باستخدام سلسلة كمفتاح وعدد صحيح كقيمة .

كما فعلنا مع Lists، دعنا نتعلم كيفية إضافة عناصر إلى ملف Dictionary. و المفتاح لافتا إلى القيمة هو جزء كبير من ما Dictionaryهو. هذا صحيح أيضًا عندما نتحدث عن إضافة عناصر إليه:

dictionary_tk = {
  "name": "Leandro",
  "nickname": "Tk",
  "nationality": "Brazilian"
}

dictionary_tk['age'] = 24

print(dictionary_tk) # {'nationality': 'Brazilian', 'age': 24, 'nickname': 'Tk', 'name': 'Leandro'}

نحن بحاجة فقط لتعيين القيمة إلى Dictionary مفتاح . لا شيء معقد هنا ، أليس كذلك؟

التكرار: التكرار من خلال هياكل البيانات

كما تعلمنا في أساسيات Python ، فإن Listالتكرار بسيط للغاية. نحن Python المطورون عادة نستخدم Forالحلقات. دعنا نقوم به:

bookshelf = [
  "The Effective Engineer",
  "The 4-hour Workweek",
  "Zero to One",
  "Lean Startup",
  "Hooked"
]

for book in bookshelf:
    print(book)

لذلك لكل كتاب في رف الكتب ، ( يمكننا فعل كل شيء به ) طباعته. بسيطة جدا وبديهية. هذه بايثون.

بالنسبة لهيكل بيانات التجزئة ، يمكننا أيضًا استخدام forالحلقة ، لكننا نطبق key:

dictionary = { "some_key": "some_value" }

for key in dictionary:
    print("%s --> %s" %(key, dictionary[key]))
    
# some_key --> some_value

هذا مثال على كيفية استخدامه. لكل keyفي dictionary، ونحن printفي keyوفي المقابلة value.

طريقة أخرى للقيام بذلك هي استخدام iteritemsالطريقة.

dictionary = { "some_key": "some_value" }

for key, value in dictionary.items():
    print("%s --> %s" %(key, value))

# some_key --> some_value

لقد قمنا بتسمية المعلمتين كـ keyو value، لكنها ليست ضرورية. يمكننا تسمية أي شيء لهم. لنرى ذلك:

dictionary_tk = {
  "name": "Leandro",
  "nickname": "Tk",
  "nationality": "Brazilian",
  "age": 24
}

for attribute, value in dictionary_tk.items():
    print("My %s is %s" %(attribute, value))
    
# My name is Leandro
# My nickname is Tk
# My nationality is Brazilian
# My age is 24

يمكننا أن نرى أننا استخدمنا السمة كمعامل لـ Dictionary key، وهي تعمل بشكل صحيح. رائعة!

فئات وكائنات

القليل من النظرية:

الكائنات هي تمثيل لأشياء من العالم الحقيقي مثل السيارات أو الكلاب أو الدراجات. الكائنات تتقاسم اثنين من الخصائص الرئيسية: بيانات و السلوك .

تحتوي السيارات على بيانات ، مثل عدد العجلات وعدد الأبواب وسعة المقاعد ، كما أنها تظهر سلوكًا : يمكنها التسريع والتوقف وإظهار كمية الوقود المتبقية وأشياء أخرى كثيرة.

نحدد البيانات كما سمات و السلوك كما طرق في البرمجة كائنية التوجه. تكرارا:

البيانات ← السمات والسلوك ← الأساليب

و الفئة هو مخطط من خلالها يتم إنشاء كائنات فردية. في العالم الحقيقي ، غالبًا ما نجد العديد من الكائنات من نفس النوع. مثل السيارات. جميعها من نفس الطراز والطراز (وجميعها مزودة بمحرك وعجلات وأبواب وما إلى ذلك). تم بناء كل سيارة من نفس مجموعة المخططات ولها نفس المكونات.

وضع برمجة Python Object-Oriented: تشغيل

بيثون، ولغة البرمجة الشيئية، لديها هذه المفاهيم: الطبقة و جوه .

الفئة عبارة عن مخطط ونموذج لأجسامها.

ذلك مرة أخرى، فئة انها مجرد نموذج، أو وسيلة لتحديد سمات و السلوك (كما تحدثنا عنها في القسم نظرية). على سبيل المثال ، فئة السيارة لها سماتها الخاصة التي تحدد الأشياء التي هي مركبات. عدد العجلات ونوع الخزان وسعة الجلوس والسرعة القصوى كلها من سمات السيارة.

مع وضع هذا في الاعتبار ، دعنا نلقي نظرة على بناء جملة Python للفئات :

class Vehicle:
    pass

نحن نحدد الفئات ببيان فئة - وهذا كل شيء. سهل أليس كذلك؟

الكائنات هي حالات من فئة . نقوم بإنشاء مثيل عن طريق تسمية الفئة.

car = Vehicle()
print(car) # <__main__.Vehicle instance at 0x7fb1de6c2638>

هنا carهو كائن (أو مثيل) من الطبقة Vehicle .

تذكر أن فئة المركبات لدينا لها أربع سمات : عدد العجلات ، ونوع الخزان ، وسعة الجلوس ، والسرعة القصوى. نضع كل هذه السمات عند إنشاء كائن السيارة . لذلك هنا ، نحدد الفصل الخاص بنا لتلقي البيانات عندما يبدأها:

class Vehicle:
    def __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):
        self.number_of_wheels = number_of_wheels
        self.type_of_tank = type_of_tank
        self.seating_capacity = seating_capacity
        self.maximum_velocity = maximum_velocity

نحن نستخدم init الطريقة . نسميها طريقة المنشئ. لذلك عندما نقوم بإنشاء كائن السيارة ، يمكننا تحديد هذه السمات . تخيل أننا نحب Tesla Model S ، ونريد إنشاء هذا النوع من الأشياء . لها أربع عجلات ، تعمل بالطاقة الكهربائية ، وتتسع لخمسة مقاعد ، وأقصى سرعة لها 250 كم / ساعة (155 ميلاً في الساعة). لنقم بإنشاء هذا الكائن:

tesla_model_s = Vehicle(4, 'electric', 5, 250)

أربع عجلات كهربائية + نوع الخزان + خمسة مقاعد + سرعة قصوى 250 كم / ساعة.

يتم تعيين جميع السمات. لكن كيف يمكننا الوصول إلى قيم هذه السمات؟ نحن نرسل رسالة إلى كائن يسأل عنهم . نحن نسميها طريقة . إنه سلوك الكائن . دعونا ننفذها:

class Vehicle:
    def __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):
        self.number_of_wheels = number_of_wheels
        self.type_of_tank = type_of_tank
        self.seating_capacity = seating_capacity
        self.maximum_velocity = maximum_velocity

    def number_of_wheels(self):
        return self.number_of_wheels

    def set_number_of_wheels(self, number):
        self.number_of_wheels = number

هذا تنفيذ من طريقتين: number_of_wheels و set_number_of_wheels . نسميها getter& setter. لأن الأول يحصل على قيمة السمة ، والثاني يعيّن قيمة جديدة للسمة.

في Python ، يمكننا القيام بذلك باستخدام @property( decorators) لتعريف gettersو setters. دعنا نراها مع الكود:

class Vehicle:
    def __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):
        self.number_of_wheels = number_of_wheels
        self.type_of_tank = type_of_tank
        self.seating_capacity = seating_capacity
        self.maximum_velocity = maximum_velocity
    
    @property
    def number_of_wheels(self):
        return self.__number_of_wheels
    
    @number_of_wheels.setter
    def number_of_wheels(self, number):
        self.__number_of_wheels = number

ويمكننا استخدام هذه الطرق كسمات:

tesla_model_s = Vehicle(4, 'electric', 5, 250)
print(tesla_model_s.number_of_wheels) # 4
tesla_model_s.number_of_wheels = 2 # setting number of wheels to 2
print(tesla_model_s.number_of_wheels) # 2

هذا يختلف قليلاً عن طرق التعريف. الأساليب تعمل كسمات. على سبيل المثال ، عندما نقوم بتعيين العدد الجديد للعجلات ، فإننا لا نطبق اثنتين كمعامل ، لكننا نعين القيمة 2 على number_of_wheels. هذا هو الطريق الوحيد لكتابة pythonic getterو setterالتعليمات البرمجية.

ولكن يمكننا أيضًا استخدام طرق لأشياء أخرى ، مثل طريقة " make_noise ". لنرى ذلك:

class Vehicle:
    def __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):
        self.number_of_wheels = number_of_wheels
        self.type_of_tank = type_of_tank
        self.seating_capacity = seating_capacity
        self.maximum_velocity = maximum_velocity

    def make_noise(self):
        print('VRUUUUUUUM')

عندما نسمي هذه الطريقة ، فإنها ترجع فقط سلسلة نصية " VRRRRUUUM. "

tesla_model_s = Vehicle(4, 'electric', 5, 250)
tesla_model_s.make_noise() # VRUUUUUUUM

التغليف: إخفاء المعلومات

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

"يمكن استخدام التغليف لإخفاء أعضاء البيانات ووظائف الأعضاء. بموجب هذا التعريف ، يعني التغليف أن التمثيل الداخلي للكائن يكون مخفيًا بشكل عام عن الأنظار خارج تعريف الكائن ". - ويكيبيديا

كل التمثيل الداخلي للكائن مخفي من الخارج. يمكن للكائن فقط التفاعل مع بياناته الداخلية.

أولا، نحن بحاجة إلى فهم كيفية publicو non-publicالمثال المتغيرات والعمل الأساليب.

متغيرات المثيل العام

بالنسبة لفئة Python ، يمكننا تهيئة a public instance variableداخل طريقة الباني. دعونا نرى هذا:

ضمن طريقة الباني:

class Person:
    def __init__(self, first_name):
        self.first_name = first_name

هنا نطبق first_nameالقيمة كوسيطة على public instance variable.

tk = Person('TK')
print(tk.first_name) # => TK

داخل الفصل:

class Person:
    first_name = 'TK'

هنا ، لا نحتاج إلى تطبيق first_nameالوسيطة ، وسيتم class attributeتهيئة جميع كائنات المثيل بـ TK.

tk = Person()
print(tk.first_name) # => TK

رائع. لقد تعلمنا الآن أنه يمكننا استخدام public instance variablesو class attributes. شيء آخر مثير للاهتمام حول publicالجزء هو أنه يمكننا إدارة القيمة المتغيرة. ماذا أعني بذلك؟ لدينا objectيمكن أن تدير قيمة المتغير لها: Getو Setالقيم المتغيرة.

مع وضع Personالفئة في الاعتبار ، نريد تعيين قيمة أخرى first_nameلمتغيرها:

tk = Person('TK')
tk.first_name = 'Kaio'
print(tk.first_name) # => Kaio

هناك نذهب. لقد قمنا فقط بتعيين قيمة أخرى ( kaio) first_nameلمتغير الحالة وقمنا بتحديث القيمة. سهل هكذا. نظرًا لأنه publicمتغير ، يمكننا فعل ذلك.

متغير المثيل غير العام

نحن لا نستخدم مصطلح "خاص" هنا ، حيث لا توجد سمة خاصة حقًا في Python (بدون قدر غير ضروري من العمل بشكل عام). - PEP 8

كما هو public instance variable، يمكننا تحديد non-public instance variableكلاهما داخل طريقة الباني أو داخل الفصل. الاختلاف في بناء الجملة هو: من أجل non-public instance variables، استخدم شرطة سفلية ( _) قبل variableالاسم.

متغيرات الحالة "الخاصة" التي لا يمكن الوصول إليها إلا من داخل كائن لا توجد في Python. ومع ذلك ، هناك اصطلاح يتبعه معظم كود Python: _spamيجب معاملة الاسم المسبق بشرطة سفلية (على سبيل المثال ) على أنه جزء غير عام من واجهة برمجة التطبيقات (سواء كانت وظيفة أو طريقة أو عضو بيانات) " - مؤسسة برمجيات بايثون

هذا مثال:

class Person:
    def __init__(self, first_name, email):
        self.first_name = first_name
        self._email = email

هل رأيت emailالمتغير؟ هذه هي الطريقة التي نحدد بها non-public variable:

tk = Person('TK', 'tk@mail.com')
print(tk._email) # tk@mail.com

يمكننا الوصول إليه وتحديثه. Non-public variablesهي مجرد اتفاقية ويجب التعامل معها على أنها جزء غير عام من واجهة برمجة التطبيقات.

لذلك نستخدم طريقة تتيح لنا القيام بذلك داخل تعريف الصنف. دعنا ننفذ طريقتين ( emailو update_email) لفهمها:

class Person:
    def __init__(self, first_name, email):
        self.first_name = first_name
        self._email = email

    def update_email(self, new_email):
        self._email = new_email

    def email(self):
        return self._email

الآن يمكننا التحديث والوصول non-public variablesباستخدام هذه الأساليب. لنرى:

tk = Person('TK', 'tk@mail.com')
print(tk.email()) # => tk@mail.com
# tk._email = 'new_tk@mail.com' -- treat as a non-public part of the class API
print(tk.email()) # => tk@mail.com
tk.update_email('new_tk@mail.com')
print(tk.email()) # => new_tk@mail.com

1. بدأنا كائنًا جديدًا مع first_nameTK و emailtk@mail.com
2. قم بطباعة البريد الإلكتروني عن طريق الوصول إلى non-public variableطريقة
3. حاولت وضع جديد emailمن صفنا
4. نحن بحاجة إلى علاج non-public variableكما non-publicجزء من API
5. تحديث non-public variableمع طريقة المثيل لدينا
6. نجاح! يمكننا تحديثه داخل الفصل الدراسي باستخدام الطريقة المساعدة

الطريقة العامة

مع public methods، يمكننا أيضًا استخدامها خارج صفنا:

class Person:
    def __init__(self, first_name, age):
        self.first_name = first_name
        self._age = age

    def show_age(self):
        return self._age

دعونا نختبرها:

tk = Person('TK', 25)
print(tk.show_age()) # => 25

رائع - يمكننا استخدامه دون أي مشكلة.

الطريقة غير العامة

لكن مع non-public methodsأننا لسنا قادرين على القيام بذلك. دعنا ننفذ نفس Personالفئة ، ولكن الآن show_age non-public methodباستخدام شرطة سفلية ( _).

class Person:
    def __init__(self, first_name, age):
        self.first_name = first_name
        self._age = age

    def _show_age(self):
        return self._age

والآن ، سنحاول استدعاء هذا non-public methodالكائن:

tk = Person('TK', 25)
print(tk._show_age()) # => 25

يمكننا الوصول إليه وتحديثه. Non-public methodsهي مجرد اتفاقية ويجب التعامل معها على أنها جزء غير عام من واجهة برمجة التطبيقات.

إليك مثال عن كيفية استخدامها:

class Person:
    def __init__(self, first_name, age):
        self.first_name = first_name
        self._age = age

    def show_age(self):
        return self._get_age()

    def _get_age(self):
        return self._age

tk = Person('TK', 25)
print(tk.show_age()) # => 25

هنا لدينا أ _get_age non-public methodو show_age public method. و show_ageيمكن استخدامها من قبل هدفنا (من طبقتنا) و _get_ageتستخدم فقط داخل تعريف الفئة لدينا (داخل show_ageطريقة). لكن مرة أخرى: كمسألة اتفاقية.

ملخص التغليف

من خلال التغليف يمكننا التأكد من إخفاء التمثيل الداخلي للكائن من الخارج.

الميراث: السلوكيات والخصائص

تشترك أشياء معينة في بعض الأشياء: سلوكها وخصائصها.

على سبيل المثال ، ورثت بعض الصفات والسلوكيات من والدي. ورثت عينيه وشعره كصفات ، ونفاد صبره وانطوائه سلوكيات.

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

دعونا نرى مثالًا آخر ونطبقه في بايثون.

تخيل سيارة. عدد العجلات وسعة الجلوس والسرعة القصوى كلها سمات للسيارة. يمكننا القول أن فئة ElectricCar ترث نفس السمات من فئة السيارة العادية .

class Car:
    def __init__(self, number_of_wheels, seating_capacity, maximum_velocity):
        self.number_of_wheels = number_of_wheels
        self.seating_capacity = seating_capacity
        self.maximum_velocity = maximum_velocity

لدينا سيارة الفئة المنفذة:

my_car = Car(4, 5, 250)
print(my_car.number_of_wheels)
print(my_car.seating_capacity)
print(my_car.maximum_velocity)

بمجرد البدء ، يمكننا استخدام كل ما instance variablesتم إنشاؤه. لطيف.

في بيثون، ونحن نطبق parent classل child classكمعلمة. و ElectricCar الطبقة يمكن أن ترث من وجهة نظرنا سيارة الفئة.

class ElectricCar(Car):
    def __init__(self, number_of_wheels, seating_capacity, maximum_velocity):
        Car.__init__(self, number_of_wheels, seating_capacity, maximum_velocity)

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

my_electric_car = ElectricCar(4, 5, 250)
print(my_electric_car.number_of_wheels) # => 4
print(my_electric_car.seating_capacity) # => 5
print(my_electric_car.maximum_velocity) # => 250

جميل.

هذا هو!

لقد تعلمنا الكثير من الأشياء عن أساسيات بايثون:

• كيف تعمل متغيرات بايثون
• كيف تعمل جمل بايثون الشرطية
• كيف تعمل حلقات Python (while & for)
• كيفية استخدام القوائم: المجموعة | مجموعة مصفوفة
• مجموعة قيمة مفتاح القاموس
• كيف يمكننا التكرار من خلال هياكل البيانات هذه
• الكائنات والفئات
• الصفات كبيانات الكائنات
• الأساليب كسلوك الكائنات
• استخدام أدوات جمع وضبط بايثون ومصمم الممتلكات
• التغليف: إخفاء المعلومات
• الميراث: السلوكيات والخصائص

***********************

***********************