• 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)
  • 相关阅读:
    A1052. Linked List Sorting (25)
    A1032. Sharing (25)
    A1022. Digital Library (30)
    A1071. Speech Patterns (25)
    A1054. The Dominant Color (20)
    A1060. Are They Equal (25)
    A1063. Set Similarity (25)
    电子码表
    矩阵键盘
    对象追踪、临时对象追踪、绝对坐标与相对坐标
  • 原文地址:https://www.cnblogs.com/wujunjie-sir/p/9246683.html
Copyright © 2020-2023  润新知