python基础笔记二_面向对象

面向对象 Object Oriented

概述

面向过程

1.分析出解决问题的步骤，然后逐步实现。
	例如：婚礼筹办
	-- 发请柬（选照片、措词、制作）
	-- 宴席（场地、找厨师、准备桌椅餐具、计划菜品、购买食材）
	-- 婚礼仪式（定婚礼仪式流程、请主持人）
2.公式：程序 = 算法 + 数据结构
3.优点：所有环节、细节自己掌控。
4.缺点：考虑所有细节，工作量大。 

面向对象

1.找出解决问题的人，然后分配职责。
例如：婚礼筹办
	-- 发请柬：找摄影公司（拍照片、制作请柬）
	-- 宴席：找酒店（告诉对方标准、数量、挑选菜品） 
	-- 婚礼仪式：找婚庆公司（对方提供司仪、制定流程、提供设备、帮助执行）
2.公式：程序 = 对象 + 交互
3.优点
(1)思想层面：
	-- 可模拟现实情景，更接近于人类思维。
	-- 有利于梳理归纳、分析解决问题。
(2)技术层面：
	-- 高复用：对重复的代码进行封装，提高开发效率。
	-- 高扩展：增加新的功能，不修改以前的代码。
	-- 高维护：代码可读性好，逻辑清晰，结构规整。
4.缺点：学习曲线陡峭。

类和对象

1.类：一个抽象的概念，即生活中的”类别”。
2.对象：类的具体实例，即归属于某个类别的”个体”。
3.类是创建对象的”模板”。
	-- 数据成员：名词类型的状态。
	-- 方法成员：动词类型的行为。
4.类与类行为不同，对象与对象数据不同。

语法

定义类

1.代码
class 类名:
	“””文档说明”””
	def _init_(self,参数列表):
		self.实例变量 = 参数
方法成员

2.	说明
-- 类名所有单词首字母大写.
--  _init_ 也叫构造函数，创建对象时被调用，也可以省略。
--  self 变量绑定的是被创建的对象，名称可以随意。

"""
    类和对象
        现实事物  -抽象化->  类  -实例化-> 对象
"""

class Wife:
    """
        抽象的老婆
    """

    # 数据：姓名、颜值、钱....
    def __init__(self, name, face_score, money):
        self.name = name
        self.face_score = face_score
        self.money = money

    # 方法(函数)：玩...
    def play(self):
        print(self.name, "在玩耍")

jg = Wife("金刚",6,5000)
jg.play()

"""
    创建1个狗类
        数据：爱称,年龄,颜色,品种
        行为：吃、坐下

    创建2个狗对象,调用相应的方法
    画出代码内存图
"""


class Dog:
    """
        狗
    """

    def __init__(self, name, age=0, color="", breed=""):
        self.pet_name = name
        self.age = age
        self.color = color
        self.breed = breed

    def eat(self):
        print(self.pet_name, "在吃")

    def sit(self):
        print(self.pet_name, "坐下")


mx = Dog("米咻", 4, "黄", "拉布拉多")
hm = Dog("黑米", 3, "黑", "拉布拉多")
mx.sit()
hm.sit()

# 练习1：
mx = Dog("米咻", 4, "黄", "拉布拉多")
d01 = mx
d01.pet_name = "咻咻"
mx.age = 5
print(d01.pet_name)
print(d01.age)
print(mx.pet_name)
print(mx.age)


# 练习2：
# 17:00
def func01(p1, p2):
    p1 = Dog("小白", 5)
    p2.pet_name = "小黑"
    p2.age = 6


mx = Dog("米咻", 4)
hm = Dog("黑米", 3)
func01(mx, hm)
print(mx.pet_name, mx.age)  # ?
print(hm.pet_name, hm.age)  # "小黑"   6

class Wife:

    def __init__(self, name, face_score, money):
        self.name = name
        self.face_score = face_score
        self.money = money

    def print_self(self):
        print("%s--%d--%d" % (self.name, self.face_score, self.money))


w01 = Wife("建宁", 86, 999999)
list_wifes = [
    w01,
    Wife("双儿", 95, 5000),
    Wife("苏荃", 98, 10000),
    Wife("阿珂", 100, 6000),
    Wife("铁锤", 80, 0),
]


# 练习1：定义函数,在老婆列表中查找双儿对象
#       测试：调用双儿对象的print_self方法
def find01():
    for item in list_wifes:
        if item.name == "双儿2":
            return item


# 测试：
result = find01()
# 如果找到了
if result:
    result.print_self()


# 练习2：定义函数,在老婆列表中查找所有老婆的姓名
#       测试：打印列表
def find02():
    # list_result = []
    # for item in list_wifes:
    #     list_result.append(item.name)
    # return list_result
    return [item.name for item in list_wifes]


print(find02())

创建对象(实例化)

变量 = 构造函数 (参数列表)

实例成员

实例变量

1.语法
	(1)定义：对象.变量名
	(2)调用：对象.变量名 

2.说明
	(1)首次通过对象赋值为创建，再次赋值为修改.
		w01 = Wife()
		w01.name = “丽丽”
		w01.name = “莉莉”
	(2)通常在构造函数(_init_)中创建。
		w01 = Wife(“丽丽”,24)
		print(w01.name)
	(3)每个对象存储一份，通过对象地址访问。
	
3.作用：描述某个对象的数据。
4.__dict__：对象的属性，用于存储自身实例变量的字典。

实例方法

1.语法
	(1) 定义：  def 方法名称(self, 参数列表):
	    方法体
	(2) 调用： 对象地址.实例方法名(参数列表)
		  不建议通过类名访问实例方法
2.说明
	(1) 至少有一个形参，第一个参数绑定调用这个方法的对象,一般命名为"self"。
	(2) 无论创建多少对象，方法只有一份，并且被所有对象共享。
3.作用：表示对象行为。

"""
    实例成员
        实例变量：对象不同的数据
        实例方法：对象相同行为
        核心逻辑：
           对象.?
"""


# 1. 标准写法
class Wife:
    def __init__(self, name):
        # 创建实例变量：对象.变量名 = 数据
        self.name = name

    def print_self(self):
        print("我叫：", self.name)

    def play(self):
        print("在玩耍")
        # 对象.方法名()
        self.print_self()


w01 = Wife("双儿")
w02 = Wife("阿珂")

# 读取实例变量：?  = 对象.变量名
print(w01.name)

# 内置实例变量
# -- 获取当前对象所有实例变量
print(w01.__dict__)

w01.play()
w02.play()

# 2. 不建议(实例变量应该由类的定义者决定)
# class Wife:
#     pass
#
# w01 = Wife()
# # 创建实例变量：对象.变量名 = 数据
# w01.name = "双儿"
# # 读取实例变量：?  = 对象.变量名
# print(w01.name)

# 3. 不建议(实例变量应该直接在init中定义)
# class Wife:
#     def __init__(self):
#         pass
#
#     def func01(self,name):
#         # 创建实例变量：对象.变量名 = 数据
#         self.name = name
#
# w01 = Wife()
# w01.func01("双儿")
# # 读取实例变量：?  = 对象.变量名
# print(w01.name)


dict01 = {
   }
dict01["name"] = "双儿"
dict01["name"] = "双双"

"""
    创建类：敌人类
        实例变量：姓名,血量,防御力,攻击力
        方法：受伤 - 血量减少
             打印自身信息 - 打印所有实例变量
    创建敌人列表(3)
        -- 定义函数,在敌人列表中找出所有活的敌人
        -- 定义函数,在敌人列表中找出攻击力大于50的敌人名称与攻击力
        -- 定义函数,在敌人列表中找出防御力最小的敌人
        -- 定义函数,在敌人列表中删除血量大于50的所有敌人
        -- 定义函数,根据攻击力进行降序排列
    体会：
        对象.?
"""


class Enemy:
    def __init__(self, name="", hp=0, defense=0, atk=0):
        self.name = name
        self.hp = hp
        self.defense = defense
        self.atk = atk

    def damage(self):
        self.hp -= 10
        print(self.name, "被攻击,血量减少10", )

    def print_self(self):
        print("我是%s血量%d防御力%d攻击力%d" % (self.name, self.hp, self.defense, self.atk))


list_enemys = [
    Enemy("成昆", 0, 10, 90),
    Enemy("玄冥一老", 90, 8, 80),
    Enemy("玄冥二老", 95, 9, 95),
]


# 练习1
def find01():
    list_result = []
    for item in list_enemys:
        if item.hp > 0:
            list_result.append(item)
    return list_result


# 测试
# for item in find01():
#     item.print_self()

for item in find01():
    item.damage()


# 练习2
def find02():
    list_result = []
    for item in list_enemys:
        if item.atk > 50:
            list_result.append((item.name, item.atk))
    return list_result


# 测试    11:30
for item in find02():
    print(item)


# 练习3
def get_min_by_defense():
    min_value = list_enemys[0]
    for i in range(1, len(list_enemys)):
        if min_value.defense > list_enemys[i].defense:
            min_value = list_enemys[i]
    return min_value


# 测试
result = get_min_by_defense()
result.damage()


# 练习3  -- 定义函数,在敌人列表中删除血量大于50的所有敌人
def delete_all_by_hp():
    count = 0
    for i in range(len(list_enemys) - 1, -1, -1):