函数基础

概念：一系列Python语句的组合，可以在程序中运行一次或者多次，一般是完成具体的独立的功能。

为什么使用函数：代码的复用最大化以及最小冗余代码，整体代码结构清晰，问题局部化。

函数定义：

def 函数名(参数列表)：0-n个

​ 函数体【一系列的Python语句，表示独立的功能】

函数的调用：

​ 本质上就是去执行函数定义里面的代码块，在调用函数之前，必须先定义。

# 函数的定义
def printInfo():
    # 函数代码块
    print('校长的身高是%f'%1.76)
    pass

# 函数的调用
printInfo()

def printInfo(name,height,weight):
    # 函数代码块
    print('%s的身高是%f'%(name,height))
    print('%s的体重是%f'%(name,weight))
    pass
# 调用带参函数
printInfo('卡卡',169,50)

函数说明文档：函数内容的第一行可以用字符串进行函数说明，也就是添加多行注释进行说明

函数参数

参数：就是函数为了实现某项特定的功能，为了得到实现功能所需要的数据。

参数的分类：

必选参数、默认参数【缺省参数】、可选参数、关键字参数

1. 必选参数

   def sum(a,b):   #形式参数：只是意义上的一种参数，在定义的时候不占内存地址
       sum = a+b
       print(sum)
       pass
   # 函数的调用    在调用的时候必选参数，是必须要赋值的
   sum(10,12)  #实际参数：10,12   实参，是实际占用内存地址的
   
   

2. 默认参数

   # 默认参数   必须在参数列表的最后面
   def sum1(a=3,b=9):
       print('默认参数使用=%d'%(a+b))
       pass
   # 默认参数调用
   sum1()      #在调用的时候如果未赋值，就会用定义函数时给定的默认值
   sum1(10)
   

3. 可变参数

   # 可变参数（当参数的个数不确定时，比较灵活
   def getComputer(*args):
       '''
       计算累加和
       args ：可变长的参数类型
       '''
       # print(args)
       re = 0
       for item in args:
           re+=item
           pass
       print('re=%d'%re)
       pass
   
   getComputer(2,3,4)
   

4. 关键字可变参数

   # 在函数体内，参数关键字是一个字典类型，key是一个字符串
   def keyFunc(**kwargs):
       print(kwargs)
       pass
   # 调用
   # keyFunc(1,2,3)    不可以传递
   dictA = {'name':'lll','age':12}
   keyFunc(**dictA)
   keyFunc(name='peter',age=90)
   keyFunc()	#空
   
   # 组合使用
   def complexFun(*args,**kwargs):
       '''
       可选参数必须在关键字可选参数之前
       可选参数：接受的数据是一个元组类型
       关键字可选参数：接受的数据是一个字典类型
       '''
       print(args)
       print(kwargs)
       pass
   complexFun(1,2,3,name='吉吉')
   complexFun(age=12)
   

函数返回值

概念：函数执行完以后会返回一个对象，如果在函数的内部有return，就可以返回实际的值，否则返回None。

类型：可以返回任意类型，取决于 return后面的类型

用途：给调用方返回数据

在一个函数体内可以出现多个return值，但只能返回一个return

# 累加
def calComputer(num):
    re=0
    i=1
    while i<=num:
        re+=i
        i+=1
        pass
    return re
    pass
# 调用函数
value=calComputer(5)
print(value)

def returnType():
    
    #return 1,2,3    #返回元组类型的数据
    return {"name":"刻苦"}	#返回字典类型的数据
    pass
print(returnType()) 

函数的4种基本类型：

1. 无参数，无返回值，一般用于提示信息打印
2. 无参数，有返回值，多用于在数据采集中，比如获取系统信息
3. 有参数，无返回值，多用在设置某些不需要返回值的参数设置
4. 有参数，有返回值，一般是计算型的，需要参数，最终也要返回结果。

局部变量

在函数内部定义的变量，作用域仅局限在函数内部

不同的函数，可以定义相同的局部变量，

作用：为了临时的保存数据，需要在函数中定义来进行存储

全局变量

当全局变量和局部变量出现重复定义的时候，会优先使用函数内部定义的变量

如果在函数的内部对全局变量进行修改的话，必须用global 关键字进行声明。

引用：

1. 在Python中，万物皆对象，在函数调用的时候，实参传递的就是对象的引用。
2. 参数传递是通过对象引用来完成，

匿名函数

使用lambda 关键字创建匿名函数，所谓匿名即这个函数没有名字，不用def 关键字来创建标准的函数。

语法：

lambda 参数1、参数2.....：执行表达式

特点：

1. 使用lambda关键字创建函数

2. 没有名字的函数

3. 匿名函数冒号后面的表达式有且只有一个，注意：是表达式，不是语句。

4. 匿名函数自带return，return的结果就是表达式计算后的结果。

   #匿名函数
   M=lambda x,y:x+y
   #通过变量去调用匿名函数
   print(M(2,4))
   
   #三元
   func=lambda x,y:x if x>y else y
   print(func(2,12))
   #直接调用
   rs=(lambda x,y:x if x>y else y)(12,21)
   print(rs)
   

   缺点：

   lambda只能是单个表达式，不是一个代码块，lambda的设计就是为了满足简单函数的场景，仅仅能封装有限的逻辑，复杂逻辑实现不了，必须使用def来处理。

递归函数

递归满足的条件：

1. 自己调用自己
2. 必须有一个明确的结束条件

优点：逻辑简单、定义简单

缺点：容易导致栈溢出，内存资源紧张，甚至内存泄漏