面向对象-练习题

# day 15
'''
1,完成下列功能:
  1.1创建一个人类Person,再类中创建3个静态变量(静态字段)
    animal = '高级动物'
    soul = '有灵魂'
    language = '语言'
  1.2在类中定义三个方法,吃饭,睡觉,工作.
  1.3在此类中的__init__方法中,给对象封装5个属性:国家,姓名,性别,年龄,  身高.
  1.4实例化四个人类对象:
    第一个人类对象p1属性为:中国,alex,未知,42,175.
    第二个人类对象p2属性为:美国,武大,男,35,160.
    第三个人类对象p3属性为:你自己定义.
    第四个人类对象p4属性为:p1的国籍,p2的名字,p3的性别,p2的年龄,p3  的身高.
  1.5 通过p1对象执行吃饭方法,方法里面打印:alex在吃饭.
  1.6 通过p2对象执行吃饭方法,方法里面打印:武大在吃饭.
  1.7 通过p3对象执行吃饭方法,方法里面打印:(p3对象自己的名字)在吃饭.
  1.8 通过p1对象找到Person的静态变量 animal
  1.9 通过p2对象找到Person的静态变量 soul
  2.0 通过p3对象找到Person的静态变量 language
'''

# 1.1  创建一个人类Person,再类中创建3个静态变量(静态字段)

class Person:
    animal = '高级动物'
    soul = '有灵魂'
    language = '语言'

# 1.2 在类中定义三个方法，吃饭，睡觉，工作。

    def meal(self):
        print('%s在吃饭' % (self.name))
    def sleep(self):
        pass
    def work(self):
        pass
# 1.3在此类中的__init__方法中,给对象封装5个属性:国家,姓名,性别,年龄,  身高。
    def __init__(self,nation,name,sex,age,height):
        self.nation = nation
        self.name = name
        self.sex = sex
        self.age = age
        self.height = height
# 1.4 实例化4个人类对象
p1 = Person('中国','alex','未知',42,175)
p2 = Person('美国','武大','男',35,160)
p3 = Person('中国','马玉刚','男',31,180)
p4 = Person('中国','武大','男',35,180)

# 1.5 通过p1对象执行吃饭方法,方法里面打印:alex在吃饭.
p1.meal()

#  1.6 通过p2对象执行吃饭方法,方法里面打印:武大在吃饭.
p2.meal()

# 1.7 通过p3对象执行吃饭方法,方法里面打印:(p3对象自己的名字)在吃饭.
p3.meal()

# 1.8 通过p1对象找到Person的静态变量 animal
print(p1.animal)

# 1.9 通过p2对象找到Person的静态变量 soul
print(p2.soul)

# 2.0 通过p3对象找到Person的静态变量 language
print(p3.language)

'''
2,通过自己创建类,实例化对象
  在终端输出如下信息
  小明，10岁，男，上山去砍柴
  小明，10岁，男，开车去东北
  小明，10岁，男，最爱大保健
  老李，90岁，男，上山去砍柴
  老李，90岁，男，开车去东北
  老李，90岁，男，最爱大保健
  老张…
'''
class Person:
    hobbly1 = '上山去砍柴'
    hobbly2 = '开车去东北'
    hobbly3 = '最爱大保健'
    def __init__(self,name,age,sex):  # 封装对象的属性。
        self.name = name
        self.age = age
        self.sex = sex
    def show(self):
        print('%s,%s,%s,%s' % (self.name, self.age, self.sex, self.hobbly1))
        print('%s,%s,%s,%s' % (self.name, self.age, self.sex, self.hobbly2))
        print('%s,%s,%s,%s' % (self.name, self.age, self.sex, self.hobbly3))

p1 = Person('小明', '10岁', '男')
p2 = Person('老李', '90岁', '男')
p1.show()
p2.show()

'''
3,模拟英雄联盟写一个游戏人物的类（升级题）.
  要求:
  (1)创建一个 Game_role的类.
  (2) 构造方法中给对象封装name,ad(攻击力),hp(血量).三个属性.
  (3) 创建一个attack方法,此方法是实例化两个对象,互相攻击的功能:
      例: 实例化一个对象 盖伦,ad为10, hp为100
      实例化另个一个对象 剑豪 ad为20, hp为80
      盖伦通过attack方法攻击剑豪,此方法要完成 '谁攻击谁,谁掉了多少血,  还剩多少血'的提示功能.
'''

class Game_role:
    def __init__(self, name, ad, hp):
        self.name = name
        self.ad = ad
        self.hp = hp
    def attack(self,p1):
        p1.hp = p1.hp - self.ad
        print('%s攻击了%s,%s还剩下%s' % (self.name, p1.name, p1.name, p1.hp))


Gailun = Game_role('盖伦', 10, 100)
Jianhao = Game_role('剑豪', 20, 80)

Gailun.attack(Jianhao)
Jianhao.attack(Gailun)

'''
4,默写内容:
  创建一个人类,定义三个静态变量,在构造方法中封装3个属性.然后实例化一个对象,对象调用自己的属性,对象调用类的静态方法,
  对象调用类中的方法.
  默写一下实例化一个对象，具体经历了哪些阶段。
'''

class Person:
    animal = '高级动物'
    soul = '有灵魂'
    language = '语言'

    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age

    def func1(self):
        print('调用类中的方法')
        pass


P1 = Person('马玉刚', 'men', 31)
print(P1.name)
print(P1.animal)
P1.func1()

'''实例化一个对象具体经历的阶段
（1）实例化对象在内存中产生一个对象空间（内存地址）。
（2）自动执行 __init__方法并且将对象空间传给了self参数。***
（3）在 __init__方法中，给对象空间封装一些静态属性。
'''

#  Day 16

'''
1，暴力摩托程序（完成下列需求）：
1.1创建三个游戏人物，分别是：
•    苍井井，女，18，攻击力ad为20，血量200
•    东尼木木，男，20，攻击力ad为30，血量150
•    波多多，女，19，攻击力ad为50，血量80
1.2创建三个游戏武器，分别是：
•    平底锅，ad为20
•    斧子，ad为50
•    双节棍，ad为65

1.3 创建三个游戏摩托车，分别是：

•    小踏板，速度60迈
•    雅马哈，速度80迈
•    宝马，速度120迈。

完成下列需求（利用武器打人掉的血量为武器的ad + 人的ad）：
（1）苍井井骑着小踏板开着60迈的车行驶在赛道上。
（2）东尼木木骑着宝马开着120迈的车行驶在赛道上。
（3）波多多骑着雅马哈开着80迈的车行驶在赛道上。
（4）苍井井赤手空拳打了波多多20滴血，波多多还剩xx血。
（5）东尼木木赤手空拳打了波多多30滴血，波多多还剩xx血。
（6）波多多利用平底锅打了苍井井一平底锅，苍井井还剩xx血。
（7）波多多利用斧子打了东尼木木一斧子，东尼木木还剩xx血。
（8）苍井井骑着宝马打了骑着小踏板的东尼木木一双节棍，东尼木木哭了，还剩xx血。（选做）
（9）波多多骑着小踏板打了骑着雅马哈的东尼木木一斧子，东尼木木哭了，还剩xx血。（选做）
'''


class Game_Role:
    def __init__(self, name, sex, age, ad, hp):
        self.name = name
        self.sex = sex
        self.age = age
        self.ad = ad
        self.hp = hp
        self.wea = Weapon()  # 将Weapon实例的对象作为Game_Role封装的一个属性。
        self.veh = Vehicle()  # 将Vehicle实例的对象作为Game_Role封装的一个属性。
    def use_wea(self, wea ):  # 定义使用的武器
        self.wea = wea
    def use_vehicle(self, vehicle,flag = 0 ):   # flag用来标识，如果为0则打印“行驶在赛道上”，否则不打印“行驶在赛道上”。
        self.veh = vehicle
        if flag ==0:
            if self.veh.moto_name == '无':
                pass
            else:
                print('%s骑着%s开着%s迈的车行驶在赛道上' % (self.name, vehicle.moto_name, vehicle.speed))
        else:
            pass
    def Strike(self, p1):
        p1.hp = p1.hp - self.getad()
        if self.wea.name == '赤手空拳'and self.veh.moto_name =='无':
            print("%s%s打了%s%s滴血，%s还剩%s血" % (self.name, self.wea.name, p1.name, self.getad(), p1.name, p1.hp))
        elif self.wea.name != '赤手空拳'and self.veh.moto_name =='无':
            print("%s利用%s打了%s一%s，%s还剩%s血" % (self.name, self.wea.name, p1.name,self.wea.name, p1.name, p1.hp))
        elif self.wea.name != '赤手空拳'and self.veh.moto_name !='无':
            print("%s骑着%s打了骑着%s的%s一%s，%s哭了，还剩%s血。" % (self.name, self.veh.moto_name, p1.veh.moto_name, p1.name, self.wea.name, p1.name, p1.hp))
    def getad(self):  # 动态的得到攻击力
            if self.wea:
                ad = self.ad + self.wea.ad
            else:
                ad = self.ad
            return ad

class Weapon:
    def __init__(self, name='赤手空拳', ad=0):
        self.name = name
        self.ad = ad


class Vehicle:
    def __init__(self, moto_name='无', speed=0):
        self.moto_name = moto_name
        self.speed = speed

g1 = Game_Role('苍井井', '女', 18, 20, 200)  # 苍井井，女，18，攻击力ad为20，血量200
g2 = Game_Role('东尼木木', '男', 20, 30, 150)  # 东尼木木，男，20，攻击力ad为30，血量150
g3 = Game_Role('波多多', '女', 19, 50, 80)  # 波多多，女，19，攻击力ad为50，血量80

w0 = Weapon('赤手空拳', 0)  # 赤手空拳，ad为0
w1 = Weapon('平底锅', 20)  # 平底锅，ad为20
w2 = Weapon('斧子', 50)  # 斧子，ad为50
w3 = Weapon('双节棍', 65)  # 双节棍，ad为65

v0 = Vehicle('无', 0)  #  无，速度0迈
v1 = Vehicle('小踏板', 60)  # 小踏板，速度60迈
v2 = Vehicle('雅马哈', 80)  # 雅马哈，速度80迈
v3 = Vehicle('宝马', 120)  # 宝马，速度120迈


# （1）苍井井骑着小踏板开着60迈的车行驶在赛道上。
g1.use_vehicle(v1)
# （2）东尼木木骑着宝马开着120迈的车行驶在赛道上。
g2.use_vehicle(v3)
# （3）波多多骑着雅马哈开着80迈的车行驶在赛道上。
g3.use_vehicle(v2)
# （4）苍井井赤手空拳打了波多多20滴血，波多多还剩xx血。
g1.use_wea(w0)
g1.use_vehicle(v0)
g1.Strike(g3)
# （5）东尼木木赤手空拳打了波多多30滴血，波多多还剩xx血。
g2.use_wea(w0)
g2.use_vehicle(v0)
g2.Strike(g3)
# （6）波多多利用平底锅打了苍井井一平底锅，苍井井还剩xx血。
g3.use_wea(w1)
g3.use_vehicle(v0)
g3.Strike(g1)
# # （7）波多多利用斧子打了东尼木木一斧子，东尼木木还剩xx血。
g3.use_wea(w2)
g3.use_vehicle(v0)
g3.Strike(g2)
# # （8）苍井井骑着宝马打了骑着小踏板的东尼木木一双节棍，东尼木木哭了，还剩xx血。（选做）
g1.use_vehicle(v3, 1)
g1.use_wea(w3)
g2.use_vehicle(v1, 1)
g1.Strike(g2)
# # （9）波多多骑着小踏板打了骑着雅马哈的东尼木木一斧子，东尼木木哭了，还剩xx血。（选做）
g3.use_vehicle(v1, 1)
g3.use_wea(w2)
g2.use_vehicle(v2, 1)
g3.Strike(g2)


# 2，定义一个类，计算圆的周长和面积。
import math


class circle:
    def Perimeter(self, r):  # 定义圆的周长函数,r为半径。
        perimeter = 2 * math.pi * r
        print('半径为%s的圆的周长为%s' % (r, perimeter))

    def Acreage(self, r):
        acreage = math.pi * (r ** 2)
        print('半径为%s的圆的面积为%s' % (r, acreage))


circle1 = circle()
circle1.Perimeter(0.5)  # 半径为0.5的圆的周长为3.141592653589793
circle1.Acreage(1)  # 半径为1的圆的面积为3.141592653589793


# 3，定义一个圆环类，计算圆环的周长和面积（升级题）。
import math
class Ring:
    def Ring_perimeter(self,r1,r2): # 定义圆环的周长，r1，r2为内环外环的半径。
        if r1 < r2:
            ring_perimeter = math.pi*2*(r2-r1)
            print('内径为%s,外径为%s的圆环的周长为%s' % (r1, r2, ring_perimeter))
        else:
            ring_perimeter =math.pi*2*(r1-r2)
            print('内径为%s,外径为%s的圆环的周长为%s' % (r2, r1, ring_perimeter))
    def Ring_Acreage(self,r1,r2):  # 定义圆环的面积，r1，r2为内环外环的半径。
        if r1 < r2:
            ring_Acreage = math.pi*(r2**2-r1**2)
            print('内径为%s,外径为%s的圆环的面积为%s' % (r1, r2, ring_Acreage))
        else:
            ring_Acreage =math.pi*(r1**2-r2**2)
            print('内径为%s,外径为%s的圆环的面积为%s' % (r2, r1, ring_Acreage))
ring1 = Ring()
ring1.Ring_perimeter(2, 1)
ring1.Ring_Acreage(2, 1)

4，默写内容:创建两个类，让一个类的对象的属性为另一个类的对象。
class Game_Role:
    area = '召唤师峡谷'

    def __init__(self, name, sex, ad, hp):
        self.name = name
        self.sex = sex
        self.ad = ad  # 攻击力
        self.hp = hp  # 血量

    def fight(self, role1):
        role1.hp = role1.hp - self.ad
        print('%s 攻击 %s, %s还剩余%s' % (self.name, role1.name, role1.name, role1.hp))
        # print(self, role1)

    def equit_weapon(self, wea):  # 组合： 对象中的属性是另一个类的对象，将Weapon类的对象sword作为Game_roles类的实例化对象P1的封装的属性。
        self.wea = wea


class Weapon:
    def __init__(self, name, ad):
        self.name = name
        self.ad = ad

    def wea_attack(self, role1, role2):
        role2.hp = role2.hp - self.ad
        print('%s 利用 %s 攻击 %s, %s还剩余%s' % (role1.name, self.name, role2.name, role2.name, role2.hp))
p1 = Game_Role('盖伦', 'man', 30, 500)
p2 = Game_Role('狗头', '公', 50, 250)
sword = Weapon('大宝剑', 40)
p1.equit_weapon(sword)  # 此方法就是给p1对象封装一个属性，属性值是sword对象***
p1.wea.wea_attack(p1, p2)  # 通过p1.wea找到sword 然后在sword.wea_attack执行方法,其中self省略了。


#  day17

# 一、简答题

# 1.面向对象的三大特性是什么？面向对象的三大特性是什么？
# 封装、继承、多态

# 2，什么是面向对象的新式类？什么是经典类？
# 新式类：继承object的类。
# 经典类：不继承object的类。
# 说明：python2x中经典类和新式类共存；python3x中全部都是新式类。

# 3，面向对象为什么要有继承？继承的好处是什么？
# 作用（1）节省代码（2）提高效率 （3）让类之间产生关联

# 4，面向对象中super的作用。
# 调用父类（超类）中需要执行的动态方法。

# 二，代码题(通过具体代码完成下列要求)：
'''
1，
a,定义一个父类Animal，在构造方法中封装三个属性，姓名，性别，年龄，再给其添加一个eat的方法，方法中显示%s正在吃饭（%s是哪个对象调用此方法，显示哪个对象名字）。
b,定义两个基类Person,Dog，全部继承这个父类Animal.
c,Person类中，有构造方法，封装一个皮肤的属性，有eat方法，方法中显示人类正在吃饭。
d,Dog类中，有构造方法，封装一个毛色的属性，有eat方法，方法中显示狗狗正在吃饭。
上面这几个类创建完成之后，完成下列要求：
①： 实例化一个人类的对象，让其只封装皮肤属性。
②： 实例化一个人类的对象，让其封装姓名，性别，年龄，皮肤四个属性。
③： 实例化一个狗类的对象，让其只封装毛色属性。
④： 实例化一个狗类的对象，让其封装姓名，性别，年龄，毛色四个属性。
⑤： 实例化一个人类的对象，让其只执行父类的eat方法（可以对人类代码进行修改）。
⑥： 实例化一个狗类的对象，让其既执行父类的eat方法，又执行子类的eat方法。

# '''

# ①： 实例化一个人类的对象，让其只封装皮肤属性。
class Animal:
    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age
    def eat(self):
        print('%s正在吃饭' % (self.name))
class Person(Animal):
    def __init__(self, skin):   # 定义人类的皮肤属性
        self.skin = skin
        # super(Person, self).__init__(name, sex, age)  # 引用父类封装的属性
    def eat(self):
        print('人类正在吃饭')
class Dog(Animal):
    def __init__(self, hair, name, sex, age):   # 定义狗的毛色属性
        self.hair = hair
        super(Dog, self).__init__(name, sex, age)   # 引用父类封装的属性
    def eat(self):
        print('狗狗正在吃饭')
p1 = Person('黄色')

# ②： 实例化一个人类的对象，让其封装姓名，性别，年龄，皮肤四个属性。
class Animal:
    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age
    def eat(self):
        print('%s正在吃饭' % (self.name))
class Person(Animal):
    def __init__(self, skin, name, sex, age):   # 定义人类的皮肤属性
        self.skin = skin
        super(Person, self).__init__(name, sex, age)  # 引用父类封装的属性
    def eat(self):
        print('人类正在吃饭')
class Dog(Animal):
    def __init__(self, hair, name, sex, age):   # 定义狗的毛色属性
        self.hair = hair
        super(Dog, self).__init__(name, sex, age)   # 引用父类封装的属性
    def eat(self):
        print('狗狗正在吃饭')
p2 = Person('黄色', '马玉刚', '男', 31)
p2.eat()

# ③： 实例化一个狗类的对象，让其只封装毛色属性。
class Animal:
    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age
    def eat(self):
        print('%s正在吃饭' % (self.name))
class Person(Animal):
    def __init__(self, skin, name, sex, age):   # 定义人类的皮肤属性
        self.skin = skin
        super(Person, self).__init__(name, sex, age)  # 引用父类封装的属性
    def eat(self):
        print('人类正在吃饭')
class Dog(Animal):
    def __init__(self, hair):   # 定义狗的毛色属性
        self.hair = hair
    def eat(self):
        print('狗狗正在吃饭')
d1 = Dog('白色')
d1.eat()

# ④： 实例化一个狗类的对象，让其封装姓名，性别，年龄，毛色四个属性。
class Animal:
    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age
    def eat(self):
        print('%s正在吃饭' % (self.name))
class Person(Animal):
    def __init__(self, skin, name, sex, age):   # 定义人类的皮肤属性
        self.skin = skin
        super(Person, self).__init__(name, sex, age)  # 引用父类封装的属性
    def eat(self):
        print('人类正在吃饭')
class Dog(Animal):
    def __init__(self, hair, name, sex, age):   # 定义狗的毛色属性
        self.hair = hair
        super(Dog, self).__init__(name, sex, age)   # 引用父类封装的属性
    def eat(self):
        print('狗狗正在吃饭')
d2 = Dog('白色', '哈士奇', '公', 2)
d2.eat()

# ⑤： 实例化一个人类的对象，让其只执行父类的eat方法（可以对人类代码进行修改）。
class Animal:
    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age
    def eat(self):
        print('%s正在吃饭' % (self.name))
class Person(Animal):
    def __init__(self, skin, name, sex, age):   # 定义人类的皮肤属性
        self.skin = skin
        super(Person, self).__init__(name, sex, age)  # 引用父类封装的属性
class Dog(Animal):
    def __init__(self, hair, name, sex, age):   # 定义狗的毛色属性
        self.hair = hair
        super(Dog, self).__init__(name, sex, age)   # 引用父类封装的属性
p3 = Person('黄色', '马玉刚', '男', 31)
p3.eat()

# ⑥： 实例化一个狗类的对象，让其既执行父类的eat方法，又执行子类的eat方法。
class Animal:
    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age
    def eat(self):
        print('%s正在吃饭' % (self.name))
class Person(Animal):
    def __init__(self, skin, name, sex, age):   # 定义人类的皮肤属性
        self.skin = skin
        super(Person, self).__init__(name, sex, age)  # 引用父类封装的属性
class Dog(Animal):
    def __init__(self, hair, name, sex, age):   # 定义狗的毛色属性
        self.hair = hair
        super(Dog, self).__init__(name, sex, age)   # 引用父类封装的属性
d3 = Dog('白色', '哈士奇', '公', 2)
d3.eat()
'''
2，
class A:
    def func(self):
        print('in A')

class B:
    def func(self):
        print('in B')

class C(A,B):
    def func(self):
        print('in C')
可以改动上上面代码，完成下列需求：
对C类实例化一个对象产生一个c1，然后c1.func()
1, 让其执行C类中的func
2，让其执行A类中的func
3，让其执行B类中的func
4，让其既执行C类中的func，又执行A类中的func
5，让其既执行C类中的func，又执行B类中的func

'''

# 01, 让其执行C类中的func
class A:
    def func(self):
        print('in A')

class B:
    def func(self):
        print('in B')

class C(A,B):
    def func(self):
        print('in C')
c1 = C()
c1.func()
print(C.__mro__)  # 查看类执行先后的顺序。

# 02，让其执行A类中的func
class A:
    def func(self):
        print('in A')

class B:
    def func(self):
        print('in B')

class C(A,B):
    def func(self):
        super(C, self).func()  # 通过该行代码，让其执行A类中的func。
c1 = C()
c1.func()
print(C.__mro__)

# 03 让其执行B类中的func
class A:
    def func(self):
        print('in A')

class B:
    def func(self):
        print('in B')

class C(B):
    def func(self):
        super().func()

c1 = C()
c1.func()

# 04 让其既执行C类中的func，又执行A类中的func
class A:
    def func(self):
        print('in A')

class B:
    def func(self):
        print('in B')

class C(A,B):
    def func(self):
        print('in C')
        super(C, self).func()  # 通过该行代码，让其执行A类中的func。
c1 = C()
c1.func()
print(C.__mro__)

# 05 让其既执行C类中的func，又执行B类中的func
class A:
    def func(self):
        print('in A')

class B:
    def func(self):
        print('in B')

class C(A,B):
    def func(self):
        print('in C')
        super(A, self).func() # 通过该行代码，让其执行A类中的func。
c1 = C()
c1.func()
print(C.__mro__)

# 3，下面代码执行结果是什么？为什么？
class Parent:
    def func(self):
        print('in Parent func')

    def __init__(self):
        self.func()

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

son1 = Son()

# 输出结果：in Son func
'''
原因：由于在继承的时候，执行的顺序是先在子类/派生类中的方法/变量。，在执行父类（超类）中的方法/变量。本题中子类中包含
func函数，所以会先执行子类中的函数。
'''

# 4
class A:
    name = []

p1 = A()
p2 = A()
p1.name.append(1)
# p1.name，p2.name，A.name 分别是什么？
print(p1.name)   # [1] ，因为name是静态变量，开辟的空间是唯一的。
print(p2.name)   # [1] ，因为name是静态变量，开辟的空间是唯一的。
print(A.name)    # [1] ，因为name是静态变量，开辟的空间是唯一的。

p1.age = 12
# p1.age，p2.age，A.age 分别又是什么？为什么？
print(p1.age)  # 12
print(p2.age)  # 报错，age是p1的特有属性
print(A.age)   # 报错，age是p1的特有属性