做设计用哪个素材网站好,用dw做的网站怎么上传,做淘宝客要有网站吗,哈尔滨比较好的设计公司面向对象编程的三大特征#xff1a;封装、继承和多态。
注意#xff1a;在python面向对象编程中#xff0c;子类对象可以传递给父类类型
一、封装 在Python中#xff0c;封装是面向对象编程中的一种重要概念#xff0c;它可以帮助我们实现数据隐藏、信息保护和代码复用。…面向对象编程的三大特征封装、继承和多态。
注意在python面向对象编程中子类对象可以传递给父类类型
一、封装 在Python中封装是面向对象编程中的一种重要概念它可以帮助我们实现数据隐藏、信息保护和代码复用。在Python中通过使用访问控制修饰符属性和方法前加上两个下划线来实现封装。 封装就是我写了一个类我将一个类的属性、方法全部包装到了一个类中。我对类中某些方法和属性进行了隐藏外部实例化之后无法通过对象.方法或对象.属性来进行直接调用。因为我不想让外部了解我的实现机理或属性但是会留出一些公有的方法来供外部间接调用这些“封装”好的属性和方法这就是封装
下面是Python中常用的封装方式
公有成员默认情况下Python中的所有成员属性和方法都是公有的可以被外部访问。例如
class MyClass:def __init__(self):self.public_var 10def public_method(self):return This is a public method.obj MyClass()
print(obj.public_var) # 10
print(obj.public_method()) # This is a public method.私有成员在成员名字前面加上两个下划线 __可以将其定义为私有成员外部无法直接访问。这种前面加两个下划线的私有成员被称为伪私有成员例如
class MyClass:def __init__(self):self.__private_var 20def __private_method(self):return This is a private method.obj MyClass()
# 尝试访问私有属性和方法
print(obj.__private_var) # 会报错
print(obj.__private_method()) # 会报错上述代码会报错原因是在类外部试图访问私有成员(私有属性、私有方法) 。
访问类中的私有成员 那么我们该如何在类外访问类中的私有成员呢答案是我们可以通过类中的公有方法来访问类中的私有成员。
class MyClass:def __init__(self):self.__private_var 20def __private_method(self):return This is a private method.# 访问私有属性 __private_vardef public_method(self):return self.__private_var# 访问私有方法 __private_methoddef get_private_method(self):return self.__private_method()obj MyClass()
# 尝试访问私有属性和方法
print(obj.__private_var) # 会报错
print(obj.__private_method()) # 会报错
print(obj.public_method()) # 20
print(obj.get_private_method()) # This is a private method. 根据上面的代码我们可以看到 当直接在类外访问私有属性或私有方法时程序会报错。我们在类中写了两个公有方法分别访问类中的私有属性和私有方法运行程序访问成功。 通过封装我们可以隐藏类的内部实现细节提高代码的安全性和可维护性。同时封装也有助于减少代码的耦合度使代码更易于理解和调试。
细节由于python语言的动态特性会出现伪私有属性的情况
其他博客看到的 在Python中可以通过在属性名前加上__实现伪私有属性但这并不是真正的私有只是一种变形实际上Python并没有真正意义上的私有属性。 伪私有属性会被重命名为_类名__属性名。这种重命名是由Python内部的机制在编译时自动完成的。
这种做法的目的是防止子类重写该属性。
例如定义一个类并使用伪私有属性 在这个示例中__pseudo_private_var 是一个伪私有属性虽然我们在类的外部尝试直接访问它会报错但实际上它的名称已经被改写成了 _MyClass__pseudo_private_var我们可以通过这个改写后的名称来访问伪私有属性。另外我们也可以通过定义公有方法来间接地访问这个伪私有属性。
封装练习
●定义Account类 1)Account类要求具有属性:姓名长度为2-4位)、余额(必须20)、密码必须是六位)如果不满足则给出提示信息并给默认值(程序员自己定) 2)通过set_xxx的方法给Account的属性赋值。 3)编写方法query_info(接收姓名和密码,如果姓名和密码正确返回该账号信息
# 分析如下
# 类名Account
# 私有属性姓名长度为2-4位、余额必须20、密码(必须为6位)
# 构造器: 无默认是一个无参的构造器
# 方法set_xxx(self, 属性名) 进行赋值并且对各个接收到的数据进行校验
# 方法query_info(self, name, pwd) 而且需要验证才返回响应信息
class Account:__name None__balance None__pwd Nonedef set_name(self, name):# 2-4位if 2 len(name) 4:self.__name nameelse:print(名字的长度不在2-4位之间!)def set_balance(self, balance):# 余额(必须20)if balance 20:self.__balance balanceelse:print(余额必须大于20!)def set_pwd(self, pwd):# 密码必须是6位if len(pwd) 6:self.__pwd pwdelse:print(密码必须设置为6位!)def query_info(self, name, pwd):if name self.__name and pwd self.__pwd:return f账户信息如下: \n账户名: {self.__name}, 账户余额: {self.__balance}else:return 请输入正确的账户名和密码account Account()
account.set_name(tim)
account.set_pwd(000000)
account.set_balance(10000)
print(account.query_info(tim, 000000))
输出结果
账户信息如下:
账户名: tim, 账户余额: 10000
部分参考自
https://www.cnblogs.com/blackmatrix/p/5600830.html
二、继承
2.1 什么是继承 在Python中继承是面向对象编程中的一个重要概念它允许一个类称为子类继承另一个类称为父类的属性和方法。通过继承子类可以复用父类的代码并且可以在不改变原有代码的情况下添加新的功能或修改已有功能。字面意思就是一个类是另一个类的子类那么这个类就可以拥有和父类一样的属性、方法。这就好比是现实当中儿子会遗传父亲的性格、长相等。 2.2 为什么需要继承 我们编写了两个类一个是Pupil类小学生一个是Graduate大学毕业生。问题两个类的属性和方法有很多是相同的怎么办这就需要我们的继承特性。
我们先来看看没有继承的代码如下所示。
class Pupil:name Noneage None__score Nonedef __init__(self, name, age):self.name nameself.age agedef show_info(self):print(fname{self.name} age{self.age} score{self.__score})def set_score(self, score):self.__score scoredef testing(self):print(f小学生在考小学数学)class Graduate:name Noneage None__score Nonedef __init__(self, name, age):self.name nameself.age agedef show_info(self):print(fname{self.name} age{self.age} score{self.__score})def set_score(self, score):self.__score scoredef testing(self):print(f大学生在考高等数学)student1 Pupil(小白, 10)
student1.testing()
student1.set_score(70)
student1.show_info()print(-----------------)
student2 Graduate(小黑, 20)
student2.testing()
student2.set_score(80)
student2.show_info()输出结果
小学生在考小学数学
name小白 age10 score70
-----------------
大学生在考高等数学
name小黑 age20 score80 分析上述代码我们可知我们创建了两个类Pupil类和Graduate类Pubil类中有name、age、_score属性有显示信息的方法show_info()有设置分数的方法set_score()有测试的方法testing()Graduate类中也有name、age、_score属性有显示信息的方法show_info()有设置分数的方法set_score()有测试的方法testing()。 我们可以看到除了testing()方法执行的功能不一样外属性和其余的方法执行的功能均一样。那么我们可以创建一个新类Student将这两个类共有的属性和方法存放在新类中随后使得这两个类与新类构成继承关系。修改后的代码如下。
# 父类
class Student:name Noneage None__score Nonedef __init__(self, name, age):self.name nameself.age agedef show_info(self):print(fname{self.name} age{self.age} score{self.__score})def set_score(self, score):self.__score scoreclass Pupil(Student):def testing(self):print(f小学生在考小学数学)class Graduate(Student):def testing(self):print(f大学生在考高等数学)student1 Pupil(小白, 10)
student1.testing()
student1.set_score(70)
student1.show_info()print(-----------------)
student2 Graduate(小黑, 20)
student2.testing()
student2.set_score(80)
student2.show_info()输出结果
小学生在考小学数学
name小白 age10 score70
-----------------
大学生在考高等数学
name小黑 age20 score802.3 注意细节
1、子类继承了所有的属性和方法非私有的属性和方法可以在子类直接访问,但是私有属性和方法不能在子类直接访问要通过父类提供公共的方法去访问
class Base:# 公共属性n1 public attribute# 私有属性__n2 private attribute# 公共方法def public_method(self):return public_method# 私有方法def __private_method(self):return private_methodclass DerivedBase(Base):# 访问公有成员def visit_public(self):print(self.n1)print(self.public_method())def visit_private(self):print(self.__n2)print(self.__private_method)A DerivedBase()
A.visit_public() # public attribute# public_methodA.visit_private() # 报错 在子类中通过访问父类的公有方法进一步访问父类的私有成员。 代码如下所示。
class Base:# 公共属性n1 public attribute# 私有属性__n2 private attribute# 公共方法def public_method(self):return public_method# 私有方法def __private_method(self):return private_method# 提供公共方法返回私有成员def method(self):print(属性, self.n1, self.__n2)print(self.__private_method())class DerivedBase(Base):# 通过父类的公有方法访问父类的私有成员def visit(self):self.method()A DerivedBase()
A.visit()
输出结果
属性 public attribute private attribute
private_method2、python编程语言中object类是所有类的一个基类 我们将光标停在如下红框位置随后按下ctrlH得到右栏内容可以清晰地看到object类是所有类的一个基类。 3、python支持多重继承
语法格式
class DerivedClassName(Base1,Base2,Base3....):..... 示例代码
class A:n1 100def sing(self):print(A sing()..., self.n1)class B:n2 200def dance(self):print(B dance()..., self.n2)class C(A, B):def visit_AB(self):self.sing()self.dance()return self.n1, self.n2c C()
print(c.visit_AB())输出结果
A sing()... 100
B dance()... 200
(100, 200)
4、在多重继承中如果有同名的成员遵守从左到右的继承优先级(即:写左边的父类优先级高写在右边的父类优先级低)
class A:n1 100class B:n1 20class C(A, B):passc C()
print(c.n1) # 100class A:n1 100class B:n1 20class C(B, A):passc C()
print(c.n1) # 20继承练习题目
编写Computer类包含CPU、内存、硬盘等属性 1) get_details方法用于返回Computer的详细信息 2)编写PC子类继承Computer类添加特有属性【品牌brand】 3)编写NotePad子类继承Computer类添加特有属性【color】 4)完成测试创建PC和NotePad对象分别给对象中特有的属性赋值以及从Computer类继承的属性赋值并使用方法打印输出信息 思路分析 1父类:Computer 2公共属性:CPU(cpu)、内存(memory)、硬盘(disk) 3构造器:__init__(self, cpu , memory,disk) 4方法: get_details(self) 5子类:PC(Computer) 6公共属性:brand 7构造器: __init__(selfcpu , memory,disk , brand)有一个新的知识点 8方法: print_info(self) 完成功能:输出pc对象的信息(即属性的信息)
class Computer:cpu Nonememory Nonedisk Nonedef __init__(self, cpu, memory, disk):self.cpu cpuself.memory memoryself.disk diskdef get_details(self):return fcpu: {self.cpu}\t内存: {self.memory}\t硬盘: {self.disk}class PC(Computer):brand Nonedef __init__(self, cpu, memory, disk, brand):# 通过super().xx 方式可以去调用父类的方法# 这里我们通过super().__init__(cpu, memory, disk)去调用父类的构造器完成对父类属性的初始化任务# self.brand brand 表示子类特有属性由子类的构造器完成初始化任务self.brand brandsuper().__init__(cpu, memory, disk)def print_info(self):# 完成打印当前对象的信息print(f品牌:{self.brand}\t{self.get_details()})pc PC(intel, 32, 1000, 戴尔)
pc.print_info()输出结果
品牌:戴尔 cpu: intel 内存: 32 硬盘: 1000
5. 调用父类成员细节问题 在Python中super() 函数是一个内置函数通常用于调用父类的方法。通过 super() 方法子类可以直接调用父类中的方法而不需要显式指定父类的名称。super() 函数通常用在子类中的构造函数中以便在子类中扩展父类的功能。
如果子类和父类出现同名成员可以通过父类名或super()访问父类的成员
基本语法1)访问父类成员方式1 -访问成员变量:父类名,成员变量 -访问成员方法:父类名,成员方法(self)2)访问父类成员方式2 -访问成员变量: super().成员变量 -访问成员方法:super().成员方法()
代码如下
class A:n1 100def run(self):print(A-run()...)class B(A):n1 200def say(self):print(f父类的n1:{A.n1} 本类的n1:{self.n1}) # 父类的n1:100 本类的n1:200# 调用父类的runA.run(self) # A-run()...# 调用本类的runself.run() # B-run()...def hi(self):print(f父类的n1 {super().n1}) # 父类的n1 100# 调用父类的runsuper().run() # A-run()...def run(self):print(fB-run()...)b B()
b.say()
b.hi()
6、访问不限于直接父类而是建立从子类向上级父类的查找关系 重写override 重写又称覆盖override指子类定义了与父类同名的属性和方法从而覆盖了父类中的属性和方法。当子类对象调用这个属性和方法时将执行子类中的属性和方法而不是父类中的属性和方法。
class A:n1 100def run(self):print(fA-run...)class B(A):# 重写A类中的n1属性n1 10# 重写A类中的run方法def run(self):print(fB-run...)b B()
print(b.n1) # 10
b.run() # B-run... 方法的覆盖允许子类在不改变方法名称的情况下重写父类的方法实现从而实现特定于子类的行为。在实际开发中方法的覆盖是面向对象编程中常用的技术可以根据需要在子类中定制特定的行为。 需要注意的是当子类覆盖父类的方法时建议遵循相同的方法签名参数列表和返回类型以确保代码的一致性和易维护性。
例题练习
●编程题 1)编写一个Person类包括属性(name、age),构造方法、say方法(返回Person自我介绍的字符串) 2)编写一个Student类继承Person类增加属性(id、score)以及构造方法重写say方法(返回Student自我介绍的信息) 3)分别创建Person和Student对象调用say方法输出自我介绍,体会里与的作用
class Person:name Noneage Nonedef __init__(self, name, age):self.name nameself.age agedef say(self):return fname:{self.name}\tage:{self.age}class Student(Person):id Nonescore Nonedef __init__(self, id, score, name, age):# 子类的特有的属性我们自己完成初始化self.id idself.score score# 调用父类的构造器完成继承父类的属性的初始化super().__init__(name, age)def say(self):return fid:{self.id}\tscore:{self.score}\t{super().say()}person Person(小白, 20)
student Student(1, 100, 小黑, 30)print(person.say()) # name:小白 age:20
print(student.say()) # id:1 score:100 name:小黑 age:30三、多态
3.1 什么是多态 举一个现实中的例子同样的一件事情不同的人处理起来他们的实现过程是完全不同的会表现出不同的形态。比如都是吃饭这个事情中国人表现的是用筷子吃饭而美国人表现的是用叉刀吃饭。这个就是相同的事情表现出了不同的“形态”。 1多态通常作用在继承的关系上。 2多态指的是方法的多态多态与属性无关。 3多态顾名思义是多种状态不同的对象调用相同的方法表现出不同的状态称为多态
先看一个问题 请编写一个程序Master类中有一个feed(喂食方法可以完成主人给动物喂食物的信息 使用传统的方法不使用多态来解决上面这个问题如下所示。
# 不涉及多态
class Food:name Nonedef __init__(self, name):self.name nameclass Fish(Food):# 特有的属性和方法passclass Bone(Food):# 特有的属性和方法passclass Animal:name Nonedef __init__(self, name):self.name nameclass Dog(Animal):passclass Cat(Animal):passclass Master:name Nonedef __init__(self, name):self.name name# 给猫猫喂鱼def feed_cat(self, cat: Cat, fish: Fish):print(f主人{self.name}给动物{cat.name}喂的食物是{fish.name})# 给小狗喂骨头def feed_dog(self, dog: Dog, bone: Bone):print(f主人{self.name}给动物{dog.name}喂的食物是{bone.name})master Master(小白)
cat Cat(小花猫)
fish Fish(黄花鱼)
dog Dog(大黄狗)
bone Bone(大棒骨)master.feed_cat(cat, fish)# 主人小白给动物小花猫喂的食物是黄花鱼master.feed_dog(dog, bone)# 主人小白给动物大黄狗喂的食物是大棒骨传统方法带来的问题是什么如何解决 问题是代码的复用性不高而且不利于代码维护和功能拓展 解决方案使用多态
使用多态 class Animal:def cry(self):passclass Cat(Animal):def cry(self):print(小猫 喵喵叫...)class Dog(Animal):def cry(self):print(小狗 汪汪叫...)class Pig(Animal):def cry(self):print(小猪 哼哼叫...)# 在python面向对象编程中子类对象可以传递给父类类型
def func(animal: Animal):print(fanimal 类型是{type(animal)})animal.cry()dog Dog()
pig Pig()
cat Cat()
func(dog) # animal 类型是class __main__.Dog# 小狗 汪汪叫...
func(pig) # animal 类型是class __main__.Pig# 小猪 哼哼叫...
func(cat) # animal 类型是class __main__.Cat# 小猫 喵喵叫...
●多态的好处 1)增加了程序的灵活性,以不变应万变不论对象千变万化使用者都是同一种形式去调用如func(animal)上述代码说明 2)增加了程序的可扩展性,通过继承Animal类创建了一个新的类使用者无需更改自己的代码还是用func(animal)去调用
使用多态优化主人喂动物问题
# 不涉及多态
class Food:name Nonedef __init__(self, name):self.name nameclass Fish(Food):# 特有的属性和方法passclass Bone(Food):# 特有的属性和方法passclass Animal:name Nonedef __init__(self, name):self.name nameclass Dog(Animal):passclass Cat(Animal):passclass Master:name Nonedef __init__(self, name):self.name name# 给动物喂食物def feed(self, animal: Animal, food: Food):print(f主人{self.name}给动物{animal.name}喂的食物是{food.name})master Master(小白)
cat Cat(小花猫)
fish Fish(黄花鱼)
dog Dog(大黄狗)
bone Bone(大棒骨)master.feed(cat, fish)# 主人小白给动物小花猫喂的食物是黄花鱼master.feed(dog, bone)# 主人小白给动物大黄狗喂的食物是大棒骨
