面向对象

一.函数式编程和面向对象的对比

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

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

　　面向对象：对函数进行分类和封装，让开发“更快更好更强...”

　　面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。

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

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

请开发一个消息提醒的功能(邮件/短信/微信)

　　函数:

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

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

def wechat(num,text):
    """
    发送微信
    :return:
    """
    print(num,text)
####便携功能
if 1==1:
    msg("15258569","网购买了一个学位课")
    email("alex@sb.com","网购买了一个学位课")
    wechat("xxxx","网购买了一个学位课")
#结果:15258569 网购买了一个学位课
#    alex@sb.com 网购买了一个学位课
#    xxxx 网购买了一个学位课

　　面向对象:

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

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

    def wechat(self,num, text):
        """
        发送微信
        :return:
        """
        print(num, text)
if 1==1:
    obj = Message()
    obj. msg("15258569","网购买了一个学位课")
    obj.email("alex@sb.com","网购买了一个学位课")
    obj.wechat("xxxx","网购买了一个学位课")
#结果:15258569 网购买了一个学位课
#    alex@sb.com 网购买了一个学位课
#    xxxx 网购买了一个学位课

总结:

　　函数:定义简单/调用简单

　　面向对象:定义复杂/调用复杂,    好处:归类,将某些类似的函数写在一起

　　1.函数式编程可能会比面向对象好

　　2.Python中支持两种编程方式

　　3.面向对象方式格式:

　　   定义:

               class   类名:         ----定义了一个类

　　　　　　def  函数名(self):    ---在类中编写了一个"方法"　

　　    调用:

　　　　   x1 = 类名()      ----创建了一个对象/实例化一个对象

　　　　   x1.函数名()      ----通过对象调用其中一个方法

　　4. 实例

 

class Account:
    def login(self):
        user = input("请输入用户名")
        pwd = input("请输入密码")
        if user =="alex" and pwd =="sb":
            print("登录成功")
        else:
            print("登录失败")
obj = Account()
obj.login()

 

对比  打印

　　函数

"""
完成以下功能:
    老狗/20岁/男/上山去砍柴
    老狗/20岁/男/开车去东北
    老狗/20岁/男/喜欢大宝剑
"""
def kc(name, age, gender):
    data = "%s,性别%s,今年%s岁,喜欢上山砍柴" % (name, gender, age)
    print(data)

def db(name, age, gender):
    data = "%s,性别%s,今年%s岁,喜欢开车去东北" % (name, gender, age)
    print(data)

def bj(name, age, gender):
    data = "%s,性别%s,今年%s岁,喜欢大宝剑" % (name, gender, age)
    print(data)

kc('老狗', 20, '男')
db('老狗', 20, '男')
bj('老狗', 20, '男')
# 结果:老狗,性别男,今年20岁,喜欢上山砍柴
#     老狗,性别男,今年20岁,喜欢开车去东北
#     老狗,性别男,今年20岁,喜欢大宝剑

　　面向对象:

class LaoGou:
    def __init__(self, name, age, gender):  # 特殊的方法,如果 类名() ,则该方法会被自动执行 (构造方法)
        self.n1 = name
        self.n2 = age
        self.n3 = gender

    def kc(self):
        data = "%s,性别%s,今年%s岁,喜欢上山砍柴" % (self.n1, self.n3, self.n2)
        print(data)

    def db(self):
        data = "%s,性别%s,今年%s岁,喜欢开车去东北" % (self.n1, self.n3, self.n2)
        print(data)

    def bj(self):
        data = "%s,性别%s,今年%s岁,喜欢大宝剑" % (self.n1, self.n3, self.n2)
        print(data)
obj = LaoGou('老狗', 20, '男')
obj.kc()
obj.db()
obj.bj()
#结果:老狗,性别男,今年20岁,喜欢上山砍柴
#    老狗,性别男,今年20岁,喜欢开车去东北
#    老狗,性别男,今年20岁,喜欢大宝剑

总结:

　　1.构造方法

　　　　实例:

class Foo:
    def __init__(self,name):    #构造方法,目的进行数据初始化 
        self.name = name
        self.age = 18
obj = Foo("王")

  通过构造方法,可以将数据进行打包,以后使用时,去其中获取即可.

 　　2.应用

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

 

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()

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

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)

二.面向对象代码如何编写

　　1.规则

class Foo:
    def __init__(self, name):
        self.name = name
    def detail(self, msg):
        print(self.name, msg)
obj = Foo("")
obj.detail("")

　　2.什么时候写?

　　　方式一方向:归类+提取公共值

　　　方式二正向:在指定类中编写和当前类相关的所有代码 + 提取公共值

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

　　1.封装:

　　　将相关功能封装到一个类中:

class Message:
    def email(self):pass
    def msg(self):pass
    def wechat(self):pass

　　　将数据封装到一个对象中:

class Person:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
obj = Person('孙福来', 18, '女')

　　2.继承:

class Base:  # 父类,基类
    def f2(self):
        print('f2')
class Foo(Base):  # 子类,派生类
    def f1(self):
        print('f1')
obj = Foo()
obj.f1()
obj.f2()
#结果: f1   f2

原则:先在自己类中找,没有就去父类

总结:

　　1.继承编写

　　class Foo(父类):

　　　　pass

　　2.支持多继承(先找左/再找右)

　　3.为什么要有多继承?

　　　　提供代码重用性

　　3.多态

　　　　多种形态或多种状态

三.面向对象的多继承　

　　a.先找左再找右

　　b.经典类和新式类

　　py2:  经典类: 一条道走到黑(深度优先)

　　　　 新式类: 如果自己或自己的前辈只要有人继承object,那么此类就是新式类

　　py3: 新式类

经典类和新式类的查找成员的顺序不一样.

　　经典类:  一条道走到黑(深度优先)

　　新式类:  C3算法实现

C3算法

　　获取第一个表头 和 其他表尾进行比较

　　　　不存在则拿走.

　　　　如果存在,则放弃,然后获取第二个表的表头再次和其他表的表尾进行比较.

　　简单:

　　　　经典类:一条道走到黑(深度优先)

　　　　新式类:留个跟. (科学C3算法)

注意事项:

　　super是遵循__mro__执行顺序.