面向对象之基础

一 类和对象

 什么是面向对象的程序设计及为什么要有它

面向过程的程序设计的核心是过程（流水线式思维），过程即解决问题的步骤，面向过程的设计就好比精心设计好一条流水线，考虑周全什么时候处理什么东西。

优点是：极大的降低了程序的复杂度

缺点是：一套流水线或者流程就是用来解决一个问题，生产汽水的流水线无法生产汽车，即便是能，也得是大改，改一个组件，牵一发而动全身。

应用场景：一旦完成基本很少改变的场景，著名的例子有Linux內核，git，以及Apache HTTP Server等。

面向对象的程序设计的核心是对象（上帝式思维），要理解对象为何物，必须把自己当成上帝，上帝眼里世间存在的万物皆为对象，不存在的也可以创造出来。面向对象的程序设计好比如来设计西游记，如来要解决的问题是把经书传给东土大唐，如来想了想解决这个问题需要四个人：唐僧，沙和尚，猪八戒，孙悟空，每个人都有各自的特征和技能（这就是对象的概念，特征和技能分别对应对象的数据属性和方法属性），然而这并不好玩，于是如来又安排了一群妖魔鬼怪，为了防止师徒四人在取经路上被搞死，又安排了一群神仙保驾护航，这些都是对象。然后取经开始，师徒四人与妖魔鬼怪神仙交互着直到最后取得真经。如来根本不会管师徒四人按照什么流程去取。

面向对象的程序设计的

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

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

应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方

面向对象的程序设计并不是全部。对于一个软件质量来说，面向对象的程序设计只是用来解决扩展性。

　1 什么是面向对象：面向对象就是一种编程思想。

　2 什么是类：一堆事物中拥有的共同功能和属性，比如说人类，动物类等等

　3 什么是对象：在类下面的调用者就是对象，比如说动物是一类，他下面的对象有猪，狗，猫等等

　　先有对象还是先有类：在现实生活中是先有对象，然后在根据这些对象而产生了类。在编程中是先有类，再有对象的。在python中，一切皆为对象

　　类是实例的抽象，父类是子类的抽象。而对象是类中方法或属性实例出来的。

在python中以为皆为对象，而类型的本身就是一个类

二 创建类和对象

  1 对象也就是一种封装的思想，不过这种思想要先进一步，对象的来源是模拟真是世界，把数据和代码封装在了一起。

  2 定义了对象的特征（变量）和技能（函数），但还不是一个完整的对象，将定义的这些称为类（class）。需要类来创建一个真正的对象，这个对象就叫做这个类的以恶实例（instance），也叫实例对象（instance objects）

  3python中一切皆为对象，且python3统一了类与类型的概念，类型就是类，所以，不管你信不信，你已经使用了很长时间的类了

1 >>> dict #类型dict就是类dict
2 <class 'dict'>
3 >>> d=dict(name='egon') #实例化
4 >>> d.pop('name') #向d发一条消息，执行d的方法pop
5 'egon'

　　

基于面向对象设计一个款游戏：英雄联盟，每个玩家选一个英雄，每个英雄都有自己的特征和和技能，特征即数据属性，技能即方法属性，特征与技能的结合体就一个对象。

　　从一组对象中提取相似的部分就是类，类所有对象都具有的特征和技能的结合体

　　在python中，用变量表示特征，用函数表示技能，因而类是变量与函数的结合体，对象是变量与方法（指向类的函数）的结合体

　　

　　补充几个有意思的点：

　　garen_hero.Q()称为向garen_hero这个对象发送了一条消息，让他去执行Q这个函数，完成一个功能，类似的有：

　　garen_hero.W()

　　garen_hero.E()

　　garen_hero.R()

　　一个英雄可以攻击另外一个英雄，这就是对象之间的交互

　　garen_hero.attack(Riven)

　基本格式

class 类名：
    类属性=什么  （类属性可有可无）
    def __init__(self,参数)：   （self参数是必须要有的，其他的参数可有可无，自己定义参数的个数）
        pass
    def 函数名（self）：      （self参数是必须要有的，其他的参数可有可无，自己定义参数的个数）
        pass　

  初识类

    在python中声明函数与声明类很相似

        声明函数

1 def functionName(args):
2      '函数文档字符串'
3       函数体 

        声明类

 1 '''
 2 class 类名:
 3     '类的文档字符串'
 4     类体
 5 '''
 6 
 7 #我们创建一个类
 8 class Data:
 9     pass 

   类有两种作用：属性引用和实例化

   属性引用（类名.属性）

>>> Garen.camp #引用类的数据属性，该属性与所有对象/实例共享
'Demacia'
>>> Garen.attack #引用类的函数属性，该属性也共享
<function Garen.attack at 0x101356510>
>>> Garen.name='Garen' #增加属性
>>> del Garen.name #删除属性

    实例化（__init__与self）

        类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征

class Garen:        #定义英雄盖伦的类，不同的玩家可以用它实例出自己英雄;
    camp='Demacia'  #所有玩家的英雄(盖伦)的阵营都是Demacia;
    def __init__(self,nickname,aggressivity=58,life_value=455): #英雄的初始攻击力58...;
        self.nickname=nickname  #为自己的盖伦起个别名;
        self.aggressivity=aggressivity #英雄都有自己的攻击力;
        self.life_value=life_value #英雄都有自己的生命值;
    def attack(self,enemy):   #普通攻击技能，enemy是敌人;
        enemy.life_value-=self.aggressivity #根据自己的攻击力，攻击敌人就减掉敌人的生命值

    实例化：类名+括号

>>> g1=Garen('草丛伦') #就是在执行Garen.__init__(g1,'草丛伦')，然后执行__init__内的代码g1.nickname=‘草丛伦’等

        self的作用是在实例化时自动将对象/实例本身传给__init__的第一个参数，self可以是任意名字，但是瞎几把写别人就看不懂了。

        这种自动传递的机制还体现在g1.attack的调用上，后续会介绍。

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

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

    创建对象和调用类

对象=类名（这里写上你对应的参数值，self不用传值）
调用方法：
对象.函数名（）

 在这里每一个类里面都必须要有一个__init__(self)这个函数的功能。他的功能是实例化一个对象

　类属性属于静态属性，而函数属性就属于动态的属性

类：类名.类属性

　　类名.类方法    (但不能调用)

对象：对象名.对象属性  对象名.类属性

　　　对象名.方法()   （调用方法，也叫做调用动态属性） 

基本实例：1

# class People:
#     def __init__(self,name,age,sex,gong):
#         self.name=name
#         self.age=age
#         self.sex=sex
#         self.gong=gong
#     def caozuo(self):
#         print('%s,%s,%s,%s'%(self.name,self.age,self.sex,self.gong))
# dui1=People('小明',18,'男','12345，上山打老虎，老虎不在家，放屁是你妈')
# dui5=People('小明',18,'男','床前明月光，衣服全脱光，举头望明月，低头看裤裆')



# class People:
#     def __init__(self,name,age,sex='男'):
#         self.name=name
#         self.age=age
#         self.sex=sex
#     def kanchai(self):
#         print('%s,%s岁,%s，上山去砍柴'%(self.name,self.age,self.sex))
#         print('%s,%s岁,%s，开车去东北' % (self.name, self.age, self.sex))
#         print('%s,%s岁,%s，最爱大保健' % (self.name, self.age, self.sex))
# dui1=People('小明',18)
# dui5=People('小明',18)
# dui1.kanchai()
# dui5.kanchai()

 实例2：

# class People:
#     def __init__(self,name,sex,aggr):
#         self.name=name
#         self.sex=sex
#         self.aggr=aggr
#         self.blood=20000
#     def attack(self,person):
#         print('%s attack %s'%(self.name,person.name))
#         person.blood-=self.aggr
#         print(person.blood)
# alex=People('alex','female',1)
# egon=People('egon','male',20000)
# alex.attack(egon)
# print('你敢打我，找死')
# egon.attack(alex)
# print('KO')

 实例3：面向对象之间的交换

# class People:
#     def __init__(self,name,sex,aggr):
#         self.name=name
#         self.sex=sex
#         self.aggr=aggr
#         self.blood=20000
#     def attack(self,dog):
#         print('%s attack %s'%(self.name,dog.name))
#         dog.blood-=self.aggr
#         print(dog.blood)
# class Dog:
#     def __init__(self,name,sex,aggr):
#         self.name=name
#         self.sex=sex
#         self.aggr=aggr
#         self.blood=20000
#     def yao(self,person):
#         print('%s yao %s'%(self.name,person.name))
#         person.blood-=self.aggr
#         print(person.blood)
# alex=Dog('alex','female',1)
# egon=People('egon','male',20000)
# alex.yao(egon)
# print('你敢敢咬我，找死')
# egon.attack(alex)
# print('KO')

 什么叫做面向对象之间的交互：在多个面向对象之间互相的调用，就叫在面向对象的交互

实例4 ：计算面积和周长：

import math
class Yuan:
    def __init__(self,ban):
        self.ban=ban
    def mian(self):
        print('圆的面积是%s'% (math.pi*self.ban**2))
    def zhou(self):
        print('圆的周长是%s'%(math.pi*2*self.ban))
yuan_1=Yuan(3)
yuan_1.mian()
yuan_1.zhou()

 补充：

 对象相关知识

对象是关于类而实际存在的一个例子，即实例

>>> g1=Garen('草丛伦') #类实例化得到g1这个实例，基于该实例我们讲解实例相关知识
>>> type(g1) #查看g1的类型就是类Garen
<class '__main__.Garen'>
>>> isinstance(g1,Garen) #g1就是Garen的实例
True

 对象/实例只有一种作用：属性引用  

#对象/实例本身其实只有数据属性
>>> g1.nickname
'草丛伦'
>>> g1.aggressivity
58
>>> g1.life_value
455
'''
查看实例属性
同样是dir和内置__dict__两种方式
特殊实例属性
__class__
__dict__
....
'''

对象/实例本身只有数据属性，但是python的class机制会将类的函数绑定到对象上，称为对象的方法，或者叫绑定方法，绑定方法唯一绑定一个对象，同一个类的方法绑定到不同的对象上，属于不同的方法，内存地址都不会一样

>>> g1.attack #对象的绑定方法
<bound method Garen.attack of <__main__.Garen object at 0x101348dd8>>

>>> Garen.attack #对象的绑定方法attack本质就是调用类的函数attack的功能，二者是一种绑定关系
<function Garen.attack at 0x101356620>

对象的绑定方法的特别之处在于：obj.func()会把obj传给func的第一个参数。

对象之间的交互

对象是关于类而实际存在的一个例子，即实例

>>> g1=Garen('草丛伦') #类实例化得到g1这个实例，基于该实例我们讲解实例相关知识
>>> type(g1) #查看g1的类型就是类Garen
<class '__main__.Garen'>
>>> isinstance(g1,Garen) #g1就是Garen的实例
True

 对象/实例只有一种作用：属性引用  

#对象/实例本身其实只有数据属性
>>> g1.nickname
'草丛伦'
>>> g1.aggressivity
58
>>> g1.life_value
455
'''
查看实例属性
同样是dir和内置__dict__两种方式
特殊实例属性
__class__
__dict__
....
'''

对象/实例本身只有数据属性，但是python的class机制会将类的函数绑定到对象上，称为对象的方法，或者叫绑定方法，绑定方法唯一绑定一个对象，同一个类的方法绑定到不同的对象上，属于不同的方法，内存地址都不会一样

>>> g1.attack #对象的绑定方法
<bound method Garen.attack of <__main__.Garen object at 0x101348dd8>>

>>> Garen.attack #对象的绑定方法attack本质就是调用类的函数attack的功能，二者是一种绑定关系
<function Garen.attack at 0x101356620>

对象的绑定方法的特别之处在于：obj.func()会把obj传给func的第一个参数。

类名称空间与对象/实例名称空间

创建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性

而类有两种属性：数据属性和函数属性

其中类的数据属性是共享给所有对象的

>>> id(r1.camp) #本质就是在引用类的camp属性，二者id一样
4315241024
>>> id(Riven.camp)
4315241024

而类的函数属性是绑定到所有对象的：

>>> id(r1.attack) 
4302501512
>>> id(Riven.attack)
4315244200

'''
r1.attack就是在执行Riven.attack的功能，python的class机制会将Riven的函数属性attack绑定给r1，r1相当于拿到了一个指针，指向Riven类的attack功能

除此之外r1.attack()会将r1传给attack的第一个参数
'''

创建一个对象/实例就会创建一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性

在obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常