初识面向对象 -类和对象命名空间、组合用法（二）

类和对象命名空间

# 类里 可以定义两种属性
# 静态属性
# 动态属性
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序列化保存到文件里