in ,

تعلم بايثون من الصفر إلى الاحتراف

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

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

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

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

الأساسيات

1.Variables

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

في 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

3.Control Flow: conditional statements

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

if True:
  print("Hello Python If")

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

2 أكبر من 1 ، لذلك يتم تنفيذ كود “الطباعة”.
سيتم تنفيذ عبارة “else” إذا كان تعبير “if” خطأ.

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 / Iterator

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

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

num = 1

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

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

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

loop_condition = True

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

شرط الحلقة هو صحيح ، لذا فهو يستمر في التكرار – حتى نقوم بتعيينه على خطأ.

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

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

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

List: Collection | Array | Data Structure

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

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

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

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

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

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

سؤال رائع. القائمة لها مفهوم يسمى الفهرس. يحصل العنصر الأول على الفهرس 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

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

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

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

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

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

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

Dictionary: Key-Value Data Structure

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

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

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

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

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_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) باستخدام سلسلة كمفتاح وعدد صحيح كقيمة.

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

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

dictionary_tk['age'] = 24

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

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

Iteration: Looping Through Data Structures

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

bookshelf = [
  "The Effective Engineer",
  "The 4 hours work week",
  "Zero to One",
  "Lean Startup",
  "Hooked"
]

for book in bookshelf:
    print(book)

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

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

dictionary = { "some_key": "some_value" }

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

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

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

dictionary = { "some_key": "some_value" }

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

# some_key --> some_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

يمكننا أن نرى أننا استخدمنا السمة كمعامل لمفتاح القاموس ، وهي تعمل بشكل صحيح. عظيم!

Classes & Objects

A little bit of theory:

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

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

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

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

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

Python Object-Oriented Programming mode: ON

Python ، كلغة برمجة موجهة للكائنات ، لديها هذه المفاهيم: فئة وكائن.

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

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

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

class Vehicle:
    pass

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

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

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

هنا السيارة هي كائن (أو مثيل) من فئة مركبة.

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

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) لتحديد حروف التعيين والضوابط. دعنا نراها مع الكود:

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. هذه طريقة واحدة لكتابة كود جامع ووسيط بيثوني.

ولكن يمكننا أيضًا استخدام طرق لأشياء أخرى ، مثل طريقة “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

Encapsulation: Hiding Information

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

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

ويكيبيديا

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

أولاً ، نحتاج إلى فهم كيفية عمل المتغيرات والطرق العامة وغير العامة.

Public Instance Variables

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

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

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

هنا نطبق قيمة first_name كوسيطة لمتغير المثيل العام.

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

داخل class:

class Person:
    first_name = 'TK'

هنا ، لا نحتاج إلى تطبيق first_name كوسيطة ، وستكون لجميع كائنات المثيل سمة فئة مهيأة باستخدام TK.

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

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

مع وضع فئة الشخص في الاعتبار ، نريد تعيين قيمة أخرى لمتغير الاسم الأول:

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

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

Non-public Instance Variable

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

PEP 8

بصفتنا متغير المثيل العام ، يمكننا تحديد متغير المثيل غير العام داخل طريقة المُنشئ أو داخل الفئة. الاختلاف في بناء الجملة هو: بالنسبة لمتغيرات المثيل غير العامة ، استخدم شرطة سفلية (_) قبل اسم المتغير.

هذا مثال:

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

هل رأيت متغير البريد الإلكتروني؟ هذه هي الطريقة التي نحدد بها المتغير غير العام:

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

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

لذلك نستخدم طريقة تتيح لنا القيام بذلك داخل تعريف الصنف. دعنا ننفذ طريقتين (البريد الإلكتروني و 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

الآن يمكننا تحديث المتغيرات غير العامة والوصول إليها باستخدام هذه الطرق. دعنا نرى:

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
  • بدأنا كائنًا جديدًا باسم first_name TK والبريد الإلكتروني tk@mail.com
  • طباعة البريد الإلكتروني عن طريق الوصول إلى المتغير غير العام بطريقة
  • حاولت تعيين بريد إلكتروني جديد من صفنا
  • نحن بحاجة إلى التعامل مع المتغير غير العام باعتباره جزءًا غير عام من واجهة برمجة التطبيقات
  • تم تحديث المتغير غير العام بطريقة المثيل الخاصة بنا
  • نجاح! يمكننا تحديثه داخل الفصل الدراسي باستخدام الطريقة المساعدة

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

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

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

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

Non-public Method

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

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

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

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

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 غير عامة وطريقة show_age العامة. يمكن استخدام show_age بواسطة كائننا (خارج الفصل الدراسي) ويتم استخدام _get_age فقط داخل تعريف الفصل الخاص بنا (داخل طريقة show_age). لكن مرة أخرى: كمسألة اتفاقية.

Encapsulation Summary

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

Inheritance: behaviors and characteristics

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

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

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

تخيل سيارة. عدد العجلات وسعة الجلوس والسرعة القصوى كلها سمات للسيارة. يمكننا القول أن فئة 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)

بمجرد البدء ، يمكننا استخدام جميع متغيرات الحالة التي تم إنشاؤها.

في Python ، نطبق فئة أصل على فئة الطفل كمعامل. يمكن لفئة 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

رااااااائع

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

كل التوفيق للجميع