面向对象的初识

import json,re
def login():
    ‘‘‘
    用户输入
    :return:
    ‘‘‘
    usename = input(‘用户名：‘).strip()
    pwd = input(‘密码：‘).strip()
    tel = input(‘电话：‘).strip()
    mail = input(‘邮箱：‘).strip()
    return {
        ‘usename‘:usename,
        ‘pwd‘:pwd,
        ‘tel‘:tel,
        ‘mail‘:mail

    }
def authentication(use_info):
    ‘‘‘
    判断用户名和密码等信息是否合法
    :return:
    ‘‘‘
    is_valid = True # 默认合法
    if len(use_info[‘usename‘])==0:
        print(‘用户名不能为空！‘)
        is_valid = False
    if len(use_info[‘pwd‘])< 6:
        print(‘密码长度不得小于6位！‘)
        is_valid = False
    if len(re.findall(‘1[0-9]{10}‘,use_info[‘tel‘]))==0:
        print(‘电话格式不对！‘)
        is_valid = False
    if not re.search(r‘@.*?.com$‘,use_info[‘mail‘]).group(): # 使用Python的r前缀，就不用考虑转义的问题,‘*‘加个?就可以让‘.‘采用非贪婪匹配
        print(‘邮箱格式不对‘)
        is_valid = False

    return {
        ‘valid‘:is_valid,
        ‘info‘:use_info
    }
def register(auth):
    ‘‘‘
    若输入信息合法则注册，写入文件或数据库
    :param auth:
    :return:
    ‘‘‘
    if auth[‘valid‘]==True:
        with open(‘data.json‘,‘w‘,encoding=‘utf-8‘) as f:
            json.dump(auth[‘info‘],f)
def main():
    ‘‘‘
    主逻辑程序
    :return:
    ‘‘‘
    use_info = login()
    auth = authentication(use_info)
    register(auth)
if __name__==‘__main__‘: # 直接调用时执行下列程序，被调用时不执行
    main()

# 现实世界中的对象：
‘‘‘
对象1 
    特征
        职业：学生
        姓名：王二
        性别：男
        年龄:22
    技能
        学习
        打游戏
对象2
    特征 
        职业：学生
        姓名：张三
        性别：男
        年龄:20
    技能
        学习
        打游戏
        看书
对象3 
    特征 
        职业：学生
        姓名：婉婉
        性别：女
        年龄:18
    技能
        学习
        打游戏
        看书
现实中的类：
    特征：
        职业：学生
    技能：
        学习
        打游戏
        看书
在程序中：
‘‘‘
# 先有类
class School_learn:
    job = ‘student‘
    def study(self):
        print(‘study hard!‘)
    def play_game(self):
        print(‘play games as little as you can‘)
    def read(self):
        print(‘read books more and more‘)

# 再调用类产生对象
student1 = School_learn()
student2 = School_learn()
student3 = School_learn()
print(student1) # <__main__.School_learn object at 0x000002B70F8D7588> 对象
print(student2)
print(student3)

　　6、面向对象三大特性

　　　　<1>封装（Encapsulation）：在类中对数据的赋值、内部调用对外部用户来说是透明不可见的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法。

　　　　<2>继承（Inheritance）：一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承。

　　　　<3>多态（Polymorphism）：多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。

注意：这里只是简单说明下几大特性，后续我们会深入探讨的的。

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. 三大特性

"""
练习: 信息管理系统
    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 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

# by luffycity.com
""""""


# ########################1. 基本使用 ###########################

# ##### 基本写法
"""
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()
# 原则:现在自己类中找,么有就去父类
"""

# ##### 为何有继承? 为了提高代码重用性
"""
class Base:
    def f1(self):
        pass

class Foo(Base):

    def f2(self):
        pass

class Bar(Base):

    def f3(self):
        pass
"""

# ########################2. 多继承 ###########################
"""
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()
"""
# 左边更亲

# ############################### 练习题 #############################
###### 习题1

# class Base:
#     def f1(self):
#         print(‘base.f1‘)
#
# class Foo(Base):
#     def f2(self):
#         print(‘foo.f2‘)


# 1. 是否执行
# obj = Foo()
# obj.f2()
# obj.f1()

# 2. 是否执行
# obj = Base()
# obj.f1()
# obj.f2() # 错

##### 习题2:
"""
class Base:
    def f1(self):
        print(‘base.f1‘)

class Foo(Base):
    def f3(self):
        print(‘foo.f3‘)
    
    def f2(self):
        print(‘foo.f2‘)
        self.f3() # obj是那一个类(Foo),那么执行方法时,就从该类开始找.
        
obj = Foo()
obj.f2() # obj是那一个类(Foo),那么执行方法时,就从该类开始找.
"""

##### 习题3:
"""
class Base:
    def f1(self):
        print(‘base.f1‘)

    def f3(self):
        print(‘foo.f3‘)

class Foo(Base):

    def f2(self):
        print(‘foo.f2‘)
        self.f3()  # obj是那一个类(Foo),那么执行方法时,就从该类开始找.


obj = Foo()
obj.f2()  # obj是那一个类(Foo),那么执行方法时,就从该类开始找.
"""
##### 习题4:
"""
class Base:
    def f1(self):
        print(‘base.f1‘)

    def f3(self):
        self.f1() # obj是那一个类(Foo),那么执行方法时,就从该类开始找.
        print(‘foo.f3‘)

class Foo(Base):

    def f2(self):
        print(‘foo.f2‘)
        self.f3()  # obj是那一个类(Foo),那么执行方法时,就从该类开始找.


obj = Foo()
obj.f2()  # obj是那一个类(Foo),那么执行方法时,就从该类开始找.
"""
##### 习题5:
"""
class Base:
    def f1(self):
        print(‘base.f1‘)

    def f3(self):
        self.f1() # obj是那一个类(Foo),那么执行方法时,就从该类开始找.
        print(‘base.f3‘)

class Foo(Base):
    def f1(self):
        print(‘foo.f1‘)

    def f2(self):
        print(‘foo.f2‘)
        self.f3()  # obj是那一个类(Foo),那么执行方法时,就从该类开始找.


obj = Foo()
obj.f2()  # obj是那一个类(Foo),那么执行方法时,就从该类开始找.
# foo.f2
# foo.f1
# base.f3

obj2 = Base()
obj2.f3()
# base.f1
# base.f3
"""
# 总结: self是那个类的对象,那么就从该类开始找(自己没有就找父类)

##### 习题6:

class Base1:
    def f1(self):
        print(‘base1.1‘)
    def f2(self):
        print(‘base1.f2‘)

class Base2:
    def f1(self):
        print(‘base2.f1‘)

    def f2(self):
        print(‘base2.f2‘)

    def f3(self):
        print(‘base2.f3‘)
        self.f1()

class Foo(Base1,Base2):

    def f0(self):
        print(‘foo.f0‘)
        self.f3()
# 1. 多继承先找左边
# 2. self到底是谁,self是那个类的对象,那么就从该类开始找(自己没有就找父类)
obj = Foo()
obj.f0()