1，# 人狗大战
def Dog(name,blood,aggr,kind):
dog = {
'name': name,
'blood': blood, # 血量
'aggr': aggr, # 攻击力
'kind': kind,
}
def bite(person):
person['blood'] -= dog['aggr']
print('%s被咬了，掉了%s的血' % (person['name'], dog['aggr']))
dog['bite'] = bite
return dog
def Person(name,blood,aggr,sex):
person = {
'name' : name,
'blood': blood, # 血量
'aggr': aggr, # 攻击力
'sex':sex,
}
def attack(dog):
dog['blood'] -= person['aggr']
print('%s被打了，掉了%s的血' % (dog['name'], person['aggr']))
person['attack'] = attack
return person
# 代码精简了 方便增加人物 方便修改 人物更加规范 —— 人模子
jin = Dog('金老板',1000,100,'teddy')
alex = Person('狗剩儿',100,1,'不详')
# nezha = Person('哪吒',200,2,'不详')
print(jin)
jin['bite'](alex)
alex['attack'](jin)
# Dog函数和Person函数 都是定义了一类事物
# 直到调用了函数，赋值了之后才真的有了一个实实在在的人或狗
# 面向对象编程
# 所谓模子 就是 类 抽象的 我能知道有什么属性 有什么技能 但不能知道属性具体的值
# jin alex nezha 就是对象 有具体的值，属性和技能都是根据类规范的
2，
class 类名:
属性 = 'a'
print(类名.属性)
类名的作用 就是操作属性 查看属性
类名的第一个字母一般大写
class Person: # 类名
country = 'China' # 创造了一个只要是这个类就一定有的属性
# 类属性 静态属性
def __init__(self,*args): # 初始化方法，self是对象，是一个必须传的参数
# self就是一个可以存储很多属性的大字典
self.name = args[0] # 往字典里添加属性的方式发生了一些变化
self.hp = args[1]
self.aggr = args[2]
self.sex = args[3]
def walk(self,n): # 方法，一般情况下必须传self参数，且必须写在第一个
# 后面还可以传其他参数，是自由的
print('%s走走走,走了%s步'%(self.name,n))
# print(Person.country) # 类名 可以查看类中的属性，不需要实例化就可以查看
alex = Person('狗剩儿',100,1,'不详') # 类名还可以实例化对象，alex对象 # 实例化
# print(alex.__dict__) # 查看所有属性
print(alex.name) # 查看属性值
# print(alex.hp) # 查看属性值
alex.walk(5) # 功能等同于Person.walk(alex，5) # 调用方法 类名.方法名(对象名)
# print(Person.__dict__['country'])
# Person.__dict__['country'] = '印度'
# print(alex.__dict__['name'])
# alex.__dict__['name'] = '二哥'
# print(alex.__dict__)
# print(alex.name)
# print(alex.name)
# alex.name = '二哥'
# alex.__dict__['name'] = '二哥'
# alex.age = 83
# print(alex.__dict__)
# print(alex.name)
# 对象 = 类名()
# 过程：
# 类名() 首先 会创造出一个对象，创建了一个self变量
# 调用init方法，类名括号里的参数会被这里接收
# 执行init方法
# 返回self
# 对象能做的事：
# 查看属性
# 调用方法
# __dict__ 对于对象的增删改查操作都可以通过字典的语法进行
# 类名能做的事：
# 实例化
# 调用方法 : 只不过要自己传递self参数
# 调用类中的属性,也就是调用静态属性
# __dict__ 对于类中的名字只能看 不能操作
3，
class Dog: def __init__(self,name,blood,aggr,kind): self.name = name self.hp = blood self.aggr = aggr self.kind = kind def bite(self,person): # 狗咬人，人掉血 person.blood -= self.aggr class Person: def __init__(self,name,blood,aggr,sex): self.name = name self.blood = blood self.aggr = aggr self.sex = sex def attack(self,dog): dog.hp -= self.aggr if dog.hp <= 0: print('%s打了%s,%s被打死了，扑街~~~'%(self.name,dog.name,dog.name)) else: print('%s打了%s,掉了%s血'%(self.name,dog.name,self.aggr)) jin = Dog('金老板',100,20,'teddy') # print(jin.name) alex = Person('alex',999,998,'不详') jin.bite(alex) # Dog.bite(jin,alex) print(alex.blood) # alex attack alex.attack(jin) # Person.attack(alex,jin) print(jin.hp)
4，
# 类里 可以定义两种属性
# 静态属性
# 动态属性
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
python = Course('egon','python','6 months',20000) # 对象中有个类对象指针，指向类。对象中使用的静态变量，来自类里面
linux = Course('egon','linux','6 months',20000)
python.language = 'En' # 对象没有改变类中的静态变量，而是在对象中新增了一个language变量
print(Course.__dict__)
print(python.__dict__)
print(linux.__dict__)
# del python.language
# 类中的静态变量 可以被对象和类调用
# 对于不可变数据类型来说，类变量最好用类名操作(才能改类中的变量)
# 对于可变数据类型来说，对象名的修改是共享的（改变类中的变量），重新赋值是独立的(只能改动对象中的变量)
比如：
python.language = 'En' # 只改y到对象中的变量
python.language[0] = 'En' # 列表是可变数据类型，加索引之后，只改列表中的不可变数据类型，列表的内存地址不会变，所以改变了列表中的内容，类中的变量值就改了
5，类的组合
# 人狗大战 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类的对象
6，
面向对象作业——校园管理系统
角色:
学校、学员、课程、讲师
要求:
1. 创建北京、上海 2 所学校
2. 创建linux , python , go 3个课程 ， linux\py 在北京开， go 在上海开
3. 课程包含，周期，价格
4. 班级关联课程、讲师
5. 创建学员时，选择学校，关联班级
5. 创建讲师角色时要关联学校
6. 提供三个角色视图
6.1 学员视图， 登陆， 查看课程、查看班级
6.2 讲师视图， 讲师可查看自己教学的班级、课程。
进阶需求：可管理自己的班级， 查看班级学员列表 ， 修改所管理的学员的成绩
6.3 管理视图，创建讲师， 创建班级，创建课程
7. 上面的操作产生的数据都通过pickle序列化保存到文件里
我的解答：
class Course:
def __init__(self,name,period,price):
self.name = name
self.period = period
self.price = price
class Teacher:
def __init__(self,name):
self.name = name
class Clas:
def __init__(self,name,course,teacher):
self.name = name
self.course = course
self.teacher = teacher
class School:
def __init__(self,name,clas):
self.name = name
self.clas = clas
class Student:
def __init__(self,name,clas):
self.name = name
self.clas = clas
# self.sort = sort
# 文件存放格式：id,teacher,school,class,course,student,sort
# 文件存放格式：id,teacher,school,class,course,student,sort
角色:
学校、学员、课程、讲师
要求:
1. 创建北京、上海 2 所学校
2. 创建linux , python , go 3个课程 ， linux\py 在北京开， go 在上海开
3. 课程包含，周期，价格
4. 班级关联课程、讲师
5. 创建学员时，选择学校，关联班级
5. 创建讲师角色时要关联学校
6. 提供三个角色视图
6.1 学员视图， 登陆， 查看课程、查看班级
6.2 讲师视图， 讲师可查看自己教学的班级、课程。
进阶需求：可管理自己的班级， 查看班级学员列表 ， 修改所管理的学员的成绩
6.3 管理视图，创建讲师， 创建班级，创建课程
7. 上面的操作产生的数据都通过pickle序列化保存到文件里