Python之路-python(面向对象一)

一、面向对象介绍

二、为什么要用面向对象开发

三、封装、继承、多态、类、方法

　　面向过程和面向对象的区别

　　编程范式：

　　　　一般情况下，拿到一个项目不同的两个人有不同的编写方式（相同的是固定的语法、数据结构）。对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别，就是编程范式。不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路， 大多数语言只支持一种编程范式，当然也有些语言可以同时支持多种编程范式。 两种最重要的编程范式分别是面向过程编程和面向对象编程。

　　面向过程（Procedural Programming）：

　　　　所谓的面向过程，就是为了完成一个需求，将一个大的需求，分成不同的模块，甚至更小的模块（方法）里面，然后程序从上往下一步一步的完成计算执行。一般学基础的同学都这么写，但是有个问题存在。大家写的都是一个模块（方法）调用下一个模块的结果，可能多个方法都取一个函数的执行结果。试想一下，如果我需要增加或减少一个功能，凡是调用这个函数（方法）结果的函数都需要进行修改。这样傻瓜式的编写过程特别不实用，如果写脚本还能凑合着用。如果做个项目呢，经常有不同的需求，这样的话等于在给自己挖坑。这就可以理解为是面向过程编程。

　　面向对象（Object-Oriented Programming ）：

　　　　OOP编程就是“类”和“对象”来创建各种模型来实现对真实世界的描述，使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

　　　　世界万物，皆可分类。世界万物，皆为对象。只要是对象，就肯定属于某种品类。只要是对象，就肯定有属性。

　　面向对象特性：

　　Class 类
　　　　一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象的都具备的属性、共同的方法。其实就是把多个有相同属性的事物抽象出来，然后定义一个类别。

　　Object 对象 
　　　　一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之前有共性，亦有不同。其实就是定义一个类以后，你类里面给这个事物定义的一些方法（其实就是属性）。定义好类了，得实现吧，例如这个类就是造机器，造出的机器就是对象，也就是实例。

　　Encapsulation 封装
　　　　在类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法。封装就是把内部不想给外部看到的数据进行封锁，只有内部可以查看调用，外部找不到。

　　Inheritance 继承
　　　　一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承

　　Polymorphism 多态
　　　　态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。
　　　　编程其实就是一个将具体世界进行抽象化的过程，多态就是抽象化的一种体现，把一系列具体事物的共同点抽象出来, 再通过这个抽象的事物, 与不同的具体事物进行对　话。

　　　　举个列子：发送一个指令，比如说我是老板要建一栋楼房。销售要去卖楼房，承包商要买材料，承包商要找工人。我只说句话，他家都分头开始工作，而不是我要一个一个的去督促说明。

 class Dos:#定义一个类狗
     def bulk(self):#类里面有对象狗，会叫吧
         print("叫一声")#具体怎么叫

 d1 = Dos()#生成一条狗
 d2 = Dos()#再生成一条狗
 d3 = Dos()#再来一条狗

 d1.bulk()#狗1叫
 d2.bulk()#狗2叫
 d3.bulk()#狗3叫
 >>>叫一声
 >>>叫一声
 >>>叫一声
简单的一个类就定义完了

 class Dos:
     def __init__(self,name):#这个类实例化，其实就是给类传值
         self.name = name

     def bulk(self):
         print("%s叫一声"%self.name)

 d1 = Dos("狗一")
 d2 = Dos("狗二")
 d3 = Dos("狗三")

 d1.bulk()
 d2.bulk()
 d3.bulk()
 >>>狗一叫一声
 >>>狗二叫一声
 >>>狗三叫一声

 类变量和实例变量的优先
 #!/usr/bin/env python
 class Person(object):
     n = 234#类变量
     def __init__(self,name,age):
         self.name = name
         self.age = age
         self.n = 123#实例变量

     def Leader(self):
         print("这里是定义领导[%s]的方法"%self.name)

 r1 = Person("哈哈哈","")#传参数给类，让它实例化

 print(r1.name,r1.n,r1.age)#打印实例参数，如果我把self.n注释掉，它肯定会去类变量取到值为234这个变量。所以得出，先找实例变量，再找类变量。
 print(Person.n)#打印类变量的方法
 >>>哈哈哈 123 11
 >>>234

 #为什么要用类变量呢，有人说我可以在初始化时候给他定义一个默认参数如下，def __init__(self,name,age,n = "baidu"),
 如果这是一个百度公司的员工信息表，我只需要每次给每个人引用n这个变量就可以给他加上说，昂，这是百度公司，但你要是直接写人默认参数，他每次都要初始化一次，这样效率明显降低。
 class Person(object):
     n = "baidu"#类变量
     def __init__(self,name,age):
         self.name = name
         self.age = age

     def Leader(self):
         print("这里是定义领导[%s]的方法"%self.name)
         print(Person.n)

 r1 = Person("哈哈哈","")
 d1 = r1.Leader()

　　析构函数：

　　　　在实例释放、销毁的时候执行。通常做一些收尾工作。例如，程序执行完毕后，关闭数据库连接等收尾工作。

　　

#析构函数，首先给类传参，执行里面一个方法，然后删除r1，然后再定义r2给类传参，再执行里面的一个方法。看结果。。
class Person(object):
    n = "baidu"#类变量
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __del__(self):
        print("程序执行完毕")

    def Leader(self):
        print("这里是定义领导[%s]的方法"%self.name)

r1 = Person("哈哈哈","")
d1 = r1.Leader()
del  r1
r2 = Person("呵呵","")
d1 = r2.Leader()
>>>这里是定义领导[哈哈哈]的方法
>>>程序执行完毕#del r1的结果，我们说了析构函数是实例释放或销毁时候执行，所以当销毁r1是后，自动执行了析构函数
>>>这里是定义领导[呵呵]的方法
>>>程序执行完毕#同上，在实例执行结尾的时候执行

　　私有属性：

　　　　我们知道有些参数我们只想让内部更改，外部职能看（当然内部也是可以更改的），那怎么办的，我们就用到了私有属性。

 class Person(object):
     n = "baidu"#类变量
     def __init__(self,name,age,money):
         self.name = name
         self.age = age
         self.__money = money

     def Leader(self):
         print("领导%s 工龄%s年 月薪%s元"%(self.name,self.age,self.__money))

 r1 = Person("A","",30000)
 d1 = r1.Leader()
 >>>领导A 工龄11年 月薪30000元
 r1.name = "B"
 r1.age =  33#更改了工龄，看结果也执行成功了
 r1.__money  = ""#把月薪该一下，我靠，前面加了__就上天了，不让改了，这下明白私有属性了吧
 d1 = r1.Leader()
 >>>领导B 工龄33年 月薪30000元

 class Person(object):
     n = "baidu"#类变量
     def __init__(self,name,age,money):
         self.name = name
         self.age = age
         self.__money = money

     def Leader(self):
         print("领导%s 工龄%s年 月薪%s元"%(self.name,self.age,self.__money))

     def Change(self):
         pass

 r1 = Person("A","",30000)
 # d1 = r1.Leader()
 print(r1.name,r1.age)
>>>A 11
 print(r1.__money)#AttributeError: 'Person' object has no attribute '__money',提示没有该属性

问题来了，那如果我非要改这个属性该怎么办呢？

 #外部查看修改不了，我就在类的内部定义一个方法，让它在内部更改
我们知道属性分静态属性（就是变量）和动态属性（其实就是类下面的方法）

 class Person(object):
     n = "baidu"#类变量
     def __init__(self,name,age,money):
         self.name = name
         self.age = age
         self.__money = money#在属性名前加两个下滑线

     def Leader(self):
         print("领导%s 工龄%s年 月薪%s元"%(self.name,self.age,self.__money))

     def Change(self):#定义的方法可以访问私有属性
         self.__money -= 10000
         print("领导%s表现不好 工龄%s  月薪涨到%s"%(self.name,self.age,self.__money))

 r1 = Person("A","",30000)
 d1 = r1.Change()
>>>>领导A表现不好 工龄11  月薪涨到20000
这就相当于封装了。

　　

　　私有方法：
　　　　说白了就是在类内部定义方法，只不过就是这个方法外部访问调用不了。我们知道私有属性是在属性前加两个下划线。那方法也是

　

 class Person(object):
     n = "baidu"#类变量
     def __init__(self,name,age,money):
         self.name = name
         self.age = age
         self.__money = money

     def Leader(self):
         print("领导%s 工龄%s年 月薪%s元"%(self.name,self.age,self.__money))

     def __Change(self):
         self.__money -= 10000
         print("领导%s表现不好 工龄%s  月薪涨到%s"%(self.name,self.age,self.__money))

 r1 = Person("A","",30000)
 d1 = r1.Change()
 》》》AttributeError: 'Person' object has no attribute 'Change'
 方法前加了两个下划线外部就访问不了了

　　继承：

　　　　

 class People(object):
     def __init__(self,name,age):
         self.name = name
         self.age = age

     def eat(self):
         print("%s eating %s"%(self.name,self.age))

     def sleep(self):
         print("%s sleep %s"%(self.name,self.age))

 class Man(People):#括号了写的是继承谁，就写谁是父类
     pass

 m1 = Man("zhangsan",33)
 m1.eat()
 #简单的继承，我给类Man传两个参数
 执行类People里面的eat方法

 class People(object):
     def __init__(self,name,age):
         self.name = name
         self.age = age

     def eat(self):
         print("%s eating %s"%(self.name,self.age))

     def sleep(self):
         print("%s sleep %s"%(self.name,self.age))

 class Man(People):#父类写了人的两个共性，吃喝睡，凡是人都需要吃喝睡。
     def Write_code(self):
         print("name:%s write code %s行 "%(self.name,self.age))

 m1 = Man("zhangsan",33)#我给类Man传参数，但是他继承的是People类，所以也就等于这里是给People传参数，但它继承了People类，所以这里就等于给自己传参数
 m1.eat()
 m1.Write_code()#男人需要干嘛呢，写代码。
 >>>zhangsan eating 33
 >>>name:zhangsan write code 33行 

#如果我在父类里面定义了一个eat，但是我子类里面再定义一个eat，他会执行谁呢？
class People(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def eat(self):
        print("%s eating %s"%(self.name,self.age))

    def sleep(self):
        print("%s sleep %s"%(self.name,self.age))

class Man(People):#父类写了人的两个共性，吃喝睡，凡是人都需要吃喝睡。
    def Write_code(self):
        print("name:%s write code %s行 "%(self.name,self.age))

    def eat(self):
        print("eating。。。。。。。。")

m1 = Man("zhangsan",33)
m1.eat()
m1.Write_code()
>>>eating。。。。。。。。#答案告诉我们，执行的是子类里面的eat
>>>name:zhangsan write code 33行 

 #如果我不想单独执行父类里面的方法，或者单独执行子类里面的方法。我想让他们同时开始工作
 class People(object):
     def __init__(self,name,age):
         self.name = name
         self.age = age

     def eat(self):
         print("%s eating %s"%(self.name,self.age))

     def sleep(self):
         print("%s sleep %s"%(self.name,self.age))

 class Man(People):#父类写了人的两个共性，吃喝睡，凡是人都需要吃喝睡。
     def Write_code(self):
         print("name:%s write code %s行 "%(self.name,self.age))

     def eat(self):
         People.eat(self)#只需要在这里加上父类的相同方法
         print("eating。。。。。。。。")

 m1 = Man("zhangsan",33)
 m1.eat()
 >>>zhangsan eating 33
 >>>eating。。。。。。。。

#首先定义了一个父类，下面定义两个子类（男人和女人）
class People(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def eat(self):
        print("%s eating %s"%(self.name,self.age))

    def sleep(self):
        print("%s sleep %s"%(self.name,self.age))

class Man(People):#父类写了人的两个共性，吃喝睡，凡是人都需要吃喝睡。
    def Write_code(self):
        print("name:%s write code %s行 "%(self.name,self.age))

    def eat(self):
        People.eat(self)
        print("eating。。。。。。。。")

class Woman(People):
    def shopping(self):
        print("name:%s go shopping %s行 "%(self.name,self.age))

m1 = Man("zhangsan",33)
m1.eat()
m1.Write_code()
w1 = Woman("lisi",23)
w1.shopping()

>>>zhangsan eating 33
>>>eating。。。。。。。。
>>>name:zhangsan write code 33行
>>>name:lisi go shopping 23行 

重构：

 class People(object):
     def __init__(self,name,age):
         self.name = name
         self.age = age

     def eat(self):
         print("%s eating %s"%(self.name,self.age))

     def sleep(self):
         print("%s sleep %s"%(self.name,self.age))

 class Man(People):#父类写了人的两个共性，吃喝睡，凡是人都需要吃喝睡。
     def __init__(self,name,age,money):#我想在Man这个子类里面再单独添加一个参数，但如果直接在父类里面添加的话，Woman这个子类也就跟着添加了，但是我只想子啊Man类里面添加这个参数。所以涉及到了重构，单独给Man这个类添加一个参数
         People.__init__(self,name,age)
         self.money = money
         print("name ：%s age ：%s %s元"%(self.name,self.age,self.money))

     def Write_code(self):
         print("name:%s write code %s行 "%(self.name,self.age))

     def eat(self):
         People.eat(self)
         print("eating。。。。。。。。")

 class Woman(People):
     def shopping(self):
         print("name:%s go shopping %s行 "%(self.name,self.age))

 m1 = Man("zhangsan",33,10000)
 m1.eat()
 >>>name ：zhangsan age ：33 10000元
 >>>>zhangsan eating 33
 >>>>eating。。。。。。。。

 #!/usr/bin/env python
 class People(object):
     def __init__(self,name,age):
         self.name = name
         self.age = age

     def eat(self):
         print("%s eating %s"%(self.name,self.age))

     def sleep(self):
         print("%s sleep %s"%(self.name,self.age))

 class Man(People):#父类写了人的两个共性，吃喝睡，凡是人都需要吃喝睡。
     def __init__(self,name,age,money):
         # People.__init__(self,name,age)#这样的话我需要知道父类的名称，如果继承的多的话，我就全部都得改
         super(Man,self).__init__(name,age)#super诞生后，我们就不用考虑父类名称
         self.money = money
         print("name ：%s age ：%s %s元"%(self.name,self.age,self.money))

     def Write_code(self):
         print("name:%s write code %s行 "%(self.name,self.age))

     def eat(self):
         People.eat(self)
         print("eating。。。。。。。。")

 class Woman(People):
     def shopping(self):
         print("name:%s go shopping %s行 "%(self.name,self.age))

 m1 = Man("zhangsan",33,10000)
 m1.eat()
 w1 = Woman("lisi",23)
 w1.shopping()
 >>>name ：zhangsan age ：33 10000元
 >>>zhangsan eating 33
 >>>eating。。。。。。。。
 >>>name:lisi go shopping 23行 

　　多继承：

 class People(object):
     def __init__(self,name,age):
         self.name = name
         self.age = age

     def eat(self):
         print("%s eating %s"%(self.name,self.age))

     def sleep(self):
         print("%s sleep %s"%(self.name,self.age))

 class Relatione(object):#定义一个交朋友的类
     def make_friends(self,obj):
         print("%s 跟 %s 交朋友"%(self.name,obj.name))

 class Man(People,Relatione):#父类写了人的两个共性，吃喝睡，凡是人都需要吃喝睡。
     def __init__(self,name,age,money):
         # People.__init__(self,name,age)#这样的话我需要知道父类的名称，如果继承的多的话，我就全部都得改
         super(Man,self).__init__(name,age)#super诞生后，我们就不用考虑父类名称
         self.money = money

     def Write_code(self):
         print("name:%s write code %s行 "%(self.name,self.age))

     def eat(self):
         People.eat(self)
         print("eating。。。。。。。。")

 class Woman(People,Relatione):
     def shopping(self):
         print("name:%s go shopping %s行 "%(self.name,self.age))

 m1 = Man("zhangsan",33,10000)
 w1 = Woman("lisi",23)
 m1.make_friends(w1)
>>>zhangsan 跟 lisi 交朋友

　　

　　新式类和经典类的区别：

　　　　新式类：

　　　　class name（object）：

class B(A):
    pass
    # def __init__(self):
    #     print("B")

class C(A):
    # def __init__(self):
    #     print("C")

class D(B,C):
    pass

obj = D()
#如果ABCD都打开，执行后，首先从左往右先打印的是B，因为D继承了B，C。如果B不执行，就执行C，如果我C也注释不执行，C继承了A，就会打印A

　　　　class name（）：#没有了object

　　看上面的例子，如果B类不执行，就直接找A了，就不会再找C类了。

　　　　总结：

　　　　　　经典类是深度优先，新式类是广度优先。