2

人狗大战

#__author : 'liuyang' 
#date : 2019/3/26 0026 下午 12:03
class Dog:
    a = 1000
    def __init__(self,name,hp,ad,sex):
        self.name = name
        self.blood = hp
        self.ad = ad
        self.type = sex
    def bite(self,person):
        person.blood -= self.ad
        print('%s 咬了 %s,%s 掉了 %s血'%(self.name,person.name,person.name,self.ad))

class Person:
    a = 1000
    def __init__(self,name,hp,ad,sex,money):
        print('执行了')
        print(name,hp,ad,sex)
        self.name = name
        self.blood = hp
        self.ad = ad
        self.type = sex
        self.money = money
        self.beg = []

    def jian23(self,dog):
        dog.hp  -= 2000
        #想怎么设计就怎么设计
        print("%s 被 %s 击中了，掉了2000，当前%s的血量为%s"%(self.name,dog.name,dog.name,dog.hp))
    def fight(self,dog): #定义在类的内部的 动态变量 方法
        dog.blood -= self.ad
        print('%s 打了 %s , %s 掉了 %s血'%(self.name,dog.name,dog.name,self.ad))
    def buy_weapon(self,weapon):
        #武器列表
            #死亡之舞
        if weapon.price < self.money:
            self.money -= weapon.price
            self.money = round(self.money, 2)
            self.beg.append(weapon)
            print('购买%s成功,您当前的余额是%s'%(weapon.name, self.money))
        else:
            print('您的余额不足，请重置后恢复')

    def use_weapon(self):
        for wea in self.beg:
            if wea.t == 'weapon':
                self.weapon = wea   #组合
                self.hp += wea.hp
                self.ad += wea.ad
                break
    #level 1
# 回合制的游戏
liuda = Person('liuda',100,1,'男')
huang = Dog('huang',1000,10,'公')
#装备
    #名字
    #价格
    #属性
    #技能
class weapon:
    def __init__(self,name,price,ad,hp):
        self.name = name
        self.price = price
        self.ad = ad
        self.hp = hp

zhuan = weapon('绝世好剑',2000000,1000,1000)
# 买装备
#人的余额 >= 商品的价格
    #能否命中 暴击

liuda.buy_weapon(zhuan)
print(liuda.beg)
liuda.use_weapon()
print(liuda.weapon.name)

# 一个对象 和另一个对象 通过另一个属性 关联在一起了
#人有 武器
#人是 一个 类
#武器 也是 类
#人 关联 武器
#人用武器招式

类的加载顺序 

#__author : 'liuyang'
#date : 2019/3/26 0026 上午 9:23
class A:
    country = 'China'
    country = 'Chi'
    print(123)
    def __init__(self):
        print('执行我啦！')

    def func(self):
        print('adjia')

    def func(self):
        print('adj',A.country)

    country = 'China'
    country = 'Chi'
# print(A.country)
# 定义类的时候 也执行了 一个缩进的话

# A.country = 'English'
#类的加载顺序
    #1. 类内部一个缩进的所有代码 都是在py文件从上到下开始解释的时候就已经被执行了
    #2. 类中的代码 永远是 从上到下依次执行的

a = A()
a.func()
# 深谙：非常透彻地了解；熟悉内中情形。谙，读作‘ān’ 熟悉。

组合；

#__author : 'liuyang' 
#date : 2019/3/26 0026 上午 9:36
class Student:
    # print(Student)
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    # print(Student)

print(Student)
yang = Student('刘大',20,'male')
print(Student)

#类和对象中的内容是分两片存储的
#  对象 里的指针可以用 类里的函数  正常使用静态的变量
# def func():
#     func()

class Student:
    country = 'China'
    def __init__(self,name,country):
        self.name = name
        self.country = country
zhang = Student('刘大','中国')
zou = Student('王二','China')

print(Student.country)
print(zou.country)
print(zhang.country)

# 对象去找类空间中的名字  的前提：在自己的空间中没有这个名字
class Student:
    country = 'China'
    def __init__(self,name):
        self.name = name

zhang = Student('刘大')
zou = Student('王二')
print(zhang.country)
Student.country = '法国人'
print(zhang.country)
zou.country = '日本人'
print(zou.country)
#在操作 静态变量的时候 应该尽量使用类名来操作而不是使用对象名

# 人物
class Person:
    money = 0
    def __init__(self,name):
        self.name = name
    def salary_deliery(self):
        Person.money += 1000
        return Person.money

a = Person('刘大').salary_deliery()
print(a)

# 爸爸妈妈

# 练习 ：写一个类：能够自动的统计这个类 有多少对象
class A:
    Count = 0
    def __init__(self,name,age,sex):
        self.name = name
        A.Count += 1
        self.age = age
        A.Count += 1
        self.sex = sex
        A.Count += 1

a = A('刘大','王二','张三')
print(A.Count)

class B:
    l = [0]
    def __init__(self,name):
        self.name = name

b1 = B('刘大')
b2 = B('王二')
print(B.l)
print(b1.l)
print(b2.l)

b1.l[0]+=1  #赋值

print(b2.l[0])
b1.l = [123]
print(b2.l[0])
print(b1.l[0])

# 只要是对一个对象 ，名字直接赋值，那么就是在这个对象的空间内创建了新的属性
# 只要是对一个可变的数据类型内部的变化，那么仍然是所有的对象和类共享这个改变的成果

#所有的静态变量都是用类名来操作 ，这样修改就能被所有的对象感知到
#如果是对于可变数据类型的静态变量 操作的是这个数据内部的内容，也可以使用对象来调用
#对象 和 类名 是一样的  静态变量最好是可变的


class Person:
    money = 0
    def __init__(self,name):
        self.name = name
    def salary_deliery(self):
        Person.money += 1000
        return Person.money
a = Person('刘大').salary_deliery()
print(a)
class Person:
    money = 0
    def __init__(self,name):
        self.name = name
    def salary_deliery(self):
        self.money += 1000
        return self.money
a = Person('刘大').salary_deliery()
print(a)

圆  学生 和日期

from math import pi
#圆环类
class Circle:
    def __init__(self,r):
        self.r = r
    def area(self):
        return 3.14*self.r**2
    def perimeter(self):
        return 2*self.r*3.14
class Ring:

    def __init__(self,r1,r2):
                            # 属性 和 对象 相对应了
        c1 = Circle(r1)
        c2 = Circle(r2)

        if c1 >= c2:
           self.outer = c1
           self.inner = c2
        else:
            self.inner = c1
            self.outer = c2
    def area(self):
        return 3.14 * self.outer**2 - 3.14 * self.inner**2
    def perimeter(self):
        return 2* 3.14 * self.outer + 2* 3.14 * self.inner
# 圆珠类
class C3d:
    def __init__(self,r,h):
        self.r = r
        self.h = h
    def area(self):
        c_area = 3.14*self.r*2
        rec_area = 2*3.14 *self.r *self.h
        return c_area*2 + rec_area

    def vic(self):
        c_area = 3.14*self.r**2
        return c_area*self.h

#耦合
# 紧耦合
    #圆形面积的公式 和 类中方法
#组合：
    #一个类的对象是另一个类对象的属性
    #圆形类的对象  是圆环类对象的outer 属性的值

# 计算圆形 相关数据的公式 只和Circle 类在一起
#其余的 用到 公式的地方都是通过Circle 类来使用的
# 公式与 其他类之间的关系 是一个“松耦合”关系

#学生类
# 入学日期
# 开学日期
    #日期的粒度  精确到年月日

# "2019-9-12"
# 年
# 月
# 日

class Date:
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day

    def date(self):
        return '%s-%s-%s'%(self.year,self.month,self.day)

class Student:
    def __init__(self,name,num,birth,in_shcool,start_day):
        self.name = name
        self.num = num
        self.birth = birth   #组合
        self.in_school = in_shcool
        self.start_day= start_day

d1 = Date(2000,1,1)
d2 = Date(2018,12,1)
d3 = Date(2019,2,1)
liu = Student('刘大',10086,d1,d2,d3)

print(liu.birth.year)
print(liu.birth.month)

class Student:
    def __init__(self,name,num,course,birth,in_shcool,start_day):
        self.name = name
        self.num = num
        self.course = course


# 课程
    #课程名
    #授课周期
    #价格
class Student:
    def __init__(self,name,num,course):
        self.name = name
        self.num = num
        self.course_name = course.name #没有把python 耦合在一起 只把 课程弄在一起
class Course:
    def __init__(self,price,period,name):
        self.price = price
        self.period = period
        self.name = name
    def date(self):
        return '%s-%s-%s'%(self.year,self.month,self.day)
python = Course('python',25000,'6 months')
s1 = Student('刘大',10085,python)
python.price = 30000
print(s1.__dict__)

默写学生和课程

例子过一遍

继续人狗大战

　　：注册 用户名

　　：充值

　　：买武器

　　：装备武器

　　：使用

　　：开战