zoukankan      html  css  js  c++  java
  • 初识面向对象 -类和对象命名空间、组合用法(二)

    类和对象命名空间

    # 类里 可以定义两种属性
    # 静态属性
    # 动态属性
    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 = 'chinese' 这里python在自己对象空间创建了language = ''chinese”(赋值)
    # print(python.language)优先调用自己的language = ''chinese”,调不到Course.language的值了
    # print(linux.language)
    # Course.language = 'Chinese'
    # print(python.language)
    # print(linux.language)

    # del python.language 删除后才能调到Course.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()


    # 类里的名字有 类变量(静态属性量)+ 方法名(动态属性)
    # 对象里的名字 对象属性
    # 对象 —— > 类
    # 对象找名字 : 先找自己的 找类的 再找不到就报错
    # 对象修改静态属性的值
    # 对于不可变数据类型来说,类变量最好用类名操作
    # 对于可变数据类型来说,对象名的修改是共享的,重新赋值是独立的

            language如果是列表

    
    

            python.language[0]=‘Chinese’  》修改,列表内存地址不变,共享

    
    

            python.language=[‘Chinese’ ]  》重新赋值,在自己对象空间创建了一个属于python的Language

    
    

    组合的用法

    # 面向对象的三大特性 : 继承 多态 封装
    # 组合
    # 人狗大战
    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类的对象

    alex.weapon.hand18(jin)#》》》相等于w.hand18(jin)

    组合练习

    # 圆形类
    # 圆环类
    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)



     总结

    # 面向对象编程
    # 思想 :角色的抽象,创建类,创建角色(实例化),操作这些实例
    # 面向对象的关键字
    # class 类名:
    #     静态属性 = 'aaa'
    #     def __init__(self):pass
    #
    # 类名.静态属性  #—— 存储在类的命名空间里
    # 对象 = 类名()  # 实例化:创造了一个self对象,执行init方法,返回self对象给外部
    # 对象.属性
    # 对象.方法    # 类名.方法(对象)
    # 对象可以使用静态变量? True
    # 类可以使用对象里的属性么? False

    
    

    # 组合
    # 一个类的对象是另外一个类对象的属性
    # 什么有什么的关系

    
    

    # class A:
    #     def __init__(self):
    #         self.name = 'egon'
    #
    # class B:
    #     def __init__(self,year,month,day):
    #         self.year = year
    #         self.month = month
    #         self.day = day
    #
    # b = B(18,1,17)
    # a = A()
    # a.birth = b
    # b.year
    # a.birthclass A:
    #     def __init__(self):
    #         self.name = 'egon'
    #
    # class B:
    #     def __init__(self,year,month,day):
    #         self.year = year
    #         self.month = month
    #         self.day = day
    #
    # b = B(18,1,17)
    # a = A()
    # a.birth = b
    # b.year
    # a.birth

    
    





    面向对象练习——校园管理系统(作业)

    
    
     
    
    

    角色:

    学校、学员、课程、讲师

    要求:

    1. 创建北京、上海 2 所学校

    2. 创建linux , python , go 3个课程 , linuxpy 在北京开, go 在上海开

    3. 课程包含,周期,价格,通过学校创建课程

    4. 通过学校创建班级, 班级关联课程、讲师

    5. 创建学员时,选择学校,关联班级

    5. 创建讲师角色时要关联学校,

    6. 提供三个角色视图

      6.1 学员视图, 登陆, 查看课程、查看班级

      6.2 讲师视图, 讲师可查看自己教学的班级、课程。

              进阶需求:可管理自己的班级, 查看班级学员列表 , 修改所管理的学员的成绩

      6.3 管理视图,创建讲师, 创建班级,创建课程

    7. 上面的操作产生的数据都通过pickle序列化保存到文件里

    
    
  • 相关阅读:
    Python入门11 —— 基本数据类型的操作
    Win10安装7 —— 系统的优化
    Win10安装6 —— 系统的激活
    Win10安装5 —— 系统安装步骤
    Win10安装4 —— 通过BIOS进入PE
    Win10安装2 —— 版本的选择与下载
    Win10安装1 —— 引言与目录
    Win10安装3 —— U盘启动工具安装
    虚拟机 —— VMware Workstation15安装教程
    Python入门10 —— for循环
  • 原文地址:https://www.cnblogs.com/mys6/p/10588814.html
Copyright © 2011-2022 走看看