day 22 面向对象的基础

面向对象：

1、简述编写和执行类中的方法的流程

class Foo:             #类的编写
    def func():
        print("我爱你")
obj = Foo()            #类的调用和执行
obj.func()

2、面向对象的三大特征？
　　封装、继承、多态

　　封装：

　　　　归类：将相关的功能封装到一个类中、

　　　　打包：将数据封装到一个对象中

　　继承：

　　　　自己没有找老爸要

　　　　当有两个类或者多个类，其中都有共同的方法时，为了避免代码重复编写，把它放到父亲中

　　多态：

　　　　python原生支持多态，崇尚鸭子模型，由于python函数传参时无法指定类型

　　　　def func (arg):  #arg可以时多种类型，只要其中有send方法即可。

　　　　　　arg.send()

3、什么是构造方法？

　　__init__

4、面向对象中为什么要有继承？

　　提高代码的复用性，调用原则：先找self所在的函数中，没有的话找父亲要，父亲没有再去找爷爷

5、python多继承的原则？
　　先从左到右

6、面向对象方式的格式？

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

7、构造方法

class Foo:
    def __init__(self,name):     #构造方法,目的进行数据初始化.
        self.name = name 
        self.age = 18 
obj = Foo('侯明魏')           #通过构造方法,可以将数据进行打包,以后使用时,去其中获取即可.
应用：1,将数据封装到对象中，以供自己再方法中调用
　　  2,将数据封装到对象中，以供其它函数调用

8、面向对象代码如何编写？

　　方式一、归类+提取公共值

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

9、self到底是谁？

　　self参数时python帮助我们自动传参

　　如果执行面向对象中的方法时，前面必须有一个对象：xxx.func()

 

s15day22 面向对象 

接下来内容:
    第一部分:面向对象
    第二部分:网络编程
    第三部分:并发编程

内容回顾:
    1. 面向过程
    
    2. 函数式编程 
        
        def func(arg):
            pass
            
        func(1)
        func(2)
        
    3. 为什么要将某些函数写在指定文件中?
        对函数进行归类
    
今日内容:
    1. 函数式编程和面向对象的对比

    2. 面向对象代码如何编写
    
    3. 面向对象三大特性:封装/继承/多态
    
内容详细:
    1. 函数式编程和面向对象的对比
        
        a. round 1 请开发一个消息提醒的功能(邮件/短信/微信)   
            
            函数:
                def email(em,text):
                    """
                    发送邮件
                    :return:
                    """
                    print(em,text)

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

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

                # 编写功能:假设用户购买课程,然后给alex发送提醒;
                if 1==1:
                    msg('188888888','张进购买了一个学位课')
                    email('alex@sb.com','张进购买了一个学位课')
                    wechat('xxxx','张进购买了一个学位课')

            面向对象:
                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)


                # 编写功能:假设用户购买课程,然后给alex发送提醒;
                if 1==1:
                    obj = Message()
                    obj.email('alex@sb.com', '张进购买了一个学位课')
                    obj.msg('188888888','张进购买了一个学位课')
                    obj.wechat('xxxx','张进购买了一个学位课')

            
            对比:
                函数:定义简单/调用简单
                面向对象:定义复杂/调用复杂   好处:归类,将某些类似的函数写在一起
                
            总结:
                1. 函数式编程可能会比面向对象好.
                2. Python中支持两种编程方式.
                3. 面向对象方式格式:
                    定义:
                        class 类名:                    - 定义了一个类
                            
                            def 函数名(self):        - 在类中编写了一个"方法"
                                pass 
                    调用:
                        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()
                                    
                
        b. round 2 打印 
            """
            完成以下功能:
                老狗/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,'男')
            kc('老狗',20,'男')
            db('老狗',20,'男')
            bj('老狗',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()
    
            
            总结:
                1. 构造方法
                    示例一:
                        class Foo:
                            
                            def __init__(self,name):     构造方法,目的进行数据初始化.
                                self.name = name 
                                self.age = 18 
                        
                        obj = Foo('侯明魏')
                        
                        通过构造方法,可以将数据进行打包,以后使用时,去其中获取即可.
                    
                    示例二:    
                        class Bar:
                            pass 
                        obj = Bar()
                    
                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. 用户登录
            2. 显示当前用户信息
            3. 查看当前用户所有的账单
            4. 购买姑娘形状的抱枕 
            
            示例:
                class UserInfo:

                    def __init__(self):
                        self.name = None

                    def info(self):
                        print('当前用户名称:%s' %(self.name,))

                    def account(self):
                        print('当前用户%s的账单是:....' %(self.name,))

                    def shopping(self):
                        print('%s购买了一个人形抱枕' %(self.name,))

                    def login(self):
                        user = input('请输入用户名:')
                        pwd = input('请输入密码:')
                        if pwd == 'sb':
                            self.name = user
                            while True:
                                print("""
                                    1. 查看用户信息
                                    2. 查看用户账单
                                    3. 购买抱枕
                                """)
                                num = int(input('请输入选择的序号:'))
                                if num == 1:
                                    self.info()
                                elif num ==2:
                                    self.account()
                                elif num == 3:
                                    self.shopping()
                                else:
                                    print('序号不存在,请重新输入')
                        else:
                            print('登录失败')

                obj = UserInfo()
                obj.login()
            
            总结:
                class Foo:
                    def func2(self):
                        print('func2')
                    
                    def func1(self):
                        self.fun2()
                        print('func1')
                        
                        
                obj = Foo()
                obj.func1()
    
        
    2. 面向对象代码如何编写
        a. 规则 
            
            class Foo:
                
                def __init__(self,name):
                    self.name = name 
                    
                    
                def detail(self,msg):
                    print(self.name,msg)
                    
            obj = Foo()
            obj.detail()
            
            
        b. 什么时候写?如何写?
            
            方式一:归类+提取公共值
                归类:
                    class File:
                        def file_read(self,file_path):
                            pass

                        def file_update(self,file_path):
                            pass

                        def file_delete(self,file_path):
                            pass

                        def file_add(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
            
            方式二:在指定类中编写和当前类相关的所有代码 + 提取公共值
                
                class Message:
                    def email(self):    
                        pass 
                
                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 - 666
                        
                
                cang = Person('苍井井', '女', 18, 1000)    # 创建苍井井角色
                dong = Person('东尼木木', '男', 20, 1800)  # 创建东尼木木角色
                bo = Person('波多多', '女', 19, 2500)      # 创建波多多角色
            
                dong.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('孙福来',18,'女')
        继承:
            class 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. 继承编写 
                    
                    class Foo(父类):
                        pass 
                        
                2. 支持多继承(先找左/再找右)
                
                
                3. 为什么要有多继承? 提供代码重用性
                
                
                练习: 找self到底是谁的对象?从谁开始找.
                
        多态: 
            多种形态或多种状态
            鸭子模型,只要可以嘎嘎叫就是鸭子.
            
            Python
                #  由于python原生支持多态,所以没有特殊性.
                """
                class Foo1:
                    def f1(self):
                        pass 
                
                class Foo2:
                    def f1(self):
                        pass 
                
                class Foo3:
                    def f1(self):
                        pass 
                        
                        
                def func(arg):
                    arg.f1()
                    
                obj = Foo1() # obj= Foo2()   obj = Foo3()
                func(obj)
                """
            
            java
                class Son(list):
                    pass 
                
                class Son1(list):
                    pass 
                
                # 以后传参时,arg可以是:list类的对象/list任何子类的对象
                public void func(list arg){
                    print(arg)
                }
                
                # obj = list()
                # obj = Son()
                obj = Son1()
                func(obj)
            
重点:
    1. 编写方式执行流程
    
    2. 如何归类?
        反向:归类+提取公共值
        正向:类相关的功能+提取公共值
        
    3. 三大特性
        
作业:练习题