【Python基础】面向对象基础和特性

面向对象基础

定义类

特征 = 属性 行为 = 方法

class 类名:
    def 方法名(self[, 参数列表]):
        pass
创建对象
对象名 = 类名()
  • 对象 = 实例 创建对象 = 实例化对象
  • 由哪一个对象调用的方法,方法内的self 就是哪一个对象的引用;
  • 打印对象和打印self得到的结果是⼀致的,都是当前对象的内存地址;
class Washer:
    def wash(self):
        print(self)
        print("洗衣服")


haier = Washer()
print(haier)
haier.wash()

"""
<__main__.Washer object at 0x00000202A0817430>
<__main__.Washer object at 0x00000202A0817430>
洗衣服
"""
添加和获取对象属性
  • 类外面添加对象属性:对象名.属性名 = 值
  • 类里面添加对象属性:self.属性名 = 值
  • 类外面获取对象属性:对象名.属性名
  • 类里面获取对象属性:self.属性名
# 定义类
class Washer:
    def print_info(self):
        # 类⾥⾯获取实例属性
        print(f"{self.name}洗⾐机的宽度是{self.width}")
        print(f"{self.name}洗⾐机的⾼度是{self.height}")

# 创建对象
haier = Washer()
# 添加实例属性
haier.name = "海尔"
haier.width = 500
haier.height = 800
# 调用实例方法
haier.print_info()
魔法方法
  • __init__:初始化对象
    当使用类名()创建对象时,为对象分配完空间后,自动调用__init__方法;
    改造初始化方法,可以让创建对象更加灵活;
  • __str__ :输出对象信息
    当使⽤print输出对象的时候,默认打印对象的内存地址;
    如果类定义了__str__⽅法,则会打印从该方法中return的数据;
  • __del__ :删除对象时调用
    当一个对象被从内存中销毁前,会自动调用__del__方法;
    如果希望在对象被销毁前,再做一些事情,可以使用该方法;
class Washer:
    def __init__(self, name):
        self.name = name
        print(f"{self.name}洗⾐机来了")

    def __str__(self):
        return f"---{self.name}洗衣机---"

    def __del__(self):
        print(f"{self.name}洗⾐机去了")


haier = Washer("海尔")
print(haier)
# 删除一个对象
del haier

print("---我在哪执行?---")

"""
海尔洗⾐机来了
---海尔洗衣机---
海尔洗⾐机去了
---我在哪执行?---
"""
对象的生命周期
  • 一个对象从调用类名()创建,生命周期开始
  • 一个对象的__del__方法一旦被调用,生命周期结束
  • 在对象的生命周期内,可以访问对象属性,或者让对象调用方法
私有属性和私有方法
  • 应用场景:在实际开发中,对象的某些属性或方法可能只希望在对象的内部被使用,而不希望在外部被访问到;
  • 定义方式:在属性名或方法名前增加两个下划线,私有属性和私有方法不能在外界直接访问;
  • 在Python中并没有真正意义的私有,伪私有
  • 在给属性或方法命名时,实际是对名称做了一些特殊处理_类名 => _类名__名称,使得外界无法访问到;
  • 在日常开发中,不要使用这种方式对象名._类名__属性名/方法名,访问对象的私有属性或私有方法;
class Women:
    def __init__(self, name):
        self.name = name
        self.__age = 18
        
    def __secret(self):
        # 在对象的方法内部,是可以访问对象的私有属性的
        print("%s 的年龄是 %d" % (self.name, self.__age))
    
        
xiaofang = Women("小芳")

# 私有属性,外部不能直接访问
print(xiaofang.__age)
# 私有方法,外部不能直接调用
xiaofang.__secret()

#

# 伪私有属性
print(xiaofang._Women__age)
# 伪私有方法
xiaofang._Women__secret()

面向对象特性

  • 封装根据职责将属性和方法封装到一个抽象的类中
    定义类的准则
  • 继承实现代码的重用,相同的代码不需要重复的编写
    设计类的技巧
  • 多态不同的对象调用相同的方法,产生不同的执行结果
    调用方法的技巧
封装
封装案例演练

需求分析:
1、房子(House)有 户型、总面积 和 家具名称列表:新房子没有任何的家具
2、家具(HouseItem)有 名称 和 占地面积,其中:
① 席梦思(bed)占地 4 平米,② 衣柜(chest)占地 2 平米,③ 餐桌(table)占地 1.5 平米
3、将以上三件家具 添加 到 房子 中
4、打印房子时,要求输出:户型、总面积、剩余面积、家具名称列表
在这里插入图片描述

代码实现:

# 1、创建家具类(HouseItem)
class HouseItem:
    def __init__(self, name, area):
        # 家具名称
        self.name = name
        # 家具占地面积
        self.area = area

    def __str__(self):
        return "【%s 占地 %.2f】" % (self.name, self.area)


# 2、创建房子类(House)
class House:
    def __init__(self, house_type, area):
        # 房子户型
        self.house_type = house_type
        # 房子总面积
        self.area = area
        # 房子剩余面积
        self.free_area = area
        # 家具名称列表
        self.item_list = []

    def __str__(self):
        return ("户型:%s\t总面积:%.2f\n剩余面积:%.2f\t家具:%s"
                % (self.house_type, self.area,
                   self.free_area, self.item_list))

    def add_item(self, item):
        print("准备添加 %s" % item)
        # ①判断家具的面积
        if item.area <= self.free_area:
            # ②将家具的名称添加到列表中
            self.item_list.append(item.name)
            print(f"{item.name}已经成功摆放到房子中了")
            # ③计算剩余面积
            self.free_area -= item.area
        else:
            print(f"{item.name}面积太大,剩余面积不足,无法容纳")


# 3、创建对象
bed = HouseItem("席梦思", 40)
chest = HouseItem("衣柜", 2)
table = HouseItem("餐桌", 20)

my_home = House("两室一厅", 60)

# 4、调用实例方法
print(my_home)
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print(my_home)

运行结果:

户型:两室一厅 总面积:60.00
剩余面积:60.00 家具:[]
准备添加 【席梦思 占地 40.00】
席梦思已经成功摆放到房子中了
准备添加 【衣柜 占地 2.00】
衣柜已经成功摆放到房子中了
准备添加 【餐桌 占地 20.00】
餐桌面积太大,剩余面积不足,无法容纳
户型:两室一厅 总面积:60.00
剩余面积:18.00 家具:['席梦思', '衣柜']
继承

子类拥有父类的所有方法和属性

class 子类名(父类名):
    pass

子类拥有父类的所有方法和属性
子类继承自父类,可以直接享受父类中已经封装好的方法,不需要再次开发
在这里插入图片描述
Dog类 是 Animal类 的 子类,Animal类 是 Dog类 的 父类,Dog类 从 Animal类 继承
Dog类 是 Animal类 的 派生类,Animal类 是 Dog类 的 基类,Dog类 从 Animal类 派生

继承的传递性
  • C类从B类继承,B类又从A类继承,那么C类就具有B类和A类的所有属性和方法;
  • 子类拥有父类以及父类的父类中封装的所有属性和方法
方法的重写

当父类的方法实现不能满足子类需求时,可对方法进行重写
在这里插入图片描述

重写父类方法有两种情况:

  1. 覆盖父类的方法
    如果在开发中,父类的方法实现和子类的方法实现完全不同,就可以使用覆盖的方式;在子类中重写父类的方法实现,相当于在子类中定义了一个和父类同名的方法并且实现;重写之后运行时,只会调用子类中重写的方法,而不再会调用父类中 封装的方法;
  2. 对父类方法进行扩展
    如果在开发中,子类的方法实现中包含父类的方法实现,父类原本封装的方法实现是子类方法的一部分,就可以使用扩展的方式;在子类中重写父类的方法,在需要的位置使用super().父类方法来调用父类方法的执行,在其他的位置针对子类的需求,编写子类特有的代码实现;
父类的私有属性和私有方法
  • 子类对象不能在自己方法内直接访问父类的私有属性或私有方法;
  • 子类对象可通过父类的公有方法间接访问到私有属性或私有方法;

在这里插入图片描述
B 的对象不能直接访问 __num2 属性
B 的对象不能在 demo 方法内访问 __num2 属性
B 的对象可以在 demo 方法内,调用父类的 test 方法
父类的 test 方法内部,能够访问 __num2 属性和 __test 方法

多继承

子类拥有多个父类且具有所有父类的属性和方法

class 子类名(父类名1, 父类名2):
    pass

使用多继承时若不同父类中存在同名的方法,子类对象在调用方法时,会调用哪一个父类中的方法呢?
在这里插入图片描述
MRO 方法搜索顺序 主要用于在多继承时判断方法、属性的调用路径
Python中针对类提供了一个内置属性 __mro__ 可以查看方法搜索顺序;在搜索方法时,是按照 __mro__ 的输出结果从左至右的顺序查找的;如果在当前类中找到方法,就直接执行不再搜索;如果没有找到,就查找下一个类中是否有,找到就直接执行不再搜索;如果找到最后一个类,还没有找到方法,程序报错;

注意:如果父类之间存在同名的属性或者方法,应该尽量避免使用多继承!

新式类与经典类
  • object是Python为所有对象提供的基类,提供有一些内置的属性和方法,可以使用dir函数查看;新式类:以object为基类的类,推荐使用;经典类:不以object为基类的类,不推荐使用;
  • Python 3.x中定义类时,如果没有指定父类,会默认使用object作为该类的基类;Python 2.x中定义类时,如果没有指定父类,则不会以object作为该类的基类;
  • 新式类和经典类在多继承时会影响到方法的搜索顺序:为了保证编写的代码能够同时在 Python 2.x 和 Python 3.x 运行,今后在定义类时,如果没有父类,建议统一继承自object
多态

不同的子类对象调用相同的父类方法,产生不同的执行结果

以继承和重写父类方法为前提
多态案例演练

需求分析:
1、在Dog类中封装game方法,普通狗只是简单的玩耍
2、定义XiaoTianDog类继承自Dog类,并重写game方法,哮天犬需要在天上玩耍
3、定义Person类,并封装一个和狗玩的方法game_with_dog
在game_with_dog方法内部,直接让狗对象调用game方法
在这里插入图片描述
Person类中只需要让狗对象调用game方法,而不关心具体是什么狗
game方法是在Dog父类中定义的
在程序执行时,传入不同的狗对象实参,就会产生不同的执行效果

代码实现:

class Dog(object):
    def __init__(self, name):
        self.name = name
    def game(self):
        print("%s 蹦蹦跳跳的玩耍" % self.name)

class XiaoTianDog(Dog):
    def game(self):
        print("%s 飞到天上去玩耍" % self.name)

class Person(object):
    def __init__(self, name):
        self.name = name
    def game_with_dog(self, dog):
        print("%s 和 %s 一起快乐的玩耍" % (self.name, dog.name))
        dog.game()


erha = XiaoTianDog("飞天二哈")
xiaoming = Person("小明")
xiaoming.game_with_dog(erha)


'''
小明 和 飞天二哈 一起快乐的玩耍
飞天二哈 飞到天上去玩耍
'''

面向对象其他

实例对象
  1. 设计类
  2. 创建对象 类名()
    在内存中为对象分配空间
    调用__init__方法为对象初始化
  3. 创建对象后,内存中就有一个实实在在的存在,即实例
    创建出来的对象 = 类的实例
    创建对象的动作 = 实例化
    对象的属性 = 实例属性
    对象调用的方法 = 实例方法

在这里插入图片描述
在程序执行时,通过 self. 访问自己的属性或调用自己的方法
每一个对象都有自己独立的内存空间,保存各自不同的属性
多个对象的方法在内存中只有一份,在调用方法时,需将对象的引用传递到方法内部

类对象
  • Python中一切皆为对象,类是一个特殊的对象
  • 通过 class 类名: 定义的类属于类对象
  • 通过 对象名 = 类名() 创建的对象属于实例对象

在这里插入图片描述
在程序运行时,通过 类名. 访问类的属性或调用类的方法
类对象在内存中只有一份,使用一个类可以创建出很多个对象实例
除了封装实例的属性和方法外,类对象也可以拥有自己的属性和方法

  • 实例方法方法内部需要访问实例属性
  • 实例方法内部可以使用类名.访问类属性
  • 类方法方法内部只需要访问类属性
  • 静态方法内部不需要访问实例属性和类属性
类属性
  • 类属性是类对象定义的属性,在class下方使用赋值语句定义;
  • 通过用来记录与这个类相关的属性,类属性不会用于记录具体对象的特征;
  • 要访问类属性的方式(向上查找机制):类名.类属性对象名.类属性(不推荐)
  • 如果使用 对象.类属性 = 值 设置值,只会给对象添加一个属性,而不会影响到类属性的值;
类方法
  • 类方法就是针对类对象定义的方法,需用修饰器@classmethod来标识;
  • 由哪一个类调用的方法,方法内的cls就是哪一个类的引用;
  • 通过类名.调用类方法,调用方法时,不需要传递cls参数;
  • 在类方法内部通过cls.访问类属性或调用其他的类方法;
@classmethod
def 类方法名(cls):
    pass
静态方法
  • 既不需要访问实例属性和调用实例方法
  • 也不需要访问类属性和调用类方法
  • 静态方法需要用修饰器@staticmethod 来标识
  • 通过类名.调用静态方法
@staticmethod
def 静态方法名():
    pass
案例演示

需求分析:
1.设计一个Game类
2.属性:
① 类属性 top_score 记录游戏的历史最高分,② 实例属性 player_name 记录当前游戏的玩家姓名
3.方法:
① 静态方法 show_help 显示游戏帮助信息,② 类方法 show_top_score 显示历史最高分,③ 实例方法 start_game 开始当前玩家的游戏
4.主程序步骤
① 查看帮助信息,② 查看历史最高分,③ 创建游戏对象,开始游戏
在这里插入图片描述

代码实现:

class Game(object):
    # 游戏最高分,类属性
    top_score = 0

    @staticmethod
    def show_help():
        print("帮助信息:让僵尸走进房间")

    @classmethod
    def show_top_score(cls):
        print("游戏最高分是 %d" % cls.top_score)

    def __init__(self, player_name):
        self.player_name = player_name

    def start_game(self):
        print("[%s] 开始游戏..." % self.player_name)
        # 使用类名.修改历史最高分
        Game.top_score = 999


# 1. 查看游戏帮助
Game.show_help()

# 2. 查看游戏最高分
Game.show_top_score()

# 3. 创建游戏对象,开始游戏
game = Game("小明")
game.start_game()

# 4. 游戏结束,查看游戏最高分
Game.show_top_score()
  • 4
    点赞
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值