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

بادئ ذي بدء ، ما هي لغة بايثون؟ وفقًا لمنشئها ، Guido van Rossum ، فإن 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مفهرس بأرقام صحيحة. ولكن ماذا لو لم نرغب في استخدام الأعداد الصحيحة كمؤشرات؟ بعض هياكل البيانات التي يمكننا استخدامها هي مؤشرات رقمية أو سلسلة أو أنواع أخرى من الفهارس.

Let’s learn about the Dictionary data structure. Dictionary is a collection of key-value pairs. Here’s what it looks like:

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

The key is the index pointing to thevalue. How do we access the Dictionaryvalue? You guessed it — using the key. Let’s try it:

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

I created a Dictionary about me. My name, nickname, and nationality. Those attributes are the Dictionarykeys.

As we learned how to access the List using index, we also use indices (keys in the Dictionary context) to access the value stored in the Dictionary.

In the example, I printed a phrase about me using all the values stored in the Dictionary. Pretty simple, right?

Another cool thing about Dictionary is that we can use anything as the value. In the DictionaryI created, I want to add the key “age” and my real integer age in it:

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

Here we have a key (age) value (24) pair using string as the key and integer as the value.

As we did with Lists, let’s learn how to add elements to a Dictionary. The keypointing to avalue is a big part of what Dictionary is. This is also true when we are talking about adding elements to it:

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

We just need to assign a value to a Dictionarykey. Nothing complicated here, right?

Iteration: Looping Through Data Structures

As we learned in the Python Basics, the List iteration is very simple. We Pythondevelopers commonly use For looping. Let’s do it:

bookshelf = [ "The Effective Engineer", "The 4-hour Workweek", "Zero to One", "Lean Startup", "Hooked" ] for book in bookshelf: print(book)

So for each book in the bookshelf, we (can do everything with it) print it. Pretty simple and intuitive. That’s Python.

For a hash data structure, we can also use the for loop, but we apply the key :

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

This is an example how to use it. For each key in the dictionary , we print the key and its corresponding value.

Another way to do it is to use the iteritems method.

dictionary = { "some_key": "some_value" } for key, value in dictionary.items(): print("%s --> %s" %(key, value)) # some_key --> some_value

We did name the two parameters as key and value, but it is not necessary. We can name them anything. Let’s see it:

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

We can see we used attribute as a parameter for the Dictionarykey, and it works properly. Great!

Classes & Objects

A little bit of theory:

Objects are a representation of real world objects like cars, dogs, or bikes. The objects share two main characteristics: data and behavior.

Cars have data, like number of wheels, number of doors, and seating capacity They also exhibit behavior: they can accelerate, stop, show how much fuel is left, and so many other things.

We identify data as attributes and behavior as methods in object-oriented programming. Again:

Data → Attributes and Behavior → Methods

And a Class is the blueprint from which individual objects are created. In the real world, we often find many objects with the same type. Like cars. All the same make and model (and all have an engine, wheels, doors, and so on). Each car was built from the same set of blueprints and has the same components.

Python Object-Oriented Programming mode: ON

Python, as an Object-Oriented programming language, has these concepts: class and object.

A class is a blueprint, a model for its objects.

So again, a class it is just a model, or a way to define attributes and behavior (as we talked about in the theory section). As an example, a vehicle class has its own attributes that define what objects are vehicles. The number of wheels, type of tank, seating capacity, and maximum velocity are all attributes of a vehicle.

With this in mind, let’s look at Python syntax for classes:

class Vehicle: pass

We define classes with a class statement — and that’s it. Easy, isn’t it?

Objects are instances of a class. We create an instance by naming the class.

car = Vehicle() print(car) # 

Here car is an object (or instance) of the classVehicle.

Remember that our vehicle class has four attributes: number of wheels, type of tank, seating capacity, and maximum velocity. We set all these attributes when creating a vehicle object. So here, we define our class to receive data when it initiates it:

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

We use the initmethod. We call it a constructor method. So when we create the vehicle object, we can define these attributes. Imagine that we love the Tesla Model S, and we want to create this kind of object. It has four wheels, runs on electric energy, has space for five seats, and the maximum velocity is 250km/hour (155 mph). Let’s create this object:

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

Four wheels + electric “tank type” + five seats + 250km/hour maximum speed.

All attributes are set. But how can we access these attributes’ values? We send a message to the object asking about them. We call it a method. It’s the object’s behavior. Let’s implement it:

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

This is an implementation of two methods: number_of_wheels and set_number_of_wheels. We call it getter & setter. Because the first gets the attribute value, and the second sets a new value for the attribute.

In Python, we can do that using @property (decorators) to define getters and setters. Let’s see it with code:

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

And we can use these methods as attributes:

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

This is slightly different than defining methods. The methods work as attributes. For example, when we set the new number of wheels, we don’t apply two as a parameter, but set the value 2 to number_of_wheels. This is one way to write pythonicgetter and setter code.

But we can also use methods for other things, like the “make_noise” method. Let’s see it:

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المثال المتغيرات والعمل الأساليب.

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

For a Python class, we can initialize a public instance variable within our constructor method. Let’s see this:

Within the constructor method:

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

Here we apply the first_name value as an argument to the public instance variable.

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

Within the class:

class Person: first_name = 'TK'

Here, we do not need to apply the first_name as an argument, and all instance objects will have a class attribute initialized with TK.

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

Cool. We have now learned that we can use public instance variables and class attributes. Another interesting thing about the public part is that we can manage the variable value. What do I mean by that? Our object can manage its variable value: Get and Set variable values.

Keeping the Person class in mind, we want to set another value to its first_name variable:

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', '[email protected]') print(tk._email) # [email protected]
يمكننا الوصول إليه وتحديثه. 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', '[email protected]') print(tk.email()) # => [email protected] # tk._email = '[email protected]' -- treat as a non-public part of the class API print(tk.email()) # => [email protected] tk.update_email('[email protected]') print(tk.email()) # => [email protected]
  1. We initiated a new object with first_name TK and email [email protected]
  2. Printed the email by accessing the non-public variable with a method
  3. Tried to set a new email out of our class
  4. We need to treat non-public variable as non-public part of the API
  5. Updated the non-public variable with our instance method
  6. Success! We can update it inside our class with the helper method

Public Method

With public methods, we can also use them out of our class:

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

Let’s test it:

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

Great — we can use it without any problem.

Non-public Method

But with non-public methods we aren’t able to do it. Let’s implement the same Person class, but now with a show_agenon-public method using an underscore (_).

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

And now, we’ll try to call this non-public method with our object:

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

ملخص التغليف

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

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

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

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

In object-oriented programming, classes can inherit common characteristics (data) and behavior (methods) from another class.

Let’s see another example and implement it in Python.

Imagine a car. Number of wheels, seating capacity and maximum velocity are all attributes of a car. We can say that anElectricCar class inherits these same attributes from the regular Car class.

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

Our Car class implemented:

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

Once initiated, we can use all instance variables created. Nice.

In Python, we apply a parent class to the child class as a parameter. An ElectricCar class can inherit from our Car class.

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

Simple as that. We don’t need to implement any other method, because this class already has it (inherited from Car class). Let’s prove it:

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

Beautiful.

That’s it!

We learned a lot of things about Python basics:

  • How Python variables work
  • How Python conditional statements work
  • How Python looping (while & for) works
  • How to use Lists: Collection | Array
  • Dictionary Key-Value Collection
  • How we can iterate through these data structures
  • Objects and Classes
  • Attributes as objects’ data
  • Methods as objects’ behavior
  • Using Python getters and setters & property decorator
  • Encapsulation: hiding information
  • Inheritance: behaviors and characteristics

Congrats! You completed this dense piece of content about Python.

إذا كنت تريد دورة Python كاملة ، فتعلم المزيد من مهارات الترميز في العالم الحقيقي وأنشئ مشاريع ، جرب برنامج Python Bootcamp لمدة شهر . اراك هناك

لمزيد من القصص والمنشورات حول رحلتي في التعلم وإتقان البرمجة ، تابع منشوري The Renaissance Developer .

استمتع بوقتك واستمر في التعلم واستمر دائمًا في البرمجة.

Twitter و Github الخاص بي. ☺