今日内容概要

• 面向对象之人狗大战
• 面向对象编程思想
• 面向对象之类与对象
• 类与对象的创建
• 对象独有的数据
• 对象独有的功能

今日内容详细

面向对象之人狗大战

编写代码简单的实现人打狗 狗咬人的小游戏
'''推导步骤1 代码定义人和狗'''
person1 = {'name': 'jason',
        'age': 18,
        'gender': 'male',
        'p_type': '猛男',
        'atk_val': 999,
        'life_val': 100000}
dog1 = {'name': '小黑',
      'd_type': '泰迪',
      'atk_val': 100,
      'life_val': 8000}
# 如果需要多个人和狗需要重复编写上述字典
'''推导步骤2 将产生人和狗的字典封装成函数 并封装人和狗的攻击函数'''
def create_person(name, age, gender, p_type, atk_val, life_val):
	person = {'name': name,
          'age': age,
          'gender': gender,
          'p_type': p_type,
          'atk_val': atk_val,
          'life_val': life_val}
	return person
def create_dog(name, d_type, attack_val, life_val):
	dog = {'name': name,
        'd_type': d_type,
        'atk_val': atk_val,
        'life_val': life_val}
	return dog

def preson_atk(preson, dog):
	print(f'人{preson.get("name")}准备揍狗{dog.get("name")}')
	dog['life_val'] -= person.get('atk_val')
	print(f'人揍了狗一拳,狗{dog.get("name")}掉血{person.get('atk_val')},    剩余血量{dog.get('life_val')})
 
def dog_atk(dog, preson):
	print(f'狗{dog.get("name")}准备咬人{preson.get("name")}'
	person['life_val'] -= dog.get('atk_val')
	print(f'狗咬了人一口,人{preson.get("name")}掉血{dog.get('atk_val')},    剩余血量{person.get('life_val')})

p1 = create_person('jason', 18, 'male', '猛男', 8000, 99999999)
d1 = create_dog('小黑', '恶霸', 800, 900000)
person_atk(p1, d1)
dog_atk(d1, p1)

'''推导步骤3 人和狗的攻击混乱'''
person_atk(d1, p1)  # 变成狗揍人
dog_atk(p1, d1)  # 变成人咬狗
          
'''推导步骤4 如何实现只有人能调用人的攻击动作 狗只能调用狗的攻击动作
>>>:数据与功能的绑定'''
def get_person(name, age, gender, p_type, atk_val, life_val):
    # 产生人的函数(功能)
    def person_atk(person, dog):
        print(f"人:{person.get('name')}准备揍狗{dog.get('name')}")
        dog['life_val'] -= person.get('atk_val')
        print(f"人揍了狗一拳 狗掉血:{person.get('atk_val')}狗剩余血         量:{dog.get('life_val')}")
    # 表示人的信息(数据)
    person = {
        'name': name,
        'age': age,
        'gender': gender,
        'p_type': p_type,
        'atk_val': atk_val,
        'life_val': life_val,
        'person_atk': person_atk
    }
    return person
          
def get_dog(name, d_type, atk_val, life_val):
    def dog_atk(dog, person):
        print(f"狗:{dog.get('name')}准备咬人:{person.get('name')}")
        person['life_val'] -= dog.get('atk_val')
        print(f"狗咬了人一口 人掉血:{dog.get('atk_val')} 人剩余             血量:{person.get('life_val')}")
    dog = {
        'name': name,
        'd_type': d_type,
        'atk_val': atk_val,
        'life_val': life_val,
        'dog_atk': dog_atk
    }
    return dog
 
person = get_person('jason', 18, 'male', '猛男', 999, 1000000)
dog = get_dog('小黑', '恶霸', 100, 1000)
person.get('person_atk')(pseson, dog)
# 字典取值取到内层攻击函数名加括号调用并传入指定个数参数
          
'''面向对象和兴思想:数据与功能的绑定'''

编程思想

1.面向过程编程
	过程及流程 面向过程就是按照固定的流程解决问题
	需要例举出每一步的流程 并且随着步骤的深入 问题的解决越来越简单
	ps:提出问题 然后指定出该问题的解决方案
2.面向对象编程
	对象即容器 数据与功能的结合体(python中一切皆对象)
	面向对象编程有点类似于造物主的感觉 我们只需要创造出一个个对象 至于该对	象将来会如何发展跟程序员没有关系 也无法控制
	如 MOBA游戏中玩家操作的角色 只有基础属性 战绩的正负根据玩家操作 无法控    制
'''
两种编程思想没有优劣之分 需要结合实际需求而定
	如果是注册 登陆 肯定是面向过程更合适
	如果是游戏人物肯定是面向对象更合适
实际编程者两种思想是彼此交融的 只不过占比不同
'''

面向对象之类与对象

对象:数据与功能的结合体             对象才是核心
类:多个对象相同数据和功能的结合体      类主要是为了节省代码
'''
举例  不同物种进行分类
一个人          对象
一群人          人类(每个人都具有相同的特征 整合为一类)

一条狗          对象
一群狗          犬类(每条狗都具有相同的特征 整合为一类)
'''

现实生活中一般都是先有对象再有类
程序中如果想要产生对象 必须先定义类

类与对象的创建

面向对象并不是一门新技术 但是为了很好的区分开 针对面向对象设计了新的语法格式
python中一定要有类 才能借助于类产生对象

1.类的语法结构
class 类名:
	'''类体代码注释'''
	对象的公共数据
	对象的公共功能
'''
class是定义类的关键字
类名的命名与变量名几乎一致 需要注意的是首字母推荐大写用于后续区分
数据:变量名与数据值的绑定 功能(方法)其实就是函数
'''
2.类的定义与调用
	类在定义阶段就睡执行类体代码 但是属于类的局部名称空间 外界无法直接获取

# 需求:清华大学学生选课系统
# 定义类
class Student:
    # 对象公共的数据
    school_name = '清华大学'

    # 对象公共的功能
    def choice_course(self):
        print('学生选课功能')
# 查看名称空间
print(Student.__dict__)  # __dict__方法可以查看对应名称空间中所有的名字
# 取名称空间中的名字
print(Student.__dict__.get('school_name'))  # 清华大学
print(Student.__dict__.get('choice_course')) # choice_course所绑定的内存地址
'''在面向对象中 类和对象访问数据或者功能 可以统一采用句点符'''
print(Student.school_name)  # 等价于上述取名字
print(Student.choice_course)
'''类名加括号就会产生对象 并且没执行一次都会产生一个全新的对象'''
obj = Student()
obj1 = Student()
print(obj.__dict__)  # 对象自己目前什么都没有 但还是可以调用类中的名字
print(obj.school_name)  # 清华大学
# 修改类中的数据
Student.school_name = '哈尔滨佛学院'
print(obj.school_name) # 哈尔滨佛学院
'''数据和功能也可以统称为属性  数据>>>:属性名   功能>>>:方法'''

对象独有的数据

class Student:
    # 对象公共的数据
    school_name = '清华大学'

    # 对象公共的功能
    def choice_course(self):
        print('学生选课功能')
     
obj = Student()
obj1 = Student()
'''推导流程1 对象手动添加独有的数据'''
print(obj.__dict__)  # 将obj名称空间中的名字以字典的形式来展示
obj.__dict__['name'] = 'jason'  
# 此时的名称空间是字典的形式 可以通过添加键值对的方式在空间中添加数据
obj.__dict__['age'] = 18
print(obj.__dict__)
print(obj.name)
print(obj.age)  
print(obj1.__dict__)
obj1.__dict__['name'] = 'kevin'
obj1.__dict__['age'] = 28
print(obj1.__dict__)
print(obj1.name)
print(obj1.age)
'''推导流程2 将添加对象独有的数据封装成函数'''
def init(obj, name, age):
    obj.__dict__['name'] = name
    obj.__dict__['age'] = age
stu1 = Student()
stu2 = Student()
init(stu1, 'jason', 18)
init(stu2, 'kevin', 28)
print(stu1.__dict__)
print(stu2.__dict__)
'''推导流程3 给学生对象添加独有数据的函数 只有学生对象才有资格调用'''
class Student:
	school_name = '清华大学'
	def init(obj, name, age):
		obj.__dict__['name'] = name
		obj.__dict__['age'] = age
	def choice_course(self):
		print('学生选课系统')
stu1 = Student()
Student.init(stu1, 'jason', 18)
stu2 = Student()
Student.init(stu2, 'kevin', 28)
print(stu1.__dict__, stu2.__dict__)
'''推导步骤4 init方法变形'''
class Student:
	school_name = '清华大学'
	
	# 类产生对象的过程中会自动触发
	def __init__(obj, name, age):
		obj.__dict__['name'] = name
		obj.__dict__['age'] = age
	def choice_course(self):
		print('学生选课系统')
stu1 = Student('jason', 18)# 会自动将创建的对象传入__Init__中的第一个参数
print(stu1.__dict__)
print(sut1.name)
'''推导步骤5 变量名修改'''
class Student:
	school_name = '清华大学'
	def init(self, name, age):
		self.name = name
		self.age = age
	def choice_course(self):
		print('学生选课系统')
stu1 = Student('jason', 18)
print(stu1.name)
print(stu1.school_name)

对象的独有功能

class Student:
	school_name = '清华大学'
	def init(self, name, age):
		self.name = name
		self.age = age
	def choice_course(self):
		print('学生选课系统')
stu1 = Student('jason', 18) 
stu2 = Student('kevin', 28)
'''直接在全局定义功能'''
def eat():
	print('正在吃东西')
stu1.eat = eat
stu1.eat()
# eat函数所有人都能调用 就不是对象独有的了
'''只能将函数放在类中 但是类中的函数又是对象公共的
定义在类中的功能 默认就是绑定给对象使用的 谁来调用谁就是主人公
'''
class Student:
	school_name = '清华大学'
	def init(self, name, age):
		self.name = name
		self.age = age
	def choice_course(self):
		print('学生选课系统')
	def eat(self):
		print(f'{self.name}正在吃东西')
stu1 = Student('jason', 18)
stu2 = Student('kevin', 28)
stu1.eat()  # jason正在吃东西
# 对象调用会自动将对象当做第一个参数传入
stu2.eat()  # kevin正在吃东西

# 对象修改数据值
stu1.name = 'tom'    # 当点的名字存在的时候 会修改对应数据值
# 对象新增数据值
stu1.hobby = 'read'  # 当点的名字不存在的时候 会新增数据

原文地址：http://www.cnblogs.com/lzjjjj/p/16851617.html