📝前言: 上一篇文章Python基础——类讲解了python语法中的类,类是面相对象的模版,这篇文章我们就初步讲解面相对象的三大特征: 1,封装 2,继承 3,多态
封装指的是:将对象的状态(属性)和行为(方法)包装在一个单一的单元中。这样做的主要目的是为了保护对象的内部状态,并确保外部世界无法随意访问或修改它。同时,封装还可以提供一种方式来控制对对象的访问,从而实现数据的安全性和完整性。
在上篇文章中,我们讲到的方法都是公共方法。公共方法是指:不使用任何特殊前缀的方法。这些方法可以在类的外部被调用,用于提供对外部世界的访问或修改对象状态的途径。
在 Python 中,私有的属性和方法可以用于保护对象内部状态: 私有属性:使用双下划线前缀来定义私有属性,例如:
__private_attr
。这样的属性在类的外部是不可见的,也不能被外部访问。 私有方法:使用双下划线前缀来定义私有方法,例如__private_method
。这样的方法在类的外部是不可见的,也不能被外部调用。
以下是一个简单的示例,展示了如何在 Python 类中使用封装:
class BankAccount:
def __init__(self, account_holder, balance=0):
self.__account_holder = account_holder
self.__balance = balance
def deposit(self, amount):
if amount > 0:
self.__balance += amount
return f"Deposited ${amount}. New balance:${self.__balance}"
else:
return "Invalid deposit amount."
def withdraw(self, amount):
if amount > 0 and amount <= self.__balance:
self.__balance -= amount
return f"Withdrew ${amount}. New balance:${self.__balance}"
else:
return "Invalid withdrawal amount or insufficient funds."
def get_balance(self):
return f"Balance for {self.__account_holder}: ${self.__balance}"
account = BankAccount("Alice", 1000)
print(account.deposit(500))
print(account.withdraw(200))
print(account.get_balance())
# 错误示范:print(account.__account_holder)
在上面的示例中,BankAccount
类有两个私有属性 __account_holder
和 __balance
,以及三个公共方法 deposit
、withdraw
和 get_balance
。通过这种方式,我们可以保护账户持有人的姓名和余额,同时允许外部世界进行存款、取款和查询余额的操作。
输出结果:
继承:当一个类继承另一个类时,它会继承另一个类的属性和方法(不含私有)。这使得我们可以创建一个新类,无需从头开始定义,又可以拥有父类的特性。(也就是说,新类是基于父类定义的) 优点: 1,代码重用:通过继承,子类可以重用父类的代码,减少重复代码。 2,增加代码的模块化:继承有助于将代码组织为更小、更相关的模块。 3,提高代码的可维护性:当需要更改基类时,所有继承的子类都会受到影响。
单继承示例(即只继承一个父类):
假设我们有一个 Vehicle
类,它代表一种交通工具。这个类有一个 drive
方法,用于驾驶交通工具。我们可以定义一个 Car
类,它继承自 Vehicle
类。Car
类将包含更多关于汽车的信息,如 brand
和 model
。
class Vehicle:
def __init__(self, make):
self.make = make
def drive(self):
return "Driving"
class Car(Vehicle):
def __init__(self, brand, model):
super().__init__(brand) # 我们调用父类的__init__方法,给子类的brand赋初始值
self.model = model
my_car = Car("Toyota", "Camry") # 用子类创建对象
# 虽然Car里面没有drive()方法,但是Car继承了Vehicle的特征,所以可以调用父类的方法
print(my_car.drive()) # 输出:Driving
多继承(继承多个父类): 语法:
calss 子类名(父类1, 父类2,……):
……
多继承中,如果父类有同名属性或方法,先继承的优先级高于后继承的:
class Vehicle1:
def drive(self):
print("driving1")
class Vehicle2:
def drive(self):
print("driving2")
class Car(Vehicle1, Vehicle2):
def __init__(self,name):
self.name = name
car1 = Car('xiaomi')
car1.drive() # 输出:driving1
子类在继承父类的特征后,可以对特征(即属性和方)进行复写(重写) 例如: 首先,我们定义一个父类 Animal,它有一个方法 speak,接下来,我们定义一个子类 Dog,它继承自 Animal,并复写父类的方法 speak:
class Animal:
def speak(self):
return "Some sound"
class Dog(Animal):
def speak(self):
return "Woof!"
# 创建Dog示例,并调用speak方法:
dog = Dog()
print(dog.speak()) # 输出: Woof!
# 可见speak的返回内容被修改了
一旦复写完父类的特征,那么调用类的成员的时候,就会调用新成员 如果需要使用被复写的父类成员,需要使用特殊方法: (因为如果在子类内调用父类的同名成员,默认是调用子类复写的)
# 第一种
父类名.成员变量
父类名.成员方法(slef)
# 第二钟(相当于用super()找到了父类)
super().成员变量
super().成员方法(self)
例如:
class Animal:
def speak(self):
return "Some sound"
class Dog(Animal):
# 复写了父类的方法:
def speak(self):
return "Woof!"
# 调用父类原来的speak方法:
# 默认调用的是子类复写以后的:
def speak2(self):
return self.speak()
def speak3(self):
return Animal.speak(self) # 或者return super().speak(self)
# 创建Dog示例,并调用speak2方法:
dog = Dog()
print(dog.speak2()) # 输出:Woof(可见默认调用的是子类复写后的)
print(dog.speak3()) # 输出:Some sound
多态是面向对象编程中的一个核心概念,它允许我们使用统一的接口来定义多种不同的实现方式。多态的主要特点是基于对象的类型进行函数的调用,而这个过程是动态绑定的,即在运行时而非编译时确定调用哪个函数。
在Python中,由于其动态类型的特性,多态是天然存在的。这里我们可以从两个方面来讨论Python中的多态: 1,动态类型:Python是一种动态类型语言,这意味着我们不需要在声明变量时指定其类型。这使得函数可以接受任何类型的参数,只要该参数支持函数期望的操作或方法。 2,方法重写:子类可以提供父类方法的特定实现(即复写)。当子类对象调用该方法时,会调用子类中的实现,而不是父类中的实现。
下面是一个简单的例子来说明Python中的多态:
class Animal:
def sound(self):
pass # pass是占位语句,用来保证代码的完整性
class Dog(Animal):
def sound(self):
return "Woof!"
class Cat(Animal):
def sound(self):
return "Meow!"
def animal_sound(animal):
return animal.sound()
d = Dog()
c = Cat()
print(animal_sound(d)) # Woof!
print(animal_sound(c)) # Meow!
在上述代码中,我们定义了一个Animal
类,它有一个sound
方法。Dog
和Cat
子类分别重写了sound
方法,提供了它们自己的实现。
animal_sound
函数接受一个Animal
类型的参数,并调用其sound
方法。由于多态,这个函数可以接受任何实现了sound
方法的对象作为参数。
(Animal
类型指的是 Animal 类
所表示的类型,即在这个例子中,它是一个抽象基类)
总之,多态允许我们编写更加通用和可扩展的代码,而不需要关心具体的对象类型。 在此,我推荐一篇写的也很好的讲解多态的文章:Python | 多态(如有侵权,请告知)