举例:猫狗大战

# 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. 因为资源和程序源码均为可复制品,所以不支持任何理由的退款兑现,请斟酌后支付下载 声明:如果标题没有注明"已测试"或者"测试可用"等字样的资源源码均未经过站长测试.特别注意没有标注的源码不保证任何可用性