day23 面向对象进阶

# 定义类
    # class
    # 函数 ： 方法   动态属性  # 类中可以定义方法，方法都有一个必须传的参数self
    # 变量 ： 类属性 静态属性  # 类中可以定义静态属性
# __init__方法 初始化方法
    # python帮我们创建了一个对象self
    # 每当我们调用类的时候就会自动触发这个方法。默认传self
    # 在init方法里面可以对self进行赋值
# self是什么 self拥有属性都属于对象
    #在类的内部，self就是一个对象
    # alex = Person()
    # alex.walk == Person.walk(alex)
# 实例化
#     对象 = 类(参数是init方法的)
# 实例、对象     完全没有区别
# 对象查看属性
    # 对象.属性名
# 对象调用方法
    # 对象.方法名(参数)    #类名.方法名(对象名，参数)
# 正方形 周长和面积
# class Square:
#     def __init__(self,side_len):
#         self.side_len = side_len
#     def perimeter(self):
#         return self.side_len * 4
#     def area(self):
#         return self.side_len ** 2
# s = Square(5)
# s.perimeter()
# s.area()
# 完成上午的作业 人狗大战

# python入门
# 需求 能翻译成python语言

# 面向对象入门
# 当你见到一个需求 你能分析出这个问题适不适合用面向对象解决
# 如果适合 你能有一些想

# 一定要选好最适合的编程方式
# 类里 可以定义两种属性
# 静态属性
# 动态属性
class Course:
    language = [‘Chinese‘]
    def __init__(self,teacher,course_name,period,price):
        self.teacher = teacher
        self.name = course_name
        self.period = period
        self.price = price
    def func(self):
        pass

# Course.language = ‘English‘
# Course.__dict__[‘language‘] = ‘Chinese‘
# print(Course.language)
python = Course(‘egon‘,‘python‘,‘6 months‘,20000)
linux = Course(‘oldboy‘,‘linux‘,‘6 months‘,20000)
#[‘chinese‘]
python.language = ‘‘
# print(python.language)
# print(linux.language)
# Course.language = ‘Chinese‘
# print(python.language)
# print(linux.language)

# del python.language
# print(python.language)
# print(python.__dict__)
# print(Course.language)
# print(linux.language)
# print(linux.__dict__)
# 类中的静态变量 可以被对象和类调用
# 对于不可变数据类型来说，类变量最好用类名操作
# 对于可变数据类型来说，对象名的修改是共享的，重新赋值是独立的

# 模拟人生
# class Person:
#     money = 0
#     def work(self):
#         Person.money += 1000
#
# mother = Person()
# father = Person()
# Person.money += 1000
# Person.money += 1000
# print(Person.money)
# mother.work()
# father.work()


# 创建一个类，每实例化一个对象就计数
# 最终所有的对象共享这个数据
# class Foo:
#     count = 0
#     def __init__(self):
#         Foo.count += 1
#
# f1 = Foo()
# f2 = Foo()
# print(f1.count)
# print(f2.count)
# f3 = Foo()
# print(f1.count)


# 认识绑定方法
# def func():pass
# print(func)
#
# class Foo:
#     def func(self):
#         print(‘func‘)
#     def fun1(self):
#         pass
# f1 = Foo()
# print(Foo.func)
# print(f1.func)
# print(f1.fun1)
#<bound method Foo.func of f1>

# 包 —— __init__
# import package —— 类的实例化的过程
# import time
# time.time()


# 类里的名字有 类变量（静态属性量）+ 方法名（动态属性）
# 对象里的名字 对象属性
# 对象 —— > 类
# 对象找名字 ： 先找自己的 找类的 再找不到就报错
# 对象修改静态属性的值
    # 对于不可变数据类型来说，类变量最好用类名操作
    # 对于可变数据类型来说，对象名的修改是共享的，重新赋值是独立的
# 面向对象的三大特性 ： 继承 多态 封装
# 组合
# 人狗大战
class Dog:
    def __init__(self,name,aggr,hp,kind):
        self.name = name
        self.aggr = aggr
        self.hp = hp
        self.kind = kind

    def bite(self,person):
        person.hp -= self.aggr

class Person:
    def __init__(self,name,aggr,hp,sex):
        self.name = name
        self.aggr = aggr
        self.hp = hp
        self.sex = sex
        self.money = 0

    def attack(self,dog):
        dog.hp -= self.aggr

    def get_weapon(self,weapon):
        if self.money >= weapon.price:
            self.money -= weapon.price
            self.weapon = weapon
            self.aggr += weapon.aggr
        else:
            print("余额不足，请先充值")

class Weapon:
    def __init__(self,name,aggr,njd,price):
        self.name = name
        self.aggr = aggr
        self.njd = njd
        self.price = price

    def hand18(self,person):
        if self.njd > 0:
            person.hp -= self.aggr * 2
            self.njd -= 1

alex = Person(‘alex‘,0.5,100,‘不详‘)
jin = Dog(‘金老板‘,100,500,‘teddy‘)
w = Weapon(‘打狗棒‘,100,3,998)
# alex装备打狗棒
alex.money += 1000
alex.get_weapon(w)
print(alex.weapon)
print(alex.aggr)
alex.attack(jin)
print(jin.hp)
alex.weapon.hand18(jin)
print(jin.hp)

# 组合 ：一个对象的属性值是另外一个类的对象
#        alex.weapon 是 Weapon类的对象
# 圆形类
# 圆环类
from math import pi
class Circle:
    def __init__(self,r):
        self.r = r
    def area(self):
        return self.r**2 * pi
    def perimeter(self):
        return 2*pi*self.r

class Ring:
    def __init__(self,outside_r,inside_r):
        self.outside_c = Circle(outside_r)
        self.inside_c = Circle(inside_r)
    def area(self):
        return self.outside_c.area() - self.inside_c.area()
    def perimeter(self):
        return self.outside_c.perimeter()+self.inside_c.perimeter()

# ring = Ring(20,10)
# print(ring.area())
# print(ring.perimeter())

# 创建一个老师类
# 老师有生日
# 生日也可以是一个类
# 组合
class Birthday:
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day

class Course:
    def __init__(self,course_name,period,price):
        self.name = course_name
        self.period = period
        self.price = price

class Teacher:
    def __init__(self,name,age,sex,birthday):
        self.name = name
        self.age = age
        self.sex = sex
        self.birthday =birthday
        self.course = Course(‘python‘,‘6 month‘,2000)

b = Birthday(2018,1,16)
egg = Teacher(‘egon‘,0,‘女‘,b)
print(egg.name)
print(egg.birthday.year)
print(egg.birthday.month)
print(egg.course.price)