6）面向对象

Posted 2020-11-06

                                     面向对象

 

游戏人狗大战：

# 函数 基础数据类型 循环 文件处理 模块
# 游戏公司
# 人狗大战
# 两个角色
# 人
    # 昵称
    # 性别
    # 生命值
    # 战斗力
    # 背包
# 狗
    # 昵称
    # 品种
    # 生命值
    # 战斗力

 

通过之前的函数来实现：

def Person(name,sex,hp,dps): #人模子
    dic = {'name':name,'sex':sex,'hp':hp,'dps':dps,'bag':[]}
    return dic
alex = Person('alex','N/A',250,5)

def Dog(name,kind,hp,dps): #狗模子
    dic = {'name':name,'kind':kind,'hp':hp,'dps':dps}
    return dic
ha2 =Dog('哈士奇','藏獒',15000,200)

def attack(person_name,dog_name,person_dps,dog_hp):
    print('%s打了%s,%s掉了%s点血,剩余%s点血' %(person_name,dog_name,dog_name,person_dps,dog_hp-person_dps))

attack(alex['name'],ha2['name'],alex['dps'],ha2['hp'])

 

 

但是患有个问题是狗血没掉：

print(ha2)

 

alex打了哈士奇,哈士奇掉了5点血,剩余14995点血

{'name': '哈士奇', 'hp': 15000, 'kind': '藏獒', 'dps': 200}

 

 

 

接下来进行修改：得到新内容：

 

 

def Person(name,sex,hp,dps): #人模子
    dic = {'name':name,'sex':sex,'hp':hp,'dps':dps,'bag':[]}
    return dic
alex = Person('alex','N/A',250,5)

def Dog(name,kind,hp,dps): #狗模子
    dic = {'name':name,'kind':kind,'hp':hp,'dps':dps}
    return dic
ha2 =Dog('哈士奇','藏獒',15000,200)
#人打狗
def attack(person,dog):
    dog['hp'] -= person['dps']
    print('%s打了%s,%s掉了%s点血,剩余%s点血' %(person['name'],dog['name'],dog['name'],person['hp'],dog['hp']))

attack(alex,ha2)
print(ha2)

alex打了哈士奇,哈士奇掉了250点血,剩余14995点血

{'name': '哈士奇', 'dps': 200, 'kind': '藏獒', 'hp': 14995}

 

 

 

#狗咬人

def bite(dog,person):
    person['hp'] -= dog['dps']
    print('%s咬了%s,%s掉了%s点血,剩余%s点血' % (dog['name'], person['name'], person['name'], dog['dps'],person['hp']))

bite(ha2,alex)
print(alex)

 

哈士奇咬了alex,alex掉了200点血,剩余50点血

{'name': 'alex', 'sex': 'N/A', 'dps': 5, 'hp': 50, 'bag': []}

 

 

 

 

这里患有一个问题

就是传参不固定会发生人咬狗事件，要想办法固定

def Person(name,sex,hp,dps): #人模子
    dic = {'name':name,'sex':sex,'hp':hp,'dps':dps,'bag':[]}

    def attack(dog):
        dog['hp'] -= dic['dps']
        print('%s打了%s,%s掉了%s点血,剩余%s点血' % (dic['name'], dog['name'], dog['name'], dic['hp'], dog['hp']))
    dic['attack'] = attack          #防止在外部去调用里面的信息调用不到
    return dic
alex = Person('alex','N/A',250,5)

def Dog(name,kind,hp,dps): #狗模子
    dic = {'name':name,'kind':kind,'hp':hp,'dps':dps}

    def bite(person):
        person['hp'] -= dic['dps']
        print('%s咬了%s,%s掉了%s点血,剩余%s点血' % (dic['name'], person['name'], person['name'], dic['dps'], person['hp']))
    dic['bite'] = bite    #防止在外部去调用里面的信息调用不到
    return dic
ha2 =Dog('哈士奇','藏獒',15000,200)
#人打狗
print(alex['attack'])
alex['attack'](ha2)

ha2['bite'](alex)

# 面向对象的编程思想
# 人狗大战
# 创建一个人
# 创建一个狗
# 人打狗 —— 函数
# 狗咬人 —— 函数

# 造模子 —— 面向对象
# 规范了一类角色的属性项目、属性的名字、技能、技能的名字
# 权限 有一些函数 只能是这个角色才能拥有 才能调用 

 

面向对象规则：

 

 

类：

具有相同属性和相同动作的一类事物，组成一个类

是抽象的

就是一个模子

 

对象：

具体的某一个具有实际属性 和具体动作的一个实体

是具体的

 

类的语法：

Class   类名：

静态属性= 任何属性 None

def 动态属性（self）：pass

 

 

只要写在类名中的名字，不管是变量名换是函数名，不能在类外直接调用

只能通过类名来使用它

 

Print(类名.静态属性)

 

1）类名的功能--------》查看静态属性

 

 

 

 

 

 

2）类的第二功能====实例化（创造对象）

 

 

 

 

Class Persion：

Pass

 

Alex = persion()

Print(alex)   #对象= 类名（）

Print(Persion)

 

 

 

 

写进来

 

 

 

 

 

 

类的实例化过程：————==++

 

 

总结：

# 类  ： 具有相同属性和相同动作的一类事物 组成一个类
# 对象 ： 具体的某一个具有实际属性 和具体动作的一个实体

# 类是抽象的
# 对象是具体的
# 类被创造出来 就是模子 是用来描述对象的

# class 类名:
#     静态属性 = 123
#     def 动态属性(self):
#         # 在类中的方法的一个默认的参数，但也只是一个形式参数,约定必须叫self
#         print('-->',self)
#
# # 只要是写在类名中的名字 不管是变量还是函数名 都不能在类的外部直接调用
# # 只能通过类名来使用它
# # 类名的第一个功能是 —— 查看静态属性
# print(类名.静态属性)   # 查看
# 类名.静态属性 = 456    # 修改
# print(类名.静态属性)
# 类名.静态属性2 = 'abc'# 增加
# print(类名.静态属性2)
# # del 类名.静态属性2  #删除
# # print(类名.静态属性2)
# print(类名.__dict__)   # 类中必要的默认值之外 还记录了程序员在类中定义的所有名字

# 类名可以查看某个方法，但是一般情况下 我们不直接使用类名来调用方法
# print(类名.动态属性)
# 类名.动态属性(1)


# 类的第二个功能是 —— 实例化（创造对象）  对象= = 类名（）
# class Person:pass
#
# alex = Person()
# 对象 = 类名()
# print(alex)  # object
# print(Person)
# alex name hp dps bag sex
# print(alex.__dict__)
# # alex.__dict__['name'] = 'alex'
# # alex.__dict__['sex'] = '不详'
# # alex.__dict__['hp'] = 250
# # alex.__dict__['dps'] = 5
# # alex.__dict__['bag'] = []
# # print(alex.__dict__)
# alex.name = 'alex'   # 给alex对象添加属性
# alex.hp = 250
# alex.dps = 5
# alex.sex = '不详'
# alex.bag = []
# print(alex.__dict__)

class Person:
    def __init__(self,name,hp,dps,sex):
        self.name = name
        self.hp = hp
        self.dps = dps
        self.sex = sex
        self.bag = []

alex = Person('alex',250,5,'N/A')
print('alex : ',alex)
print(alex.__dict__)
print(alex.name)
# 为什么会执行init中的内容？
# self到底是什么？
# 实例化的过程
# 类名()就是实例化
# 在实例化的过程中 发生了很多事情是外部看不到的
# 1.创建了一个对象
# 2.自动调用__init__方法
# 这个被创造的对象会被当做实际参数传到__init__方法中，并且传给第一个参数self
# 3.执行init方法中的内容
# 4.自动的把self作为返回值 返回给实例化的地方

 

 

 

对象名。方法名 相当与调用一个函数，这个函数默认吧对象作为第一个参数传入函数

 

class Person:
    def __init__(self,name,hp,dps,sex):
        self.name = name
        self.hp = hp
        self.dps = dps
        self.sex = sex
        self.bag = []
    def attack(self,dog):
        dog.hp -= self.dps
        print('%s打了%s,%s掉了%s点血,剩余%s点血' % (self.name,dog.name,dog.name,self.dps,dog.hp))


class Dog:
    def __init__(self,name,kind,hp,dps):
        self.name = name
        self.kind = kind
        self.hp = hp
        self.dps = dps

    def bitte(self,person):
        person.hp -= self.dps
        print('%s咬了%s,%s掉了%s点血,剩余%s点血' % (self.name,person.name,person.name,self.dps,person.hp))


ha2 = Dog('哈士奇','藏獒',1500,200)
alex = Person('alex',250,5,'N/A')
alex.attack(ha2)# Person.attack(alex)
ha2.bitte(alex)

 

#对象名.方法名 相当于调用一个函数，默认吧对象作为第一个参数传入函数

 

from  math import pi


#类 园  属性 方法

class Circle:
    def __init__(self,r):
        self.r = r

    def area(self):  #面积
        return pi * self.r**2

    def perimeter(self): #周长
        return self.r*pi*2
c1 = Circle(2)

 

 

每一个角色都有属于自己的属性和方法

当一个类在创建一个实例的时候，就产生了一个这个实例和类之间的联系

可以通过实例  对象找到实例化他的类

  

在访问变量的时候，都先使用自己的命名空间中的，如果自己的空间中没有，再到类的空间中去找

在使用对象修改静态变量的过程中，相当于在自己的空间中创建了一个新的变量

 

在类的静态变量中操作，应该使用类名来直接进行操作，不会出现乌龙问题

 

 

 

 

class Foo:
    count = 0
    def __init__(self):
        Foo.count +=1

f1 = Foo()
print(Foo.count)
[Foo() for i in range(10)]
print(Foo.count)

 组合：

 

继承：解决代码的冗余

可以多继承

 

单继承：

 

class Parent:
    pass

class Son(Parent):
    pass

#Son这个类继承了Parent类
#父类、基类、超类----Parent类
#子类、派生类-----Son类

 

 

多继承：

class Parent:
    pass

class Parent2:
    pass

class Son(Parent,Parent2):
    pass

 

 

举个例子：

class Animal:
    def __init__(self,name,hp,dps):
        self.name = name
        self.hp = hp
        self.dps = dps
class Person(Animal):pass
class Dog(Animal):pass

alex = Person('alex',250,5)
ha2 = Person('哈士奇',15000,200)
print(alex.__dict__)
print(ha2.__dict__)

 

子类的空间找不到就到父类的里面去找

 

class Animal:
    def __init__(self,name,hp,dps):
        self.name = name
        self.hp = hp
        self.dps = dps
class Person(Animal):
    def __init__(self, name, hp, dps):
        print('-----%')
class Dog(Animal):pass

alex = Person('alex',250,5)
# ha2 = Person('哈士奇',15000,200)
print(alex.__dict__)
# print(ha2.__dict__)


#先找对象的空间----创建对象的类的内存空间-----父类的内存空间

 

 

继承例子：

 

class Animal:
    def __init__(self,name,hp,dps):
        self.name = name
        self.hp = hp
        self.dps = dps
class Person(Animal):
    def __init__(self, name, hp, dps,sex):
        Animal.__init__(self,name,hp,dps)   #继承
        self.sex = sex

class Dog(Animal):pass

alex = Person('alex',250,5,'N/A')
# ha2 = Person('哈士奇',15000,200)
print(alex.__dict__)
# print(ha2.__dict__)


#先找对象的空间----创建对象的类的内存空间-----父类的内存空间

 

 

 

在优化一下：

class Animal:   #动物类
    def __init__(self,name,hp,dps):
        self.name = name
        self.hp = hp
        self.dps = dps
class Person(Animal):  #人类
    def __init__(self, name, hp, dps,sex):
        # Animal.__init__(self,name,hp,dps)   #继承
        super().__init__(name,hp,dps)
        self.sex = sex                      #派生属性

class Dog(Animal):#狗类
    def __init__(self,name,hp,dps,kind):
        # Animal.__init__(self, name, hp,dps) #继承
        super().__init__(name,hp,dps)
        self.kind = kind                            #派生属性


alex = Person('alex',250,5,'N/A')
ha2 = Person('哈士奇',15000,200,333)
print(alex.__dict__)
print(ha2.__dict__)

 

 

class Animal:   #动物类
    def __init__(self,name,hp,dps):
        self.name = name
        self.hp = hp
        self.dps = dps
    def eat(self):   #附加属性吃药回血
        print('%s吃药回血了'%(self.name))
class Person(Animal):  #人类
    def __init__(self, name, hp, dps,sex):
        # Animal.__init__(self,name,hp,dps)   #继承
        super().__init__(name,hp,dps)
        self.sex = sex                      #派生属性

class Dog(Animal):#狗类
    def __init__(self,name,hp,dps,kind):
        # Animal.__init__(self, name, hp,dps) #继承
        super().__init__(name,hp,dps)
        self.kind = kind                            #派生属性


alex = Person('alex',250,5,'N/A')
ha2 = Person('哈士奇',15000,200,'藏獒')
print(alex.__dict__)
print(ha2.__dict__)
ha2.eat()

 

对象的内存空间---创建的对象的类的内存空间------父类的内存空间

class Foo:
    def __init__(self):
        self.func()
    def func(self):
        print('in Foo')

class Son(Foo):
    def func(self):
        print('in Son')

Son()

 

钻石继承：

class A:
    def f(self):
        print('in A')

class B(A):
    def f(self):
        print('in B')

class C(A):
    def f(self):
        print('in C')

class D(B,C):
    def f(self):
        print('in D')

d = D()
d.f()

print(D.mro())    #mro可以知道顺序

 

D----->-B----->C-------->A：查找的顺序

 

小乌龟模型：

 

 

查找太麻烦了，这个不合理

 

 

这个合理每个点，出现一次