一.面向对象小游戏
1.金角大王和孙悟空
def get_person(name, t_type, attack_val, life_val):
data_dict = {
'name': name,
't_ype': t_type,
'attack_val': attack_val,
'life_val': life_val
}
return data_dict
def get_dog(name, t_type, attack_val, life_val):
data_dict = {
'name': name,
't_type': t_type,
'attack_val': attack_val,
'life_val': life_val
}
return data_dict
p1 = get_person('孙悟空', '石猴', 45, 3000)
p2 = get_dog('金角大王', '书童', 30, 2000)
def attack(person_obj, dog_obj):
print('当前孙悟空血量为: %s' % person_obj.get('life_val'))
person_obj['life_val'] -= dog_obj.get('attack_val')
print("""金角大王拿出来了紫金葫芦对着悟空就是攻击
悟空掉血 %s 剩余血量 % s """ % (dog_obj.get('attack_val'), person_obj['life_val']))
def attack_dog(dog_obj, person_obj):
print('当前金角大王的血量为: %s' % dog_obj.get('life_val'))
dog_obj['life_val'] -= person_obj.get('attack_val')
print("""悟空拿着金箍棒就是戳 金角大王损失血量为 %s 剩余血量为 %s""" % (dog_obj.get('life_val'), dog_obj['life_val']))
attack(p1, p2)
print(p1)
attack_dog(p2, p1)
print(p2)
当前孙悟空血量为: 3000
金角大王拿出来了紫金葫芦对着悟空就是攻击
悟空掉血 30 剩余血量 2970
{'name': '孙悟空', 't_ype': '石猴', 'attack_val': 45, 'life_val': 2970}
当前金角大王的血量为: 2000
悟空拿着金箍棒就是戳 金角大王损失血量为 30 剩余血量为 1955
{'name': '金角大王', 't_type': '书童', 'attack_val': 30, 'life_val': 1955}
1.1总结
"""
名字是可以随意调用的
可以变成孙悟空拿出来了紫金葫芦对着金角大王进行攻击
有缺陷
函数体代码可以调用全局名称空间
"""
2.利用面向对象思维方法
def get_person(name, t_type, attack_val, life_val):
def attack(person_obj, dog_obj):
print('金角大王血量为%s' % dog_obj.get('life_val'))
dog_obj['life_val'] -= person_obj.get('attack_val')
print("""悟空拿着金箍棒就是戳 金角大王损失血量为 %s 剩余血量为 %s""" % (dog_obj.get('attack_val'), dog_obj['life_val']))
data_dict = {
'name': name,
't_type': t_type,
'attack_val': attack_val,
'life_val': life_val,
'attack': attack} # 通过这里进行绑定
return data_dict
def get_dog(name, t_type, attack_val, life_val):
def attack_dog(dog_obj, person_obj):
print('当前孙悟空血量为: %s' % person_obj.get('life_val'))
person_obj['life_val'] -= dog_obj.get('attack_val')
print("""金角大王拿出来了紫金葫芦对着悟空就是攻击
悟空掉血 %s 剩余血量 % s """ % (dog_obj.get('attack_val'), person_obj['life_val']))
data_dict = {
'name': name,
't_type': t_type,
'attack_val': attack_val,
'life_val': life_val,
'attack_dog': attack_dog} # 通过这里进行绑定
return data_dict
p1 = get_person('孙悟空', '石猴', 45, 3000)
p2 = get_dog('金角大王', '书童', 30, 2000)
p1['attack'](p1, p2)
p2['attack_dog'](p2, p1)
总结
"""
实现功能绑定闭包函数
数据不可以任意调用
存在于局部空间名称内
通过绑定局部名称空间地址
不可以随便调用
"""
二.一般编程思想与面向对象编程思想
# 1.面向过程编程:
注：1.注册，2.登陆，3.添加等
# 通过流程顺序，逐步进行操作
# 2.面向对象编程：
# '对象'相当与一个容器（载体）将数据整合一块
# 上述例子，可称为对象
"""函数内包含了数据，和对应的功能，称之为面向对象编程"""
# 不难发现在python 中一切皆为对象
三.类与对象区分概念
# 1.对象:数据与功能的结合体
# 2.类：种类，分类，一类，相当于对象持有的公共特征（数据，功能）
# 都称作'类'
# >>>类 也算对象，但要有区分
四.类的创建
"""
在代码编程中是先有类才能有对象
"""
语法结构
# 1.class 类名:类体代码
# 2.class是定义类的关键字
# 3.类名类似于函数名 但是首字母推荐大写 用于区分
# 4.类体代码就是存放对象公共数据和功能的地方
# 5.数据: 变量名 = 变量值
# 6.功能: 函数
4.1例
class Student:
school = '家里蹲大学' # 学生类公共的数据
prtin('school') # 无需调用可直接打印(家里蹲大学) 产生类的名称空间
def choose_course(self): # 学生类公共的功能（self）是一个形数
print('学生选专业') # 打印学生选择专业
# 1.查看名称空间的方法>>>:__dict__
# 2.print(Student.__dict__) # 返回值是一个字典包 含类里面公共数据（也就是学生公共数据）
# 3.print(Student.__dict__['school']) # 获取类中的数据（也可以称为属性）
# 4.print(Student.__dict__['choose_course']) # 获取类中的功能（也可以称为属性）
"""类获取数据和功能有一个简便的方式>>>:句点符"""
print(Student） # 和上述1结果一样
print(Student.school) # 和上述2结果一样
print(Student.choose_course) # 和上述3结果一样
五.对象的创建
# 1.p1 = Student() # 类名加括号就是产生了对象赋予变量名p1
# 2.pront(p1.__dict__) # 对象是空的返回空字典
# 3.print(p1.Student) # 家里蹲大学
"""类存放的对象公共的数据和公共的功能，产生的对象都可以访问类中公共的数据和功能"""
# 4.Student.school = '床上躺大学' # 同等于 Student.__dict__['school'] = '床上躺大学' 修改名字与值的对应关系 字典修改值
# 5.print(p1.Student) # 床上躺大学 修改后
六.对象实例化
class Student:
def __init__(self, name, age, gender):
'''该方法就一个功能>>>:给对象添加独有的数据'''
self.name = name # obj.__dict__['name'] = name
self.age = age # obj.__dict__['age'] = age
self.gender = gender # obj.__dict__['gender'] = gender
# 学生类公共的数据
school = '清华大学'
# 学生类公共的功能
def choose_course(self):
print('学生选课功能')
# obj1 = Student() # 目前对象没有自己独有的属性
# obj2 = Student() # 目前对象没有自己独有的属性
# print(obj1.__dict__) # 大白话就是给字典添加键值对
# print(obj2.__dict__) # 大白话就是给字典添加键值对
'''方案1:逐步给对象添加独有的数据'''
# obj1.__dict__['name'] = 'jason' # obj1.name = 'jason'
# obj1.__dict__['age'] = 18 # obj1.age = 18
# obj1.__dict__['gender'] = 'male' # obj1.gender = 'male'
# obj2.__dict__['name'] = 'kevin' # obj2.name = 'kevin'
# obj2.__dict__['age'] = 2 # obj2.age = 28
# obj2.__dict__['gender'] = 'female' # obj2.gender = 'female'
# print(obj1.__dict__,obj2.__dict__)
# print(obj1.name) # jason
# print(obj2.name) # kevin
'''方案2:将冗余的添加步骤封装成函数'''
# def init(obj,name,age,gender):
# obj.name = name # obj.__dict__['name'] = name
# obj.age = age # obj.__dict__['age'] = age
# obj.gender = gender # obj.__dict__['gender'] = gender
# init(obj1,'jason',18,'male')
# init(obj2,'kevin',28,'female')
# print(obj1.name)
# print(obj2.name)
'''方案3:简单的封装成函数没有提现出面向对象整合的精髓>>>:将函数写到类中去'''
# obj1 = Student()
# obj2 = Student()
# Student.set_info(obj1,'jason',18,'male')
# Student.set_info(obj2,'kevin',28,'female')
# print(obj1.name) # jason
# print(obj2.name) # kevin
'''方案4:类中针对给对象创建独有数据的函数名 专门定义了一个固定的方法'''
# obj1 = Student('jason', 18, 'male')
# obj2 = Student('kevin', 28, 'female')
# print(obj1.__dict__)
# print(obj2.__dict__)
"""
类中的__init__方法会在类产生对象的时候自动执行
类产生对象的具体步骤
1.先创建一个没有独有数据的空对象 {}
2.将空对象和类括号内传入的数据一并交给__init__执行
__init__的第一个参数就是对象本身
__init__(obj,name,age,gender)
3.将创建好的对象自动返回
给你提供这种方式能够减少代码的编写
ps:针对括号内第一个形参self其实就是一个普通的变量名而已
只不过该变量名将来专门接收对象的 所以给它起了个固定的名字叫self
七.绑定方法
"""
在类中定义的函数默认都是绑定给对象使用的
即对象来调 会自动将对象当做第一个参数传入
"""
class Student:
school = '清华大学'
# __init__方法不要自己去调用
def __init__(self, name, age):
self.name = name
self.age = age
def func(self):
print('%s正在调用func方法'%self.name)
def index(self):
print('%s正在调用index方法'%self.name)
obj1 = Student('jason', 18)
# print(obj1)
obj2 = Student('kevin', 28)
# 类调用类中函数 有几个参数就需要传几个参数
# Student.func(123,222)
# 对象调用类中函数 会将当前调用的对象当做第一个参数自动传入
# obj1.func()
# obj2.func()
# print(obj1.func)
# print(obj2.index)
'''所以应该能理解为什么类中所有的函数第一个参数都是self'''
