python_面向对象编程

一、编程范式

　　程序员通过特定的语法+数据结构+算法告诉计算机如果执行任务，实现这个过程有不同的编程方式，对这些不同的编程方式进行归纳总结得出来的编程方式类别，即为编程范式

     编程范式：面向过程编程、面向对象编程、函数式编程

二、面向对象编程  OOP编程

      面向对象编程的使用场合：

　　　　　1、需要设定一个模板

              2、几个对象拥有相同的参数

              3、连接数据库、备份数据库，测试备份文件可用性

      面向对象编程的核心特性：

      1、类 class

          类及时就有相同属性对象的原型/模板，类中封装了对象的共同属性和方法       

class English(object):
    def __init__(self,name,age):  #构造函数  构造方法=初始化方法
        self.name=name   #成员属性
        self.age=age
    def approch(self):
        print('%s %age are learning English '%(self.name,self.age))
person1=English('小楠','23')  #进行实例化，   实例化后产生的对象就是实例，通过__init__（）接受参数
person1.approch()

        ①每个def 函数中都至少一个self参数

        ②第一个函数__init__(self)为构造函数（方法），或者叫初始化函数，类被实例化的时候会自动调用这个方法

        ③函数approach(self) 叫做类的方法，动态方法

         注意类除了有动态方法，还有一个静态方法，动态属性中参数必须有self，如果需求中有的函数不需要传入这个参数，可以用静态属性来设定一个函数@staticmethod

class one(object):
    @staticmethod
    def n1():  #不需要必须填写self，可以传入其他参数
        print('我是一个静态方法')
one.n1()  #不需要实例化，直接通过类来调用

        有上密码呢代码可以看出，静态方法的特性：

                    ① 静态方法也存在于类中，但是不需要self参数，可以是任意个

                    ② 静态方法的调用可以直接调用，不需要实例化，通过类调用即可

        ④析构方法：

#析构函数：__del__
class one(object):
    def __init__(self,name):
        self.name=name
    def fun(self):
        print('%s is classy'%self.name)
    def __del__(self):
        print('del.................')
per1=one('songxiaonan')
per1.fun()

'''__init__:构造函数
   __del__:删除已经构造的函数'''

 

      2、对象 

          类需要实例化之后才可以被调用, 类实例化之后就是一个实例，即对象。 一个类可以被多次实例化，每个实例（对象）也可以用不同的属性和方法

         比如：有一个one1类， 实例化两次

1 person1=English('小楠','23')  #进行实例化，   实例化后产生的对象就是实例，通过__init__（）接受参数
2 person1.approch()  

    实例化后既可以通过实例来调动类中的方法

     3、封装

          类封装了：属性和方法

          对象封装了：成员属性   

           类中的属性：成员属性，共有属性，私有属性

 

class one(object):
    country='China' #      公有属性
    def __init__(self,name,age):
        self.name=name  #      成员属性
        self.age=age
        self.__weight=30#      私有属性
    def shot(self):
        print('message：%s %s' %(self.name,self.age) )

 

         私有属性：外部不可以访问，只能在类内部访问的属性。以__开头：self.__name

         ①如何在外部可以访问私有属性呢?

            在类的内部定义一个方法，返回私有属性值，然后在外部调用这个方法

class one(object):
    country='China' 
    def __init__(self,name):
        self.name=name  
        self.__weight=30# 私有属性
    def weight(self):   #返回私有属性值，外部就可以访问私有属性了
        return self.__weight
d1=one('song',22)
print(d1.weight())   #  30

         ②如果想通过重新定义一个函数访问，也可以强制访问

print(d1._one__weight)  #  30

　　　　公有属性：在类中直接定义，而不是再构造方法中

 

                          共有属性和构造方法、类的其他方法是平级的，类中的所有方法可以共享该属性

class one(object):
    country='China' #共有属性
    def __init__(self,name,age):
        self.name=name  
        self.age=age
d1=one('song',22)
print(d1.country)  # 输出 China
print(one.country) # 输出 China

 

          共有属性可以通过实例调用，也可以直接通过类来调用

          修改共有属性： 是通过类调用该属性进行修改，而不是实例调用该属性进行修改

one.country='US'
print(d1.country)  # 输出 US
print(one.country) # 输出 US

d1.country='Japan'  #注意：这里并不是在修改类的共有属性，而是又重新定义了一个成员属性，和原有的共有属性没有关系
print(d1.country)  # 输出 Japan
print(one.country) # 输出 China

 

     4、继承

         继承是面向对象的一个重要特性，继承可以保留原来的功能，又可以在不需要重新编写前类的情况下，对这些功能进行扩展

         基类：one1

 

class one1(object):
    country='China'
    def __init__(self,name,age):
        self.name=name
        self.age=age
        self.__weight=30
    def shot(self):
        print('message：%s %s' %(self.name,self.age) )
    def weight(self):
        return self.__weight

 

        子类：n1

class n1(one1):
    def n1_func(self):
        print('%s 的兴趣是：%s'%(self.name,self.hobby))
p1=n1('宋晓楠','22')
p1.shot()  # 直接可调用父类的shot方法         message：宋晓楠 22
p1.n1_func()   # 子类自己的方法   宋晓楠 的兴趣是：学习

            如果子类需要有新的参数出入，那么就需要对类的构造方法进行重构，但是子类重构父类的方法后，就会覆盖父类的构造方法，那么如何不覆盖父类的初始化函数同时又重构自己的初始化函数呢？   ——先继承，再重构

class n1(one1):
    def __init__(self,name,age,hobby):  #如果子类  没有传入新参数的需求，就不需要重构__init__()
        one1.__init__(self,name,age) #先继承,再重构    经典类写法
        #上句代码 等同于=super(n1,self)__init__(self,name,age)  新式类写法
        self.hobby=hobby
    def n1_func(self):
        print('%s 的兴趣是：%s'%(self.name,self.hobby))
p1=n1('宋晓楠','22','学习')
p1.shot()  # 直接可调用父类的shot方法         message：宋晓楠 22
p1.n1_func()   # 子类自己的方法   宋晓楠 的兴趣是：学习

      4.1 多继承：多个父类继承、多级继承

         1、继承多个父类

class School(object):
    def info(self):
        print('我是另外一个父类')
class Teacher(SchoolMessage,School):   #   继承多个类
    def __init__(self,name,age,sex,sala,course):
        SchoolMessage.__init__(self,name,age,sex)
        self.sala=sala
        self.course=course
    def teaching(self):
        print('我是 %s 老师，所授课程是：%s'%(self.name,self.course))
t1=Teacher('小花',30,'女','10000','数学')
t1.info()  #  输出：我是另外一个父类

          2、多级继承

 

            py3中无论是经典类和新式类，继承调用的时候，都是广度查找：先查找上一级中，上一级没有再去查找上上级'''

 

class F1(object):
    def __int__(self):
        print('F1')
    def a1(self):
        print('F1a1')
    def a2(self):
        print('F1a2')
class F2(F1):
    def __int__(self):
        print('F2')
    def a1(self):
        self.a2()
        print('F2a1')
    def a2(self):
        print('F2a2')
class F3(F2):
    def __int__(self):
        print('F3')
    def a2(self):
        print('F2a3')

obj=F3()
obj.a1()   #多级继承  进行广度查找

'''输出：  F2a3
           F2a1'''

　　5、多态

            作用：接口的重用

class Animal(object):
    def talk(self):
        raise NotImplementedError('必须被子类调用才可以。。')
# a=Animal()
# a.talk() #    NotImplementedError: 必须被子类调用才可以。。

class cat(Animal):
    def talk(self):
        print('cat')
class dog(Animal):
    def talk(self):
        print('dog')

b=cat()
b.talk()
c=dog()
c.talk()

　　现在只能通过两个实例 b和c分别来调取talk才可以实现talk方法

　　多态的意义在于，值通过一个接口就可以实现cat和dog的talk，
　　比如： 只通过Animal(obj) 这个接口 将b和c分别传入 就可以实现不同实例的talk

　　目前 这个需求多态的实现方法：

def Animal(obj):   #在类外面定义一个函数，将实例单过参数传进去
    obj.talk()
Animal(b)
Animal(c)