开头

你现在是一家游戏公司得开发人员，现在需要开发一款叫做<植物大战僵尸>的游戏，咱们就得思考，植物和僵尸作战，那至少需要2种角色，一个是植物，一个是僵尸，并且植物和僵尸都拥有不同的属性和功能，比如豌豆射手可以分为连发和单发，僵尸也分为好多种，就其中的铁桶僵尸和普通僵尸的防御和血量都是不同的，那么我们应该怎么描述这种不同种类和不同角色的功能呢？

搜罗了自己账务的信息，写出了下面的代码来描述植物和僵尸其中的两个角色

def zhiwu(name, agg, job, guard):
    '''
    name：名称，agg：攻击力，job：功能，guard：防御力
    '''
    data = {
        'name':name,
        'agg':agg,
        'job':job,
        'guard':guard
    }

    return data

def jiangshi(name, agg, type):
    '''
    name:名称
    agg：攻击力
    type:类型
    '''
    data = {
        'name':name,
        'agg':agg,
        'type':type
    }
    
    return data

上面两个方法相当于创建了两个模板，游戏里的每个植物和僵尸都拥有相同的属性。游戏开始，你根据一个植物或者一个僵尸传入具体信息来塑造一个具体的植物或者僵尸，怎么生成呢？如下

wandou = zhiwu("豌豆射手", "10", "单发", "8")
tietong = jiangshi("铁桶僵尸", "7", "10")

两个角色对象生成了，豌豆射手和铁桶僵尸还有不同的属性，植物会发射子弹射击僵尸，僵尸会移动到植物附近攻击植物，这些攻击的功能怎么实现呢？。。。。每个功能可以再写一个函数，想执行哪个功能就调用那个函数就可以了。

def Shooting(x,y):
    print(f"{x['name']} 攻击了 {y['name']} {x['guard']} 滴血")


def bite(x,y):
    print(f"{y['name']} 攻击了 {x['name']} {y['guard']} 滴血")

结果如下

面向过程VS面向对象

面向对象编程——Object Oriented Programming，简称OOP，是一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数，也就是我们常说的对象属性以及对象方法。

面向过程的程序设计把计算机程序视为一系列的命令集合，即一组函数的顺序执行。为了简化程序设计，面向过程把函数继续切分为子函数，即把大块函数通过切割成小块函数来降低系统的复杂度。

举个栗子：把大象装进冰箱需要三个步骤，面向过程和面向对象2种不同的思想

面向过程：需要我们操作者一步一步的执行步骤。

面向对象：把冰箱当作对象，对冰箱封装三个功能(打开，存放，关闭)，调用冰箱方法，冰箱执行功能。

面向过程的程序设计

面向过程的程序设计的核心是过程（流水线式思维), 过程即解决问题的步骤，面向过程的设计就好比精心设计好一条流水线，考虑周全什么时候处理什么东西。

优点是：极大的降低了写程序的复杂度，只需要顺着要执行的步骤，堆叠代码即可。

缺点是：一套流水线或者流程就是用来解决一个问题，代码牵一发而动全身。

应用场景：一旦完成基本很少改变的场景，著名的例子有Linux內核，git，以及Apache HTTP Server等。

面向对象的程序设计

优点是：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。

缺点：可控性差，无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法预测最终结果。

应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方。

在python 中面向对象的程序设计并不是全部。

面向对象编程可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

就像想造车. 首先先写车类，类就是图纸. 后面使用这张图纸去造车，先有类   后创建对象。

类与对象

# 函数声明
def 函数名(args):
      函数体 

# 声明一个类
class 类名：
    类变量=值
    def 实例方法(self,*args,**kwargs):
        pass

# 示例
class Car:

    legs=4 # 类变量
    def __init__(self,name,type): # 类必不可少的方法,用于实例化
        self.name=name
        self.type=type

    def drive(self): # 根据Dog类自定义的实例方法
        print("drive...")

注意：__init__() 方法是一个特殊的方法，被称为类的构造函数或初始化方法，当初案件了这个类的实例时就会调用该方法。

类的实例化

bao = Car("宝马","进口车")

ben = Car("奥拓","国产")

self讲解

self代表类的实例本身，而非类。类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

声明一个类
class Student:
	'''
    这是一个学生类

    '''
	# name = "张三"
	# 实例方法
	def study(self):
		print("self",self)
		print("self id",id(self))
		print("%s正在学习"%self.name)

# 实例化对象
# 构建类的实例对象  类名()
s1 = Student()

s1.name = "yujie"
s1.age = 18
s1.ID = 2021001

# s2 = Student()
# s2.name = "zicheng"
# s2.age = 18
# s2.ID = 124

s1.study() # self : s1
print("s1 id",id(s1))
# s2.study() # self : s2

从执行结果可以很明显的看出，self 代表的是类的实例，代表当前对象的地址。self 不是 python 关键字，我们把他换成 this 或者其他任何单词也是可以正常执行的。

类实例变量的增删改查

class Hero:

	def __init__(self, name, sex, hp,  weapon, level=2, exp=2000, money=10000):  # 类必不可少的方法,用于实例化
		self.name = name  # 英雄的名字
		self.sex = sex  # 英雄的性别
		self.hp = hp  # 英雄生命值
		self.level = level  # 英雄的等级
		self.exp = exp  # 英雄的经验值
		self.money = money  # 英雄的金币


Ning = Hero("ning","zokey",100,80)

# 查看属性
print(Ning.sex)
print(Ning.money)

# 添加一个属性
Ning.age = 18

# 修改属性
Ning.money = 22000

# 删除属性
del Ning.age

面向对象的组合用法

class Weapon:
    def __init__(self,name,av,color):
        # 实例属性
        self.name=name        # 名称
        self.av=av            # 攻击力
        self.color=color      # 颜色
gun=Weapon("激光枪",100,"red")

class Hero:

    def __init__(self,name,sex,hp,ce,weapon,level=2,exp=2000,money=10000): # 类必不可少的方法,用于实例化
        self.name=name        # 名字
        self.sex=sex          # 性别
        self.hp=hp            # 血量
        self.ce=ce            # 攻击力
        self.level=level      # 等级
        self.exp=exp          # 经验
        self.money=money      # 金币
        self.weapon=weapon    # 武器


zkh=Hero("史瑞克","srk",100,80,gun)
print(zkh.weapon.color)