编程范式

编程是 程序 员 用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程 ， 一个程序是程序员为了得到一个任务结果而编写的一组指令的集合，正所谓条条大路通罗马，实现一个任务的方式有很多种不同的方式， 对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别，即为编程范式。 不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路， 大多数语言只支持一种编程范式，当然也有些语言可以同时支持多种编程范式。 两种最重要的编程范式分别是面向过程编程和面向对象编程。

面向过程编程(Procedural Programming)
Procedural programming uses a list of instructions to tell the computer what to do step-by-step. 
面向过程编程依赖 - 你猜到了- procedures，一个procedure包含一组要被进行计算的步骤， 面向过程又被称为top-down languages， 就是程序从上到下一步步执行，一步步从上到下，从头到尾的解决问题 。基本设计思路就是程序一开始是要着手解决一个大的问题，然后把一个大问题分解成很多个小问题或子过程，这些子过程再执行的过程再继续分解直到小问题足够简单到可以在一个小步骤范围内解决。

这样做的问题也是显而易见的，就是如果你要对程序进行修改，对你修改的那部分有依赖的各个部分你都也要跟着修改， 举个例子，如果程序开头你设置了一个变量值 为1 ， 但如果其它子过程依赖这个值 为1的变量才能正常运行，那如果你改了这个变量，那这个子过程你也要修改，假如又有一个其它子程序依赖这个子过程 ， 那就会发生一连串的影响，随着程序越来越大， 这种编程方式的维护难度会越来越高。 
所以我们一般认为， 如果你只是写一些简单的脚本，去做一些一次性任务，用面向过程的方式是极好的，但如果你要处理的任务是复杂的，且需要不断迭代和维护 的， 那还是用面向对象最方便了。

封装

封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。

封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

class Role(object):
    n = 123 #类变量,大家公用的属性，节省开销
    n_list=[]
    def __init__(self,name,role,weapon,life_value=http://www.mamicode.com/1000,money=500):
        #构造函数
        #在实例化时做一些类的初始化工作
        self.name=name#实例变量（静态属性），作用域就是实例本身
        self.role=role
        self.weapon=weapon
        self.__life_value=http://www.mamicode.com/life_value
        self.money=money
    def __del__(self):
        print("龙哥是我偶像！！！")
    def shot(self):
        print("name :%s weapon :%s life_val:%s" %(self.name,self.weapon,self.__life_value))

    def __got_shot(self):
        #print("{name} got shot".format(name=self.name))
        self.__life_value -=10
    def buy_gun(self,gun_name):
        print(" %s just bought %s" %(self.name,self.weapon))
      #  __got_shot(self)

r1 = Role("Tom","police","AK47")
#print(r1.liefe_value)
r1.buy_gun("AK47")
r2 = Role("Jack","teor","B22")

# r1.n=100
# r1.n2=456
#del Role.n
# r1.n_list.append("from r1")
# r2.n_list.append("from r2")
# print(r1.n,r1.n2)
# print(r2.n)
# print(Role.n)
# print(r1.n_list)
# print(Role.n_list)

继承

面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

通过继承创建的新类称为“子类”或“派生类”。

被继承的类称为“基类”、“父类”或“超类”。

继承的过程，就是从一般到特殊的过程。

要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。

在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。

继承概念的实现方式有三类：实现继承、接口继承和可视继承。

在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。

OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。

class People:
    def __init__(self,name):
        self.name=name
    def eat(self):
        print("{name} is eating !".format(name=self.name))
    def sleep(self):
        print("{name} is sleeping ".format(name=self.name))

class Relation(object):
    def make_friends(self,obj):
        print("%s is making friends with %s" %(self.name,obj.name))

class man(People,Relation):
    def eat(self):
        People.eat(self)
        print("eating from class man")

    def piao(self):
        print("%s is piaoing " % self.name)
class women (People):

    def birth(self):
        print ("%s is giving birth" % self.name)
m1=man("Tom")
f1=women("Jane")
m1.make_friends(f1)
# m1.eat()
# f1.birth()

三.多态

多态