面向对象初阶

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

#开发一个消息提醒的功能
#函数版:
def email(address,text):
    """

    :return:
    """
    print(address,text)
def tel(num,text):
    """

    :param num:
    :param text:
    :return:
    """
    print(num,text)
def wechat(num,text):
    """

    :param num:
    :param text:
    :return:
    """
    print(num,text)
#编写功能:假如有人购买课程发送提醒信息
if 1==1:
    

#=========面向对象版本=========
class Message:
    def email(address, text):
        """

        :return:
        """
        print(address, text)

    def tel(num, text):
        """

        :param num:
        :param text:
        :return:
        """
        print(num, text)

    def wechat(num, text):
        """

        :param num:
        :param text:
        :return:
        """
        print(num, text)
# 编写功能:有人购买课程提醒
if 1==1:
    obj=Message()
    obj.email('163@qq', "有人买啦")
    obj.tel(18888888, "有人买啦")
    obj.wechat('163@qq', "有人买啦")

对比的结果:1函数,定义简单/调用简单 2面向对象:定义复杂/调用复杂/  好处就是 分类 把类似函数集合在一起

面向对象的正常格式:

定义:

class 类名:    #定义了一个类

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

　　　　pass

调用:

obj=类名+()    #创建了一个对象/实例化一个对象

obj.函数名()  #通过对象调用其中的一个方法

用户登录示例:

class denglu:
    def login(self):
        user=input("请输入名字：")
        pwd=input("请输入密码：")
        if user=='alex'and pwd=='123':
            print("登陆成功")
        else:print("登录失败")
obj=denglu()
obj.login()

打印:

请打印下列内容:

老狗/20岁/男/上山去砍柴

老狗/20岁/男/开车去东北

老狗/20岁/男/喜欢大保健

汪汪

构造方法:

示例一:
class Foo:
    def __init__(self,name):
        self.name=name
        self.age=18
obj=Foo('alex')
示例二:
class Bar:
    pass
obj=Bar()

应用:

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

2面向对象代码如何编写

规则:

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

什么时候写+如何写

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

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

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面向对象三大特性:封装,继承和多态

封装:

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

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

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

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

继承:先在自己类中找,没有再去父类中找

            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,继承编写,2支持多继承(先左后右)3提高代码重用率

多态: 多种形态,状态     

# 由于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)