020_面向对象

Posted 2021-02-13 eternity-twinkle

1，面向对象 、面向过程

　　1.1，面向过程：就像解数学题一样，针对要解决的问题按照解题过程，解题步骤编写程序

 

　　　　优点是：极大的降低了写程序的复杂度，只需要顺着要执行的步骤，堆叠代码即可。

　　　　缺点是：一套流水线或者流程就是用来解决一个问题，代码牵一发而动全身。

　　1.2，面向对象：以现实世界为映像，针对具体的事物进行编程

　　　　以现实世界为映像，将就具有同种属性，行为的归为一类，就像名词，人、猫、笔，等；对于类中的每一个具体的事物，即个体称为对象，就像 ，人有张三、李四。

　　　　类：是对象的抽象化

　　　　对象：是类的具体化，实例化；

　　　　实例化：就是通过类属性，建造一个具体的事即对象的过程。例如：通过人这个类创建张三，李四等一个个具体的人物(即对象）的过程。

　　　　优点是：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。

　　　　缺点：可控性差，无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法预测最终结果。于是我们经常看到一个游戏人某一参数的修改极有可能导致阴霸的技能出现，一刀砍死3个人，这个游戏就失去平衡。

2，面向对象引导

　　通过面向对象的思想，用面向过程的编程方式编写。

    # 人狗大战
def Dog(name,blood,aggr,kind):
    dog = {
        ‘name‘: name,
        ‘blood‘: blood,  # 血量
        ‘aggr‘: aggr,  # 攻击力
        ‘kind‘: kind,
    }
    def bite(person):
        person[‘blood‘] -= dog[‘aggr‘]
        print(‘%s被咬了，掉了%s的血‘ % (person[‘name‘], dog[‘aggr‘]))
    dog[‘bite‘] = bite
    return dog


def Person(name,blood,aggr,sex):
    person = {
        ‘name‘ : name,
        ‘blood‘: blood,   # 血量
        ‘aggr‘: aggr,      # 攻击力
        ‘sex‘:sex,
    }
    def attack(dog):
        dog[‘blood‘] -= person[‘aggr‘]
        print(‘%s被打了，掉了%s的血‘ % (dog[‘name‘], person[‘aggr‘]))
    person[‘attack‘] = attack
    return person

#以上创建了两个模型，就是面向对象所说的类

jin = Dog(‘金老板‘,1000,100,‘teddy‘)    #面向对象所说的实例化，jin即为对象
alex = Person(‘狗剩儿‘,100,1,‘不详‘)
nezha = Person(‘哪吒‘,200,2,‘不详‘)
print(jin)
jin[‘bite‘](alex)
alex[‘attack‘](jin)
# 直到调用了函数，赋值了之后才真的有了一个实实在在的人或狗

3，定义一个简单的类

class 类名：
    属性 = ‘a‘

print(类名.属性)

• 类名为与python中的函数名区分，一般第一个字母大写
• 类名的作用 就是操作属性 查看属性

4，对象属性

　　4.1，

class Person:         #不能象函数那样定义参数，传参；而是通过‘__init__()‘传参；
     def __init__(self,*args):    #初始化方法，调用这个类创建对象时，会自动执行；
	print(args)

alex = Person(‘狗剩儿‘,100,1,‘不详‘)	#类的实例化，即创建实体对象

　　4.2，

class Person:        
     def __init__(self,*args):  # self就是一个可以存储很多属性的大字典；必须传参数
	self.name = args[0]   # 往字典里添加属性的方式发生了一些变化
        self.hp = args[1]
        self.aggr = args[2]
        self.sex = args[3]
# 	 print(alex.__dict__) # 查看所有属性 ，是一个字典

alex = Person(‘狗剩儿‘,100,1,‘不详‘)
print(alex) #是一个地址 
print(alex.name)  # 查看属性值

　　4.3，用函数的方式解释下上面的类函数

def Person(*args,**kwargs):
    self = {}
    def attack(self,dog):
        dog[‘life_value‘] -= self[‘aggressivity‘]

    def __init__(name,aggressivity,life_value):
        self[‘name‘] = name
        self[‘aggressivity‘] = aggressivity
        self[‘life_value‘] = life_value
        self[‘attack‘] = attack

    __init__(*args,**kwargs)
    return self

egg = Person(‘egon‘,78,10)
print(egg[‘name‘])

5，添加方法 （一类事物具有的行为）

class Person:        
     def __init__(self,*args):  # self就是一个可以存储很多属性的大字典
	self.name = args[0]   # 往字典里添加属性的方式发生了一些变化
        self.hp = args[1]
        self.aggr = args[2]
        self.sex = args[3]
     def walk(self):
	print(‘走走‘)

alex = Person(‘狗剩儿‘,100,1,‘不详‘)
print(alex)	#是一个地址
alex.walk(alex)  #实例对象调用方法：“对象名.方法名(参数)”  
# Person.walk(alex)  #可以这样调用方法，但不是对象调用，不要用。	
print(alex.name)  # 查看属性值

6，类，对象中的属性问题

　　6.1，类，对象的属性都是用字典保存的，可以用字典的方法。但类的属性属于静态变量，不能修改。

一：我们定义的类的属性到底存到哪里了？有两种方式查看
dir(类名)：查出的是一个名字列表
类名.__dict__:查出的是一个字典，key为属性名，value为属性值

二：特殊的类属性
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类(在讲继承时会讲)
类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)

　　

print(Person.__dict__) #类的字典
print(alex.__dict__)	#对象的字典

# __dict__ 对于对象的增删改查操作都可以通过字典的语法进行
print(Person.__dict__[‘country‘])
Person.__dict__[‘country‘] = ‘印度‘
print(alex.__dict__[‘name‘])
alex.__dict__[‘name‘] = ‘二哥‘
print(alex.name)

#其实面向对象可以通过下面的方法进行上面的操作
print(alex.name)
alex.name = ‘二哥‘
alex.age = 83
print(alex.name)