标签：obj name val get python 7.26 dog person 之类

今日学习内容

• 面向对象
• 编程思想（面向过程、面向对象）
• 类与对象的概念
• 类与对象的创建
• 对象的实例化方法（独有数据）
• 对象的绑定方法（独有功能）

面向对象铺垫

• 需求：

  ​ 模拟人和狗相互攻击的过程以及结果

  • 推导步骤1: 直接手写字典模拟一个个人和狗

  
  person_1= {  # 使用字典模拟人的各种状态
      'name': 'jason',
      'person_type': '肌肉男',
      'attack_val': 1000,
      'life_val': 2000 }
  
  person_2= {  # 使用字典模拟人的各种状态
      'name': 'make',
      'person_type': '宅男',
      'attack_val': 300,
      'life_val': 1000 }
  
  dog_1 = {  # 使用字典模拟狗的各种状态
      'name': '黑狗',
      'd_type': '泰迪',
      'attack_val': 100,
      'life_val': 500 }
  
  dog_2 = {  # 使用字典模拟狗的各种状态
      'name': '黄狗',
      'd_type': '藏獒',
      'attack_val': 1000,
      'life_val': 1200 }
  
  
  

  • 推导步骤2: 由于定义人和狗的字典基本不变 但是在很多地方又需要反复使用 所以封装成函数

  def get_person(name,gender, age, p_type, attack_val, life_val):
  
      person_obj = {
          'name': name,
          'gender': gender,
          'age': age,
          'p_type': p_type,
          'attack_val': attack_val,
          'life_val': life_val    }
      return person_obj
  # 这样直接调用人的传参就比较方便使用了
  
  p1 = get_person('jason','man',18,'肌肉男',1000,2000)
  p2 = get_person('nana','woman',28,'淑女',100,800)
  
  
  def get_dog(name, d_type, attack_val, life_val):
      
      dog_obj = {
          'name': name,
          'd_type': d_type,
          'attack_val': attack_val,
          'life_val': life_val  }
      return dog_obj
  # 这样直接调用狗的函数传参就比较方便使用了
  d1 = get_dog('辣鸡狗','小土狗',800, 5000)
  d2 = get_dog('拉吉狗','土小狗',100, 200)
  

  • 推导步骤3: 让人和狗具备攻击的能力 本质其实就是定义两个函数供人和狗调用

  # 人攻击狗定义的函数
  def person_attack(person_obj, 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):
      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')))
  
   
  
  # 把上个步骤定义好的人的状态 和 狗的状态拿下来直接调用就可以了
  p1 = get_person('jason','man',18,'肌肉男',1000,2000)
  p2 = get_person('nana','woman',28,'淑女',100,800)
  d1 = get_dog('小黄狗','中华田园犬',800, 5000)
  d2 = get_dog('小奶狗','哈士奇',100, 200)
  
  person_attack(p1, d1)  # 即将被攻击的狗:小黄狗 当前血量:5000
  # 人:jason 锤了 狗:小黄狗 狗掉血:1000 剩余血量:4000
  dog_attack(d2, p2)  # 即将被攻击的人:nana 当前血量:800
  # 狗:小奶狗 咬了 人:nana 人掉血:100 剩余血量:700
  
  &&&：人和狗攻击的函数 可以被任意调用
  person_attack(d1, p1)  # 即将被攻击的狗:jason 当前血量:2000
  # 人:小黄狗 锤了 狗:jason 狗掉血:800 剩余血量:1200
  """
  上述结果基于在调用函数时  按照函数形参的对应对象 传的实参   
  很容易把参数对象弄反   人和狗攻击的函数 可以被任意调用
  """
  

  • 推导步骤4: 人跟人攻击狗的函数绑定 狗跟狗攻击人的函数绑定
    我们定义的函数默认情况下都是可以被任意调用的 但是现在我们想实现定义的函数只有特定的东西才可以调用

  
  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, 5000)
  p1 = get_person('jason','man',18,'肌肉男',1000,2000)
  
  p1.get('person_attack')(p1, d1)  # 可以执行
  p1.get('person_sttcak')(d1,p1)  # 调换了参数 直接报错
  

  • 总结：

    将人的数据跟人的功能绑定到一起
    只有人可以调用人的功能
    将狗的数据跟狗的功能绑定到一起
    只有狗可以调用狗的功能
    我们将数据与功能绑定到一起的操作起名为:'面向对象编程'

    本质:将特定的数据与特定的功能绑定到一起 将来只能彼此相互使用

  • 编程思想

  面向过程编程
  之前所学的所有的编程都是面向过程编程

  面向过程就是编写执行一系列的流程 按照流程步骤依次去执行 最终得出结果

  • 面向对象编程

  核心就是 【对象】二字

  对象就像一个容器一样 里面将数据和功能绑定在一起

  • 区别

  面向过程编程相当于让你给出一个问题的具体解决方案

  面向对象编程相当于让你创造出一些具体的事物 后就不需要在去操作了

  上述两种编程思想没有优劣之分 仅仅是使用场景不同
  甚至很多时候是两者混合使用

对象与类的概念

对象:数据与功能的结合体

类:多个对象相同的数据和功能的结合体

类主要用于记录多个对象相同的数据和功能
对象则用于记录多个对象不同的数据和功能
提醒:在面向对象编程中 类仅仅是用于节省代码 对象才是核心

对象与类的创建

1.建类的完整语法
class Student:
2.Student是类的名字
	类名的命名跟变量名一致 并且推荐首字母大写(为了更好的区分)
3.类体代码
	公共的数据\公共的方法
ps:类体代码在类定义阶段就会执行!!!

    
# class Student:
#     school = '清华大学'
#
#     def choice_course(self):
#         print('正在选课')

# 查看名称空间的方法
# print(Student.__dict__)  # 使用该方法查看名称空间 可以看成是一个字典
# print(Student.__dict__['school'])  # 使用字典的取值方式获取名字
# print(Student.__dict__.get('choice_course'))  # 使用字典的取值方式获取名字
'''在面向对象编程中 想要获取名称空间中的名字 可以采用句点符'''

print(Student.school)  # 清华大学
print(Student.choice_course)  # <function Student.choice_course at 0x0237B028>

'''类实例化产生对象: 类名加括号'''
stu = Student()
print(stu)  # <__main__.Student object at 0x0151A2F8>
print(stu.school)  # 清华大学
# print(stu1)  # <__main__.Student object at 0x000001D923B04A60>
# print(stu2)  # <__main__.Student object at 0x0000025E8A48F130>
# print(stu1.__dict__, stu2.__dict__)  # {} {}
Student.school = '复旦大学'  # 修改school键对应的值
stu = Student()
stu1 = Student()
print(stu.school)  # 复旦大学
print(stu1.school)  # 复旦大学
"""
我们习惯将类或者对象句点符后面的东西称为属性名或者方法名
"""

对象独有的数据

# 学生类
# class Student:
#     # 学生对象公共的数据
#     school = '清华大学'
#
#     # 学生对象公共的方法
#     def choice_course(self):
#         print('正在选课')

'''推导思路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)
# obj2 = Student()
# obj2.__dict__['name'] = 'kevin'
# obj2.__dict__['age'] = 28
# obj2.__dict__['gender'] = 'female'
# print(obj2.name)
# print(obj2.age)
# print(obj2.gender)
# print(obj2.school)
'''推导思路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: 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.__dict__)  # {'name': 'jason', 'age': 18, 'gender': 'male'}
stu2 = Student('kevin', 28, 'female')
print(stu2.__dict__)  # {'name': 'kevin', 'age': 28, 'gender': 'female'}

标签：obj,name,val,get,python,7.26,dog,person,之类
来源： https://www.cnblogs.com/55wym/p/16522795.html

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