复习整理3

类：具有相同属性和技能的一类事物
对象：具体的类的表现（类的实例）

# # 面向对象结合函数
# # 类：具有相同属性和技能的一类事物
# # 对象：具体的类的表现（类的实例）
#
# # class  定义类的关键字
#
# class Person:  # 第一个字母大写  # 类里面一般两部分：变量部分，方法（函数）部分
#     """注释"""
#     mind = "思想"
#     animal = "动物"
#     faith = "信仰"  # 变量也可以称为静态变量或者静态字段
#
#     def __init__(self):
#         print(self)
#         print(666)
#         # self.name = name
#         # self.age = age
#         # self.sex = sex
#
#     def work(self):
#         print("都得工作")
#
#     def sleep(self):  # 方法（函数）
#         print("休息")
#
#
# # 类名的角度
# # 类名中的静态变量
# # #1  __dict__
# # print(Person.__dict__)  # 以字典形式返回类中所有内容
# # print(Person.__dict__["mind"])  # 只能查询，不能进行增删改
#
# # # 2  利用点 .
# # print(Person.mind)  # 查
# # Person.money = "RMB"  # 增加
# # print(Person.__dict__)
# # Person.animal = "猴子" # 改
# # print(Person.__dict__["animal"])
# # del Person.mind  # 删
#
# #     # 操作类中的方法
# # print(Person.__dict__)
# # Person.__dict__["work"](1)  # 工作中不用
# # Person.work(2)   # 基本不用
#
# # 对象的角度
# # Person() 类名加()叫做实例化的过程
# # 只要类名（）产生一个对象，自动执行__init__方法
# p = Person()    # 类名()产生了一个对象内存地址，然后实例化将内存地址传递给__init__函数里面第一个位置参数，也就是self，执行__init__
# print(p)


class Person:  # 第一个字母大写  # 类里面一般两部分：变量部分，方法（函数）部分
    """注释"""
    mind = "思想"
    animal = "动物"
    faith = "信仰"  # 变量也可以称为静态变量或者静态字段

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

    def work(self):
        print("都得工作")

    def sleep(self):  # 方法（函数）
        print("休息")

p = Person("ly", "99", "m") # 这里的p和self 的地址是相同的，也可以看作是对象内存空间。

# 1 类名+()  产生一个实例（对象，对象空间）
#2 自动执行类中的__init__方法，将对象空间传递给__init__的self参数
# 给对象封装相应的属性
print(p.__dict__)

# 对象操做类中的静态变量只能查询
print(p.animal)
# 对象调用类中的方法
p.sleep()

作业

# class Persom:
#     animal = "动物"
#     soul = "有趣的灵魂"
#     language = "语言"
#
#     def __init__(self,country,name,age,sex,height):
#         self.country = country
#         self.name = name
#         self.age = age
#         self.sex = sex
#         self.height = height
#
#     def eat(self):
#         print("%s吃饭了" % self.name)
#
#     def sleep(self):
#         print("睡觉")
#
#     def work(self):
#         print("工作")
#
#
# p1 = Persom("中国", "y", 6, "男", 178)
# p2 = Persom("美国", "武大", 7, "男", 174)
# p3 = Persom("中国", "小", 8, "男", 17)
# p4 = Persom(p1.country, p2.name, p3.age, p3.sex, p3.height)
# print(p4.__dict__)
#
# p1.eat()

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

    def dbj(self):
        print("%s 最爱大保健" % self.name)

    def kc(self):
        print("%s 上山去砍柴" % self.name)

    def db(self):
        print("%s 去东北" % self.name)

p1 = Person("小明", 2 ,"男")
p1.kc()

类名称空间，查询

class Perso:
    animal = "动物"
    soul = "有趣的灵魂"
    language = "语言"

    def __init__(self,country,name,age,sex,height):
        self.country = country
        self.name = name
        self.age = age
        self.sex = sex
        self.height = height  # 构造方法，封装属性，自动执行

    def eat(self):
        print("%s吃饭了" % self.name)

    def sleep(self):
        print("睡觉")

    def work(self):
        print("工作")


p1 = Perso("中国", "y", 6, "男", 178)
# p2 = Persomn("美国", "武大", 7, "男", 174)
print(p1.animal)

# class Persom 时，自动创建内存空间，再把静态变量animal = "动物 soul = "有趣的灵魂" language = "语言"写入内存空间，
# 再把各个函数的名称和地址写入空间
# 读到类名+()产生一个（含有类对象指针）实例空间，执行__init__,将空间地址传给self，并向__init__里面传值
# 比如一个实例，通过实例我们可以访问对象封装的属性，也可以访问静态变量，先访问实例内存空间是否含有该变量，如果没有则再通过类对象指针访问该变量
# 查询顺序:对象.属性：对象空间 >  类空间 > 父类空间>......
#          类名.属性 > 类空间> 父类空间>.....



# 计算一个类实例化多少对象

class Count:
    count = 0
    def __init__(self):
        Count.count += 1
        # Count.count = self.count + 1  # 第一次实例化，self.count 在类空间z中找到Count.count为0，执行一次后Count.count 变为1
        # 通过 对象变量   不能改变    类变量

obj1 = Count()
obj1 = Count()
obj1 = Count()
obj1 = Count()
obj1 = Count()  # 只要类名()就表示实例化一次，所以会执行__init__
print(obj1.count)


# count = 0
# def func():
#     count += 1
#     print(count)
#
# func()    # UnboundLocalError: local variable 'count' referenced before assignment 局部变量不能修改

练习

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

    def attack(self,p):
        print("%s攻击%s，%s掉了%s的血,还剩%s血" %(self.name, p.name, p.name, self.ad, p.hp-self.ad))
        p.hp -= self.ad

jh = Game_role("剑豪", 50, 200)
gl = Game_role("盖伦", 20, 500)
gl.attack(jh)
print(jh.hp)

组合

# # 给一个类的对象封装一个属性，这个属性是另一个类的对象
#
# # 版本一：添加武器,但是代码不合理，淘汰
# class Game_role:
#     def __init__(self, name, ad, hp):
#         self.name = name
#         self.ad = ad
#         self.hp = hp
#
#     def attack(self, p):
#         print("%s攻击%s，%s掉了%s的血,还剩%s血" % (self.name, p.name, p.name, self.ad, p.hp - self.ad))
#         p.hp -= self.ad
#
#
# class Weapon:
#     def __init__(self, name, ad):
#         self.name = name
#         self.ad = ad
#
#     def fight(self, p1, p2):
#         p2.hp -= self.ad
#         print("%s用%s打了%s，%s掉了%s的血,还剩%s血"
#               % (p1.name, self.name, p2.name, p2.name, self.ad, p2.hp))
#
#
# # axe = Weapon("斧头", 15)
# # Broadsword = Weapon("大长刀", 99)
#
#
# jh = Game_role("剑豪", 50, 200)
# gl = Game_role("盖伦", 20, 500)
# # axe.fight(jh, gl)
# # Broadsword.fight(gl, jh)
# # gl.attack(jh)
# # print(jh.hp)


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

    def attack(self, p):
        print("%s攻击%s，%s掉了%s的血,还剩%s血" % (self.name, p.name, p.name, self.ad, p.hp - self.ad))
        p.hp -= self.ad

    def armament_weapon(self, wea):
        self.wea = wea


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

    def fight(self, p1, p2):
        p2.hp -= self.ad
        print("%s用%s打了%s，%s掉了%s的血,还剩%s血"
              % (p1.name, self.name, p2.name, p2.name, self.ad, p2.hp))

jh = Game_role("剑豪", 50, 200)
gl = Game_role("盖伦", 20, 500)
axe = Weapon("斧头", 15)
Broadsword = Weapon("大长刀", 99)
jh.armament_weapon(axe)  # 给jh装备武器axe
jh.wea.fight(jh,gl)