Python函数的重载、多态和继承

一、函数重载

Python重载函数是指函数可以接受不同数量或类型的参数，这样可以使得函数可以处理多种情况。函数重载是指有多个参数签名（即函数在定义时参数个数跟类型）并且有多个舍入函数体实现。也就是，具有相同名称但实现多个不同的功能。调用重载函数时，运行时首先评估传递给函数调用的参数，并以此判断调用相应的实现。它使得用相同的函数名，可以处理不同类型或数量上的参数。

Python中，可以实现函数重载的方法有三种：

• 实现同名不同参数函数
  需要根据不同参数进行分别实现，但代码编写较繁琐，可读性不强。
• 根据实参类型确定调用函数
  可以根据实参的类型，通过类型检查选择不同的函数。使代码更清晰，提高代码可读性。
• 通过 *args和 *kwargs形参对函数进行重载
  可以使用args形参来接收可变的位置参数，使用kwargs来接收可变的关键字参数，这种方式可以 同时支持不定数量参数和不同类型参数。

# First multiply method.
# Takes two argument and print their value
def multiply(a, b):
    re = a * b
    print(re)

# Second multiply method.
# Takes three argument and print their value
def multiply(a, b,c):
    re = a * b * c
    print(re)

multiply(3, 4)

multiply(3, 4, 5) # This line will call the second multiply method.

Python不支持自定义函数的重载。 当我们用相同的名称定义多个函数时，后一个函数始终会覆盖前一个函数，因此，在命名空间中，每个函数名始终只有一个entry。

二、函数多态

在python中根据参数的不同可以使同一函数的工作方式不同（多态）

# Function to take multiple arguments 
def add(datatype, *args): 

    # if datatype is int 
    # initialize answer as 0 
    if datatype =='int': 
        answer = 0
        
    # if datatype is str 
    # initialize answer as '' 
    if datatype =='str': 
        answer ='' 

    # Traverse through the arguments 
    for x in args: 

        # This will do addition if the 
        # arguments are int. Or concatenation 
        # if the arguments are str 
        answer = answer + x 

    print(answer) 

# Integer 
add('int', 5, 6) 		# 11
# String 
add('str', 'Hi ', 'Bob') 		# Hi Bob

三、函数继承

python中的类支持继承，并且支持多继承。python中默认情况是继承自object（object是python中所有类的基类）

1. 什么是继承？
   一个类可以继承另外一个类，继承者我们叫子类，被继承者叫父类。继承就是让子类直接拥有父类中的内容
2. 可以继承哪些内容
   所有的属性和方法都可以继承

class Person(object):
    num = 61

    # 注意：__slots__对应的值不会被继承
    __slots__ = ('name', 'age', 'sex')

    def __init__(self):
        self.name = '张三'
        self.age = 0
        self.sex = '男'

    def show_message(self):
        print('%s你好吗?' % self.name)

# Student类继承自Person类
class Student(Person):
    pass

# 创建学生对象
stu1 = Student()
# 对象属性可以继承
print(stu1.name, stu1.age, stu1.sex)

# 类的字段可以继承
print(Student.num)

# 对象方法可以继承
stu1.show_message()

p1 = Person()
# p1.color = '黄色'
stu1.color = '白色'
print(stu1.color)

备注：

def __init__(self):
        self.name = '张三'
        self.age = 0
        self.sex = '男'

self 代表着实例, 所以 self.name/self.age/self.sex 是 ‘实例属性’

总结：区分清 “类属性” 和 “实例属性” 的概念:直接定义在类下面的是类属性, 定义在__init__中的self.xxx是实例属性

子类-添加方法

1. 添加一个新的方法
   直接在子类中声明其他的方法;
   添加后子类可以调用自己的方法也可以调用父类的方法，但是父类不能调用子类的方法
2. 重写父类的方法: 重新实现父类的方法
   完全重写 - 覆盖父类的功能 - 直接在子类中重新实现父类的方法
   部分重写 - 保留父类的功能，添加新的功能 - 在子类中实现父类方法的时候通过super()去调用父类的方法，
   再添加新的功能
   注意：a.可以子类的方法中通过super()去调用父类的方法
   super(类, 对象)- 获取对象中父类的部分(要求对象是这个指定的类的对象)
   b.静态方法中不能使用super()
3. 类中方法的调用过程
   通过对象或者类调用方法的时候，先看当前类中是否声明过这个方法，如果声明过就直接调用当前类对应的方法;
   如果当前类中没有声明过，会去找父类中有没有声明过这个方法，声明过就调用父类的方法;
   如果父类中也没有声明过，就去找父类的父类…以此类推，直到object中也没有声明过，程序才会崩溃
   构造函数

class Person:
    # 类的字段
    num = 61

    # 对象属性
    def __init__(self):   # 有self则为 实例方法，代表实例
        self.name = '张三'  # 实例变量，保存特征值
        self.age = 0
        self.sex = '男'

    def fun1(self):   # 有self则为 实例方法，代表实例
        print('Person的对象方法')

    # 方法
    def show_message(self):		# 有self则为 实例方法，代表实例
        print('%s,你好吗？' % self.name)

    @staticmethod
    def info():
        print('我是人类')


class Student(Person):

    def study(self):
        print('%s在学生' % self.name)

'''
类变量、实例变量、实例方法、类方法、静态方法类方法和静态方法不能访问实例变量
在函数中不带self的是类方法或静态方法，不能访问实例变量
实例方法中默认参数self，类方法中默认参数cls，静态方法没有默认参数
类方法中用@classmethod 这种装饰器，静态方法中用@staticmethod 这种装饰器
'''
    @classmethod		 # @classmethod # 类方法。装饰器
    def message(cls):   
        super().info()
        print('我是学生!')

    # 完全重写
    @staticmethod   #@staticmethod # 静态方法。装饰器
    def info():
        print('我是学生！！！')

    # 保留父类的功能
    def show_message(self):
        super().show_message()
        print('我去上学~')
        super().fun1()

# Student.info()

备注：

（1）类中的方法都是普通方法，第一个参数是self，这种方法只能被实例调用，如果被classmethod装饰，这个方法就是类方法，可以被类和实例调用

class Student():
    @classmethod		 # @classmethod # 类方法。装饰器
    def message(self):
        print('我是学生!')

stu = Student()
print(stu.message())  # 输出我是学生
print(Student.message())  # 输出我是学生

class Student():

    def message(self):
        print('我是学生!')

stu = Student()
print(stu.message())  # 输出我是学生
print(Student.message())  # 报错

File "D:/xxxxx/xxxx.py", line 199, in print(Student.message())TypeError: message() missing 1 required positional argument: 'self'
因为message（）第一个参数是self，这种方法只能被实例调用

（2）带参函数 举例：fun1(self)
函数有self则为 实例方法，代表实例

p = Person()   # 实例化
print(p.fun1())   	# 输出Person的对象方法
print(Person().fun1())    	# 输出Person的对象方法
print(Person.fun1()) 	# 报错

File "D:/xxxxx/xxxx.py", line 76, in print(Person.fun1()) TypeError: fun1() missing 1 required positional argument: 'self'
因为方法fun1带参数（fun1是实例方法），实例方法需要通用实例对象来访问。

（3）不带参数 举例：info()
因为info()无self参数，所以直接调用
在函数中不带self的是类方法或静态方法，不能访问实例变量

print(Person.info())  # 输出我是人类

子类-添加属性

1. 添加类的字段
   直接在子类中添加新的字段
2. 添加对象属性
   a.继承对象属性是通过继承父类的init方法继承下来的
   b.如果想要在保留父类继承下来的对象属性的前提下，添加新的对象属性，
   需要在子类的init方法中，通过super()去调用父类的init方法

class Person:
    num = 61

    def __init__(self, name):
        self.name = name
        self.age = 0


class Student(Person):
    number = 100

    def __init__(self, name):
        super().__init__(name)
        self.study_id = '001'


print(Student.number, Student.num)

stu1 = Student('小明')
print(stu1.name, stu1.age, stu1.study_id)

# 练习：
# 声明一个动物类，有属性：年龄，颜色，类型。
#  要求创建动物对象的时候类型和颜色必须赋值，年龄可以赋值也可以不赋值
# 声明一个猫类，有属性:年龄，颜色，类型, 爱好
# 要求创建猫对象的时候，颜色必须赋值，年龄和爱好可以赋值也可以不赋值，类型不能赋值


class Aniaml:
    def __init__(self, type, color, age=0):
        self.type = type
        self.color = color
        self.age = age


class Cat(Aniaml):
    def __init__(self, color, age=0, hobby=''):
        super().__init__('猫科', color, age)
        self.hobby = hobby


an1 = Aniaml('犬科', '黄色')
an2 = Aniaml('犬科', '黄色', 10)

cat1 = Cat('白色')
cat2 = Cat('灰色', 3)
cat3 = Cat('灰色', hobby='睡觉')
cat4 = Cat('灰色', 3, '睡觉')

参考文章:
https://blog.csdn.net/bai666ai/article/details/123998686
https://www.jianshu.com/p/4b1f9257a2f2