Python面向对象——面向对象练习

Python面向对象——面向对象练习

面向对象封装案例（一）

01 封装

1.封装是面向对象编程的一大特点
2.面向对象编程的第一步——将属性和方法 封装到一个抽象的类中
3.外界使用类创建对象，然后让对象调用方法
4.对象方法的细节都被封装在类的内部

02 小明爱跑步

需求
1.小明 体重 75.0公斤
2.小明每次 跑步 会减肥0.5公斤
3.小明每次 吃东西 体重增加1公斤

class Person:
    def __init__(self,name,weight):
        # self.属性 = 形参
        self.name=name
        self.weight = weight
    def __str__(self):
        return "我的名字叫 %s 体重是 %.2f 公斤" %(self.name,self.weight)
    def run(self):
        print("%s 爱跑步，跑步锻炼身体" %self.name)
        self.weight-=0.5
    def eat(self):
        print("%s 是吃货，吃完这顿再减肥" %self.name)
        self.weight+=1

xiaoming = Person("小明",75.0)
xiaoming.run()
xiaoming.eat()
print(xiaoming)

（1）小明爱跑步扩展——小美也爱跑步

需求
1.小明和小美都爱跑步
2.小明 体重 75.0公斤
3.小美 体重 45.0公斤
4.每次 跑步 都会减少0.5公斤
5.每次 吃东西 都会增加1公斤

提示
1.在对象的方法内部，是可以直接访问对象的属性的
2.同一个类创建的多个对象之间，属性互不干扰

class Person:
    def __init__(self,name,weight):
        # self.属性 = 形参
        self.name=name
        self.weight = weight
    def __str__(self):
        return "我的名字叫 %s 体重是 %.2f 公斤" %(self.name,self.weight)
    def run(self):
        print("%s 爱跑步，跑步锻炼身体" %self.name)
        self.weight-=0.5
    def eat(self):
        print("%s 是吃货，吃完这顿再减肥" %self.name)
        self.weight+=1

xiaoming = Person("小明",75.0)
xiaoming.run()
xiaoming.eat()
print(xiaoming)

xiaomei = Person("小美",45.0)
xiaomei.eat()
xiaomei.run()
print(xiaomei)

03 存放家具

需求
1.房子（House）有户型、总面积和家具名称列表
　　新房子没有任何的家具
2.家具（HouseItem）有名字和占地面积，其中
　　**席梦思（bed）**占地 4 平米
　　衣柜（chest）占地 2 平米
　　餐桌（table）占地 1.5 平米
3.将以上三件家具 添加到房子中
4.打印房子时，要求输出：户型、总面积、剩余面积、家具名称列表

剩余面积
1.在创建房子对象时，定义一个剩余面积的属性，初始值和总面积相等
2.当调用 add_item 方法，向房间添加家具时，让剩余家具 -= 家具面积

家具类以及创建家具对象

class HouseItem:
    def __init__(self,name,area):
        self.name=name
        self.area=area
    def __str__(self):
        return "[%s] 占地 %.2f" %(self.name,self.area)

# 1.创建家具
bed = HouseItem("席梦思",4)
chest = HouseItem("衣柜",2)
table = HouseItem("餐桌",1.5)

print(bed)
print(chest)
print(table)

定义房子类

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):
         # Python 能够自动的将一对括号内部的代码连接在一起
        return ("户型：%s\n总面积：%.2f[剩余：%.2f]\n家具：%s" 
        % (self.house_type,self.area,self.free_area,self.item_list))

    def add_item(self,item):
        print("要添加 %s" % item)

# 2.创建房子对象
my_home = House("两室一厅",60)

my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)

print(my_home)

小结

1.创建了一个房子类，使用到__init__和__str__两个内置方法
2.准备了一个add_item方法准备添加家具
3.使用房子类创建了一个房子对象
4.让房子对象调用了三次add_item方法，将三件家具以实参传递到add_item内部

添加家具

需求
1.判断家具的面积是否超过剩余面积，如果超过，提示不能添加这件家具
2.将家具的名称追加到家具名称列表中
3.用房子的剩余面积 - 家具面积

    def add_item(self,item):
        print("要添加 %s" % item)
        # 1.判断家具的面积
        if item.area > self.free_area:
            print("%s 的面积太大了，无法添加" %item.name)
            return

        # 2.将家具的名称添加到列表中
        self.item_list.append(item.name)

        # 3.计算剩余面积
        self.free_area -= item.area

面向对象封装案例（二）

目标

1.士兵突击案例
2.身份运算符

封装

1.封装是面向对象编程的一大特点
2.面向对象编程的第一步——将属性和方法 封装到一个抽象的类中
3.外界使用类创建对象，然后让对象调用方法
4.对象方法的细节都被封装在类的内部

一个对象的属性可以是另一个类创建的对象

01 士兵突击

需求
1.士兵 许三多有一把AK47
2.士兵可以开火
3.枪能够发射子弹
4.枪装填子弹——增加子弹数量

class Gun:
    def __init__(self,model):
        # 1.枪的型号
        self.model = model
        
        # 2.子弹的数量
        self.bullet_count = 0
        
    def add_bullet(self,count):
        self.bullet_count += count
        
    def shoot(self):
        # 1.判断子弹数量
        if self.bullet_count <= 0:
            print("[%s] 没有子弹了..." %self.model)
            return
        
        # 2.发射子弹，-1
        self.bullet_count -= 1
        
        # 3.提示发射信息
        print("[%s] 突突突... [%d]" %(self.model,self.bullet_count))

class Soldier:
    def __init__(self,name):
        # 1.姓名
        self.name = name
        # 2.枪-新兵没有枪
        self.gun = None
    def __str__(self):
        return "%s 有一把 %s" %(self.name,self.gun)
    def fire(self):
        # 1.判断士兵是否有枪
        if self.gun is None:
            print("[%s] 还没有枪..." %self.name)
            return

        # 2.高喊口号
        print("冲啊...[%s]" %self.name)

        # 3.让枪装填子弹
        self.gun.add_bullet(50)

        # 4.让枪发射子弹
        self.gun.shoot()

# 1.创建枪对象
ak47 = Gun("AK47")

# 2.创建许三多
xusanduo = Soldier("许三多")
xusanduo.gun = ak47
xusanduo.fire()

02 身份运算符

身份运算符用于比较两个对象的内存地址是否一致——是否是对同一个对象的引用
在 Python 中针对 None 比较时，建议使用 is 判断

运算符	描述	示例
is	is 是判断两个标识符是不是引用同一个对象	x is y，类似id(x) ==id(y)
is not	is not 是判断两个标识符是不是引用不同对象	x is not y，类似id(a) != id(b)

is 与 == 区别：

is 用于判断两个变量 引用对象是否为同一个
== 用于判断引用变量的值是否相等

私有属性和私有方法

01 应用场景及定义方式

应用场景

1.在实际开发中，对象的某些属性或方法可能只希望在对象的内部被使用，而不希望在外部被访问到
2.私有属性就是对象不希望公开的属性
3.私有方法就是对象不希望公开的方法

定义方法

在定义属性或方法时，在属性名或者方法名前增加两个下划线，定义的就是私有属性或方法

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()

02 伪私有属性和私有方法（科普）

提示：在日常开发中，不要使用这种方法，访问对象的 私有属性 或 私有方法
Python 中，并没有真正意义的私有
1.在给属性、方法命名时，实际是对名称做了一些特殊处理，使得外界无法访问到
2.处理方法：在名称前面加上_类名 => _类名__名称

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._Women__age)
# 访问私有方法
xiaofang._Women__secret()