上节课回顾：
属性：类属性 实例属性 私有属性（前面双下划线） 内置属性（前后都有双下划线）
方法：实例方法 静态方法 类方法 内置方法 私有方法
class 类名：
类主体（属性+方法）
def 实例方法名（self）:
实例方法体

一、私有属性+私有方法

属性名：私有属性名
私有方法：私有方法名 

  2. class people: 
  3.     """描述一个中国人类""" 
  4.     fuse="yellow" #类属性1 
  5.     language = "chain" # 类属性2 
  6.     __weight=90 
  8.     # 构造方法‐‐‐》名字特殊 __init__ 调用特殊：实例化时调用 
  9.     # 什么时候会重构构造方法‐‐‐》初始化数据 
  10.     def __init__(self,name,classname): 
  11.         print(f"实例化了一个对象，她的名称{name}，班级{classname}") 
  12.         self.name=name #实例属性：实例对象自己私有。‐‐‐》self.name self.classname 
  13.         self.classname=classname 
  15.     def __speakmimi(self):16 print("这是一个私有方法") 
  18.     # 定义行为？ 说话 睡觉 
  19.     def speak(self): 
  20.         print(self,type(self)) 
  21.         print("我说就是中国话") 
  22.         print("告诉一个秘密，我的体重是:", self.__weight) 
  23.         self.__speakmimi() 
  25. xingji=people("xingji","M211") 
  26. # print(xingji.__weight) 
  27. xingji.speak() 
  28. # print(xingji.__weight) 
  29. # xingji.__speakmimi 
  31. print("私有属性及私有方法只能类内部使用，实例对象或类不可以在外部使用，" 
  32. "但是可以通过此种格式调用：对象._类名+私有属性/私有方法") 
  34. print("1外部获取私有属性",xingji._people__weight) 
  35. print("2外部获取私有方法：") 
  36. xingji._people__speakmimi()

二、模块导包

from 模块 import 方法
from 上一级模块 import 下一级模块
import 模块

三、main()

main函数是调试代码的入口函数
也就是执行当前模块会执行，其他模块调用不会执行

四、面向对象特征：封装

封装：面向对象编程的第一步 将属性和方法封装到一个抽象的类中，外界使用类创建对象，然后让对象调用方法，对象方法的细节都被封装在类的内部 

  1. """ 
  2. 需求：小明爱跑步 
  3. 1.小明体重75.0公斤 属性 ‐‐> 
  4. 2.每次跑步会减肥0.5公斤 行为 
  5. 3.每次吃东西体重会增加1公斤 行为 
  6. 4.小美的体重是45.0公斤 属性 
  7. """ 
  8. # 定义一个类来进行表示 小明 小美 
  9. class julebu: 
  11.     def __init__(self,name,weight): 
  12.         self.name=name 
  13.         self.weight=weight 
  15.     def eat(self): 
  16.         self.weight +=1 
  17.         print(f"每次吃东西体重会增加1公斤，你现在的体重{self.weight}") 
  18.         pass 
  20.     def pao(self): 
  21.         self.weight‐=0.5 
  22.         print("每次跑步会减肥0.5公斤,现在体重",self.weight) 
  25. xming=julebu("小明",75) 
  26. xming.pao() 
  27. xming.eat() 
  28. print(xming.weight) 
  29. xmei=julebu("小美",45) 
  30. xmei.pao() 
  31. xmei.pao() 
  32. xmei.eat() 
  33. print(xmei.weight) 
  34. c=julebu("cc",120) 
  35. c.pao()36 c.eat() 
  36. c.eat() 
  37. print(c.weight) 
  39. # 一、 
  40. # # 1、摆放家具 
  41. # # 需求： 
  42. # # 1）房子有户型，总面积和家具名称列表 房子‐‐‐》 属性 面积和家具名称列表 
  43. # # ?? ?新房子没有任何的家具 初始化时候特征 
  44. # # 2）家具有名字和占地面积，其中 家具对象 ‐‐‐‐》属性：名字和占地面积 
  45. # # ?? ?床：占4平米 ‐ 床 属性：面积 
  46. # # ?? ?衣柜：占2平面 衣柜 属性：面积 
  47. # # ?? ?餐桌：占1.5平米 
  48. # # 3）将以上三件家具添加到房子中 行为 
  49. # # 4）打印房子时，要求输出:户型，总面积，剩余面积，家具名称列表 ‐‐‐》 获取属性 
  51. # 分析对象相同属性及行为 及这些对象存在逻辑关系

作业

作业答案_面向对象2.txt
附加作业.txt

  1. # 一、1、摆放家具
  2. # 需求：
  3. # 1）房子有户型，总面积和家具名称列表   # 属性
  4. #     新房子没有任何的家具               # 初始化
  5. # 2）家具有名字和占地面积，其中        # 属性
  6. #     床：占4平米                      # 实例
  7. #     衣柜：占2平面                    # 实例
  8. #     餐桌：占1.5平米                  # 实例
  9. # 3）将以上三件家具添加到房子中        # 行为
  10. # 4）打印房子时，要求输出:户型，总面积，剩余面积，家具名称列表
  12. class House():
  14.     def __init__(self, house_type, total_area):
  15.         self.house_type = house_type
  16.         self.total_area = total_area
  17.         self.left_area = total_area
  18.         self.jj_list = []
  20.     def add_jj(self, project):
  21.         if project.jj_area > self.left_area:
  22.             print("%s家具面积太大，无法添加"%project.jj_name)
  23.         self.left_area -= project.jj_area
  24.         self.jj_list.append(project.jj_name)
  26.     def __str__(self):
  27.         return f"户型：{self.house_type}\n总面积：{self.total_area}\n剩余面积：{self.left_area}\n家具名称列表：{self.jj_list}"
  29. class Jiaju():
  31.     def __init__(self, name, area):
  32.         self.jj_name = name
  33.         self.jj_area = area
  34. if __name__ == "__main__":
  35.     chuang = Jiaju("床", 4)
  36.     yigui = Jiaju("衣柜", 2)
  37.     canzhuo = Jiaju("餐桌", 1.5)
  38.     # big_jj = Jiaju("超大家具", 100)
  39.     house = House("三室一厅", 80)
  40.     house.add_jj(chuang)
  41.     house.add_jj(yigui)
  42.     house.add_jj(canzhuo)
  43.     # house.add_jj(big_jj)
  44.     print(house)
  1. # 二、2、需求：
  2. #      1）士兵瑞恩有一把AK47                  # 属性
  3. #      2）士兵可以开火(士兵开火扣动的是扳机)    # 行为
  4. #      3）枪 能够 发射子弹(把子弹发射出去)      # 行为
  5. #      4）枪 能够 装填子弹 --增加子弹的数量     # 行为
  7. class Soldier():
  9.     def __init__(self, soldier_name, gun_project):
  10.         self.soldier_nam = soldier_name
  11.         self.gun = gun_project
  13.     def fire(self, load_num, shot_num):
  14.         if shot_num > load_num + self.gun.num_bullet:
  15.             print(f"子弹不足，请装弹！当前子弹数：{self.gun.num_bullet + load_num}")
  16.             self.left_num = self.gun.num_bullet + load_num
  17.         else:
  18.             self.gun.load(load_num)
  19.             self.gun.shot(shot_num)
  20.             self.left_num = self.gun.num_bullet
  22.     def __str__(self) -> str:
  23.         return f"士兵：{self.soldier_nam}\n枪{self.gun.gun_name}剩余子弹数：{self.left_num}"
  25. class Gun():
  27.     def __init__(self, gun_name):
  28.         self.num_bullet = 0
  29.         self.gun_name = gun_name
  31.     def load(self, num):
  32.         self.num_bullet += num
  34.     def shot(self, num):
  35.         self.num_bullet -= num
  37. if __name__ == "__main__":
  38.     AK47 = Gun("AK47")
  39.     AK47.load(4)
  40.     ruien = Soldier("ruien", AK47)
  41.     ruien.fire(3,9)
  42.     print(ruien)
  1. # 一、请写一个小游戏，人狗大战，2个角色，人和狗，
  2. # 游戏开始后，生成2个人，3条狗，互相混战，
  3. # 人被狗咬了会掉血，
  4. # 狗被人打了也掉血，
  5. # 狗和人的攻击力，具备的功能都不一样。
  7. class People():
  9.     def __init__(self, p_name, p_life, p_attack):
  10.         self.p_name = p_name
  11.         self.p_life = p_life
  12.         self.p_attack = p_attack
  14.     def play(self, dog):
  15.         if self.p_life > 0:
  16.             dog.d_life -= self.p_attack
  17.         else:
  18.             print(f"人类{self.p_name}已经挂了，打不了狗子{dog.d_name}了")
  19.         if dog.d_life <= 0:
  20.             print(f"狗子{dog.d_name}已经挂了")
  21.             dog.d_life = 0
  23.     def __str__(self):
  24.         return f"人类{self.p_name}剩余血量{self.p_life}"
  26. class Dog():
  28.     def __init__(self, d_name, d_life, d_attack):
  29.         self.d_name = d_name
  30.         self.d_life = d_life
  31.         self.d_attack = d_attack
  33.     def bite(self, people):
  34.         if self.d_life > 0:
  35.             people.p_life -= self.d_attack
  36.         else:
  37.             print(f"狗子{self.d_name}已经挂了，咬不了人类{people.p_name}了")
  38.         if people.p_life <= 0:
  39.             print(f"人类{people.p_name}已经挂了")
  40.             people.p_life = 0
  42.     def __str__(self):
  43.         return f"狗子{self.d_name}剩余血量{self.d_life}"
  45. if __name__ == "__main__":
  46.     zhangsan = People("张三", 20, 4)
  47.     lisi = People("李四", 15, 5)
  48.     dog1 = Dog("黑狗", 10, 6)
  49.     dog2 = Dog("黄狗", 12, 5)
  50.     dog3 = Dog("白狗", 11, 7)
  51.     dog1.bite(zhangsan)
  52.     dog1.bite(lisi)
  53.     dog2.bite(lisi)
  54.     zhangsan.play(dog2)
  55.     lisi.play(dog2)
  56.     dog3.bite(lisi)
  57.     lisi.play(dog2)
  58.     print(zhangsan,lisi,dog1,dog2,dog3)