面向对象

面向过程：根据业务逻辑从上到下写垒代码

函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可

def email(em,text):
    """
    发送邮件
    :return:
    """
    print(em,text)

def msg(tel,text):
    """
    发送短信
    :return:
    """
    print(tel,text)

def wechat(num,text):
    """
    发送微信
    :return:
    """
    print(num,text)

　　

面向对象：对函数进行分类和封装。

class Message:
    def email(self, em, text):
        """
        发送邮件
        :return:
        """
        print(em,text)
    
    def msg(self, tel, text):
        """
        发送短信
        :return:
        """
        print(tel,text)
    
    def wechat(self, num, text):
        """
        发送微信
        :return:
        """
        print(num,text)

 

创建类和对象

类就是一个模板，模板里可以包含多个函数，函数里实现一些功能

对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

定义:
    class 类名:              - 定义了一个类
        
        def 函数名(self):    - 在类中编写了一个"方法"
            pass 
调用:
    x1 = 类名()              - 创建了一个对象/实例化一个对象
    x1.函数名()               - 通过对象调用其中一个方法.

 

构造方法的目的是进行数据初始化。通过构造方法,可以将数据进行打包,以后使用时,去其中获取即可

class Fir:
    def __init__(self,name,age):   #称为构造方法，根据类创建对象时自动执行
        self.name = name
        self.age = age

obj1 = Fir('zhh',18)
obj2 = Fir('zhangqiang',73)

self 是一个形式参数，当执行 obj1 = Foo('zhh', 18 ) 时，self 等于 obj1
当执行 obj2 = Foo('zhangqiang', 73 ) 时，self 等于 obj2

 

应用 1 将数据封装到对象中,以供自己在方法中调用

class FileHandler:
    def __init__(self,file_path):
        self.file_path = file_path
        self.f = open(self.file_path, 'rb')

    def read_first(self):
        # self.f.read()
        # ...
        pass

    def read_last(self):
        # self.f.read()
        # ...
        pass

    def read_second(self):
        # self.f...
        # ...
        pass

obj = FileHandler('C:/xx/xx.log')
obj.read_first()
obj.read_last()
obj.read_second()
obj.f.close()

 

2将数据封装到对象中,以供其他函数调用

def new_func(arg):
    arg.k1
    arg.k2
    arg.k6

class Foo:
    def __init__(self,k1,k2,k6):
        self.k1 = k1
        self.k2 = k2
        self.k6 = k6

obj = Foo(111,22,333)
new_func(obj)

 

面向对象的三大特性:封装/继承/多态 

封装

顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

所以，在使用面向对象的封装特性时，需要：

• 将内容封装到某处
• 从某处调用被封装的内容

第一步：将内容封装到某处

class Person:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

obj = Person('孙福来',18,'女')

第二步：从某处调用被封装的内容

通过self调用

class Person:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

    def detail(self):
        print(self.name)
        print(self.age)

obj = Person('孙福来',18,'女')
obj.detail()

通过直接调用

class Person:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

obj = Person('孙福来',18,'女')
print(obj.name)     #直接调用object对象的name属性

 

继承

将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。实现代码的复用

继承的编写

class（父类）：

　　pass

支持多继承（从左到右查找）

class Base1:
    def show(self):
        print('Base1.show')

class Base2:
    def show(self):
        print('Base2.show')

class Foo(Base1,Base2):
    pass

obj = Foo()
obj.show()

 多继承查找顺序

a. 先找左再找右
class A(object):
    pass


class B(object):
    def f1(self):
        print('B')


class C(A,B):
    pass

obj = C()

obj.f1()

b. 经典类和新式类
py2:
    经典类
    新式类，如果自己或自己的前辈只要有人继承object，那么此类就是新式类。
py3:
    新式类

经典类和新式类的查找成员的顺序不一样。
    经典类，一条道走到黑（深度优先）。
    新式类，C3算法实现（python2.3更新时c3算法）。

Foo + (C,D,F,G) + (G,D,G,W) + (I,G,D,G,W) 
获取第一个表头 和 其他表位进行比较
    不存在则拿走。
    如果存在，则放弃，然后获取第二个表的表头再次和其他表的表尾进行比较。