标签：__ name Power python flow value 面向对象 blood

面向对象

实例介绍（人狗大战）

# 人狗大战

# 先创建人的数据 可以创建多个人
people1 = {
    'name' : 'su',
    'age' : 22,
    'Power value' : 800,  # 战力值
    'blood_flow' : 8000,  # 血容量
    'weapon' : 'Lavinia arrow' #武器 神箭
}
people2 = {
    'name' : 'princess',
    'age' : 22,
    'Power value' : 900,  # 战力值
    'blood_flow' : 8888,  # 血容量
    'weapon' : 'excalibur' #武器 神剑
}
。。。。。。
# 先创建人的数据 创建多个的话每一次代码都是重复的 所以包装成函数便于调用
def person(name, age, Power_value, blood_flow, weapon):
    people = {
        'name': name,
        'age': age,
        'Power_value': Power_value,  # 战力值
        'blood_flow': blood_flow,  # 血容量
        'weapon': weapon  # 武器 神箭
    }
    return people


people1 = person('su', 22, 800, 8000, 'Lavinia arrow')
people2 = person('princess', 22, 900, 8888, 'excalibur')
# 还有可以创建多个人 只要把相应的参数传进去就可以了

------------


# 创建狗的数据
dog1 = {
    'name' : '哮天犬',
    'age' : 1,
    'Power value' : 200,
    'blood_flow' : 6000, 
    'weapon'  : 'tooth'  # 牙齿
}

dog2 = {
    'name' : '藏獒',
    'age' : 2,
    'Power value' : 800,
    'blood_flow' : 6000,
    'weapon'  : 'dog paw ' # 狗爪子
}
。。。。。
创建狗的数据 创建多个的话每一次代码都是重复的 所以包装成函数便于调用
def dogs(name, age, Power_value, blood_flow, weapon):
    dog = {
        'name': name,
        'age': age,
        'Power_value': Power_value,
        'blood_flow': blood_flow,
        'weapon': weapon  # 牙齿
    }
    return dog
dog1 = dogs('哮天犬',1,200,6000,'tooth')
dog2 = dogs('藏獒',2,800,6000, 'dog paw ')

# 让人和狗具备攻击的能力 本质其实就是定义两个函数供人和狗调用
# 设置一个专门给人调用的函数来攻击狗

def person_attack(person, dogs):
    print('即将被攻击的狗:%s 当前血量:%s' % (dogs.get('name'), dogs.get('blood_flow')))  # 先展示当前狗的状态
    dogs['blood_flow'] -= person.get('Power_value')  # 人射狗 直接用狗的生命值减去人的攻击力
    print('人:%s 用武器:%s 射了 狗:%s 狗掉血:%s 剩余血量:%s' % (
        person.get('name'),person.get('weapon'), dogs.get('name'), person.get('Power_value'), dogs.get('blood_flow')))

# 设置一个专门给狗调用的函数来攻击人
def dog(dogs, person):
    print('即将被攻击的人:%s 当前血量:%s' % (person.get('name'), person.get('blood_flow')))  # 先展示当前人的状态
    person['blood_flow'] -= dogs.get('Power_value')  # 狗挠人 直接用人的生命值减去狗的攻击力
    print('狗:%s 用武器：%s 挠了 人:%s 人掉血:%s 剩余血量:%s' % (
        dogs.get('name'),dogs.get('weapon') ,person.get('name'), dogs.get('Power_value'), person.get('blood_flow')))

# 调用攻击彼此的函数
res1 = person_attack(people2, dog2)
res2 = dog(dog1, people1)

打印结果是：
即将被攻击的狗:藏獒 当前血量:6000
人:princess 用武器:excalibur 射了 狗:藏獒 狗掉血:900 剩余血量:5100
即将被攻击的人:su 当前血量:8000
狗:哮天犬 用武器：tooth 挠了 人:su 人掉血:200 剩余血量:7800

人狗大战优化版

# 人和狗攻击的函数 可以被任意调用
res1 = dog(people2, dog2)
res2 = person_attack(dog1, people1)
# 这样就容易乱套
即将被攻击的人:藏獒 当前血量:6000
狗:princess 用武器：excalibur 挠了 人:藏獒 人掉血:900 剩余血量:5100
即将被攻击的狗:su 当前血量:8000
人:哮天犬 用武器:tooth 射了 狗:su 狗掉血:200 剩余血量:7800

------------
def person(name, age, Power_value, blood_flow, weapon):
    def person_attack(person, dogs):
        print('即将被攻击的狗:%s 当前血量:%s' % (dogs.get('name'), dogs.get('blood_flow')))  # 先展示当前狗的状态
        dogs['blood_flow'] -= person.get('Power_value')  # 人攻击狗 直接用狗的生命值减去人的攻击力
        print('人:%s 用武器:%s 射了 狗:%s 狗掉血:%s 剩余血量:%s' % (
            person.get('name'), person.get('weapon'), dogs.get('name'), person.get('Power_value'),
            dogs.get('blood_flow')))
    people = {
        'name': name,
        'age': age,
        'Power_value': Power_value,  # 战力值
        'blood_flow': blood_flow,  # 血容量
        'weapon': weapon , # 武器 神箭
        'person_attack' : person_attack
            }
    return people


people1 = person('su', 22, 800, 8000, 'Lavinia arrow')
people2 = person('princess', 22, 900, 8888, 'excalibur')

def dogs(name, age, Power_value, blood_flow, weapon):
    def dog(dogs, person):
        print('即将被攻击的人:%s 当前血量:%s' % (person.get('name'), person.get('blood_flow')))  # 先展示当前人的状态
        person['blood_flow'] -= dogs.get('Power_value')  # 狗攻击人 直接用人的生命值减去狗的攻击力
        print('狗:%s 用武器：%s 挠了 人:%s 人掉血:%s 剩余血量:%s' % (
            dogs.get('name'), dogs.get('weapon'), person.get('name'), dogs.get('Power_value'),
            person.get('blood_flow')))
    dog = {
        'name': name,
        'age': age,
        'Power_value': Power_value,
        'blood_flow': blood_flow,
        'weapon': weapon,  # 牙齿
         'dog' : dog
    }
    return dog
dog1 = dogs('哮天犬', 1, 200, 6000, 'tooth')
dog2 = dogs('藏獒', 2, 800, 6000, 'dog paw ')

people2['person_attack'](people2,dog2) 
# 即将被攻击的狗:藏獒 当前血量:6000  人:princess 用武器:excalibur 射了 狗:藏獒 狗掉血:900 剩余血量:5100

总结

1.将人的数据与人的功能绑定在一起，只有人能调用
2.将狗的数据与狗的功能绑定在一起 ，只有狗能调用

# 我们将这种数据与功能绑定在一起的整合称之为：“面向对象” 的编程思想。

编程思想

面向过程

# 面向过程的编程思想就是按照步骤一步一步去执行实现最终结果的过程
例如：我们写的一些校验代码之类的
第一步先是获取用户输入
第二步比对用户名密码
第三步写入文件
等等。。。

过程可以理解成是流水线 面向过程编程可以理解成是在创建一条流水线

面向对象

# 面向对象的编程思想就是创造出一个东西 让他的功能和数据结合在一起 ，但是不需要获取它的结果
例如：上面我们写的模拟人狗大战的小游戏，这类游戏人物，王者荣耀里的英雄一样，我们只是创造出来了他，让他有了功能和数据的结合， 但是最终他在玩家手里输出产生不同的结果。

#面向对象编程核心就是'对象'二字，对象其实就是一个容器 里面将数据和功能绑定到了一起

对象与类的概念

对象的概念

# 对象就是数据与功能的结合体
就是用于记录多个不同的数据与功能的结合体

类的概念

# 多个对象的数据与功能结合体
用于记录多个相同的数据与功能结合体
但是！每个对象可以有自己的独特数据与功能
在面向对象编程中 类仅仅是用于节省代码 对象才是核心

类与对象的创建

类的定义

# 在现实生活中理论是应该先有一个个的个体(对象)再有一个个的群体(类)在编程世界中必须要先有类才能产生对象

也就是说，我们要先定义类，才能产生对象

# class 定义类的关键词
class people :
# people 就是定义这个类的名字  
    school = '新东方'
    def message(self):
        people1 = {
            'name' : 'princess',
            'age' : 22,
            'Power value' : 900,  # 战力值
            'blood_flow' : 8888,  # 血容量
            'weapon' : 'excalibur'} #武器 神剑
        return people1

    # 类体代码一般表示公共的数据或公共的方法
     （就是底下产生的对象都可以用的数据）
    与函数体不同的是 ：
	#类的名字一般建议首字母大写以便于区分 
	#不加括号 
	#类在定义阶段就会执行代码 而函数体需要调用才能执行
	

类查看名称空间的方法

# 方法1：（不推荐使用）

# 类名加__dict__ 
print(people.__dict__)  # 可以把打印结果看成是一个字典
{'__module__': '__main__', 'school': '新东方', 'message': <function people.message at 0x000002089065C0D0>, '__dict__': <attribute '__dict__' of 'people' objects>, '__weakref__': <attribute '__weakref__' of 'people' objects>, '__doc__': None}
print(people.__dict__.get('school'))  # 新东方
print(people.__dict__['message'])  # <function people.message at 0x0000022B320BC0D0>

------------
# 方法2：
********可以采用句点符.的方式查看空间名称*********
print(people.school)  # 新东方
print(people.message)  # <function people.message at 0x000001D209BAC0D0>

对象的实例化

# 类名加括号就可以产生对象 people（）每一次加括号都是一个新的对象
res = people()
res2 = people()
print(res) # <__main__.people object at 0x0000024F8EE48400>
print(res2) # <__main__.people object at 0x00000155120D8438>


------------
# 由于这两个对象都是类产生的 所以他们可以拿到公共数据
print(res.school)  #新东方
print(res2.school) #新东方

# 可以通过属性或方法的方式去修改类的公共数据
people.school = '清华大学'
print(res.school)   # 清华大学
print(res2.school)  # 清华大学

对象的绑定方法

对象的独有数据

# 给对象创建独有的数据
# 1.直接用__dict__创建
res.__dict__['name'] = 'summer'
print(res.name)  # summer

------------


# 2.用句点符
res.age = 18
print(res.age)

------------


# 3.将添加的独有数据封装成函数 (更方便 适用于多数据使用)
def func(name, age, Power_value, blood_flow, weapon):
    res.__dict__['name'] = name
    res.__dict__['age'] = age
    res.__dict__['Power_value'] = Power_value
    res.__dict__['blood_flow'] = blood_flow
    res.__dict__['weapon'] = weapon

res = people()
func('su', 22, 800, 8000, 'Lavinia arrow')
print(res.__dict__) # {'name': 'su', 'age': 22, 'Power_value': 800, 'blood_flow': 8000, 'weapon': 'Lavinia arrow'}

将对象独有数据整合

# 将函数func放在people里面 只有people产生的对象才可以用

方法1：

class people :
    def func(name, age, Power_value, blood_flow, weapon):
        res.__dict__['name'] = name
        res.__dict__['age'] = age
        res.__dict__['Power_value'] = Power_value
        res.__dict__['blood_flow'] = blood_flow
        res.__dict__['weapon'] = weapon
    school = '新东方'
    def message(self):
        print('123')

---

方法2

class people :
    def func(res,name, age, Power_value, blood_flow):
        # 第一个参数必须是对象本身！！！！
        res.name = name    
        res.age = age     
        res.Power_value = Power_value    
        res.blood_flow = blood_flow   
    school = '新东方'
    def message(self):
        print('123')

res = people()
print(res.__dict__) # {}
people.func(res,'princess', 22, 900, 8888)
print(res.__dict__)   # {'name': 'princess', 'age':22,'Power_value': 900, 'blood_flow': 8888}

方法3

# 把func改成__init__方法之后可以直接调用
1.先产生一个空对象
2.自动调用__init__方法 ，将产生的空对象当第一个参数传进去
3.第一个参数有一个名称self，如果写的是self的话，会自动默认将空对象当作第一个参数传进去 ，表示当前被执行的对象

第一个参数的值会随着调用的对象产生改变
class people :
    def __init__(self,name, age, Power_value, blood_flow):
        # 第一个参数必须是对象本身！！！！
        self.name = name
        self.age = age
        self.Power_value = Power_value
        self.blood_flow = blood_flow
    school = '新东方'
    def message(self):
        print('123')

res = people('princess', 22, 900, 8888)
print(res.__dict__)
# {'name': 'princess', 'age': 22, 'Power_value': 900, 'blood_flow': 8888}

标签：__,name,Power,python,flow,value,面向对象,blood
来源： https://www.cnblogs.com/Hsummer/p/16522452.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。