Hướng dẫn which oop principle is majorly used by python to perform abstraction? - nguyên tắc oop nào được python chủ yếu sử dụng để thực hiện trừu tượng?

Trừu tượng, đóng gói, kế thừa, đa hình là bốn trụ cột của người Hồi giáo của lập trình hướng đối tượng. Chúng tôi sẽ xem qua một lời giải thích ngắn gọn về từng người ở Python, và cách chúng liên quan đến bức tranh của ngôi nhà (mong muốn) của tôi ở trên. are the “four pillars” of Object-Oriented Programming. We will go over a brief explanation of each in Python, and how they relate to the picture of my (wishful) house above.

Đóng gói

Nhà tôi có một mái nhà để bảo vệ bên trong khỏi mưa. Nó có một cánh cửa để ngăn chặn bất cứ ai chỉ lang thang. Chắc chắn, nó cũng có cửa sổ- nhưng tôi có cửa chớp trên những người đó và kiểm soát những người mà tôi muốn nhìn vào. Theo những cách này, ngôi nhà của tôi được gói gọn, hoặc được bảo vệ, được bảo vệ, từ bên ngoài. Khi tôi gói gọn một cái gì đó trong mã của mình, tôi thận trọng để không để các hiệu ứng bên ngoài tác động đến mã đó. Khi tôi tuân thủ nguyên tắc này, nó làm cho mã của tôi dễ dự đoán hơn và không dễ bị lỗi.When I encapsulate something in my code, I am taking caution to not let outside effects impact that code. When I adhere to this principle, it makes my code more predictable, and not as vulnerable to bugs.

class House:  

def set_wall_material(self, wall_material):
self.wall_matrial = wall_material

def get_wall_material(self):
print(self.wall_material)

Chuyện gì đang xảy ra ở đây?

Chúng tôi đang sử dụng một setter setter và một người nhận được để đặt thuộc tính wall_material trên thể hiện House của chúng tôi và sau đó lấy thuộc tính đó bằng một phương thức riêng biệt, get_wall_material. Lưu ý rằng chúng tôi đã không khởi tạo House của chúng tôi với wall_material, thay vào đó, chúng tôi đang xác định các phương thức xử lý việc nhận và cài đặt của thuộc tính riêng.

Di sản

Ngôi nhà có khí đốt, điện và nước. Tất cả ba trong số những điều này là tiện nghi, và các tiện nghi chia sẻ một số điểm chung. Ví dụ, tất cả chúng đều có thể được coi là trên mạng hoặc trên mạng, nhưng tất cả họ đều có một đơn vị khác nhau mà chúng được đo lường. Hãy để chúng tôi xem làm thế nào chúng ta có thể tạo ra một lớp cha mẹ, Các lớp học,

# The parent classclass Amenity:
def __init__(self, is_running):
self.is_running = is_running
def set_is_running(self, currently_running):
self.is_running = currently_running
print(f"{self} is running: {self.is_running}")
# Children classes. We first use the __init__ method to add properties to the class, and the super().__init__ method to inherit all of the parents class functionalityclass Gas(Amenity):
def __init__(self, is_running, cubic_feet):
self.cubic_feet = cubic_feet
super().__init__(is_running)
def __str__(self):
return f"<{self.__class__.__name__}: {self.cubic_feet}/cuft of gas>"
class Electricity(Amenity):
def __init__(self, is_running, watts):
self.watts = watts
super().__init__(is_running)

def __str__(self):
return f"<{self.__class__.__name__}: {self.watts}/watts of electricity>"

class Water(Amenity):
def __init__(self, is_running, gallons):
self.gallons = gallons
super().__init__(is_running)
def __str__(self):
return f"<{self.__class__.__name__}: {self.gallons}/gallons of water>"
# Driver Code
g = Gas(False, 236)
e = Electricity(False, 104.2)
w = Water(True, 16)
g.set_is_running(True)
g.set_is_running(False)
e.set_is_running(True)
e.set_is_running(False)
w.set_is_running(True)
w.set_is_running(False)
# Output
is running: True
is running: False
is running: True
is running: False
is running: True
is running: False
0,
# The parent classclass Amenity:
def __init__(self, is_running):
self.is_running = is_running
def set_is_running(self, currently_running):
self.is_running = currently_running
print(f"{self} is running: {self.is_running}")
# Children classes. We first use the __init__ method to add properties to the class, and the super().__init__ method to inherit all of the parents class functionalityclass Gas(Amenity):
def __init__(self, is_running, cubic_feet):
self.cubic_feet = cubic_feet
super().__init__(is_running)
def __str__(self):
return f"<{self.__class__.__name__}: {self.cubic_feet}/cuft of gas>"
class Electricity(Amenity):
def __init__(self, is_running, watts):
self.watts = watts
super().__init__(is_running)

def __str__(self):
return f"<{self.__class__.__name__}: {self.watts}/watts of electricity>"

class Water(Amenity):
def __init__(self, is_running, gallons):
self.gallons = gallons
super().__init__(is_running)
def __str__(self):
return f"<{self.__class__.__name__}: {self.gallons}/gallons of water>"
# Driver Code
g = Gas(False, 236)
e = Electricity(False, 104.2)
w = Water(True, 16)
g.set_is_running(True)
g.set_is_running(False)
e.set_is_running(True)
e.set_is_running(False)
w.set_is_running(True)
w.set_is_running(False)
# Output
is running: True
is running: False
is running: True
is running: False
is running: True
is running: False
1 và
# The parent classclass Amenity:
def __init__(self, is_running):
self.is_running = is_running
def set_is_running(self, currently_running):
self.is_running = currently_running
print(f"{self} is running: {self.is_running}")
# Children classes. We first use the __init__ method to add properties to the class, and the super().__init__ method to inherit all of the parents class functionalityclass Gas(Amenity):
def __init__(self, is_running, cubic_feet):
self.cubic_feet = cubic_feet
super().__init__(is_running)
def __str__(self):
return f"<{self.__class__.__name__}: {self.cubic_feet}/cuft of gas>"
class Electricity(Amenity):
def __init__(self, is_running, watts):
self.watts = watts
super().__init__(is_running)

def __str__(self):
return f"<{self.__class__.__name__}: {self.watts}/watts of electricity>"

class Water(Amenity):
def __init__(self, is_running, gallons):
self.gallons = gallons
super().__init__(is_running)
def __str__(self):
return f"<{self.__class__.__name__}: {self.gallons}/gallons of water>"
# Driver Code
g = Gas(False, 236)
e = Electricity(False, 104.2)
w = Water(True, 16)
g.set_is_running(True)
g.set_is_running(False)
e.set_is_running(True)
e.set_is_running(False)
w.set_is_running(True)
w.set_is_running(False)
# Output
is running: True
is running: False
is running: True
is running: False
is running: True
is running: False
2.All three of these things are amenities, and amenities share some things in common. For example, they can all be considered “on” or “off”, but yet they all have a different unit that they are measured in. Let us see how we can create a parent class, Amenity, and extend its functionality to three children classes,
# The parent classclass Amenity:
def __init__(self, is_running):
self.is_running = is_running
def set_is_running(self, currently_running):
self.is_running = currently_running
print(f"{self} is running: {self.is_running}")
# Children classes. We first use the __init__ method to add properties to the class, and the super().__init__ method to inherit all of the parents class functionalityclass Gas(Amenity):
def __init__(self, is_running, cubic_feet):
self.cubic_feet = cubic_feet
super().__init__(is_running)
def __str__(self):
return f"<{self.__class__.__name__}: {self.cubic_feet}/cuft of gas>"
class Electricity(Amenity):
def __init__(self, is_running, watts):
self.watts = watts
super().__init__(is_running)

def __str__(self):
return f"<{self.__class__.__name__}: {self.watts}/watts of electricity>"

class Water(Amenity):
def __init__(self, is_running, gallons):
self.gallons = gallons
super().__init__(is_running)
def __str__(self):
return f"<{self.__class__.__name__}: {self.gallons}/gallons of water>"
# Driver Code
g = Gas(False, 236)
e = Electricity(False, 104.2)
w = Water(True, 16)
g.set_is_running(True)
g.set_is_running(False)
e.set_is_running(True)
e.set_is_running(False)
w.set_is_running(True)
w.set_is_running(False)
# Output
is running: True
is running: False
is running: True
is running: False
is running: True
is running: False
0,
# The parent classclass Amenity:
def __init__(self, is_running):
self.is_running = is_running
def set_is_running(self, currently_running):
self.is_running = currently_running
print(f"{self} is running: {self.is_running}")
# Children classes. We first use the __init__ method to add properties to the class, and the super().__init__ method to inherit all of the parents class functionalityclass Gas(Amenity):
def __init__(self, is_running, cubic_feet):
self.cubic_feet = cubic_feet
super().__init__(is_running)
def __str__(self):
return f"<{self.__class__.__name__}: {self.cubic_feet}/cuft of gas>"
class Electricity(Amenity):
def __init__(self, is_running, watts):
self.watts = watts
super().__init__(is_running)

def __str__(self):
return f"<{self.__class__.__name__}: {self.watts}/watts of electricity>"

class Water(Amenity):
def __init__(self, is_running, gallons):
self.gallons = gallons
super().__init__(is_running)
def __str__(self):
return f"<{self.__class__.__name__}: {self.gallons}/gallons of water>"
# Driver Code
g = Gas(False, 236)
e = Electricity(False, 104.2)
w = Water(True, 16)
g.set_is_running(True)
g.set_is_running(False)
e.set_is_running(True)
e.set_is_running(False)
w.set_is_running(True)
w.set_is_running(False)
# Output
is running: True
is running: False
is running: True
is running: False
is running: True
is running: False
1, and
# The parent classclass Amenity:
def __init__(self, is_running):
self.is_running = is_running
def set_is_running(self, currently_running):
self.is_running = currently_running
print(f"{self} is running: {self.is_running}")
# Children classes. We first use the __init__ method to add properties to the class, and the super().__init__ method to inherit all of the parents class functionalityclass Gas(Amenity):
def __init__(self, is_running, cubic_feet):
self.cubic_feet = cubic_feet
super().__init__(is_running)
def __str__(self):
return f"<{self.__class__.__name__}: {self.cubic_feet}/cuft of gas>"
class Electricity(Amenity):
def __init__(self, is_running, watts):
self.watts = watts
super().__init__(is_running)

def __str__(self):
return f"<{self.__class__.__name__}: {self.watts}/watts of electricity>"

class Water(Amenity):
def __init__(self, is_running, gallons):
self.gallons = gallons
super().__init__(is_running)
def __str__(self):
return f"<{self.__class__.__name__}: {self.gallons}/gallons of water>"
# Driver Code
g = Gas(False, 236)
e = Electricity(False, 104.2)
w = Water(True, 16)
g.set_is_running(True)
g.set_is_running(False)
e.set_is_running(True)
e.set_is_running(False)
w.set_is_running(True)
w.set_is_running(False)
# Output
is running: True
is running: False
is running: True
is running: False
is running: True
is running: False
2.

# The parent classclass Amenity:
def __init__(self, is_running):
self.is_running = is_running
def set_is_running(self, currently_running):
self.is_running = currently_running
print(f"{self} is running: {self.is_running}")
# Children classes. We first use the __init__ method to add properties to the class, and the super().__init__ method to inherit all of the parents class functionalityclass Gas(Amenity):
def __init__(self, is_running, cubic_feet):
self.cubic_feet = cubic_feet
super().__init__(is_running)
def __str__(self):
return f"<{self.__class__.__name__}: {self.cubic_feet}/cuft of gas>"
class Electricity(Amenity):
def __init__(self, is_running, watts):
self.watts = watts
super().__init__(is_running)

def __str__(self):
return f"<{self.__class__.__name__}: {self.watts}/watts of electricity>"

class Water(Amenity):
def __init__(self, is_running, gallons):
self.gallons = gallons
super().__init__(is_running)
def __str__(self):
return f"<{self.__class__.__name__}: {self.gallons}/gallons of water>"
# Driver Code
g = Gas(False, 236)
e = Electricity(False, 104.2)
w = Water(True, 16)
g.set_is_running(True)
g.set_is_running(False)
e.set_is_running(True)
e.set_is_running(False)
w.set_is_running(True)
w.set_is_running(False)
# Output
is running: True
is running: False
is running: True
is running: False
is running: True
is running: False

Trừu tượng hóa

Ngôi nhà màu xanh tuyệt đẹp của tôi trên một cái ao kỳ lạ có nước, điện và khí đốt- nhưng bạn không cần phải biết mỗi thứ này hoạt động như thế nào. Thay vào đó, bạn lật công tắc đèn và đèn bật sáng; Bạn bật bếp và một vòng tròn màu xanh của ngọn lửa nhẹ nhàng cuộn lên trên; Bạn đẩy tay cầm vòi lên và một dòng nước trong vắt đổ ra. Tường và nền tảng của ngôi nhà trừu tượng hóa các chi tiết về cách những thứ này hoạt động, và bạn là khách của tôi tận hưởng chúng một cách hạnh phúc không biết về dây dài, ống bị chôn sâu và bể nước lớn cung cấp cho bạn những tiện nghi này. Trừu tượng trong Python là quá trình che giấu việc triển khai thực sự của một ứng dụng từ người dùng và chỉ nhấn mạnh cách sử dụng ứng dụng. Hãy cùng xem xét các ví dụ về các lớp trừu tượng trong Python:Abstraction in Python is the process of hiding the real implementation of an application from the user and emphasizing only how to use the application. Let’s look at examples of abstract classes in Python:

# We import ABC and abstractmethod from the abc module
from
abc import ABC, abstractmethod
# Amenity becomes our abstract base class (ABC)
class Amenity(ABC):
def turn_on(self):
pass
# We extend our ABC to three new child classes
class Electricity(Amenity):
def turn_on(self):
print("You flipped the light switch!")
class Water(Amenity): def turn_on(self):
print("You pressed the faucet up!")
class Gas(Amenity): def turn_on(self):
print("You turned the knob on the stovefront!")
# Driver code
W = Electricity()
W.turn_on()
E = Water()
E.turn_on()
G = Gas()
G.turn_on()
# Output
You pressed the faucet up!
You flipped the light switch!
You turned the knob on the stovefront!

Chuyện gì đang xảy ra ở đây?

Chúng tôi đang sử dụng một setter setter và một người nhận được để đặt thuộc tính wall_material trên thể hiện House của chúng tôi và sau đó lấy thuộc tính đó bằng một phương thức riêng biệt, get_wall_material. Lưu ý rằng chúng tôi đã không khởi tạo House của chúng tôi với wall_material, thay vào đó, chúng tôi đang xác định các phương thức xử lý việc nhận và cài đặt của thuộc tính riêng.you can turn it on. We leave the implementation of it to each of our amenity child classes.

Di sản

Ngôi nhà có khí đốt, điện và nước. Tất cả ba trong số những điều này là tiện nghi, và các tiện nghi chia sẻ một số điểm chung. Ví dụ, tất cả chúng đều có thể được coi là trên mạng hoặc trên mạng, nhưng tất cả họ đều có một đơn vị khác nhau mà chúng được đo lường. Hãy để chúng tôi xem làm thế nào chúng ta có thể tạo ra một lớp cha mẹ, Các lớp học,

# The parent classclass Amenity:
def __init__(self, is_running):
self.is_running = is_running
def set_is_running(self, currently_running):
self.is_running = currently_running
print(f"{self} is running: {self.is_running}")
# Children classes. We first use the __init__ method to add properties to the class, and the super().__init__ method to inherit all of the parents class functionalityclass Gas(Amenity):
def __init__(self, is_running, cubic_feet):
self.cubic_feet = cubic_feet
super().__init__(is_running)
def __str__(self):
return f"<{self.__class__.__name__}: {self.cubic_feet}/cuft of gas>"
class Electricity(Amenity):
def __init__(self, is_running, watts):
self.watts = watts
super().__init__(is_running)

def __str__(self):
return f"<{self.__class__.__name__}: {self.watts}/watts of electricity>"

class Water(Amenity):
def __init__(self, is_running, gallons):
self.gallons = gallons
super().__init__(is_running)
def __str__(self):
return f"<{self.__class__.__name__}: {self.gallons}/gallons of water>"
# Driver Code
g = Gas(False, 236)
e = Electricity(False, 104.2)
w = Water(True, 16)
g.set_is_running(True)
g.set_is_running(False)
e.set_is_running(True)
e.set_is_running(False)
w.set_is_running(True)
w.set_is_running(False)
# Output
is running: True
is running: False
is running: True
is running: False
is running: True
is running: False
0,
# The parent classclass Amenity:
def __init__(self, is_running):
self.is_running = is_running
def set_is_running(self, currently_running):
self.is_running = currently_running
print(f"{self} is running: {self.is_running}")
# Children classes. We first use the __init__ method to add properties to the class, and the super().__init__ method to inherit all of the parents class functionalityclass Gas(Amenity):
def __init__(self, is_running, cubic_feet):
self.cubic_feet = cubic_feet
super().__init__(is_running)
def __str__(self):
return f"<{self.__class__.__name__}: {self.cubic_feet}/cuft of gas>"
class Electricity(Amenity):
def __init__(self, is_running, watts):
self.watts = watts
super().__init__(is_running)

def __str__(self):
return f"<{self.__class__.__name__}: {self.watts}/watts of electricity>"

class Water(Amenity):
def __init__(self, is_running, gallons):
self.gallons = gallons
super().__init__(is_running)
def __str__(self):
return f"<{self.__class__.__name__}: {self.gallons}/gallons of water>"
# Driver Code
g = Gas(False, 236)
e = Electricity(False, 104.2)
w = Water(True, 16)
g.set_is_running(True)
g.set_is_running(False)
e.set_is_running(True)
e.set_is_running(False)
w.set_is_running(True)
w.set_is_running(False)
# Output
is running: True
is running: False
is running: True
is running: False
is running: True
is running: False
1 và
# The parent classclass Amenity:
def __init__(self, is_running):
self.is_running = is_running
def set_is_running(self, currently_running):
self.is_running = currently_running
print(f"{self} is running: {self.is_running}")
# Children classes. We first use the __init__ method to add properties to the class, and the super().__init__ method to inherit all of the parents class functionalityclass Gas(Amenity):
def __init__(self, is_running, cubic_feet):
self.cubic_feet = cubic_feet
super().__init__(is_running)
def __str__(self):
return f"<{self.__class__.__name__}: {self.cubic_feet}/cuft of gas>"
class Electricity(Amenity):
def __init__(self, is_running, watts):
self.watts = watts
super().__init__(is_running)

def __str__(self):
return f"<{self.__class__.__name__}: {self.watts}/watts of electricity>"

class Water(Amenity):
def __init__(self, is_running, gallons):
self.gallons = gallons
super().__init__(is_running)
def __str__(self):
return f"<{self.__class__.__name__}: {self.gallons}/gallons of water>"
# Driver Code
g = Gas(False, 236)
e = Electricity(False, 104.2)
w = Water(True, 16)
g.set_is_running(True)
g.set_is_running(False)
e.set_is_running(True)
e.set_is_running(False)
w.set_is_running(True)
w.set_is_running(False)
# Output
is running: True
is running: False
is running: True
is running: False
is running: True
is running: False
2.
When we previously used inheritance, we explicitly linked parent classes to child classes to write reusable code. Polymorphism is achieving the same outcome of shared properties and methods but there is no link between the code; instead, we write the properties and methods to operate in similar and logical ways, allowing us to freely swap classes and methods and being able to expect a similar output.

# Define two classes that have similar implementation and therefore can be mixed and matched in an iteration.class Gas:
def __init__(self, price, unit):
self.price = price
self.unit = unit
def info(self):
print(f"I am gas. My price is {self.price}, measured in {self.unit}.")
def make_sound(self):
print("psssssssssssssss")
class Water:
def __init__(self, price, unit):
self.price = price
self.unit = unit
def info(self):
print(f"I am water. My price is {self.price}, measured in {self.unit}.")
def make_sound(self):
print("whooooooosh")
# Driver Code
g = Gas(0.43, 'cu/ft')
w = Water(0.075, 'gallons')
for amenity in (g, w):
amenity.make_sound()
amenity.info()
# Output
psssssssssssssss
I am gas. My price is 0.43, measured in cu/ft.
whooooooosh
I am water. My price is 0.075, measured in gallons.

Trừu tượng hóa

Ngôi nhà màu xanh tuyệt đẹp của tôi trên một cái ao kỳ lạ có nước, điện và khí đốt- nhưng bạn không cần phải biết mỗi thứ này hoạt động như thế nào. Thay vào đó, bạn lật công tắc đèn và đèn bật sáng; Bạn bật bếp và một vòng tròn màu xanh của ngọn lửa nhẹ nhàng cuộn lên trên; Bạn đẩy tay cầm vòi lên và một dòng nước trong vắt đổ ra. Tường và nền tảng của ngôi nhà trừu tượng hóa các chi tiết về cách những thứ này hoạt động, và bạn là khách của tôi tận hưởng chúng một cách hạnh phúc không biết về dây dài, ống bị chôn sâu và bể nước lớn cung cấp cho bạn những tiện nghi này. Trừu tượng trong Python là quá trình che giấu việc triển khai thực sự của một ứng dụng từ người dùng và chỉ nhấn mạnh cách sử dụng ứng dụng. Hãy cùng xem xét các ví dụ về các lớp trừu tượng trong Python:

https://grandorimichael.medium.com/

Sự trừu tượng trong OOPS trong Python là gì?

Sự trừu tượng trong Python được định nghĩa là một quá trình xử lý sự phức tạp bằng cách che giấu thông tin không cần thiết từ người dùng. Đây là một trong những khái niệm cốt lõi của các ngôn ngữ lập trình hướng đối tượng (OOP).a process of handling complexity by hiding unnecessary information from the user. This is one of the core concepts of object-oriented programming (OOP) languages.

Làm thế nào để bạn làm một sự trừu tượng trong Python?

Trừu tượng dữ liệu trong Python có thể đạt được thông qua việc tạo các lớp trừu tượng và kế thừa chúng sau này.Trước khi thảo luận về các lớp trừu tượng là gì, chúng ta hãy giới thiệu ngắn gọn về thừa kế.Kế thừa trong OOP là một cách thông qua đó một lớp kế thừa các thuộc tính và phương thức của một lớp khác.creating abstract classes and inheriting them later. Before discussing what abstract classes are, let us have a brief introduction of inheritance. Inheritance in OOP is a way through which one class inherits the attributes and methods of another class.

Những khái niệm OOPS nào được hỗ trợ trong Python?

Các khái niệm OOP (lập trình hướng đối tượng) trong Python bao gồm lớp, đối tượng, phương pháp, kế thừa, đa hình, trừu tượng hóa dữ liệu và đóng gói.Class, Object, Method, Inheritance, Polymorphism, Data Abstraction, and Encapsulation.

Là trừu tượng là một nguyên tắc của OOP?

Trong lập trình hướng đối tượng, sự trừu tượng là một trong ba nguyên tắc trung tâm (cùng với đóng gói và kế thừa).Thông qua quá trình trừu tượng, một lập trình viên che giấu tất cả trừ dữ liệu liên quan về một đối tượng để giảm độ phức tạp và tăng hiệu quả.abstraction is one of three central principles (along with encapsulation and inheritance). Through the process of abstraction, a programmer hides all but the relevant data about an object in order to reduce complexity and increase efficiency.