面向对象 类
今日内容
人狗大战：
编写代码简单的实现人打狗 狗咬人的小游戏
推导步骤1:代码定义出人和狗
person1 {'name':'joyce','age':23,'attack_val':666,'life_val':
100}
person2 = {'name': 'akilan','age':25,'attack_val':88,'life_val': 100}
dog1 = {'name': 'kevin','age': 22,'attack_val': 1,'life_val': 100}
dog2 = {'name': 'juju','age': 22,'attack_val': 0.5,'life_val': 20}
# 如果想定义很多人和狗就需要反复写很多次这个字典
推导步骤2:将产生人和狗信息的字典封装成函数
并封装人和狗攻击的函数
def create_person(name,age,attack_val,life_val):
person_dict = {'name': name,
'age':age,
'attack_val':attack_val ,
'life_val': life_val}
return person_dict
def create_dog(name,age,attack_val,life_val):
dog_dict = {'name': name,
'age': age,
'attack_val':attack_val ,
'life_val': life_val}
return dog_dict
p1 = create_person('joyce',23,666,10000000)
p2 = create_person('akilan',26,888,10000000)
d1 = create_dog('kevin',22,1,100)
d2 = create_dog('juju',22,0.5,20)
print(p1,p2)
#{'name': 'joyce', 'age': 23, 'attack_val': 666, 'life_val': 10000000} {'name': 'akilan', 'age': 26, 'attack_val': 888, 'life_val': 10000000}
print(d1,p2)
#{'name': 'kevin', 'age': 22, 'attack_val': 1, 'life_val': 100} {'name': 'akilan', 'age': 26, 'attack_val': 888, 'life_val': 10000000}
# 定义出人打狗 狗咬人的动作
def person_attack(person_dict,dog_dict):
print(f'人：{person_dict.get("name")}准备打狗')
dog_dict['life_val']-=person_dict.get('attack_val')
print(f'人：{person_dict.get("name")}打了狗一拳 狗掉血{person_dict.get("attack_val")} 狗剩余血量{dog_dict.get("life_val")}')
def dog_attack (dog_dict,person_dict):
print(f'狗：{dog_dict.get("name")}准备咬人')
person_dict['life_val']-=person_dict.get('attack_val')
print(f'狗：{dog_dict.get("name")}咬了人一口 人掉血{dog_dict.get("attack_val")} 人剩余血量{person_dict.get("life_val")}')
person_attack(p1,d1)
# 人：joyce准备打狗
# 人：joyce打了狗一拳 狗掉血666 狗剩余血量-566
dog_attack(d2,p2)
# 狗：juju准备咬人
# 狗：juju咬了人一口 人掉血0.5 人剩余血量9999112
推导步骤3:定义的函数可以随意使用 所以人和狗的信息会混乱
person_attack(d1,p1)
dog_attack(p2,d2)
#人狗信息换位置了
面向对象核心思路前戏：
推导步骤4:如何实现只有人只能调用的人的攻击动作
狗只能调用狗的攻击动作>>>:数据与功能的绑定
def get_person(name, age, attack_val, life_val):
# 产生人的函数(功能)
def person_attack(person_dict, dog_dict):
print(f"人:{person_dict.get('name')}准备揍狗:{dog_dict.get('name')}")
dog_dict['life_val'] -= person_dict.get('attack_val')
print(f"人揍了狗一拳 狗掉血:{person_dict.get('attack_val')} 狗剩余血量:{dog_dict.get('life_val')}")
# 表示人的信息(数据)
person_dict = {
'name': name,
'age': age,
'attack_val': attack_val,
'life_val': life_val,
'person_attack': person_attack
}
return person_dict
def get_dog(name, attack_val, life_val):
def dog_attack(dog_dict, person_dict):
print(f"狗:{dog_dict.get('name')}准备咬人:{person_dict.get('name')}")
person_dict['life_val'] -= dog_dict.get('attack_val')
print(f"狗咬了人一口 人掉血:{dog_dict.get('attack_val')} 人剩余血量:{person_dict.get('life_val')}")
dog_dict = {
'name': name,
'attack_val': attack_val,
'life_val': life_val,
'dog_attack': dog_attack
}
return dog_dict
person1 = get_person('jason', 18, 8000, 99999999)
dog1 = get_dog('小黑', 800, 900000)
person1.get('person_attack')(person1, dog1)
#人:jason准备揍狗:小黑
# 人揍了狗一拳 狗掉血:8000 狗剩余血量:892000
"""面向对象核心思想：数据与功能的绑定"""
编程思想
1.面向过程编程
过程就是编程的流程 面向过程就是按照固定的顺序去解决问题
eg：ATM之前几乎都是面向编程过程
需要写出每一步的流程 有顺序的去深入 一步一步解决问题 使问题变得越来越简单
ps：提出问题 然后制定解决问题的方案
2.面向对象编程
对象即容器 数据与功能的结合体 一切皆对象
面向对象编程就是我们需要创造出一个个带有功能的都西昂
至于他干什么用怎么用 我们不用管
"""
两种编程思想没有优略之分 需要结合实际需求而定
注册 登录 等功能 面向过程编程更合适
如果需求是跟人物有关 面向对象更合适
实际编程两种思想是彼此交融的 只不过占比不同
"""
面对对象之类与对象
对象：数据与功能的结合体 对象才是核心
类：多个对象相同数据和功能的结合体 类主要是省代🐎
"""
一个人 人
一群人 人类
一只居 对象
一群居 juju类
"""
现实生活中 是先有类 才有的对象
程序中如果想产生对象 必须先定义类
类与对象的创建
面向对象并不是一门新的技术 但是为了很好的一眼区分 针对面向对象设计了新的语法格式
python中一定要有类 才能借助类产生对象
# 1.类的语法结构
class 类名:
"""注释代码"""
对象公共的数据
对象公共的功能
1.1class 是定义类的关键字
1.2类名和变量名几乎一致 类名的开头字母推荐大写
1.3数据：变量名与数据值的绑定（字典） 功能其实就是（函数）
# 2.类的定义与调用
类在定义阶段就会执行类体代码 但是属于类的局部命名称空间 外界无法直接调用
华德学院选课系统
'''定义类'''
class Student:
#对象公共的数据
school_name = '哈尔滨华德学院'
#对象的公共功能
def choice_coruse(self):
print('学生选课功能')
#查看名称空间
print(Student.__dict__)
#{'__module__': '__main__', 'school_name': '哈尔滨华德学院', 'choice_coruse': <function Student.choice_coruse at 0x0000020C8EBC6700>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}
print(Student.__dict__.get('school_name'))
#哈尔滨华德学院 Student 里面公共数据
print(Student.__dict__.get('choice_coruse'))
#<function Student.choice_coruse at 0x000001C3F3696700> Student 里面公共功能
'''在面向对象中 类和对象访问数据或者功能 可以统一采用句点符'''
print(Student.school_name)
# 哈尔滨华德学院
print(Student.choice_coruse)
# <function Student.choice_coruse at 0x000001DCB8EF7940>
#. = .__dict__.get
#类的调用>>>>:产生对象
'''类名加括号就会产生对象 并且每执行一次都会产生一个新的对象'''
obj1 = Student()
obj2 = Student()
obj3 = Student()
print(obj1,obj2,obj3)
# <__main__.Student object at 0x000001BC650D3B50>
# <__main__.Student object at 0x000001BC650D3AF0>
# <__main__.Student object at 0x000001BC65118F10>
#对象都不一样 每次都是产生一个新的对象
print(obj1.__dict__)
print(obj2.__dict__)
print(obj3.__dict__)
#{} 全是空的 内存地址里什么都没有
print(obj1.school_name)
#哈尔滨华德学院 对象直接.公共数据就可以获取值
Student.school_name = '清华大学'
print(obj1.school_name)
#清华大学 类名.公共数据名 附新的值
'''数据和功能 也可以统称为属性 数据>>>属性 功能>>>方法'''
对象独有的数据
class Student:
# 对象公共的数据
school_name = '清华大学'
# 对象公共的功能
def choice_course(self):
print('学生选课功能')
obj1 = Student()
obj2 = Student()
'''推导流程1:每个对象手动添加独有的数据'''
# print(obj1.__dict__)
# obj1.__dict__['name'] = 'jason'
# obj1.__dict__['age'] = 18
# obj1.__dict__['hobby'] = 'study'
# print(obj1.__dict__)
# print(obj1.name)
# print(obj1.age)
# print(obj1.hobby)
# print(obj2.__dict__)
# obj2.__dict__['name'] = 'kevin'
# obj2.__dict__['age'] = 28
# obj2.__dict__['hobby'] = 'music'
# print(obj2.__dict__)
# print(obj2.name)
# print(obj2.age)
# print(obj2.hobby)
'''推导流程2:将添加对象独有数据的代码封装成函数'''
# def init(obj, name, age, hobby):
# obj.__dict__['name'] = name
# obj.__dict__['age'] = age
# obj.__dict__['hobby'] = hobby
# stu1 = Student()
# stu2 = Student()
# init(stu1, 'jason', 18, 'music')
# init(stu2, 'kevin', 29, 'read')
# print(stu1.__dict__)
# print(stu2.__dict__)
'''推导流程3:给学生对象添加独有数据的函数只有学生对象有资格调用'''
# class Student:
# # 对象公共的数据
# school_name = '清华大学'
#
# # 专门给学生添加独有数据的功能
# def init(obj, name, age, hobby):
# obj.__dict__['name'] = name
# obj.__dict__['age'] = age
# obj.__dict__['hobby'] = hobby
#
# # 对象公共的功能
# def choice_course(self):
# print('学生选课功能')
# stu1 = Student()
# Student.init(stu1, 'jason', 18, 'music')
# stu2 = Student()
# Student.init(stu2, 'kevin', 29, 'read')
# print(stu1.__dict__, stu2.__dict__)
'''推导步骤4:init方法变形'''
# class Student:
# # 对象公共的数据
# school_name = '清华大学'
#
# # 专门给学生添加独有数据的功能 类产生对象的过程中自动触发
# def __init__(obj, name, age, hobby):
# obj.__dict__['name'] = name
# obj.__dict__['age'] = age
# obj.__dict__['hobby'] = hobby
#
# # 对象公共的功能
# def choice_course(self):
# print('学生选课功能')
#
# stu1 = Student('jason', 18, 'read')
# print(stu1.__dict__)
# print(stu1.name)
# print(stu1.school_name)
'''推导步骤5:变量名修改'''
class Student:
# 对象公共的数据
school_name = '清华大学'
# 专门给学生添加独有数据的功能 类产生对象的过程中自动触发
def __init__(self, name, age, hobby):
self.name = name # self.__dict__['name'] = name
self.age = age
self.hobby = hobby
# 对象公共的功能
def choice_course(self):
print('学生选课功能')
stu1 = Student('jason', 18, 'read')
print(stu1.name)
print(stu1.school_name)
对象独有的功能
class Student:
# 对象公共的数据
school_name = '清华大学'
# 专门给学生添加独有数据的功能 类产生对象的过程中自动触发
def __init__(self, name, age, hobby):
self.name = name # self.__dict__['name'] = name
self.age = age
self.hobby = hobby
# 对象公共的功能
def choice_course(self):
print(f'学生{self.name}正在选课')
stu1 = Student('jason', 18, 'music')
stu2 = Student('kevin', 28, 'read')
# 1.直接在全局定义功能 该函数就不是学生对象独有的了
# def eat():
# print('吃东西')
# stu1.eat = eat
# print(stu1.__dict__)
# stu1.eat()
# 2.只能将函数放在类中 但是类中的函数又是对象公共的
'''定义在类中的功能 默认就是绑定给对象使用的 谁来调谁就是主人公'''
# Student.choice_course(123) # 类调用需要自己传参数
# stu1.choice_course() # choice_course(stu1) 对象调用会自动将对象当做第一个参数传入
# stu1.choice_course()
# stu2.choice_course()
# 对象修改数据值
stu1.name = 'tony' # 当点的名字已经存在的情况下 则修改对应的值
# 对象新增数据值
stu1.pwd = 123 # 当点的名字不存在的情况下 则新增数据
print(stu1.__dict__)
原文地址：http://www.cnblogs.com/lzy199911/p/16852205.html
声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。
