020_面向对象

1，面向对象 、面向过程

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

　　　　优势是：极大的下降了写程序的复杂度，只须要顺着要执行的步骤，堆叠代码便可。

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

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

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

　　　　类：是对象的抽象化

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

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

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

　　　　缺点：可控性差，没法向面向过程的程序设计流水线式的能够很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，即使是上帝也没法预测最终结果。因而咱们常常看到一个游戏人某一参数的修改极有可能致使霸道的技能出现，一刀砍死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(self.__dict__)	# 查看全部属性 ，是一个字典

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

# {'name': '狗剩儿', 'hp': 100, 'aggr': 1, 'sex': '不详'}
# <__main__.Person object at 0x0000027E82A034E0>
# 狗剩儿

　　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()  #实例对象调用方法：“对象名.方法名(参数)”  
# 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)