面向对象1

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

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

函数:

　　

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

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

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

编写功能:
    if 条件:
        email('xxx','xxx')
        msg('xxx','xxx')
        wechat('xxx','xxx')

面向对象:

　　

class Message:
    def mail(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)

编写功能:
    if 条件:
        obj = Message()
        obj.email('xxx','xxx')
        obj.msg('xxx','xxx')
        obj.wechat('xxx','xxx')

对比:

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

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

总结:

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

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

　　3.面向对象方式的格式:

　　　　定义:

　　　　　　class 类名:

　　　　　　　　def 函数名(self):

　　　　　　　　　　pass

　　　　调用:

　　　　　　x = 类名()

　　　　　　x.函数名()

　　　　示例:

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

　　4.构造方法:

　　　　

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

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

　　5.应用:

　　　　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()
        ...
        
    def read_last(self):
        self.read()
        ...

obj = FileHandler(path)
obj.read_first()
obj.read_last()

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

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

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

obj = Foo(11,22,33)
new_func(obj)

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

　　1.规则

　　　　

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

obj = Foo()
obj.detail()

　　2.什么时候写,如何写

　　　　a.归类+提取公共值

　　　　　　归类:

class File:
    def file_read(self,file_path):
        pass
    
    def file_update(self,file_path):
        pass
    
    def file_delete(self,file_path):
        pass

class Excel:
    def excel_read(self,file_path):
        pass
    
    def excel_update(self,file_path):
        pass

    def excel_delete(self,file_path):
        pass
    
    def excel_add(self,file_path):
        pass

　　　　提取公共值:

class File:
    def __init__(self,file_path):
        self.file_path = file_path
    
    def file_read(self):
        pass

    def file_update(self):
        pass

    def file_delete(self):
        pass

    def file_add(self):
        pass

class Excel:
    def __init__(self,file_path):
        self.file_path = file_path

    def excel_read(self):
        pass
    
    def excel_update(self):
        pass

    def excel_delete(self):
        pass

    def excel_add(self):
        pass

　　　　b.在指定类中编写和当前类相关的所有代码 + 提取公共值

class Person:
    def __init__(self,na,gen,age,fig):
        self.name = na
        self.gender = gen
        self.age = age
        self.fight = fig

    def grassland(self):
        self.fight = self.fight -10
       
    def practice(self):
        self.fight = self.fight + 90
        
    def incest(self):
        self.fight = self.fight  - 100

a = Person('abc','男',18,1000)
d = Person('def','女',20,1000)
q = Person('qwe','男',22,1000)

d.grassland()

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

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

　　　　

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("abc",18,"男")

　　继承:

　　

def SuperBase:
    def f3(self):
        print('f3')

    class Base(SuperBase):
        def f2(self):
            print("f2")
    class Foo(Base):
        def f1(self):
            print("f1")

obj = Foo()
obj.f1()
obj.f2()
obj.f3()

#原则:先在自己类中找,诶呦就去父类找

总结:

　　1.继承编写

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

　　3.为什么要有多继承?提供代码重用性

　　

　　多态:多种形态。在面向对象语言中，接口的多种不同的实现方式即为多态。