Python(13)-函数,lambda语句

函数：有独立功能的代码块，组织（封装）成为小模块，有需要的时候调用。

自己编写第三方库：封装，修改功能代码块，增加函数定义，在其他程序中导入自己写的函数，来使用函数中的功能。

1 函数定义

定义一个函数的语法：

def 函数名()：

函数封装的代码

def test1():

print(‘hello world’)

函数中变量的命名规则与变量命名的规则相同

2 函数调用

定义好一个函数之后只是表明封装了一段代码，如果不调用函数函数是无法主动执行的。在函数名之后加一个小括号就能够完成函数调用工作。

带参数函数调用： 在函数名后按照定义变量的顺序依次填写实际要计算的参数。

Python不能在函数定义之前用函数名调用函数

3 函数注释文档

给Python中的函数添加注释 函数上方保留两个空行，函数的注释在函数定义下方第一行，三个引号，填写注释内容。


在函数调用出：View-》quick document快速文档(ctrl+q)->查看函数的注释说明信息。

在pycharm 文档注释解释函数功能基础上，要求同时显示参数说明
文档注释的模板：在“”“后面写 函数作用，在每个参数后写参数的含义

4 函数参数

参数：函数内部需要处理函数外部数据时，可以通过参数传递
函数的参数用以增加函数的通用性。

函数的参数类型：形参和实参
定义函数时的参数：形参，告诉使用者，要传两个参数，在函数内部当变量使用。
调用函数时的参数：实参，实实在在的参数。

示例函数：Sum_2_num() -实现两个数字求和，把需要计算的数字，通过参数的形式传递给函数。在括号里填写参数，多个参数之间用逗号分隔。

4.1 参数列表,默认参数,任意参数

4.1.1 无缺省值参数

def sum_2_num(num1,num2):…

4.1.2（部分）缺省值参数

（参数带默认值）

def sum_2_num(num1,num2=1):…

函数定义时，给参数设定默认值，当函数有外部参数传入时，使用传入的实参，没有参数传入时使用缺省值
好处： 简化常用情况下的参数传递
使用情况： 常见的值设为参数的默认值，不传递参数就能会调用默认值

定义参数的缺省值：在参数名后面加=加默认值就可以了。在指定缺省参数的默认值时，应该使用最常见的值作为默认值

注意事项：
a).定义位置：缺省参数应该放在参数列表的末尾，
b).调用多个缺省参数的函数：利用变量名=变量值来传递参数，避免传递位置错误

gl_list=[6,3,9]
#默认按升序排序，日常升序多
#gl_list.sort()
#如果需要降序排列，要指定reverse参数
gl_list.sort(reverse=True)
print(gl_list)

4.1.3 数量不定形参数

一个函数需要处理的参数个数是不确定的，这个时候可以使用多值参数来定义该函数。
多值参数好处：调用函数会比较方便。两种方式定义多值参数的方法：
a).参数名前面+*
b).参数名前面+**

*args
**kwargs

def sum_numbers(num1, *numbers):
    print(num1, numbers)        # 1 (2, 3, 4)
    s = num1
    for val in numbers:
        s += val
    print(s)                    # s = 10
    
sum_numbers(1,2,3,4)

使用元组和字典传递数量不定的参数，拆包操作

def demo(*args,**kwargs):
    print(args)
    print(kwargs)

gl_nums=(1,2,3)
gl_dict={"name":"xiaoming","age":18}

demo(gl_nums,gl_dict)
#输出：
#((1, 2, 3), {'age': 18, 'name': 'xiaoming'})
#{}

#拆包，
demo(*gl_nums,**gl_dict)
#等价于
demo(1,2,3,name="xiaoming",age=18)

注意：在函数中，参数在使用前必须被赋值。

4.2 可变对象和不可变对象

python 中的所有对象分为可变对象和不可变对象。所谓可变对象指的是，对象的内容可变，而不可变对象的内容不可变化。

不可变对象	数值类型，字符串，元组
可变对象	字典，列表

Python 参数都是对对象引用。如果在函数内部，尝试修改不可变对象，程序会在函数中生成新的对象，函数外被引用的对象则不会被改变。

1.函数内部，使用赋值语句操作不可变类型的实参，不会改变函数外的相对应的参数值

def demo(num,num_list):
    print("内部的代码")
    # 函数内部，对参数的赋值语句
    num = 100
    num_list=[1,2,3]
    print(num)
    print(num_list)
    print("函数执行完成")
gl_num=99
gl_list=[4,5,6]
demo(gl_num,gl_list)
print(gl_num)
print(gl_list)

输出

内部的代码
100
[1, 2, 3]
函数执行完成
99
[4, 5, 6]

2.函数内部，使用赋值语句操作可变类型的实参，会改变函数外的相对应的参数值

def changeable(list):
    list[0] = 2
    print(list)
lis = [1, 2, 3]
print(lis)
changeable(lis)
print(lis)

输出：

[1, 2, 3]
[2, 2, 3]
[2, 2, 3]

3.在函数内部使用可变类型的数据的方法，会改变外部实参。

def demo(num_list):
    print("函数内部的代码")
    #使用方法修改列表的内容,在函数内部使用方法是没有智能提示的
    num_list.append(9)
    print(num_list)
    print("函数执行完成")
gl_list=[1,2,3]
demo(gl_list)
print(gl_list)

输出:

函数内部的代码
[1, 2, 3, 9]
函数执行完成
[1, 2, 3, 9]

4.列表使用+=本质上是调用extend方法：可以把另外一个列表的内容加到当前列表下。

数字、字符串，使用+=先相加再赋值，列表+=会改变函数外面的变量：

def demo(num,num_list):
    print("函数开始")
    # num=num+num,不会改变外面实参
    num+=num
    # 调用方法，会改变外面是实参
    num_list+=num_list
    print(num)
    print(num_list)
    print("函数完成")

gl_num=9
gl_list=[1,2,3]
demo(gl_num,gl_list)

print(gl_num)
print(gl_list)

使用等价的语句则不会：

def demo(num,num_list):
    print("函数开始")
    # num=num+num,不会改变外面实参
    num+=num
    # 赋值语句，不会改变外面实参
    #num_list=num_list+num_list
    print(num)
    print(num_list)
    print("函数完成")

4.3 作用域

python在创建、改变、查找变量名时都是在命名空间中进行的，即在相应的作用域下进行的。Python不能声明变量，当变量初始化处就决定了这个变量存在于哪个作用域中。

默认情况下：函数中定义局部变量，主程序中定义全局变量。函数内部可以使用全局变量。

4.3.1 globals()函数

在函数内部，也可以使用globals函数访问全局变量。

x = 1
def print_x():
    x = 2
    print(globals()["x"])
    print(x)
print_x()

输出

1
2

4.3.2 global 声明变量为全局变量

def defin_gx():
    global gx     # 注意啦注意啦，下面使用的gx 使用的是全局变量哈
    gx = 3 
gx = 1
defin_gx()
print(gx)

输出

3

5 函数返回值

一个函数执行结束后，告诉调用者执行的结果。使用 return关键字返回执行结果，可以使用一个变量来接受返回的结果。

在return语句后的函数语句是无法到达的，所以，return语句应该作为函数的最后一句话

5.1返回单个值

return num

5.2返回多个值

返回多个结果(函数返回当前的温度和湿度)

def measure():
    #测量温度和湿度
    print("测量开始")
    temp=39
    wetness=50
    print("测量结束")
    # 元组-可以多个数据，因此可以使用元组让函数一次性返回多个值
    # 如果返回的数据类型是元组，小括号可以省略，否则有小括号提示
    #return (temp,wetness)
    return temp,wetness

#元组。从元组中拿到单独的数据
result=measure()
#需要拿到温度和湿度,
print(result[0])
print(result[1])

#如果函数返回的类型是元组，同时希望单独处理元组中的元素
#可以使用多个变量，一次性接受函数 的返回值
#注意使用多个变量接受结果时，变量的个数应该和元组中元素的个数保持一致
gl_temp,gl_wetness=measure()
print(gl_temp)
print(gl_wetness)

6 函数的嵌套调用

一个函数中嵌套另外一个函数

 
def test1():
    print('1' * 50)
    
def test2():
    print("-" * 50)
    test1()
    print("+" * 50)
    
test2()

**温馨提示：**项目出现新的需求时，不要急着改变已经测试好的程序，另求他法，尽可能不要在原有的函数或者模块中改动，因为要求可能还会变回去。

7 函数的递归

一个函数数的递归：自己调用自己
特点：
1.要传入参数，是会根据参数的不同做不同处理，
2.递归一定要有一个出口，没有出口会出现死循环

递归执行流程：每次递归调用的核心就是处理的参数会改变。
案例演练：接收数字num，完成1+2+num用递归完成。遍历整个文件目录，递归算法编写出来的十分有效果

def sum_num(num):
    # 出口
    if num==1:
        return 1
    # 数字累加
    #假设sum_number能够完成1...num-1之间的累加
    temp=sum_num(num-1)
    return num+temp

result=sum_num(5)
print(result)

8 lambda语句

lambda用于创建匿名函数。对于一些抽象的、不会在其他地方复用的函数，可以使用lambda语句使代码变得精简。

# lambda表达式
g = lambda x : x + 1
print(g(1))

冒号左边是函数的参数，有多个参数使用逗号分割开。
冒号右边是返回值，只能有一个返回值，包含实际计算操作

注意lambda语句只有一个返回值一个表达式，不能含有命令。

demo: lambda语句实现任意底数的函数

from math import log
def make_logarithmic_function(base):
    return lambda x:log(x, base)
my_lf = make_logarithmic_function(base=3)

print(my_lf(9))

输出

2.0