Lập trình hướng đối tượng trong Python
- Thứ năm - 29/05/2025 01:33
- In ra
- Đóng cửa sổ này
Lập trình hướng đối tượng Python là gì? Dưới đây là mọi điều bạn cần biết về lập trình hướng đối tượng hay OOP trong Python.
Lập trình hướng đối tượng có một số ưu điểm so với các mẫu thiết kế khác. Phát triển nhanh hơn và rẻ hơn, với khả năng bảo trì phần mềm tốt hơn. Đổi lại, điều này dẫn đến phần mềm chất lượng cao hơn, cũng có thể mở rộng bằng các phương pháp và thuộc tính mới. Tuy nhiên, quá trình tìm hiểu nó cũng khó hơn. Khái niệm này có thể quá phức tạp đối với người mới bắt đầu. Về mặt tính toán, phần mềm OOP chậm hơn và sử dụng nhiều bộ nhớ hơn vì phải viết nhiều dòng mã hơn.
Lập trình hướng đối tượng dựa trên mô hình lập trình bắt buộc, sử dụng các câu lệnh để thay đổi trạng thái của chương trình. Nó tập trung vào việc mô tả cách chương trình nên hoạt động. Ví dụ về ngôn ngữ lập trình bắt buộc là C, C++, Java, Go, Ruby và Python. Điều này trái ngược với lập trình khai báo, tập trung vào những gì chương trình máy tính nên thực hiện, mà không chỉ định cách thực hiện. Ví dụ là các ngôn ngữ truy vấn cơ sở dữ liệu như SQL và XQuery, trong đó người ta chỉ cho máy tính biết dữ liệu nào cần truy vấn từ đâu.
Python là một trong số ngôn ngữ lập trình phổ biến nhất hiện nay. Bạn dễ dàng tìm thấy nó trong các ứng dụng, phần mềm hay trang web thông dụng. Điểm nổi bật của Python là nó có tính hướng đối tượng mạnh. Dưới đây là những điều bạn cần biết về lập trình hướng đối tượng trong Python.
Giới thiệu về OOP trong Python
Lập trình hướng đối tượng Python (OOP) là một mô hình lập trình sử dụng các đối tượng và lớp trong lập trình. Nó nhằm mục đích triển khai các thực thể trong thế giới thực như kế thừa, đa hình, đóng gói, v.v. bằng lập trình. Khái niệm chính của OOP là liên kết dữ liệu và các chức năng hoạt động trên dữ liệu đó với nhau thành một đơn vị duy nhất để không phần nào khác của mã có thể truy cập dữ liệu này.
Các khái niệm cơ bản trong lập trình Python hướng đối tượng:
- Class
- Objects
- Polymorphism
- Encapsulation
- Inheritance
- Data Abstraction
Khái niệm về OOP trong Python tập trung vào việc tạo code sử dụng lại. Khái niệm này còn được gọi là DRY (Don't Repeat Yourself).
Một ví dụ về class là lớp Dog. Đừng nghĩ về nó như một con chó cụ thể, hoặc con chó của riêng bạn. Chúng ta đang mô tả một con chó là gì và có thể làm gì, nói chung. Chó thường có tên và tuổi; đây là các thuộc tính thể hiện. Chó cũng có thể sủa; đây là một phương thức.
Khi bạn nói về một con chó cụ thể, bạn sẽ có một đối tượng trong lập trình: một đối tượng là một thể hiện của một lớp. Đây là nguyên tắc cơ bản mà lập trình hướng đối tượng dựa trên. Vì vậy, con chó Ozzy của tôi, ví dụ, thuộc về lớp Dog. Các thuộc tính của nó là name = 'Ozzy' và age = '2'. Mỗi con chó khác nhau sẽ có các thuộc tính khác nhau.
Giờ hãy cùng nhau tìm hiểu chi tiết nhé!
Các nguyên lý
Trong Python, khái niệm về OOP tuân theo một số nguyên lý cơ bản là tính đóng gói, tính kế thừa và tính đa hình.
- Tính kế thừa (Inheritance): cho phép một lớp (class) có thể kế thừa các thuộc tính và phương thức từ các lớp khác đã được định nghĩa.
- Tính đóng gói (Encapsulation): là quy tắc yêu cầu trạng thái bên trong của một đối tượng được bảo vệ và tránh truy cập được từ code bên ngoài (tức là code bên ngoài không thể trực tiếp nhìn thấy và thay đổi trạng thái của đối tượng đó).
- Tính đa hình (Polymorphism): là khái niệm mà hai hoặc nhiều lớp có những phương thức giống nhau nhưng có thể thực thi theo những cách thức khác nhau.
Lớp (Class) và Đối tượng (Object)
Class và Object là hai khái niệm cơ bản trong lập trình hướng đối tượng.
Đối tượng (Object) là những thực thể tồn tại có hành vi.
Ví dụ đối tượng là một xe ô tô có tên hãng, màu sắc, loại nguyên liệu, hành vi đi, dừng, đỗ, nổ máy...
Lớp (Class) là một kiểu dữ liệu đặc biệt do người dùng định nghĩa, tập hợp nhiều thuộc tính đặc trưng cho mọi đối tượng được tạo ra từ lớp đó.
Thuộc tính là các giá trị của lớp. Sau này khi các đối tượng được tạo ra từ lớp, thì thuộc tính của lớp lúc này sẽ trở thành các đặc điểm của đối tượng đó.
Phân biệt giữa Đối tượng (Object) và Lớp (Class):
Đối tượng (Object): có trạng thái và hành vi.
Lớp (Class): có thể được định nghĩa như là một template mô tả trạng thái và hành vi mà loại đối tượng của lớp hỗ trợ. Một đối tượng là một thực thể (instance) của một lớp
Ví dụ về Class và Object:
class Car:
# thuộc tính lớp
loaixe = "Ô tô"
# thuộc tính đối tượng
def __init__(self, tenxe, mausac, nguyenlieu):
self.tenxe = tenxe
self.mausac = mausac
self.nguyenlieu = nguyenlieu
# instantiate the Car class
toyota = Car("Toyota", "Đỏ", "Điện")
lamborghini = Car("Lamborghini", "Vàng", "Deisel")
porsche = Car("Porsche", "Xanh", "Gas")
# access the class attributes
print("Porsche là {}.".format(porsche.__class__.loaixe))
print("Toyota là {}.".format(toyota.__class__.loaixe))
print("Lamborghini cũng là {}.".format(lamborghini.__class__.loaixe))
# access the instance attributes
print("Xe {} có màu {}. {} là nguyên liệu vận hành.".format( toyota.tenxe, toyota.mausac, toyota.nguyenlieu))
print("Xe {} có màu {}. {} là nguyên liệu vận hành.".format( lamborghini.tenxe, lamborghini.mausac,lamborghini.nguyenlieu))
print("Xe {} có màu {}. {} là nguyên liệu vận hành.".format( porsche.tenxe, porsche.mausac, porsche.nguyenlieu))
Kết quả trả về sẽ là:
Porsche là Ô tô.
Toyota là Ô tô.
Lamborghini cũng là Ô tô.
Xe Toyota có màu Đỏ. Điện là nguyên liệu vận hành.
Xe Lamborghini có màu Vàng. Deisel là nguyên liệu vận hành.
Xe Porsche có màu Xanh. Gas là nguyên liệu vận hành.
>
Chương trình trên tạo một lớp Car, sau đó xác định các thuộc tính, đặc điểm của đối tượng
Chúng ta truy cập thuộc tính class bằng cách sử dụng __class __.loaixe. Các thuộc tính lớp được chia sẻ cho tất cả các cá thể của lớp.
Tương tự, chúng ta truy cập các thuộc tính instance bằng cách sử dụng toyota.tenxe, toyota.mausac và toyota.nguyenlieu.
Tuy nhiên, các thuộc tính instance là khác nhau cho mỗi cá thể của một lớp.
So sánh class cha và class con
Ví dụ tạo một class con cho từng thành phần:
class Dog:
species = "Canis familiaris"
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return f"{self.name} is {self.age} years old"
def speak(self, sound):
return f"{self.name} says {sound}"
Nhớ rằng để tạo một class con, bạn tạo class mới bằng tên riêng của nó, rồi nhập tên class cha vào trong dấu ngoặc đơn. Thêm dòng sau vào file dog.py để tạo 3 class con mới cho class Dog:
class JackRussellTerrier(Dog): pass class Dachshund(Dog): pass class Bulldog(Dog): Pass
Nhấn F5 để lưu và chạy file. Với claas đã được xác định, giờ bạn có thể khởi tạo một số giống chó cụ thể trong cửa sổ tương tác:
>>> miles = JackRussellTerrier("Miles", 4)
>>> buddy = Dachshund("Buddy", 9)
>>> jack = Bulldog("Jack", 3)
>>> jim = Bulldog("Jim", 5)
Các phiên bản của lớp con kế thừa tất cả các thuộc tính và phương thức của lớp cha:
>>> miles.species
'Canis familiaris'
>>> buddy.name
'Buddy'
>>> print(jack)
Jack is 3 years old
>>> jim.speak("Woof")
'Jim says Woof'
Để xác định class một đối tượng được cung cấp thuộc về, bạn có thể dùng type() sau:
>>> type(miles) <class '__main__.JackRussellTerrier'>
Nếu muốn xác định xem liệu miles có phải một phiên bản của class Dog? Bạn có thể làm việc này bằng isinstance():
>>> isinstance(miles, Dog) True
Nhìn chung, toàn bộ đối tượng được tạo từ class con là các phiên bản của class cha, dù chúng có thể không phải phiên bản của class con khác.
Điểm cần ghi nhớ về class
- Class được tạo bởi class keyword (từ khóa).
- Thuộc tính là biến thuộc về class.
- Thuộc tính luôn công khai và có thể được truy cập bằng toán tử (.). Ví dụ: Myclass.Myattribute
Phương thức
Phương thức (Method) là các hàm được định nghĩa bên trong phần thân của một lớp. Chúng được sử dụng để xác định các hành vi của một đối tượng.
Ví dụ về Class và Method
class Car:
# thuộc tính đối tượng
def __init__(self, tenxe, mausac, nguyenlieu):
self.tenxe = tenxe
self.mausac = mausac
self.nguyenlieu = nguyenlieu
# phương thức
def dungxe(self, mucdich):
return "{} đang dừng xe để {}".format(self.tenxe,mucdich)
def chayxe(self):
return "{} đang chạy trên đường".format(self.tenxe)
def nomay(self):
return "{} đang nổ máy".format(self.tenxe)
# instantiate the Car class
toyota = Car("Toyota", "Đỏ", "Điện")
lamborghini = Car("Lamborghini", "Vàng", "Deisel")
porsche = Car("Porsche", "Xanh", "Gas")
# call our instance methods
print(toyota.dungxe("nạp điện"))
print(lamborghini.chayxe())
print(porsche.nomay())
Chạy chương trình, màn hình sẽ trả về kết quả:
Toyota đang dừng xe để nạp điện
Lamborghini đang chạy trên đường
Porsche đang nổ máy
Ở ví dụ này, có ba phương thức là dungxe(), chayxe() và nomay(). Chúng được gọi là phương thức instance bởi vì chúng được gọi trên một đối tượng instance (toyota, lamborghini, porsche).
Kế thừa (Inheritance)
Kế thừa là khả năng của một class để lấy hoặc kế thừa các thuộc tính từ một lớp khác. Lớp dẫn xuất các thuộc tính được gọi là lớp dẫn xuất hoặc lớp con và lớp mà từ đó các thuộc tính được dẫn xuất được gọi là lớp cơ sở hoặc lớp cha. Lợi ích của việc thừa kế là:
Nó thể hiện tốt các mối quan hệ tại thế giới thực.
- Nó cung cấp khả năng tái sử dụng code. Bạn không phải viết lại code nhiều lần. Ngoài ra, nó cũng cho phép lập trình viên thêm nhiều tính năng hơn vào class mà không cần chỉnh sửa nó.
- Về bản chất, nó có tính chất bắc cầu. Điều đó có nghĩa nếu class B kế thừa class A khác, thì tất cả class phụ của B sẽ tự động kế thừa A.
Các kiểu kế thừa:
- Kế thừa đơn: Kế thừa một cấp cho phép lớp dẫn xuất kế thừa các đặc điểm từ lớp cha đơn.
- Kế thừa đa cấp: Kế thừa đa cấp cho phép một lớp dẫn xuất kế thừa các thuộc tính từ lớp cha trực tiếp, từ đó kế thừa các thuộc tính từ lớp cha của nó.
- Kế thừa theo thứ bậc: Kế thừa ở cấp độ thứ bậc cho phép nhiều lớp dẫn xuất kế thừa các thuộc tính từ một lớp cha.
- Đa kế thừa: Kế thừa nhiều cấp cho phép một lớp dẫn xuất kế thừa các thuộc tính từ nhiều lớp cơ sở.
# Lớp cha
class Car:
# Constructor
def __init__(self, hangxe, tenxe, mausac):
# Lớp Car có 3 thuộc tính: tenxe, mausac, hang xe
self.hangxe = hangxe
self.tenxe = tenxe
self.mausac = mausac
# phương thức
def chayxe(self):
print ("{} đang chạy trên đường".format(self.tenxe))
def dungxe(self, mucdich):
print ("{} đang dừng xe để {}".format(self.tenxe, mucdich))
# Lớp Toyota mở rộng từ lớp Car.
class Toyota(Car):
def __init__(self, hangxe, tenxe, mausac, nguyenlieu):
# Gọi tới constructor của lớp cha (Car)
# để gán giá trị vào thuộc tính của lớp cha.
super().__init__(hangxe, tenxe, mausac)
self.nguyenlieu = nguyenlieu
# Kế thừa phương thức cũ
def chayxe(self):
print ("{} đang chạy trên đường".format(self.tenxe))
# Ghi đè (override) phương thức cùng tên của lớp cha.
def dungxe(self, mucdich):
print ("{} đang dừng xe để {}".format(self.tenxe, mucdich))
print ("{} chạy bằng {}".format(self.tenxe, self.nguyenlieu))
# Bổ sung thêm thành phần mới
def nomay(self):
print ("{} đang nổ máy".format(self.tenxe))
toyota1 = Toyota("Toyota", "Toyota Hilux", "Đỏ", "Điện")
toyota2 = Toyota("Toyota", "Toyota Yaris", "Vàng", "Deisel")
toyota3 = Toyota("Toyota", "Toyota Vios", "Xanh", "Gas")
toyota1.dungxe("nạp điện")
toyota2.chayxe()
toyota3.nomay()
Kết quả trả về:
Toyota Hilux đang dừng xe để nạp điện
Toyota Hilux chạy bằng Điện
Toyota Yaris đang chạy trên đường
Toyota Vios đang nổ máy
Chương trình này tạo hai lớp kế thừa: lớp cha Car và lớp con Toyota.
Khai báo constructor mới để gán giá trị vào thuộc tính của lớp cha. Hàm super() đứng trước phương thức __init __ để gọi tới nội dung __init __ của Car.
Class Toyota kế thừa hàm chayxe() và dungxe() của class Car đồng thời sửa đổi một hành vi thể hiện ở phương thức dungxe(). Sau đó lớp con bổ sung thêm thành phần mới là nomay() để mở rộng kế thừa.
Đóng gói (Encapsulation)
Sử dụng OOP trong Python, chúng ta có thể hạn chế quyền truy cập vào trạng thái bên trong của đối tượng. Điều này ngăn chặn dữ liệu bị sửa đổi trực tiếp, được gọi là đóng gói. Trong Python, chúng ta biểu thị thuộc tính private này bằng cách sử dụng dấu gạch dưới làm tiền tố: “_” hoặc “__“.
class Computer:
def __init__(self):
self.__maxprice = 900
def sell(self):
print("Giá bán sản phẩm là: {}".format(self.__maxprice))
def setMaxPrice(self, price):
self.__maxprice = price
c = Computer()
c.sell()
# thay đổi giá:
c.__maxprice = 1000
c.sell()
# sử dụng hàm để thay đổi giá:
c.setMaxPrice(1000)
c.sell()
Màn hình hiển thị kết quả:
Giá bán sản phẩm là: 900
Giá bán sản phẩm là: 900
Giá bán sản phẩm là: 1000
>
Ở ví dụ này, bạn khởi tạo class Computer, sử dụng __init __() để lưu trữ giá bán tối đa của máy tính. Nhưng sau khi sử dụng, bạn có nhu cầu sửa đổi giá, tuy nhiên không thể thay đổi theo cách bình thường vì Python đã coi __maxprice là thuộc tính private. Vậy nên để thay đổi giá trị, ta sử dụng hàm setter setMaxPrice().
Đa hình (Polymorphism)
Tính đa hình là khái niệm mà hai hoặc nhiều lớp có những phương thức giống nhau nhưng có thể thực thi theo những cách thức khác nhau.
Giả sử, chúng ta cần tô màu một hình khối, có rất nhiều lựa chọn cho hình của bạn như hình chữ nhật, hình vuông, hình tròn. Tuy nhiên, bạn có thể sử dụng cùng một phương pháp để tô màu bất kỳ hình dạng nào.
class Toyota:
def dungxe(self):
print("Toyota dừng xe để nạp điện")
def nomay(self):
print("Toyota nổ máy bằng hộp số tự động")
class Porsche:
def dungxe(self):
print("Porsche dừng xe để bơm xăng")
def nomay(self):
print("Porsche nổ máy bằng hộp số cơ")
# common interface
def kiemtra_dungxe(car): car.dungxe()
# instantiate objects
toyota = Toyota()
porsche = Porsche()
# passing the object
kiemtra_dungxe(toyota)
kiemtra_dungxe(porsche)
Ở ví dụ này, bạn vừa tạo hai lớp Toyota và Porsche, cả hai lớp đều có phương thức dungxe(). Truy nhiên hàm của chúng khác nhau. Ta sử dụng tính đa hình để tạo hàm chung cho hai lớp, đó là kiemtra_dungxe(). Tiếp theo, bạn truyền đối tượng toyota và porsche vào hàm vừa tạo, và ta lấy được kết quả như này:
Toyota dừng xe để nạp điện
Porsche dừng xe để bơm xăng
Vậy là Quantrimang vừa giới thiệu cho bạn những điểm nổi bật của OOP rồi. Qua bài viết, có thể rút ra một số nhận xét như này:
- Lập trình trở nên dễ dàng và hiệu quả hơn.
- Class có thể chia sẻ được nên code dễ dàng được sử dụng lại.
- Năng suất của chương trình tăng lên
- Dữ liệu an toàn và bảo mật với trừu tượng hóa dữ liệu.
Nhìn chung, lập trình hướng đối tượng là một khái niệm cơ bản trong Python, trao quyền cho các nhà phát triển xây dựng ứng dụng theo mô-đun, có thể bảo trì và mở rộng. Bằng cách hiểu các nguyên tắc cốt lõi của OOP (lớp, đối tượng, kế thừa, đóng gói, đa hình và trừu tượng), các lập trình viên có thể tận dụng toàn bộ tiềm năng OOP của Python để thiết kế các giải pháp thanh lịch và hiệu quả cho những vấn đề phức tạp.
