举例:猫狗大战
# 1.例如我们要编写一个猫狗对战小游戏
# 首先我们要定义一个猫,和一只狗
cat1 = {
'name': '小白猫',
'type': '宠物猫',
'attack_val': 20,
'life_val': 120}
dog1 = {
'name': '小黑狗',
'type': '流浪狗',
'attack_val': 60,
'life_val': 240}
# 由于考虑多我们只会可能要多次使用并且创作多个 猫 狗 所以函数封装
def get_cat(name, type, attack_val, life_val):
cat = {
'name': name,
'type': type,
'attack_val': attack_val,
'life_val': life_val}
return cat
def get_dog(name, type, attack_val, life_val):
dog = {
'name': name,
'type': type,
'attack_val': attack_val,
'life_val': life_val}
return dog
# 创造一个猫攻击的函数,和狗攻击的函数
def dog_attack(dog_obj, person_obj):
# 使用最简答的掉血逻辑 血量减去对方攻击力
print('当前猫的血量是:%s' % person_obj.get('life_val'))
person_obj['life_val'] -= dog_obj.get('attack_val')
print("""猫:%s 挠了狗:%s 一口 狗掉血:%s 剩余血量:%s""" % (
dog_obj.get('name'), person_obj.get('name'), dog_obj.get('attack_val'), person_obj['life_val']))
# 创造一个狗攻击的函数,和狗攻击的函数
def person_attack(person_obj, dog_obj):
print('当前狗的血量是:%s' % dog_obj.get('life_val'))
dog_obj['life_val'] -= person_obj.get('attack_val')
print("""狗:%s 锤了猫:%s 一下 猫掉血:%s 剩余血量:%s""" % (
person_obj.get('name'), dog_obj.get('name'), person_obj.get('attack_val'), dog_obj['life_val']))
# 创造出来 猫和狗
c1 = get_cat('小白','宠物',100,500)
d1 =get_dog('小黑','流浪狗',300,2000)
# 开始攻击
dog_attack(c1,d1)
dog_attack(c1,d1)
dog_attack(c1,d1)
数据与功能的绑定,使攻击动作绑定对于对象,
1.函数嵌套
# 把猫攻击动作 放到 猫的函数里
def get_cat(name, type, attack_val, life_val):
def cat_attack(cat, dog):
# 使用最简答的掉血逻辑 血量减去对方攻击力
print('当前猫的血量是:%s' % dog.get('life_val'))
dog['life_val'] -= cat.get('attack_val')
print("""猫:%s 挠了狗:%s 一口 狗掉血:%s 剩余血量:%s""" % (
cat.get('name'), dog.get('name'), cat.get('attack_val'), dog['life_val']))
cat = {
'name': name,
'type': type,
'attack_val': attack_val,
'life_val': life_val,
'cat_attack':cat_attack #通过生成猫后形成的字典 来调用猫攻击动作
}
return cat
def get_dog(name, type, attack_val, life_val):
def dog_attack(person_obj, dog_obj):
print('当前狗的血量是:%s' % dog_obj.get('life_val'))
dog_obj['life_val'] -= person_obj.get('attack_val')
print("""狗:%s 锤了猫:%s 一下 猫掉血:%s 剩余血量:%s""" % (
person_obj.get('name'), dog_obj.get('name'), person_obj.get('attack_val'), dog_obj['life_val']))
dog = {
'name': name,
'type': type,
'attack_val': attack_val,
'life_val': life_val,
'dog_attack':dog_attack
}
return dog
# 创造出来 猫和狗
c1 = get_cat('小白','宠物',100,500) # 先 生成 一个猫
d1 = get_dog('小黑','流浪狗',300,2000)
c1['cat_attack'](c1,d1) #这样就相当于 先生成一个猫,然后发动猫的攻击
d1['dog_attack'](d1,c1)
d1['dog_attack'](d1,c1) # 这样就相当于 狗 和 狗攻击绑定了 不生成狗 就无法使用狗攻击
#!!!面向对象核心思想!!! 数据与功能的绑定!!
编程思想
1. 面向过程编程
过程即流程 面向过程就是按照固定的流程解决问题
eg: 例如我们常用的 注册功能 登录功能 等
都是一步一步的流程慢慢写出来的,随着步骤的深入 问题就慢慢的解决了
是通过过程从来解决问题的,过程是可控制的
2. 面向对象编程
对象即是容器, 就是数据与功能的结合体(python中一切都可以是对象)
eg: 游戏人物
王者荣耀中的英雄,后裔 小乔等 都可以称之为对象
面向对象就是创造一个对象 至于对象接下来的发展和程序员无关,也无法控制
"""
上述两种编程思想没有优劣之分 需要结合实际需求而定
如果需求是注册 登录 人脸识别肯定面向过程更合适
如果需求是游戏人物肯定是面向对象更合适
实际编程两种思想是彼此交融的 只不过占比不同
"""
面向对象中的类与对象
对象:数据和功能的结合体,对象才是核心
类;多个对象具有相同的数据和功能的集合体 类主要的作用就是节约代码
"""
一个人 对象
一群人 人类(所有人相同的特征)
一条狗 对象
一群狗 犬类(所有狗相同的特征)
"""
现实中一般是先有对象再有类
程序中如果想要产生对象 !!必须要先定义出类!!
与对象的创建
面向对象并不是一门新的技术 但是为了很好的一眼区分开 针对面向对象设计了新的语法格式
python中一定要有类 才能借助于类产生对象
1.如果创建一个类 关键词 class!
语法结构:
class 类名:
'''类的注释'''
对象公共的数据
对象公共的功能
2. 类名的命名和变量名方法一致,尽量做到见面知意,类的命名首字母需要大写
3. 数据: 变量名与数据值的绑定
4. 功能: 其实就是函数方法
2.类的定义与调用
类在定义阶段就会执行类里面的子代码,类里面的变量名属于局部空间,外界无法直接使用,类不需要调用,定义好以后 类里面的子代码自动生效。
举例: #需求清华大学的学生选课系统
class Student:
# 先填写所有对象的公共数据
school_name = '清华大学'
# 填写对象的公共功能
def choice_course(self):
print('欢迎进入学生选课系统')
# print(Student.school_name)
# 类定义好之后 就可以直接调用 类名.的方式进行使用类里面的变量名
# 如何基于类 生成一个对象
student = Student()
student1 = Student()
'''类名加括号就会产生对象 并且每执行一次都会产生一个全新的对象'''
print(student)
#查看对象里面有什么
print(student.__dict__)
#发现通过类创造的对象 暂时没有内容,其实这个对象已经包含了类里面的公用数据和方法
'''在面向对象中 类和对象访问数据或者功能 可以统一采用句点符'''
print(student.school_name) # 清华大学 公共的数据和方法会默认添加如对象中
Student.school_name = '北京大学' # 更改类里面的公共数据
print(student.school_name) # 北京大学 通过类创造的对象,获取的是类里面的公共数据和方法 当类里面的数据或方法发生改变后,对应这里也会变化
print(student1.school_name) # 北京大学 通过类创造的对象,获取的是类里面的公共数据和方法 当类里面的数据或方法发生改变后,对应这里也会变化
!!当类里面的公共数据或方法有变动后,则会影响到接下来所有的类对象!!
!!!得到理论,当通过类创造出来的对象,该对象会拥有类里面的公共数据和方法 可以调用!!
对象添加独有数据
class Student:
# 对象的公共数据
school_name = '清华大学'
# 对象的公共功能
def choice_course(self):
print('欢迎进入学生选课系统')
student = Student()
# 通过类 创建出一个对象
student1 = Student()
# 通过类 创建出一个对象 每个对象都是不同的内存地址
'''推导流程1:每个对象手动添加独有的数据'''
student1.__dict__['name'] = '张无忌'
# 给对象添加独有的数据
student1.__dict__['age'] = 19
print(student1.name)
print(student1.age)
student.__dict__['name'] = '赵敏'
student.__dict__['age'] = 18
# 给对象添加独有的数据
print(student.name)
print(student.age)
'''推导流程2:将添加对象独有数据的代码封装成函数'''
def init(object,name,age):
object.__dict__['name'] = name
object.__dict__['age'] = age
init(student,'张三丰',68)
print(student.name)
print(student.age)
# 通过给函数传参的方式 实现了添加对象独有数据
'''推导流程3:给学生对象添加独有数据的函数只有学生对象有资格调用'''
class Student:
# 对象的公共数据
school_name = '清华大学'
def init(object, name, age):
object.__dict__['name'] = name
object.__dict__['age'] = age
# 对象的公共功能
def choice_course(self):
print('欢迎进入学生选课系统')
student2 = Student()
Student.init(student2,'金毛狮王',56)
# 这样就可以直接进行对象独有数据添加,并且是专属于这个类来调用的
print(student2.__dict__)
'''推导步骤4:init方法变形'''
class Student:
# 对象的公共数据
school_name = '清华大学'
# __init__可以使类产生对象的过程中自动触发
def __init__(object, name='暂未填写', age ='暂未填写'):
object.__dict__['name'] = name
object.__dict__['age'] = age
# 对象的公共功能
def choice_course(self):
print('欢迎进入学生选课系统')
student = Student('张无忌')
student2 = Student('金毛狮王',56)
print(student2.__dict__)
# 未使用__init__ student2= Student()
# Student.init(student2,'金毛狮王',56)
# 使用后 student2 = Student('金毛狮王','56')
# 类产生对象的过程中自动触发
print(student.__dict__)
'''推导步骤5:变量名修改'''
class Student:
# 对象的公共数据
school_name = '清华大学'
# __init__可以使类产生对象的过程中自动触发
def __init__(self, name='暂未填写', age='暂未填写'):
self.__dict__['name'] = name
self.__dict__['age'] = age
# 对象的公共功能
def choice_course(self):
print('欢迎进入学生选课系统')
student2 = Student('周芷若',17)
# 可以通过直接赋值的方法改变对象里面的数据
print(student2.__dict__)
print(student2.school_name)
del student2.name
# 删除对象中的数据
print(student2.__dict__)
对象添加独有方法/功能
class Student:
school_name = '清华大学'
# __init__可以使类产生对象的过程中自动触发
def __init__(self, name='暂未填写', age='暂未填写'):
self.name = name
self.age = age
# 对象的公共功能 self参数 等于默认传入对象本身
def choice_course(self):
print(f'欢迎 {self.name} 选课系统')
# 可以利用本身类对象的变量名 不同的类对象 变量名对应的数据也不同
student = Student('张无忌', 22)
student1 = Student('赵敏', 22)
student.choice_course() # = choice_course(student)
student1.choice_course() # = choice_course(student)
# 类的对象 可以直接调用 类里面的方法,不需要传参,默认传参就是对象本身
student1.name = '赵敏'
# 更改对象中的数据,直接通过.的方式 再次赋值即可
student1.nation = '蒙古族'
# 新增对象数据,有则更改 无则新增
原文地址:http://www.cnblogs.com/moongodnnn/p/16852103.html
1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
2. 分享目的仅供大家学习和交流,请务用于商业用途!
3. 如果你也有好源码或者教程,可以到用户中心发布,分享有积分奖励和额外收入!
4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
5. 如有链接无法下载、失效或广告,请联系管理员处理!
6. 本站资源售价只是赞助,收取费用仅维持本站的日常运营所需!
7. 如遇到加密压缩包,默认解压密码为"gltf",如遇到无法解压的请联系管理员!
8. 因为资源和程序源码均为可复制品,所以不支持任何理由的退款兑现,请斟酌后支付下载
声明:如果标题没有注明"已测试"或者"测试可用"等字样的资源源码均未经过站长测试.特别注意没有标注的源码不保证任何可用性