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

# 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

# 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

# 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

# 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

# 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

# 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

# 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

# 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

# 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 = unitdef 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 = unitdef 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/