Python函数

1. 函数的定义

　　1. 函数代码用关键字def声明，后接函数标志性名称（参数)
　　2. 函数参数放置（）中，可以有零个或多个
　　3. return 表达式结束函数
　　4. 匿名函数：lambda
　　　　1. lambda函数的主体是一个表达式，封装量非常有限
　　　　2. lambda函数拥有自己的命名空间，不能访问自己参数列表之外或全局里的变量
　　　　3. lambda函数只有一行

匿名函数
    x_ = lambda name, age: print(f'{age}岁的{name}')
    x_('小米',22)        # 22岁的小米
    
函数中封装匿名函数
    def myFunc(n):
        return lambda a: a * n
    print(myFunc(2)(10))        # 20

　　5. 参数的几种类型：

　　　　1. 必须参数：如果函数在声明的时候带了形参，则调用的时候必须传入参数
　　　　2. 关键字参数：关键字参数在传入时可以不按顺序，会根据参数的名称进行匹配
　　　　3. 默认参数：即在声明的时候形参携带了默认参数，如果调用的时候没有进行传参，则使用默认参数
　　　　4. 不定长参数：
　　　　　　1. *　　　　　　 带了*号的参数会以元组的形式传入，存放所有未命名的变量参数
　　　　　　2. **　　　  　　 带了**号的参数以字典的形式传入
　　　　　　3. * 单独出现　　*号导读出现，则*号后面的参数必须以关键字形式传入　　　

不定长参数
    * 以元组形式导入
        def printInfo(arg1, *argTuple):
            print(arg1)  　　　　　　# 10
            print(argTuple)  　　　 # (20, 30, 40)  后续为未名的变量以元组形式存放
            return
        printInfo(10,20,30,40)

    ** 以字典的形式导入
        def  printInfo(arg, **argDict):
            print(arg)　　　　　　　　　　# 1
            print(argDict)          　 # {'a'=A, 'b'=B}
            return
        printInfo(1, a='A', b='B')

    * 单独出现
        def printInfo(arg1, arg2, *, arg3):
            print(arg1+arg2+arg3)
            return
        printInfo(1, 2, arg3=3)                # 6

 

2. 递归函数

　　递归函数就是函数调用自身的过程　

例1：用递归函数实现数额阶乘
    常规函数实现方式
    def jiehceng(n):
        result = n
        for i in range(1,n):
            result *= i
        return result
    print(jiecheng(4))            # 24

    递归函数实现阶乘
    def factRecur(n):
        if n == 1:   return 1
        else:
            return n * factRecur(n-1)
    print(factRecur(4))            # 24

例2：递归函数实现斐波那契数列
    def fibRecur(n):
        if n == 1 or n == 2:   return 1
        else:
            return fibRecur(n-1) + fibRecur(n-2)
    print(fibRecur(10)                # 55

 

3. 构造函数

构造函数：类对象初始化的时候自动调用，用__init__命名，一个class类中只有一个构造函数
    例：
    class gouZao：
        def  __init__(self, name, age):
            self.name = name
            self.age = age
        def person(self):
            return f'我叫{self.name},今年{self.age}岁。'

　　gou = gouZao('张三','21')　　　　# 我叫张三，今年21岁。

构造函数中子类重写父类的方法
　　class father:
　　　　def __init__(self,x):
　　　　　　self.x = x
　　　　def write(self):
　　　　　　print('我是父类的方法')

　　class son(father):
　　　　def __init__(self):
　　　　　　pass
　　　　def write(self):
　　　　　　print('我是子类的方法')
　　mySon = son()
　　mySon.write()　　# 我是子类的方法，因为方法名相同，所以父类的方法在子类继承后被重写了

强制调用父类的私有方法
　　class Father:
　　　　def __init__(self,x):
　　　　　　self.x = x
　　　　def __action(self):
　　　　　　print('我是父类的私有方法')

　　class Son(Father):
　　　　def __init__(self):
　　　　　　pass
　　　　def action(self):
　　　　　　super()._Father__action()

　　Son().action()　　　　# 我是父类的私有方法，子类要调用父类的私有方法，需要调用super函数，并且父类前面需要添加_下划线

构造函数继承，调用父类中未绑定的方法，会引发钻石继承问题
　　class A:
   　　 def __init__(self):
   　　     print('我是A~')

　　class B1(A):
 　　   def __init__(self):
     　　   A.__init__(self)
      　　  print('我是B1')

　　class B2(A):
    　　def __init__(self):
    　　    A.__init__(self)
     　　   print('我是B2')

　　class C(B1, B2):
  　　  def __init__(self):
    　　    B1.__init__(self)
   　　     B2.__init__(self)
   　　     print('我是C~')

　　c = C()  # 连续打印了两次A的内容，不符合

解决钻石继承的问题————super(),继承父类的方法
　　class A:
  　　  def __init__(self):
   　　     print('我是A~')

　　class B1(A):
 　　   def __init__(self):
       　　 super().__init__()
  　　      print('我是B1')

　　class B2(A):
    　　def __init__(self):
      　　  super().__init__()
       　　 print('我是B2')

　　class C(B1, B2):
    　　def __init__(self):
        　　super().__init__()
       　　 print('我是C~')

　　c = C()

　　# 类的方法解析顺序mro(),或者__mro__()
　　print(C.mro())　　　# [<class '__main__.C'>, <class '__main__.B1'>, <class '__main__.B2'>, <class '__main__.A'>, <class 'object'>]
　　print(B1.mro())　　 # [<class '__main__.B1'>, <class '__main__.A'>, <class 'object'>]
　　print(C.__mro__)　　# (<class '__main__.C'>, <class '__main__.B1'>, <class '__main__.B2'>, <class '__main__.A'>, <class 'object'>)
　　print(B1.__mro__)　 # (<class '__main__.B1'>, <class '__main__.A'>, <class 'object'>)