Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem nó cùng với hướng dẫn bằng văn bản để hiểu sâu hơn về sự hiểu biết của bạn: Giới thiệu về lập trình hướng đối tượng [OOP] trong Python This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Intro to Object-Oriented Programming [OOP] in Python
Lập trình hướng đối tượng [OOP] là một phương pháp cấu trúc một chương trình bằng cách bó các thuộc tính và hành vi liên quan đến các đối tượng riêng lẻ. Trong hướng dẫn này, bạn sẽ tìm hiểu những điều cơ bản của lập trình hướng đối tượng trong Python. [OOP] is a method of structuring a program by bundling related properties and behaviors into individual objects. In this tutorial, you’ll learn the basics of object-oriented programming in Python.
Về mặt khái niệm, các đối tượng giống như các thành phần của một hệ thống. Hãy nghĩ về một chương trình như một dây chuyền lắp ráp nhà máy của các loại. Ở mỗi bước của dây chuyền lắp ráp, một thành phần hệ thống xử lý một số vật liệu, cuối cùng chuyển đổi nguyên liệu thô thành một sản phẩm hoàn chỉnh.
Một đối tượng chứa dữ liệu, như các vật liệu thô hoặc được xử lý trước ở mỗi bước trên một dây chuyền lắp ráp và hành vi, như hành động mỗi thành phần dây chuyền lắp ráp thực hiện.
Trong hướng dẫn này, bạn sẽ học cách:
- Tạo một lớp, giống như một bản thiết kế để tạo một đối tượngclass, which is like a blueprint for creating an object
- Sử dụng các lớp để tạo các đối tượng mớicreate new objects
- Các hệ thống mô hình với kế thừa lớp họcclass inheritance
Lập trình hướng đối tượng trong Python là gì?
Lập trình hướng đối tượng là một mô hình lập trình cung cấp một phương tiện cấu trúc các chương trình để các thuộc tính và hành vi được gói vào các đối tượng riêng lẻ.objects.
Chẳng hạn, một đối tượng có thể đại diện cho một người có tài sản như tên, tuổi tác, và địa chỉ và hành vi như đi bộ, nói chuyện, thở và chạy. Hoặc nó có thể đại diện cho một email với các thuộc tính như danh sách người nhận, chủ thể, và cơ thể và các hành vi như thêm tệp đính kèm và gửi.properties like a name, age, and address and behaviors such as walking, talking, breathing, and running. Or it could represent an email with properties like a recipient list, subject, and body and behaviors like adding attachments and sending.
Nói cách khác, lập trình hướng đối tượng là một cách tiếp cận để mô hình hóa cụ thể, những thứ thực tế, như xe hơi, cũng như quan hệ giữa mọi thứ, như công ty và nhân viên, sinh viên và giáo viên, v.v. OOP mô hình các thực thể trong thế giới thực như các đối tượng phần mềm có một số dữ liệu liên quan đến chúng và có thể thực hiện các chức năng nhất định.
Một mô hình lập trình phổ biến khác là lập trình thủ tục, cấu trúc một chương trình giống như một công thức trong đó nó cung cấp một tập hợp các bước, dưới dạng các chức năng và khối mã, lưu lượng tuần tự để hoàn thành một nhiệm vụ.procedural programming, which structures a program like a recipe in that it provides a set of steps, in the form of functions and code blocks, that flow sequentially in order to complete a task.
Điều quan trọng là các đối tượng là trung tâm của lập trình hướng đối tượng trong Python, không chỉ đại diện cho dữ liệu, như trong lập trình thủ tục, mà còn trong cấu trúc tổng thể của chương trình.
Xác định một lớp học trong Python
Các cấu trúc dữ liệu nguyên thủy, giống như các số, chuỗi và danh sách được thiết kế để thể hiện các mẩu thông tin đơn giản, chẳng hạn như chi phí của một quả táo, tên của một bài thơ hoặc màu sắc yêu thích của bạn, tương ứng. Điều gì sẽ xảy ra nếu bạn muốn đại diện cho một cái gì đó phức tạp hơn?
Ví dụ, hãy để nói rằng bạn muốn theo dõi nhân viên trong một tổ chức. Bạn cần lưu trữ một số thông tin cơ bản về từng nhân viên, chẳng hạn như tên, tuổi, vị trí và năm họ bắt đầu làm việc.
Một cách để làm điều này là đại diện cho mỗi nhân viên như một danh sách:
kirk = ["James Kirk", 34, "Captain", 2265]
spock = ["Spock", 35, "Science Officer", 2254]
mccoy = ["Leonard McCoy", "Chief Medical Officer", 2266]
Có một số vấn đề với phương pháp này.
Đầu tiên, nó có thể làm cho các tệp mã lớn hơn khó quản lý hơn. Nếu bạn tham khảo
>>> Dog[]
4 Một số dòng cách xa danh sách >>> Dog[]
5 được khai báo, bạn sẽ nhớ rằng phần tử có chỉ mục >>> Dog[]
6 là tên của nhân viên?Thứ hai, nó có thể giới thiệu lỗi nếu không phải mọi nhân viên đều có cùng số lượng các yếu tố trong danh sách. Trong danh sách
>>> Dog[]
7 ở trên, độ tuổi bị thiếu, vì vậy >>> Dog[]
8 sẽ trả lại >>> Dog[]
9 thay vì tuổi của Tiến sĩ McCoy.Một cách tuyệt vời để làm cho loại mã này dễ quản lý hơn và có thể duy trì hơn là sử dụng các lớp.classes.
Các lớp học vs
Các lớp được sử dụng để tạo cấu trúc dữ liệu do người dùng xác định. Các lớp xác định các chức năng được gọi là các phương thức, xác định các hành vi và hành động mà một đối tượng được tạo từ lớp có thể thực hiện với dữ liệu của nó.methods, which identify the behaviors and actions that an object created from the class can perform with its data.
Trong hướng dẫn này, bạn sẽ tạo ra một lớp
>>> Dog[]
0 lưu trữ một số thông tin về các đặc điểm và hành vi mà một con chó cá nhân có thể có.Một lớp học là một bản thiết kế cho cách xác định một cái gì đó. Nó không thực sự chứa bất kỳ dữ liệu nào. Lớp
>>> Dog[]
0 chỉ định rằng một tên và một độ tuổi là cần thiết để xác định một con chó, nhưng nó không chứa tên hoặc tuổi của bất kỳ con chó cụ thể nào.Mặc dù lớp là bản thiết kế, một thể hiện là một đối tượng được xây dựng từ một lớp và chứa dữ liệu thực. Một ví dụ của lớp
>>> Dog[]
0 không phải là một kế hoạch chi tiết nữa. Nó có một con chó thực sự với một cái tên, giống như Miles, người mà bốn tuổi.instance is an object that is built from a class and contains real data. An instance of the >>> Dog[]
0 class is not a blueprint anymore. It’s an actual dog with a
name, like Miles, who’s four years old.Nói cách khác, một lớp học giống như một hình thức hoặc bảng câu hỏi. Một ví dụ giống như một hình thức đã được điền thông tin. Giống như nhiều người có thể điền vào cùng một hình thức với thông tin độc đáo của riêng họ, nhiều trường hợp có thể được tạo từ một lớp duy nhất.
Cách xác định một lớp học
Tất cả các định nghĩa lớp bắt đầu với từ khóa
>>> Dog[]
3, được theo sau là tên của lớp và một dấu hai chấm. Bất kỳ mã nào được thụt vào bên dưới định nghĩa lớp được coi là một phần của cơ thể lớp.Ở đây, một ví dụ về một lớp
>>> Dog[]
0:Phần thân của lớp
>>> Dog[]
0 bao gồm một câu lệnh: Từ khóa >>> Dog[]
6. >>> Dog[]
6 thường được sử dụng làm người giữ chỗ cho biết mã cuối cùng sẽ đi đâu. Nó cho phép bạn chạy mã này mà không cần phải ném lỗi.Lớp
>>> Dog[]
0 hiện đang rất thú vị, vì vậy, hãy để cho nó lên một chút bằng cách xác định một số thuộc tính mà tất cả các đối tượng >>> Dog[]
0 nên có. Có một số thuộc tính mà chúng ta có thể chọn, bao gồm tên, tuổi, màu áo và giống. Để giữ cho mọi thứ đơn giản, chúng tôi sẽ chỉ sử dụng tên và tuổi.Các thuộc tính mà tất cả các đối tượng
>>> Dog[]
0 phải được xác định trong một phương thức gọi là >>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
1. Mỗi khi một đối tượng >>> Dog[]
0 mới được tạo, >>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
1 đặt trạng thái ban đầu của đối tượng bằng cách gán các giá trị của các thuộc tính của đối tượng. Nghĩa là, >>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
1 khởi tạo từng phiên bản mới của lớp.state of the object by assigning the values of the object’s properties. That is, >>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
1 initializes each new instance of the class.Bạn có thể cung cấp
>>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
1 bất kỳ số lượng tham số nào, nhưng tham số đầu tiên sẽ luôn là một biến được gọi là >>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
6. Khi một thể hiện lớp mới được tạo, cá thể được tự động chuyển đến tham số >>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
6 trong >>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
1 để các thuộc tính mới có thể được xác định trên đối tượng.attributes can be defined on the object.Hãy để cập nhật lớp
>>> Dog[]
0 với phương thức >>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
1 tạo ra các thuộc tính >>> class Dog:
... species = "Canis familiaris"
... def __init__[self, name, age]:
... self.name = name
... self.age = age
1 và >>> class Dog:
... species = "Canis familiaris"
... def __init__[self, name, age]:
... self.name = name
... self.age = age
2:class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
Lưu ý rằng chữ ký của phương thức
>>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
1 được thụt vào bốn không gian. Cơ thể của phương pháp được thụt lề bởi tám không gian. Sự thụt này là cực kỳ quan trọng. Nó nói với Python rằng phương pháp >>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
1 thuộc về lớp >>> Dog[]
0.Trong phần thân của
>>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
1, có hai tuyên bố sử dụng biến >>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
6:
8 Tạo một thuộc tính gọi là>>> class Dog: ... species = "Canis familiaris" ... def __init__[self, name, age]: ... self.name = name ... self.age = age
9 và gán cho nó giá trị của tham số>>> class Dog: ... species = "Canis familiaris" ... def __init__[self, name, age]: ... self.name = name ... self.age = age
9. creates an attribute called>>> class Dog: ... species = "Canis familiaris" ... def __init__[self, name, age]: ... self.name = name ... self.age = age
9 and assigns to it the value of the>>> class Dog: ... species = "Canis familiaris" ... def __init__[self, name, age]: ... self.name = name ... self.age = age
9 parameter.>>> class Dog: ... species = "Canis familiaris" ... def __init__[self, name, age]: ... self.name = name ... self.age = age
1 tạo một thuộc tính gọi là>>> Dog[] Traceback [most recent call last]: File "", line 1, in Dog[] TypeError: __init__[] missing 2 required positional arguments: 'name' and 'age'
2 và gán cho nó giá trị của tham số>>> Dog[] Traceback [most recent call last]: File "", line 1, in Dog[] TypeError: __init__[] missing 2 required positional arguments: 'name' and 'age'
2. creates an attribute called>>> Dog[] Traceback [most recent call last]: File "", line 1, in Dog[] TypeError: __init__[] missing 2 required positional arguments: 'name' and 'age'
2 and assigns to it the value of the>>> Dog[] Traceback [most recent call last]: File "", line 1, in Dog[] TypeError: __init__[] missing 2 required positional arguments: 'name' and 'age'
2 parameter.>>> Dog[] Traceback [most recent call last]: File "", line 1, in Dog[] TypeError: __init__[] missing 2 required positional arguments: 'name' and 'age'
Các thuộc tính được tạo trong
>>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
1 được gọi là thuộc tính thể hiện. Một giá trị thuộc tính thể hiện là cụ thể cho một trường hợp cụ thể của lớp. Tất cả các đối tượng >>> Dog[]
0 đều có tên và tuổi, nhưng các giá trị cho các thuộc tính >>> class Dog:
... species = "Canis familiaris"
... def __init__[self, name, age]:
... self.name = name
... self.age = age
9 và >>> Dog[]
Traceback [most recent call last]:
File "", line 1, in
Dog[]
TypeError: __init__[] missing 2 required positional arguments: 'name' and 'age'
2 sẽ thay đổi tùy thuộc vào thể hiện >>> Dog[]
0.instance attributes. An instance attribute’s value is specific to a particular
instance of the class. All >>> Dog[]
0 objects have a name and an age, but the values for the >>> class Dog:
... species = "Canis familiaris"
... def __init__[self, name, age]:
... self.name = name
... self.age = age
9 and >>> Dog[]
Traceback [most recent call last]:
File "", line 1, in
Dog[]
TypeError: __init__[] missing 2 required positional arguments: 'name' and 'age'
2 attributes will vary depending on the >>> Dog[]
0 instance.Mặt khác, các thuộc tính lớp là các thuộc tính có cùng giá trị cho tất cả các trường hợp lớp. Bạn có thể xác định thuộc tính lớp bằng cách gán một giá trị cho một tên biến bên ngoài
>>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
1.class attributes are attributes that have the same value for all class instances. You can define a class attribute by assigning a value to a variable name outside of >>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
1.Ví dụ: lớp
>>> Dog[]
0 sau đây có thuộc tính lớp có tên >>> buddy = Dog["Buddy", 9]
>>> miles = Dog["Miles", 4]
1 với giá trị >>> buddy = Dog["Buddy", 9]
>>> miles = Dog["Miles", 4]
2:class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
Các thuộc tính lớp được xác định trực tiếp bên dưới dòng đầu tiên của tên lớp và được thụt vào bởi bốn không gian. Chúng phải luôn được gán một giá trị ban đầu. Khi một thể hiện của lớp được tạo, các thuộc tính lớp sẽ tự động được tạo và gán cho các giá trị ban đầu của chúng.
Sử dụng các thuộc tính lớp để xác định các thuộc tính nên có cùng giá trị cho mọi thể hiện lớp. Sử dụng các thuộc tính thể hiện cho các thuộc tính thay đổi từ trường hợp này sang trường hợp khác.
Bây giờ chúng tôi có một lớp
>>> Dog[]
0, hãy để tạo ra một số con chó!Khởi tạo một đối tượng trong Python
Mở cửa sổ tương tác Idle Idle và nhập như sau:
>>>
>>> class Dog:
... pass
Điều này tạo ra một lớp
>>> Dog[]
0 mới không có thuộc tính hoặc phương thức.Tạo một đối tượng mới từ một lớp được gọi là khởi tạo một đối tượng. Bạn có thể khởi tạo một đối tượng
>>> Dog[]
0 mới bằng cách nhập tên của lớp, theo sau bằng cách mở và đóng dấu ngoặc đơn:instantiating an object. You can instantiate a new >>> Dog[]
0 object by typing the name of the class, followed by opening and closing parentheses:>>>
>>> Dog[]
Điều này tạo ra một lớp
>>> Dog[]
0 mới không có thuộc tính hoặc phương thức.memory address that indicates where the >>> Dog[]
0 object is stored in your computer’s memory. Note that the address you see on your screen will be different.Tạo một đối tượng mới từ một lớp được gọi là khởi tạo một đối tượng. Bạn có thể khởi tạo một đối tượng
>>> Dog[]
0 mới bằng cách nhập tên của lớp, theo sau bằng cách mở và đóng dấu ngoặc đơn:>>>
>>> Dog[]
Điều này tạo ra một lớp
>>> Dog[]
0 mới không có thuộc tính hoặc phương thức.Tạo một đối tượng mới từ một lớp được gọi là khởi tạo một đối tượng. Bạn có thể khởi tạo một đối tượng
>>> Dog[]
0 mới bằng cách nhập tên của lớp, theo sau bằng cách mở và đóng dấu ngoặc đơn:>>>
>>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
Điều này tạo ra một lớp
>>> Dog[]
0 mới không có thuộc tính hoặc phương thức.Tạo một đối tượng mới từ một lớp được gọi là khởi tạo một đối tượng. Bạn có thể khởi tạo một đối tượng >>> Dog[]
0 mới bằng cách nhập tên của lớp, theo sau bằng cách mở và đóng dấu ngoặc đơn:
>>> Dog[]
Bây giờ bạn có một đối tượng
>>> Dog[]
0 mới tại >>> buddy = Dog["Buddy", 9]
>>> miles = Dog["Miles", 4]
7. Chuỗi các chữ cái và số trông hài hước này là một địa chỉ bộ nhớ cho biết nơi đối tượng >>> Dog[]
0 được lưu trữ trong bộ nhớ máy tính của bạn. Lưu ý rằng địa chỉ bạn thấy trên màn hình của bạn sẽ khác.>>>
>>> class Dog:
... species = "Canis familiaris"
... def __init__[self, name, age]:
... self.name = name
... self.age = age
Để khởi tạo các đối tượng của lớp
>>> Dog[]
0 này, bạn cần cung cấp các giá trị cho >>> class Dog:
... species = "Canis familiaris"
... def __init__[self, name, age]:
... self.name = name
... self.age = age
9 và >>> Dog[]
Traceback [most recent call last]:
File "", line 1, in
Dog[]
TypeError: __init__[] missing 2 required positional arguments: 'name' and 'age'
2. Nếu bạn don lồng, thì Python sẽ tăng một class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
19:>>>
>>> Dog[]
Traceback [most recent call last]:
File "", line 1, in
Dog[]
TypeError: __init__[] missing 2 required positional arguments: 'name' and 'age'
Để chuyển các đối số cho các tham số
>>> class Dog:
... species = "Canis familiaris"
... def __init__[self, name, age]:
... self.name = name
... self.age = age
9 và >>> Dog[]
Traceback [most recent call last]:
File "", line 1, in
Dog[]
TypeError: __init__[] missing 2 required positional arguments: 'name' and 'age'
2, hãy đặt các giá trị vào dấu ngoặc đơn sau tên lớp:>>>
>>> buddy = Dog["Buddy", 9]
>>> miles = Dog["Miles", 4]
Điều này tạo ra hai trường hợp
>>> Dog[]
0 mới cho một con chó chín tuổi tên Buddy và một cho một con chó bốn tuổi tên Miles.Phương pháp
>>> Dog[]
0 Lớp ____ ____ ____61 có ba tham số, vậy tại sao chỉ có hai đối số được truyền cho nó trong ví dụ?Khi bạn khởi tạo một đối tượng
>>> Dog[]
0, Python sẽ tạo một thể hiện mới và chuyển nó đến tham số đầu tiên của >>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
1. Điều này về cơ bản loại bỏ tham số >>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
6, vì vậy bạn chỉ cần lo lắng về các tham số >>> class Dog:
... species = "Canis familiaris"
... def __init__[self, name, age]:
... self.name = name
... self.age = age
9 và >>> Dog[]
Traceback [most recent call last]:
File "", line 1, in
Dog[]
TypeError: __init__[] missing 2 required positional arguments: 'name' and 'age'
2.Sau khi bạn tạo các phiên bản
>>> Dog[]
0, bạn có thể truy cập các thuộc tính thể hiện của chúng bằng cách sử dụng ký hiệu chấm:dot notation:>>>
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
0Bạn có thể truy cập các thuộc tính lớp theo cùng một cách:
>>>
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
1Một trong những lợi thế lớn nhất của việc sử dụng các lớp để tổ chức dữ liệu là các trường hợp được đảm bảo có các thuộc tính mà bạn mong đợi. Tất cả các trường hợp
>>> Dog[]
0 đều có các thuộc tính class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
13, >>> class Dog:
... species = "Canis familiaris"
... def __init__[self, name, age]:
... self.name = name
... self.age = age
1 và >>> class Dog:
... species = "Canis familiaris"
... def __init__[self, name, age]:
... self.name = name
... self.age = age
2, vì vậy bạn có thể sử dụng các thuộc tính đó với sự tự tin khi biết rằng chúng sẽ luôn trả về một giá trị.Mặc dù các thuộc tính được đảm bảo tồn tại, giá trị của chúng có thể được thay đổi một cách linh hoạt:
>>>
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
2Trong ví dụ này, bạn thay đổi thuộc tính
>>> class Dog:
... species = "Canis familiaris"
... def __init__[self, name, age]:
... self.name = name
... self.age = age
2 của đối tượng class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
36 thành class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
37. Sau đó, bạn thay đổi thuộc tính class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
13 của đối tượng class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
39 thành class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
40, là một loài mèo. Điều đó làm cho Miles trở thành một con chó khá kỳ lạ, nhưng nó là Python hợp lệ!Điểm quan trọng ở đây là các đối tượng tùy chỉnh có thể thay đổi theo mặc định. Một đối tượng có thể thay đổi nếu nó có thể được thay đổi một cách linh hoạt. Ví dụ, danh sách và từ điển là có thể thay đổi, nhưng chuỗi và bộ dữ liệu là bất biến.
Phương pháp thể hiện
Các phương thức thể hiện là các hàm được xác định bên trong một lớp và chỉ có thể được gọi từ một thể hiện của lớp đó. Giống như
1, một phương thức thể hiện tham số đầu tiên luôn luôn là >>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
6. are functions that are defined inside a class and can only be called from an instance of that class. Just like >>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
>>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
1, an instance method’s first parameter is always >>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
6.Mở cửa sổ Trình chỉnh sửa mới trong IDLE và nhập lớp
>>> Dog[]
0 sau:class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
3Lớp
>>> Dog[]
0 này có hai phương thức thể hiện:
45 Trả về một chuỗi hiển thị tên và tuổi của con chó. returns a string displaying the name and age of the dog.class Dog: def __init__[self, name, age]: self.name = name self.age = age
46 có một tham số gọi làclass Dog: def __init__[self, name, age]: self.name = name self.age = age
47 và trả về một chuỗi chứa tên chó và âm thanh mà con chó tạo ra. has one parameter calledclass Dog: def __init__[self, name, age]: self.name = name self.age = age
47 and returns a string containing the dog’s name and the sound the dog makes.class Dog: def __init__[self, name, age]: self.name = name self.age = age
Lưu lớp
>>> Dog[]
0 đã sửa đổi vào một tệp có tên class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
49 và nhấn F5 để chạy chương trình. Sau đó, mở cửa sổ tương tác và nhập phần sau để xem các phương thức thể hiện của bạn trong hành động:F5 to run the program. Then open the interactive window and type the following to see your instance methods in action:>>>
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
4Trong lớp
>>> Dog[]
0 trên, class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
45 trả về một chuỗi chứa thông tin về phiên bản >>> Dog[]
0 class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
39. Khi viết các lớp học của riêng bạn, bạn có một ý tưởng tốt để có một phương thức trả về một chuỗi chứa thông tin hữu ích về một thể hiện của lớp. Tuy nhiên, class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
45 không phải là cách làm điều này.
Khi bạn tạo đối tượng
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
55, bạn có thể sử dụng class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
56 để hiển thị một chuỗi trông giống như danh sách:>>>
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
5Hãy để xem những gì xảy ra khi bạn
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
56 đối tượng class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
39:>>>
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
6Khi bạn
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
59, bạn sẽ nhận được một tin nhắn trông khó hiểu nói với bạn rằng class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
39 là một đối tượng >>> Dog[]
0 tại địa chỉ bộ nhớ class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
62. Thông điệp này rất hữu ích. Bạn có thể thay đổi những gì được in bằng cách xác định một phương thức thể hiện đặc biệt gọi là class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
63.Trong cửa sổ Trình chỉnh sửa, hãy thay đổi tên của phương thức
>>> Dog[]
0 class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
45 thành class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
63:class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
7Lưu tệp và nhấn F5. Bây giờ, khi bạn
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
59, bạn sẽ nhận được đầu ra thân thiện hơn nhiều:F5. Now, when you class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
59, you get a much friendlier output:>>>
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
8Các phương pháp như
>>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
1 và class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
63 được gọi là các phương thức Dunder vì chúng bắt đầu và kết thúc với các dấu gạch dưới kép. Có nhiều phương pháp Dunder mà bạn có thể sử dụng để tùy chỉnh các lớp trong Python. Mặc dù quá nâng cao một chủ đề cho một cuốn sách Python bắt đầu, hiểu các phương pháp Dunder là một phần quan trọng trong việc làm chủ lập trình hướng đối tượng trong Python.dunder methods because they begin and end with double underscores. There are many dunder methods that you can use to customize classes in Python. Although too advanced a topic for a beginning Python book, understanding dunder methods is an important part of mastering object-oriented programming in Python.Trong phần tiếp theo, bạn sẽ thấy cách đưa kiến thức của mình tiến thêm một bước và tạo các lớp từ các lớp khác.
Kiểm tra việc hiểu của bạn
Mở rộng khối bên dưới để kiểm tra sự hiểu biết của bạn:
Tạo một lớp
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
70 với hai thuộc tính thể hiện:
71, nơi lưu trữ tên của màu xe hơi như một chuỗiclass Dog: def __init__[self, name, age]: self.name = name self.age = age
72, lưu trữ số dặm trên xe như một số nguyênclass Dog: def __init__[self, name, age]: self.name = name self.age = age
Sau đó, khởi tạo hai đối tượng
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
70 Một chiếc xe màu xanh với 20.000 dặm và một chiếc xe màu đỏ với 30.000 dặm và in ra màu sắc và số dặm của chúng. Đầu ra của bạn sẽ trông như thế này:class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
9Bạn có thể mở rộng khối bên dưới để xem giải pháp:
Đầu tiên, hãy tạo một lớp
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
70 với các thuộc tính thể hiện class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
71 và class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
72:class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
0Các tham số
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
77 và class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
78 của >>> a = Dog[]
>>> b = Dog[]
>>> a == b
False
1 được gán cho class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
80 và class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
81, tạo ra hai thuộc tính thể hiện.Bây giờ bạn có thể tạo hai phiên bản
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
70:class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
1Ví dụ
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
83 được tạo bằng cách chuyển giá trị class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
84 cho tham số class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
77 và class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
86 cho tham số class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
78. Tương tự, class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
88 được tạo với các giá trị class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
89 và class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
90.Để in màu và số dặm của mỗi đối tượng
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
70, bạn có thể lặp qua class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
92 chứa cả hai đối tượng:class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
2Chuỗi F trong vòng lặp
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
93 ở trên chèn các thuộc tính class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
71 và class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
72 vào chuỗi và sử dụng định dạng định dạng class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
96 để in số dặm được nhóm bởi hàng ngàn và tách bằng dấu phẩy.Đầu ra cuối cùng trông như thế này:
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
9Khi bạn đã sẵn sàng, bạn có thể chuyển sang phần tiếp theo.
Kế thừa từ các lớp khác trong Python
Kế thừa là quá trình mà một lớp đảm nhận các thuộc tính và phương thức của một lớp khác. Các lớp mới được thành lập được gọi là các lớp con và các lớp mà các lớp con được bắt nguồn từ các lớp cha.child classes, and the classes that child classes are derived from are called parent classes.
Các lớp con có thể ghi đè hoặc mở rộng các thuộc tính và phương thức của các lớp cha. Nói cách khác, các lớp con kế thừa tất cả các thuộc tính và phương thức của cha mẹ nhưng cũng có thể chỉ định các thuộc tính và phương thức duy nhất cho chính chúng.
Mặc dù sự tương tự là hoàn hảo, bạn có thể nghĩ về sự kế thừa đối tượng giống như di truyền di truyền.
Bạn có thể đã thừa hưởng màu tóc của bạn từ mẹ của bạn. Nó là một thuộc tính mà bạn được sinh ra. Hãy để nói rằng bạn quyết định tô màu cho tóc màu tím. Giả sử mẹ của bạn không có mái tóc màu tím, bạn chỉ cần ghi đè thuộc tính màu tóc mà bạn được thừa hưởng từ mẹ.overridden the hair color attribute that you inherited from your mom.
Bạn cũng thừa hưởng, theo một nghĩa nào đó, ngôn ngữ của bạn từ cha mẹ của bạn. Nếu bố mẹ bạn nói tiếng Anh, thì bạn cũng sẽ nói tiếng Anh. Bây giờ hãy tưởng tượng bạn quyết định học một ngôn ngữ thứ hai, như tiếng Đức. Trong trường hợp này, bạn đã mở rộng các thuộc tính của mình vì bạn đã thêm một thuộc tính mà cha mẹ bạn không có.extended your attributes because you’ve added an attribute that your parents don’t have.
Ví dụ về công viên chó
Giả vờ một lúc bạn ở một công viên chó. Có rất nhiều con chó của các giống chó khác nhau tại công viên, tất cả đều tham gia vào các hành vi chó khác nhau.
Giả sử bây giờ bạn muốn mô hình hóa công viên chó với các lớp Python. Lớp
>>> Dog[]
0 mà bạn đã viết trong phần trước có thể phân biệt chó bằng tên và tuổi nhưng không phải bằng giống.Bạn có thể sửa đổi lớp
>>> Dog[]
0 trong cửa sổ Trình chỉnh sửa bằng cách thêm thuộc tính class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
99:class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
4Các phương pháp thể hiện được xác định trước đó được bỏ qua ở đây vì chúng không quan trọng cho cuộc thảo luận này.
Nhấn F5 để lưu tệp. Bây giờ bạn có thể mô hình hóa công viên chó bằng cách khởi tạo một loạt các con chó khác nhau trong cửa sổ tương tác:F5 to save the file. Now you can model the dog park by instantiating a bunch of different dogs in the interactive window:
>>>
class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
5Mỗi giống chó có những hành vi hơi khác nhau. Ví dụ, những chú chó bulông có một vỏ cây thấp nghe giống như WOOF, nhưng Dachshunds có một vỏ cây cao hơn nghe có vẻ giống Yap hơn.
Chỉ sử dụng lớp
>>> Dog[]
0, bạn phải cung cấp một chuỗi cho đối số class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
47 của class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
46 mỗi khi bạn gọi nó theo phiên bản >>> Dog[]
0:>>>
class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
6Mỗi giống chó có những hành vi hơi khác nhau. Ví dụ, những chú chó bulông có một vỏ cây thấp nghe giống như WOOF, nhưng Dachshunds có một vỏ cây cao hơn nghe có vẻ giống Yap hơn.
Chỉ sử dụng lớp
>>> Dog[]
0, bạn phải cung cấp một chuỗi cho đối số class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
47 của class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
46 mỗi khi bạn gọi nó theo phiên bản >>> Dog[]
0:Chuyển một chuỗi cho mỗi cuộc gọi đến class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
46 là lặp đi lặp lại và bất tiện. Hơn nữa, chuỗi đại diện cho âm thanh mà mỗi trường hợp >>> Dog[]
0 tạo nên được xác định bằng thuộc tính class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
99 của nó, nhưng ở đây bạn phải chuyển đúng chuỗi chính xác cho class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
46 mỗi khi nó được gọi.
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
>>> Dog[]
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
Bạn có thể đơn giản hóa trải nghiệm làm việc với lớp
>>> Dog[]
0 bằng cách tạo ra một lớp con cho mỗi giống chó. Điều này cho phép bạn mở rộng chức năng mà mỗi lớp con được kế thừa, bao gồm chỉ định một đối số mặc định cho class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
46.Các lớp phụ huynh so với các lớp con
class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
7Hãy để tạo ra một lớp trẻ em cho mỗi trong ba giống được đề cập ở trên: Jack Russell Terrier, Dachshund và Bulldog.
class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
8Để tham khảo, ở đây, định nghĩa đầy đủ của lớp
>>> Dog[]
0:F5 to save and run the file. With the child classes defined, you can now instantiate some dogs of specific breeds in the interactive
window:>>>
class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
9Mỗi giống chó có những hành vi hơi khác nhau. Ví dụ, những chú chó bulông có một vỏ cây thấp nghe giống như WOOF, nhưng Dachshunds có một vỏ cây cao hơn nghe có vẻ giống Yap hơn.
>>>
>>> class Dog:
... pass
0Mỗi giống chó có những hành vi hơi khác nhau. Ví dụ, những chú chó bulông có một vỏ cây thấp nghe giống như WOOF, nhưng Dachshunds có một vỏ cây cao hơn nghe có vẻ giống Yap hơn.
>>>
>>> class Dog:
... pass
1Điều gì sẽ xảy ra nếu bạn muốn xác định xem
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
39 cũng là một ví dụ của lớp >>> Dog[]
0? Bạn có thể làm điều này với class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
16 tích hợp:>>>
>>> class Dog:
... pass
2Lưu ý rằng
class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
16 có hai đối số, một đối tượng và một lớp. Trong ví dụ trên, class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
16 kiểm tra xem class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
39 là một ví dụ của lớp >>> Dog[]
0 và trả về class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
21.Các đối tượng
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
39, class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
36, class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
24 và class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
25 đều là các trường hợp >>> Dog[]
0, nhưng class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
39 không phải là một ví dụ class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
28 và class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
24 không phải là ví dụ class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
30:>>>
>>> class Dog:
... pass
3Tổng quát hơn, tất cả các đối tượng được tạo từ một lớp con là những trường hợp của lớp cha, mặc dù chúng có thể không phải là trường hợp của các lớp con khác.
Bây giờ bạn đã tạo ra các lớp trẻ em cho một số giống chó khác nhau, hãy để cho mỗi giống chó của riêng mình.
Mở rộng chức năng của lớp cha
Vì các giống chó khác nhau có vỏ hơi khác nhau, bạn muốn cung cấp giá trị mặc định cho đối số
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
47 về các phương pháp class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
46 tương ứng của chúng. Để làm điều này, bạn cần ghi đè class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
46 trong định nghĩa lớp cho mỗi giống.Để ghi đè một phương thức được xác định trên lớp cha, bạn xác định một phương thức có cùng tên trên lớp con. Ở đây, những gì trông giống như lớp
class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
34:>>> class Dog:
... pass
4Bây giờ
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
46 được xác định trên lớp class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
34 với đối số mặc định cho class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
47 được đặt thành class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
38.Cập nhật
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
49 với lớp class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
34 mới và nhấn F5 để lưu và chạy tệp. Bây giờ bạn có thể gọi class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
46 trên một ví dụ class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
34 mà không chuyển đối số cho class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
47:F5 to save and run the file. You can now call class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
46 on a class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
34 instance without passing an argument to class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
47:>>>
>>> class Dog:
... pass
5Đôi khi những con chó tạo ra những tiếng sủa khác nhau, vì vậy nếu Miles tức giận và gầm gừ, bạn vẫn có thể gọi
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
46 với một âm thanh khác:>>>
>>> class Dog:
... pass
6Một điều cần lưu ý về sự kế thừa của lớp là các thay đổi đối với lớp cha mẹ tự động tuyên truyền đến các lớp con. Điều này xảy ra miễn là thuộc tính hoặc phương thức được thay đổi không được ghi đè trong lớp con.
Ví dụ: trong cửa sổ Trình chỉnh sửa, thay đổi chuỗi được trả về bởi
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
46 trong lớp >>> Dog[]
0:>>> class Dog:
... pass
7Lưu tệp và nhấn F5. Bây giờ, khi bạn tạo một thể hiện
class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
28 mới có tên class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
25, class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
49 trả về chuỗi mới:F5. Now, when you create a new class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
28 instance named class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
25, class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
49 returns the new string:>>>
>>> class Dog:
... pass
8Tuy nhiên, việc gọi
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
46 trên một ví dụ class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
34 won đã hiển thị kiểu đầu ra mới:>>>
>>> class Dog:
... pass
9Đôi khi nó có ý nghĩa để ghi đè hoàn toàn một phương thức từ một lớp cha. Nhưng trong trường hợp này, chúng tôi không muốn lớp
class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
34 mất bất kỳ thay đổi nào có thể được thực hiện theo định dạng của chuỗi đầu ra của class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
53.Để làm điều này, bạn vẫn cần xác định phương thức
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
46 trên lớp trẻ class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
34. Nhưng thay vì xác định rõ ràng chuỗi đầu ra, bạn cần gọi lớp ____5050 class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
46 bên trong lớp con Lát class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
46 bằng cách sử dụng các đối số tương tự mà bạn đã chuyển sang class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
59.Bạn có thể truy cập lớp cha từ bên trong phương pháp của lớp con bằng cách sử dụng
class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
60:>>> Dog[]
0Khi bạn gọi
class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
61 bên trong class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
34, Python tìm kiếm lớp cha, >>> Dog[]
0, cho phương thức class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
46 và gọi nó với biến class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
47.Cập nhật
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
49 với lớp class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
34 mới. Lưu tệp và nhấn F5 để bạn có thể kiểm tra nó trong cửa sổ tương tác:F5 so you can test it in the interactive
window:>>>
>>> Dog[]
1Bây giờ khi bạn gọi
class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
68, bạn sẽ thấy đầu ra phản ánh định dạng mới trong lớp >>> Dog[]
0.Kiểm tra việc hiểu của bạn
Mở rộng khối bên dưới để kiểm tra sự hiểu biết của bạn:
Tạo một lớp
class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
70 kế thừa từ lớp >>> Dog[]
0. Cung cấp cho đối số class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
47 của class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
73 giá trị mặc định là class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
74. Sử dụng mã sau cho lớp phụ huynh >>> Dog[]
0 của bạn:class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
7Bạn có thể mở rộng khối bên dưới để xem giải pháp:
Tạo một lớp gọi là
class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
70 kế thừa từ lớp >>> Dog[]
0 và ghi đè phương thức class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
46:>>> Dog[]
3Tham số
class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
47 trong class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
73 được cung cấp giá trị mặc định là class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
74. Sau đó, class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
60 được sử dụng để gọi phương thức của lớp cha ____ ____146 với cùng một đối số được chuyển đến class Dog:
def __init__[self, name, age]:
self.name = name
self.age = age
47 dưới dạng phương thức class Dog:
# Class attribute
species = "Canis familiaris"
def __init__[self, name, age]:
self.name = name
self.age = age
70 Lớp ____ ____146.Sự kết luận
Trong hướng dẫn này, bạn đã tìm hiểu về lập trình hướng đối tượng [OOP] trong Python. Hầu hết các ngôn ngữ lập trình hiện đại, chẳng hạn như Java, C#và C ++, tuân theo các nguyên tắc OOP, vì vậy kiến thức bạn có được ở đây sẽ được áp dụng cho dù sự nghiệp lập trình của bạn sẽ đưa bạn đến đâu.
Trong hướng dẫn này, bạn đã học được cách:
- Xác định một lớp, là một loại bản thiết kế cho một đối tượngclass, which is a sort of blueprint for an object
- Khởi tạo một đối tượng từ một lớpobject from a class
- Sử dụng các thuộc tính và phương thức để xác định các thuộc tính và hành vi của một đối tượngattributes and methods to define the properties and behaviors of an object
- Sử dụng kế thừa để tạo các lớp con từ lớp chainheritance to create child classes from a parent class
- Tham chiếu một phương thức trên lớp cha bằng cách sử dụng
60class Dog: # Class attribute species = "Canis familiaris" def __init__[self, name, age]: self.name = name self.age = age
60class Dog: # Class attribute species = "Canis familiaris" def __init__[self, name, age]: self.name = name self.age = age
- Kiểm tra xem một đối tượng có kế thừa từ lớp khác bằng cách sử dụng
16 khôngclass Dog: # Class attribute species = "Canis familiaris" def __init__[self, name, age]: self.name = name self.age = age
16class Dog: # Class attribute species = "Canis familiaris" def __init__[self, name, age]: self.name = name self.age = age
Nếu bạn thích những gì bạn đã học trong mẫu này từ Python Basics: Giới thiệu thực tế về Python 3, thì hãy chắc chắn kiểm tra phần còn lại của cuốn sách.
Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem nó cùng với hướng dẫn bằng văn bản để hiểu sâu hơn về sự hiểu biết của bạn: Giới thiệu về lập trình hướng đối tượng [OOP] trong Python This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Intro to Object-Oriented Programming [OOP] in Python