Python语法基础（七）

🌈个人主页：羽晨同学 

💫个人格言:“成为自己未来的主人~”  

我们今天的这篇文章，主要和大家讲一下函数重写的问题。

首先，我们要知道的是，函数重写是有前提条件的，那就是继承。

自定义函数的重写

首先，我们来说一下自定义函数的重写。

我们先来定义一个父类和子类的函数。

class Animal():
    def style(self):
        print('walking')
class Cat(Animal):
    pass
class Dog(Animal):
    pass

你看，这是我们定义的一段函数，父类是动物类，子类是Cat和Dog。

我们需要注意的第一点是：

如果子类未重写父类中的函数，则子类可以继承父类中的函数。

如果子类中重写了父类中的函数，那么就调用子类函数。

而当子类重写函数的时候，如果仍然需要父类中的函数的功能，那么我们就可以在子类中调用父类函数。

class Bird(Animal):
    def style(self):
        # super().style()
        # Animal.style(self)
        # super(Bird,self).style()
        print('flying')

比如说，我们定义了一个鸟的子类，并且，我们重写了style函数。

当我们运行这个类的时候，会调用子类中的函数。

b=Bird()
b.style()

系统函数的重写

首先，我们要明确的是，python中所有类的父类都是object，所以自定义的类默认使用的系统功能都继承自object

比如说，我们创建一个类。

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

然后，我们将这个类进行实例化。

p1=Person('张三',18)

当我们打印一个对象的时候，我们默认会调用系统的魔术方法__str__

该函数的返回值默认就是当前对象在内存中的地址。

print(p1) # <__main__.Person object at 0x000001A61A067890>
print(p1.__str__()) # <__main__.Person object at 0x000001A61A067890>

我们再来定义一个类，并且我们重写一下这个魔术方法。

class Person2():
    def __init__(self,name,age):
        self.name=name
        self.age=age
    # 重写__str__
    def __str__(self):
        # 注意，必须返回一个字符串，一般情况下，返回和当前对象相关的属性信息
        return f'姓名:{self.name},年龄：{self.age}'
    def __repr__(self):
        return f'姓名:{self.name},年龄：{self.age}'
    __repr__=__str__ # 函数的本质

这个时候，我们再将这个类进行实例化，并打印刚才的魔术方法

p2=Person2('张三',18)
print(p2)
print(p2.__str__())

你看，打印出来的结果变成了这样子。

当我们重写子类中的函数的时候，会优先调用子类的函数。

我们将对象添加到容器中，直接打印容器，默认仍然显示地址，所以此时需要重写__repr__

我们来看下面的代码。

l=[p2]
print(l)

重写之后，就变成了这个样子。

装饰器修饰函数

我们在上一篇文章中说了一下装饰器修饰函数的部分。

我们来回顾一下。

# 1、装饰器装饰函数
def wrapper(func): #装饰函数参数命名
    def inner():
        func() # 调用原函数
        print('函数-----new-----')
    return inner
@wrapper # 相当于调用外部函数wrapper
def check():
    print('函数-----checking')
check() # 相当于调用内部函数inner

装饰器修饰类

其实和装饰器修饰函数大概是相同的，我们来看下面的代码。

# 2、装饰器装饰类
def wrapper(cls):  #装饰函数参数命名 cls: 表示需要被装饰的类
    def inner():
        cls()      # 创建对象
        print('类-----new-----')
    return inner

@wrapper           # 相当于调用外部函数wrapper
class Check():
    print('类------Check')
Check()

当我们用一个类常见两个对象的时候，这两个对象是不同的，因为它们的地址不同。

# 1、普通类
class Book():
    def __init__(self,name,data):
        print('init-------')
        self.name=name
        self.data=data
b1=Book('钢铁是怎样练成的',2001)
b2=Book('python从入门到精通',2015)

print(b1 is b2) # False
print(id(b1)==id(b2)) # False

这个是代码执行出来的结果，很明显，这两个对象是完全不同的。

但是，如果我们存储被装饰的类，就可以创建出来唯一的对象。

比如说，我们来看下面的这段代码。

def wrapper(cls):
    # 存储被装饰的类可以创建的唯一的对象
    instance = None
    def inner(*args,**kwargs):
        # ls(*args,**kwargs) 每执行一次，就会创建一个新的对象，要实现单例类，就控制它只执行一次
        nonlocal instance
        if not instance:
            instance=cls(*args,**kwargs)
        return instance
    return inner

@wrapper
class Person():
    def __init__(self,name,age):
        print('init------')
        self.name=name
        self.age=age

p1=Person('张三',10) # 创建对象
p2=Person('李四',52) # 获取对象
print(p1 is p2) # True
print(p2.name)
print(p1.name)

你看，这个时候，我们创建出来的对象就是相同的，都是第一个对象，第二个常见对象的值不会进行操作。

好了，我们今天的文章就到这里，我们下次再见。