标签：obj name val person 创建 get dog 面向对象 理解
目录一、面向对象前戏
1.推导步骤一，用字典模拟人和狗
person = {
'name': 'jason',
'p_type': '猛男',
'attack_val': 800,
'life_val': 2000
}
dog = {
'name': '旺财',
'd_type': '泰迪',
'attack_val': 50,
'life_val':800
}
2.推导步骤二，将字典封装成函数
def get_person(name, gender, age, p_type, attack_val,life_val):
"""
专用用于产生用户字典(创造人)
:param name: 姓名
:param gender: 性别
:param age: 年龄
:param d_type: 类型
:param attack_val:攻击力
:param life_val: 生命值
:return: 人的字典(人)
"""
person_obj = {
'name': 'jason',
'p_type': '猛男',
'attack_val': 800,
'life_val': 2000
}
return person_obj
def get_dog(name, d_type, attack_val,life_val):
"""
专用用于产生狗字典(创造狗)
:param name: 姓名
:param d_type: 类型
:param attack_val:攻击力
:param life_val: 生命值
:return: 狗的字典(狗)
"""
dog_obj = {
'name': name,
'd_type': d_type,
'attack_val': attack_val,
'life_val': life_val
}
return dog_obj
3.推导步骤三，二者具有攻击的能力（定义俩个函数供人和狗调用）
def person_attack(person_obj, dog_obj):
"""
专用提供给人调用 攻击狗
:param person_obj: 传人数据(字典)
:param dog_obj: 传狗数据(字典)
"""
print('即将被攻击的狗:%s 当前血量:%s' % (dog_obj.get('name'), 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.get('life_val')))
def dog_attack(dog_obj, person_obj):
"""
专用提供给狗调用 攻击人
:param dog_obj: 传狗数据(字典)
:param person_obj: 传人数据(字典)
"""
print('即将被攻击的人:%s 当前血量:%s' % (person_obj.get('name'), 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.get('life_val')))
# 调用产生人和狗的函数
p = get_person('jason', 'male', 18, '猛男', 8000, 90000)
d = get_dog('小黄狗', '法斗', 800, 8000)
# 调用攻击彼此的函数
person_attack(p, d)
'''
即将被攻击的狗:小黄狗 当前血量:8000
人:jason 砍了 狗:小黄狗 狗掉血:800 剩余血量:7200
'''
dog_attack(p, d)
'''
即将被攻击的人:小黄狗 当前血量:8000
狗:jason 咬了 人:小黄狗 人掉血:800 剩余血量:7200
'''
存在缺陷
人和狗攻击的函数，可以被任意调用，人可以调用狗攻击的功能，狗可以调用人攻击的功能
4.人狗攻击乱套，俩者函数可以随意调用
# 调用攻击彼此的函数
person_attack(p, d)
'''
即将被攻击的狗:小黄狗 当前血量:8000
人:jason 砍了 狗:小黄狗 狗掉血:800 剩余血量:7200
'''
dog_attack(p, d)
'''
即将被攻击的人:小黄狗 当前血量:8000
狗:jason 咬了 人:小黄狗 人掉血:800 剩余血量:7200
'''
5.将人与人攻击狗的函数绑定，狗与狗攻击人的函数绑定
def get_person(name, gender, age, p_type, attack_val, life_val):
"""
专用用于产生用户字典(创造人)
:param name: 姓名
:param gender: 性别
:param age: 年龄
:param d_type: 类型
:param attack_val:攻击力
:param life_val: 生命值
:return: 人的字典(人)
"""
def person_attack(person_obj, dog_obj):
"""
专用提供给人调用 攻击狗
:param person_obj: 传人数据(字典)
:param dog_obj: 传狗数据(字典)
"""
print('即将被攻击的狗:%s 当前血量:%s' % (dog_obj.get('name'), 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.get('life_val')))
person_obj = {
'name': name,
'gender': gender,
'age': age,
'p_type': p_type,
'attack_val': attack_val,
'life_val': life_val,
'person_attack':person_attack
}
return person_obj
def get_dog(name, d_type, attack_val, life_val):
"""
专门用于产生狗字典(狗)
:param name: 狗的名字
:param d_type: 狗的类型
:param attack_val: 狗的攻击力
:param life_val: 狗的生命值
:return: 狗的字典(狗)
"""
def dog_attack(dog_obj, person_obj):
"""
专用提供给狗调用 攻击人
:param dog_obj: 传狗数据(字典)
:param person_obj: 传人数据(字典)
"""
print('即将被攻击的人:%s 当前血量:%s' % (person_obj.get('name'), 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.get('life_val')))
dog_obj = {
'name': name,
'd_type': d_type,
'attack_val': attack_val,
'life_val': life_val,
'dog_attack':dog_attack
}
return dog_obj
d1 = get_dog('小黄狗', '恶霸犬', 800, 8000)
p1 = get_person('jason', 'male', 18, '猛男', 8000, 90000)
p1.get('person_attack')(p1, d1)
总结
1.将人的数据与人的功能绑定在一起，只有人可以调用人的功能
2.将狗的数据与狗的功能绑定在一起，只有狗可以调用狗的功能
3.我们将数据与功能绑定在一起的操作称为：'面向对象编程'，本质就是将特定的数据与特定的功能绑定在一起，将来只能批次互相使用
二、编程思想
1.面向对象编程
1.就是按照指定的步骤依次执行，最终就可以得到想要的结果，过程就像我们之前写的ATM+购物车，就是在执行一系列的流程
2.例子一：将风扇可以是一个对象。如果我们把风扇当作一个对象，那么它的属性就是——颜色、型号、价格、品牌等等，它的行为（函数）是换挡、转动。
3.例子二：如果我们把狗当作一个对象，那么它的属性就是——它的颜色、品种、名字、生命力等，而它的行为（函数）是行走、叫、吃喝等。
4.面向过程编程，核心就是'过程'俩个字，在做一件事情的时候，将这个事情划分为好几个步骤，然后一步一步的去实现，最终结合起来，形成了整件事，
5.例如:我俩在做ATM+购物车的时候，我们先构思里它能实现的功能，然后将功能一个个的写出来，然后再结合起来，就是一个项目。
2.面向对象编程
1.核心就是'对象'俩个字，对象其实就是一个容器，里面将数字和功能绑定到了一起
2.例子一：人狗大战中对数据和功能的整合
3.例子二：模块文件内含有数据和功能函数
4.不同的功能被归纳到不同的类中。然后由类产生出对象，这些对象之间的相互作用
俩者的区别
1.面向过程编程相当于让你给出一个问题的具体解决方案
2.面向对象编程相当于让你创造出一些事物之后不用你管
三、对象和类的概念
1.如何理解对象
1.数据与功能的结合体，主要用于记录多个对象相同的数据和功能
2.对象就是具体的，可以有它的姓名、颜色、品种，它是一个实实在在存在的东西
2.如何理解类
1.多个对象相同的数据和功能的结合体，主要用于记录多个对象不同的数据和功能
2也可以理解为类里面装着对象，类比较抽象，只是笼统的概括一下，就比如'学生类'，没有具体的指谁，里面可以有张三，也可以有李四。
3简单来说就是某一类事物，它们具有相同的属性和行为或者说是方法，在代码中我们将这些行为或者方法定
义成函数。
ps:对象是核心，类的使用仅仅是为了节省代码
四、对象与类的创建
1.理论知识
在编程世界中必须要先有类才能产生对象，面向对象编程本质就是将数据和功能绑定到了一起，但是为了突出面向对象编程的形式，python特地开发了一套语法专门用于面向对象编程的操作
2.创建类的语法
class Student
# 学生对象公共的数据
# 学生对象公共的方法
'''
对语法的解释说明：
class是定义类的关键字
People是类的名字，类名的命名跟变量名一致，为了更好的区分推荐首字母大写
类体代码 公共的数据，或者公共的方法
可以创建空的类
类体最常见的是变量的定义和函数的定义，但其实类体可以包含任意Python代码，类体的代码在类定义阶段就会执行，因而会产生新的名称空间用来存放类中定义的名字，可以打印Student.__dict__来查看类这个容器内盛放的东西
'''
3.查看名称空间的方法
3.1.使用.__dict__,使用该方法查看名称空间，可以看作是一个字典
class Student: # 类的命名应该使用“驼峰体”
school='清华大学' # 数据
def choose(self): # 功能
print('%s is choosing a course' %self.name)
print(Student.__dict__)
'''{..., 'school': '清华大学', 'choose': <function Student.choose at 0x1018a2950>,...}'''
3.2.使用字典的取值方式取值
print(Student.__dict__['school'])
print(Student.__dict__.get('choice_course'))
3.4.在面向对象编程中，想要获取名称空间中的名字，可以采用句点符
print(Student.school)
print(Student.choice_course)
3.5.类实例化产生对象
语法结构就是：类名加括号
stu1 = Student()
# 调用类的过程称为将类实例化，拿到的返回值就是程序中的对象，或称为一个实例
stu2 = Student()
print(stu1) # <__main__.Student object at 0x000001D923B04A60>
print(stu2) # <__main__.Student object at 0x0000025E8A48F130>
print(stu1.__dict__, stu2.__dict__) # {} {}
Student.school = '北京大学' # 修改school键对应的值
"""
我们习惯将类或者对象句点符后面的东西称为属性名或者方法名
每实例化一次Student类就得到一个学生对象，每一次都不一样
"""
五、对象独有的数据
class Student:
# 学生对象公共的数据
school = '清华大学'
# 学生对象公共的方法
def choice_course(self):
print('正在选课')
1.推导思路1：直接利用__dict__的方法向字典添加键值对
obj1 = Student()
obj1.__dict__['name'] = 'jason' # 等价于 obj1.name = 'jason'
obj1.__dict__['age'] = 18 # 等价于 obj1.age = 18
obj1.__dict__['gender'] = 'male' # ...
print(obj1.name)
print(obj1.age)
print(obj1.gender)
print(obj1.school)
2.推导思路2: 将添加独有数据的代码封装成函数
def init(obj,name,age,gender):
obj.__dict__['name'] = name
obj.__dict__['age'] = age
obj.__dict__['gender'] = gender
stu1 = Student()
stu2 = Student()
init(stu1,'jason',18,'male')
init(stu2, 'kevin',28,'female')
print(stu1.__dict__)
print(stu2.__dict__)
3.推导思路3: init函数是专用给学生对象创建独有的数据
init函数其他对象不能调用，面向对象思想就是将数据和功能整合到一起，将函数封装到学生类中 这样只有学生类产生的对象才有资格访问
class Student:
"""
1.先产生一个空对象
2.自动调用类里面的__init__方法 将产生的空对象当成第一个参数传入
3.将产生的对象返回出去
"""
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 choice_course(self):
print('正在选课')
# stu1 = Student()
# print(stu1.__dict__)
# Student.init(stu1, 'jason', 18, 'male')
# print(stu1.__dict__)
# print(stu1.name)
stu1 = Student('jason', 18, 'male')
print(stu1)
stu2 = Student('kevin', 28, 'female')
print(stu2)
标签：obj,name,val,person,创建,get,dog,面向对象,理解 来源： https://www.cnblogs.com/zxr1002/p/16522111.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。