面向对象微讲解
面向对象微讲解
-
面向对象的思想演变
点击查看推导过程
''' 假如我们想实现一个人狗大战的功能，就一个小小的功能我们来看看怎么做 ''' # 1. 先定义人和狗的技能、血量、防御，我们可以用字典来存储这些数据 # person_dict = { # 'name': 'oscar', # 'skill': '火焰攻击', # 'hurt': 100, # 'volume': 500 # } # person1_dict = { # 'name': 'kevin', # 'skill': '寒冰攻击', # 'hurt': 80, # 'volume': 450 # } # dog_dict = { # 'name': '土狗', # 'skill': '土崩', # 'hurt': 50, # 'volume': 300 # } # dog1_dict = { # 'name': '修勾', # 'skill': '撕咬', # 'hurt': 60, # 'volume': 400 # } # 角色我们只写了四个，就发现代码有些冗余了，而且还有很多重复的代码，所以我们用函数来定义一个创建角色的方法 # def person_func(name, skill, hurt, volume): # person_dict = { # 'name': name, # 'skill': skill, # 'hurt': hurt, # 'volume': volume # } # return person_dict # # # def dog_func(name, skill, hurt, volume): # dog_dict = { # 'name': name, # 'skill': skill, # 'hurt': hurt, # 'volume': volume # } # return dog_dict # # # 创建角色 # person1 = person_func('oscar', '火焰攻击', 100, 500) # person2 = person_func('kevin', '寒冰攻击', 80, 450) # dog1 = dog_func('土狗','土崩',50,300) # dog2 = dog_func('修狗','撕咬',80,400) # # 封装一个攻击函数 # def skill_person(person,dog): # print('人物角色:%s 使用: %s 攻击动物角色:%s'% (person['name'],person['skill'],dog['name'])) # dog['volume'] -= person['hurt'] # print('攻击成功，%s受到%s点伤害，血量剩余为%s'% (dog['name'],person['hurt'],dog['volume'])) # def skill_dog(dog,person): # print('动物角色:%s 使用: %s 攻击人物角色:%s'% (dog['name'],dog['skill'],person['name'])) # person['volume'] -= dog['hurt'] # print('攻击成功，%s受到%s点伤害，血量剩余为%s'% (person['name'],dog['hurt'],person['volume']))skill_person(person2,dog2)
skill_dog(dog1,person1)
'''
人物角色:kevin 使用: 寒冰攻击 攻击动物角色:修狗
攻击成功，修狗受到80点伤害，血量剩余为320
动物角色:土狗 使用: 土崩 攻击人物角色:oscar
攻击成功，oscar受到50点伤害，血量剩余为45
'''我们想要的效果有了，但是呢有一些问题，我们来看
skill_dog(person1,dog1)
'''
动物角色:oscar 使用: 火焰攻击 攻击人物角色:土狗
攻击成功，土狗受到100点伤害，血量剩余为200
'''我们发现该方法不结合实际，人可以调用狗的方法，狗可以调用人的方法，那要怎么给他们加一个限制呢我们来看
def person_func(name, skill, hurt, volume):
# 把人物的攻击方法写进创建人物角色的方法中，这样就只有人物角色才可以调用这个方法了
def skill_person(person, dog):
print('人物角色:%s 使用: %s 攻击动物角色:%s' % (person['name'], person['skill'], dog['name']))
dog['volume'] -= person['hurt']
print('攻击成功，%s受到%s点伤害，血量剩余为%s' % (dog['name'], person['hurt'], dog['volume']))
person_dict = {
'name': name,
'skill': skill,
'hurt': hurt,
'volume': volume,
'skill_person': skill_person
}
return person_dictdef dog_func(name, skill, hurt, volume):
# 把狗的攻击方法写进创建狗的方法中，这样就只有动物角色才可以调用这个方法了
def skill_dog(dog, person):
print('动物角色:%s 使用: %s 攻击人物角色:%s' % (dog['name'], dog['skill'], person['name']))
person['volume'] -= dog['hurt']
print('攻击成功，%s受到%s点伤害，血量剩余为%s' % (person['name'], dog['hurt'], person['volume']))
dog_dict = {
'name': name,
'skill': skill,
'hurt': hurt,
'volume': volume,
'skill_dog': skill_dog
}
return dog_dict创建角色
person1 = person_func('oscar', '火焰攻击', 100, 500)
person2 = person_func('kevin', '寒冰攻击', 80, 450)
dog1 = dog_func('土狗','土崩',50,300)
dog2 = dog_func('修狗','撕咬',80,400)
person1'skill_person'
dog1'skill_dog'
以上的推导就是面向对象的思想的演变，以上的代码将人物角色、动物角色的数据与功能整合到一起的操作就是面向对象编程的思想。
-
编程思想
1.面向过程编程
面向过程编程的核心就是'过程'，就是将程序的执行分步操作，在分步过程中解决问题。就象我们的自行车流水线，开头
上来一个车架，放在传送带上，然后就开始装轮子，装完轮子装链条，然后就是脚踏板，然后再检验一下脚踏板的压力，然后装脚
踏板的挡板，然后就是座套，再然后就是车把，这样我们的一个自行车就完成了，就是一步一步分步操作的，中间还有很多的检查，
这样出错了就可以直接纠正，然后放在流水线上就这下一步操作。
这个例子呢就是一步一步分步的操作，在我们IT行业这样的操作就叫面向过程编程。
2.面向对象编程
面向对象编程的核心就是'对象'，'对象'其实就是一个容器，里面整合了数据和功能，满足这个条件的就是'对象'。比如
我们刚刚写的那个人狗大战的小游戏，最后把人物角色、动物角色的数据与功能整合到一起，就可以称之为面向对象编程，还比如我
们在pycharm写代码的py文件，文件里面也有功能、数据，也可以称之为面向对象编程。还比如我们人，其实就是一个对象，我们有
手有脚，就相当于数据，我们可以吃饭、跑、游泳，这就是我们的功能，当我们来跑、吃饭的时候也可以称之为面向对象编程。
面向过程编程与面向对象编程两者没有优劣之分，具体的要结合实际的业务情况，很多时候两者都是共同使用的，只是使用的比例不同。
-
类与对象的概念
我们刚刚已经讲过对象就是数据与功能的结合体。
我们再来讲讲类，见名知意就是种类、类别，比如我们经常说的犬类、人类、猫类等等，都属于一个类别，但是他们又各不相同，各自
有各自的特点，但是呢他们又有很多相似的点，‘比如随便来条狗我们都知道他是一条狗’。所以呢'类'，就是相当于很多的个体有很多
相同的特征，这里很多个体可以是很多人，组成的就是人类，也可以是很多狗，组成就是犬类;但是在IT中呢，个体就相当于对象，特
征就相当于数据、功能，所以IT中的'类'就是很多的对象具有相同特征(数据、功能)的群体。
-
类与对象的创建
#我们刚刚讲过类与对象的概念，在代码的编程中是先有类再有对象的
我们来定义一个类，然后产生对象
# 定义一个学生类
class Student:
# 学生类公共的数据
school = '复旦大学'
# 学生类公共的功能
def chooes_course(self):
print('学生选课')
'''
创建类的语法结构
class 类名:
类体代码
'''
# 1.class是定义类的关键字
# 2.类名类似于函数名，但是首字母推荐大写
# 3.类体代码就是存放对象公共数据和功能的地方(数据:变量名 = 变量值 功能:函数)
注意:类中的子代码，就是类体代码是无需调用就会执行的，然后产生类的名称空间。
类获取数据和功能的方法:dict
print(Student.__dict__) # 返回的是一个字典
print(Student.__dict__['school']) # 复旦大学 获取类中的属性
print(Student.__dict__['chooes_course']) # <function Student.chooes_course at 0x0000014DFFF7BB70> 获取类中的属性
便捷方式:局点符
print(Student.school) # 复旦大学
print(Student.chooes_course) # <function Student.chooes_course at 0x0000014DFFF7BB70>
类产生对象的方法
obj1 = Student() # 类名加括号产生对象
obj2 = Student() # 类名加括号产生对象
print(obj1.__dict__,obj2.__dict__) # {} {}
print(obj1.school) # 复旦大学
print(obj1.chooes_course) # <bound method Student.chooes_course of <__main__.Student object at 0x000001F87BCDB4A8>>
Student.school = '清华大学' # 修改类中的属性值
print(obj1.school) # 清华大学
-
对象的实例化
我们用类产生对象的时候，对象是没有自己独有的属性的:
class Student:
school = '复旦大学'
def chooes_course(self):
print('学生选课')
print(obj1.__dict__,obj2.__dict__) # {} {} 目前对象没有自己独有的属性
我们想要对象有自己独有的属性，就要添加，也就是添加键值对:
obj1.__dict__['name'] = 'oscar'
obj1.__dict__['age'] = '21'
obj2.__dict__['name'] = 'jason'
obj2.__dict__['age'] = '18'
也可以使用便捷方式添加
'''
obj1.name = 'oscar'
obj1.age = '21'
obj2.name = 'jason'
obj2.age = '18'
'''
print(obj1.__dict__,obj2.__dict__) # {'name': 'oscar', 'age': '21'} {'name': 'jason', 'age': '18'}
print(obj1.name) # oscar
print(obj2.name) # jason
我们会发现有很多冗余的代码，因为创建对象的时候可能会有很多，我们可以封装成函数:
def init(obj,name,age):
obj.name = name
obj.age = age
init(obj1,'oscar',21)
print(obj1.name) # oscar
但是呢简单的封装成函数没有提现出面向对象整合的精髓，所以我们将函数写到类中去:
class Student:
def init(obj,name,age):
obj.name = name
obj.age = age
school = '复旦大学'
def chooes_course(self):
print('学生选课')
obj1 = Student() # 类名加括号产生对象
obj2 = Student() # 类名加括号产生对象
Student.init(obj1,'oscar',21)
print(obj1.name) # oscar
类中针对给对象创建独有数据的函数名，python专门定义了一个固定的方法:
class Student:
def __init__(self,name,age):
self.name = name
self.age = age
school = '复旦大学'
def chooes_course(self):
print('学生选课')
obj1 = Student('oscar',21)
obj2 = Student('jason',18)
print(obj1.name) # oscar
print(obj2.age) # 18
'''
类中的__init__方法会在类产生对象的时候自动执行。
类创建的具体步骤:
1.先创建一个没有独有数据的空对象
2.将空对象和类括号内传入的数据一并交给__init__执行，__init__的第一个参数就是对象本身。
3.将创建好的对象自动返回
'''
-
绑定方法
在类中定义的函数默认都是绑定给对象使用的，即对象只要来调用，就会将该对象最为第一个参数传入:
class Student:
def __init__(self,name,age):
self.name = name
self.age = age
school = '复旦大学'
def course(self):
print(self)
def chooes_course(self):
print('%s找到我了' % self.name)
def chooes(self):
print('%s找到我了' % self.name)
obj1 = Student('oscar',21)
obj2 = Student('jason',18)
# 类调用类中的方法，有几个参数就需要传入几个参数
Student.course(123) # 123
# 对象调用类中的函数，会将当前调用的对象当做第一个参数自动传入
obj1.chooes_course() # oscar找到我了
这里是IT小白陆禄绯，欢迎各位大佬的指点！！！
浙公网安备 33010602011771号