面向对象过程

- 面向对象（属性与方法）去进行编码的过程

### 面向过程VS面向对象

- 编程思想不同：

- 面向过程：是一种以过程为中心的编程思想

- 面向对象：是一类以对象为核心的编程思想

- 特点不同：

- 面向过程：主要分析出解决问题所需要的步骤，用函数把这些步骤一步步实现，使用的十九一个个依次调用即可

- 面向对象：主要找出问题中的共性问题，作为对象进行操作

### 面向对象中常用的术语：

- 类：可以理解为一个模板，通过它可以创建出无数个具体实例

- 对象：类不能直接使用，需要通过类实例化（类的实例又称对象）之后才能使用

- 属性：类中所有的变量称为属性

- 方法：类所拥有的函数通常称为方法：方法可以分为类方法（@classmethod 修饰的方法）

- 静态方法（@staticmethod修饰的方法）和实例方法。类中定义的方法默认是实例方法，实例方法至少要包含一个self参数，只能和类的对象一起使用

- 面向对象最重要的概念就是类和实例，牢记类是抽象的模板，而实例是根据类创建出来的一个个具体的对象，每个对象都拥有相同的方法。

- class首字母大写 class Name(object):

- 类的参数self

- self 是类函数中的必传参数，且必须放在第一个参数位置

- self 是一个对象，他代表实例化的变量自身

- self 可以直接通过点来定义一个类变量 self.name = 'mark'

- self中的变量与含有self参数的函数可以在类中的任何一个函数内随意调用

- 非函数中定义的变量在定义的时候不用self

def sleep3(name):
    return name+'3'

class Person(object):
    name = None
    age = None

    def run(self):
        print(f'{self.name} 在奔跑')

    def jump(self):
        print(f'{self.name} 在跳跃')

    def work(self):
        self.run()
        self.jump()
        def sleep2(name):  #  函数中定义新的函数
            return name
        result = sleep2(self.name)
        print('sleep2 result is ',result)
        r3 = sleep3(self.name) # 调用全局函数sleep3
        print(r3)

    def sleep(): # 类中self是必传参数，否则无法调用
        print('sleep')

mark = Person()
mark.run()
mark.name = 'mark'
mark.run()

lily = Person()
lily.run()
lily.name = 'lily'
lily.run()
lily.top = 163
print(lily.top)
# print(mark.top)#报错 top是属于lily这个对象新加的属性
print('========')
lily.work()
# lily.sleep() # 报错，无法调用
print('-------')
print(sleep3('lily'))

 - python中self代表类的实例：self在定义类的方法时是必须有的，虽然在调用的时候不必传入对应的参数

- python中只有针对类来说self才有意义，python中所说的self，就是指类中的self

- self只能再python类的方法中使用

- 属性：

- (1）如果变量定义在类下面而不是类的方法下面，那这个变量即是类的属性也是类实例的属性。

- （2）如果变量定义在类的方法下面，如果加了self，那这个变量就是类实例的属性，不是类的属性；如果没加self，这个变量只是这个方法的局部变量，既不是类的属性也不是类实例的属性。

- 方法:

- （1）如果在类中定义函数时加了self，那这个函数就是类实例的方法，而不是类的方法。

- （2）如果在类中定义函数时没有加self，那这个函数就只是类的方法，而不是类实例的方法。

class Dog:
    # 定义在类的下面，而不是类的方法下面,那这个变量即是类的属性也是类实例的属性。
    color = 'yellow'
    name = 'lucy'

    # 如果变量定义在类的方法下面，如果加了self，那这个变量就是类实例的属性，不是类的属性；
    # 如果没加self，这个变量只是这个方法的局部变量，既不是类的属性也不是类实例的属性。
    def __init__(self):
        self.a = 13
        b = 6
        print(b)

# （1）如果在类中定义函数时加了self，那这个函数就是类实例的方法，而不是类的方法。
# （2）如果在类中定义函数时没有加self，那这个函数就只是类的方法，而不是类实例的方法。
    def eat1():
        print('类的方法')
    def eat2(self):
        print('类实例的方法')

print(Dog.color)
duoduo = Dog()
print(duoduo.color)
# print(Dog.a) # 报错，找不到类属性a
print(duoduo.a) # 输出13
# print(duoduo.b) # 报错，找不到类实例属性b
Dog.eat1()
# Dog.eat2() # 报错，不能调用，需要传参
# duoduo.eat1() # 报错，不能调用
duoduo.eat2()

构造函数：

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

    def run(self):
        print(f'{self.name} 在奔跑')

    def jump(self):
        print(f'{self.name} 在跳跃')

    def work(self):
        self.run()
        self.jump()
        print(f'{self.name} 的年龄是 {self.age}')

mark = Person(name='mark')
mark.work()
print('========')
mark.name = 'mark.li' # 能正常修改
mark.work()

print('-------')
luck = Person(name='luck',age=16)
luck.work()

- 对象的生命周期，python中会自动管理内存周期

- 实例化__init__:对象的生命周期开始（内存中分配一个内存块）

- __del__：删除对象（从内存中释放这个内存块）

私有函数和私有变量

- 无法被实例化后的对象调用的类中的函数与变量

- 类内部可以调用私有函数与变量

- 只希望类内部业务调用，不希望被使用者调用

- 私有变量私有函数：变量或者函数前添加__（2个下划线） （补充说明：前后都有的是内置函数）

class Dog(object):
    __dog_type = 'dog'

    def __init__(self,name,age=None):
        self.name = name
        self.__age = age

    def run(self):
        result = self.__run()
        print(result)

    def __run(self):
        return f'{self.__dog_type} {self.name} 在奔跑'

    def jump(self):
        result = self.__jump()
        print(result)

    def __jump(self):
        return f'{self.__dog_type} {self.name} 在跳跃'

    def work(self):
        self.run()
        self.jump()
        print(f'{self.name} 的年龄是 {self.__age}')

mark = Dog(name='mark',age=4)
mark.work()
print(dir(Dog))
re = mark._Dog__jump()
print(re)
# print(mark.__dog_type)# 类外不能调用私有属性
print(mark._Dog__dog_type)

- python中的装饰器

- 是一种函数，可以接受函数作为参数，可以返回函数

- 接收一个函数，内部对其处理，然后返回一个新的函数，动态增强函数功能

- 列子：a函数是装饰器，将c函数作为参数传入给a函数，在a函数中可以选择执行或者不执行c函数，也可以选择对c函数的结果进行二次加工处理

- def out(func_args):外围函数 （传入需要处理的函数）

- def inter(*args,**kwargs): 内嵌函数 （因为不知道传入的func_args传入的是什么参数，所以选择可变参数）

- return func_args(*args,**kwargs) （业务逻辑代码）

- return inter (必须的一步，外围函数返回内嵌函数：所有业务逻辑都在内嵌函数中，不返回内嵌函数，就无法调用)

- 装饰器的用法：方法一：将被调用的函数，直接作为参数传入装饰器的外围函数

- 方法二：使用@符号，将装饰器与被调用函数绑定在一起，@+装饰器函数，放在被调用的函数的上一行，被调用函数正常定义，只需要直接调用被执行函数即可

def check_str(func):
    print('func',func)
    def inner(*args,**kwargs):
        result = func(*args,**kwargs)
        print('args',args,kwargs)
        if result == True:
            return '%s 验证 通过'% result
        else:
            return '%s 验证 不通过'% result
    return inner

@check_str
def test(data):
    if len(data) >= 3:
        return True
    else:
        return False

result = test('ok')
print(result)

result = test(data='okk')
print(result)

- 类的常用装饰器：classmethod；staticmethod; property

- classmethod—将类函数，可以不经过实例化而直接被调用

- staticmethod—将类函数可以不经过实例化而直接被调用，被该装饰器调用的函数不许传递self或cls参数，且无法再该函数内调用其他类函数或变量

- property—将类函数的执行免去括弧，类似于调用属性（变量）一样

class Test(object):
    def __init__(self,a):
        self.a = a

    def run(self):
        print('run')
        self.jump() #正常调用
        self.sleep()

    @classmethod
    def jump(cls):
        print('jump')
        # cls.run() #不能调用，仍然报错

    @staticmethod
    def sleep():
        print('I want sleep')

t = Test('a')
t.run()
# Test.run() # TypeError: run() missing 1 required positional argument: 'self## '
Test.jump()
print('======')
t.jump()
Test.sleep()
t.sleep()
print('------')
t.run()

class Test1(object):
    def __init__(self,name):
        self.__name = name

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self,value):
        self.__name =value

t1 = Test1(name='mark')
print(t1.name)
t1.name = 'mark.li'
print('----',t1.name)

输出：

run
jump
I want sleep
jump
======
jump
I want sleep
I want sleep
------
run
jump
I want sleep
mark
---- mark.li

- 类的继承：通过继承基类来得到基类的功能，被继承的类称作父类或基类，继承者称为子类

- 代码的复用：子类拥有父类所有的属性和方法，父类不具备子类自有的属性和方法

class Parent(object):
    def __init__(self,name,sex):
        self.name = name
        self.sex = sex

    def walk(self):
        return f'{self.name} can walk'

    def is_sex(self):
        if self.sex == 'boy':
            return f'{self.name} is a boy'
        else:
            return f'{self.name} is a girl'

class ChildOne(Parent):
    def play_football(self):
        return f'{self.name} play football very well'

class ChildTwo(Parent):
    def play_piano(self):
        return f'{self.name} play piano very well'

c_one = ChildOne(name='mark',sex='boy')
re = c_one.play_football()
print(re)
re = c_one.is_sex()
print(re)

c_two = ChildTwo(name='lucy',sex='girl')
re = c_two.play_piano()
print(re)
re = c_two.walk()
print(re)

print('======')
p = Parent(name='Lcuk',sex='boy')
pre = p.walk()# 只能调用自己的，不能调用子类的
print(pre)

- 类的多态实现：子类中重写父类的方法

class Father(object):
    def talk(self):
        print('father is talking')

    def jump(self):
        print('具有jump功能')

class Brothor(Father):
    def run(self):
        print('brother is running')

    def talk(self):
        print('brother is talking')

class Mark(Father):
    def talk(self):
        print('mark is talking')


if __name__=='__main__':
    br = Brothor()
    br.run()
    br.talk()
    br.jump()
    fa = Father()
    fa.talk()
    ma = Mark()
    ma.talk()

class Parent():
    def __init__(self,p):
        print('hello I am parent %s'% p)

class Child(Parent):
    def __init__(self,c):
    # def __init__(self, c,p):
        print('hello I am child %s'% c)
        # super(当前类，类的实例).父类方法,python3中可以不用传
        # super(Child,self).__init__(p)
        super().__init__(p='luck')


if __name__ == '__main__':
    mark = Child(c='mark')
    # mark = Child(c='mark',p='luck')

- 类的多重继承：可以继承多个父类（基类）

- class Child(Parent1,Parent2,Parent3...) 逗号隔开，从左向右一次继承

class Tool(object):
    def work(self):
        print('tool work')

    def knife(self):
        print('Use a knife to cut fruit')

class Food(object):
    def work(self):
        print('Food work')

    def fruit(self):
        print('I like fruit')

class Person(Food,Tool):
    def __init__(self,name):
        self.name = name
        print(f'hello , I am {self.name}')

if __name__ == '__main__':
    mark = Person(name='mark')
    mark.fruit()
    mark.knife()
    mark.work()
    print(Person.__mro__)#可以查看继承顺序

- 类的高级函数 __str__ __getattr__ __setattr__ __call__

- __str__ 功能：如果定义了该函数，当print当前实例化对象的时候，会返回该函数的return信息

- __getattr__ 当调用的属性或者方法不存在时，会返回该方法定义的信息

- __setattr__ 拦截当前类中不存在的属性和值，并设置，__setattr__(self, key, value)

- __call__ 本质是将一个实例化的类变成一个函数

class Test(object):
    pass

class Test1(object):
    def __str__(self):
        return 'this is a test class(这是一个描述信息)'

    def __getattr__(self, key):# 当调用的属性或者方法不存在时，会返回该方法定义的信息
        return f' key:{key} 不存在'

    def __setattr__(self,key,value): # 处理当前类中不存在的属性和值
        print(key,value)
        print(self.__dict__)# 每一个类中都有一个这样的内置字典函数
        # if key not in self.__dict__:
        self.__dict__[key] = value
        print(self.__dict__)

    def __call__(self, *args, **kwargs):#将一个实例化的类变成一个函数
        print('call func ',args,kwargs)


if __name__ == '__main__':
    t = Test()
    print(t)
    # print(t.a) # 报错'Test' object has no attribute 'a'
    t1 = Test1()
    print(t1)
    print(t1.a)
    print(t1.hy)
    t1.name = 'LUCK'
    print(t1.name)
    t1('nancy')
    t1(name='xiaoyun')
    # t1.a.b.c 链式操作

class Test2(object):
    def __init__(self,attr=''):
        self.__attr = attr

    # def __call__(self, *args, **kwargs):
    #     print('call-func: key is %s'%self.__attr)

    def __call__(self,name):
        print('call-func2: key is %s'% name)

    # def __call__(self):
    #     print('call-func-test')

    def __getattr__(self, key):
        if self.__attr:
            key = '{}.{}'.format(self.__attr,key)
        else:
            key = key
        print(key)
        return Test2(key) # 通过类函数调用类对象，（）再次完成一次实例化，类似于递归

t2 = Test2()
t2.a.b.c.d  # 调用的__getattr__函数
# t2.a.b.c()  # 调用的__call__函数，并且可以传参
t2.a.b.c('niuniu')

t2.name.sex.age(18)