python-函数

函数

1. 函数是什么？

　　定义：

1. 一组语句通过一个名字（函数名）封装

2. 通过调用函数名执行

3.函数可以带参数

def test():     # 定义一个函数
    print('test')
    

test()  # 调用一个函数

def abc(a, b):  # 定义一个abc函数,可以带参数

    c = a+b
    return c    # 代表函数的结束并返回计算结果
    print('结果是',c)    #这句不会执行


resu = abc(3, 4)   # 调用函数abc    函数返回的结果赋给参数
print(resu)

特性：

1.减少重复代码

2.程序变得可扩展

3.变得易维护

2. 函数参数

1. 形参

　　1.调用时分配内存单元，结算时释放内存单元。            ——》如下：当函数执行完时str的值就不能在函数外面使用了

　　2.函数内部有效，函数执行完结束后主函数不能使用这个参数。　　——》str只有在test函数里有效

2. 实参

　　1.可以是常量、变量、表达式、函数。　　——》a是变量

　　2.调用函数时，要预先赋值。　　——》a要先赋值，才能进行传进函数里进行运算。

def test(str):     # str——》形参
    print('test', str)


a = '哈哈'
test(a)  # a——》实参

3. 默认

　　在定义函数时指定。

　　调用函数时有值传入，使用函数的值。

　　调用函数时没有值传入，使用默认参数的值

4. 关键

　　位置参数——函数传参时必须按照函数定义的位置填。

　　关键参数——使用关键参数,传参时可以不按位置填。

def test(str, age, county='CN'):     # county='CN'默认参数，
    print('test', str, age, county)  # county 有传值——》用函数的值 ；没传值——》用定义的值


a = '哈哈'
test(a, 22, county='JP')  # a：位置参数
test(a, age=22)  # age=22 关键参数；关键参数必须放在位置参数后

5. 非固定

　　不确定用户传入多少个参数。

　　1.*args——》返回元组

　　2.**kwargs——》返回字典

def func(*args, **kwargs):  # *args和**kwargs这个就是非固定参数
    name = args[0]   # args 返回的是一个元组
    password = kwargs['password']  # kwargs返回的是一个字典
    print(type(args), type(kwargs))
    print(name, password)


func('abc', password='123')  # 非固定参数值传入方式 'abc'=>args ,'password=123'=>kwargs

输出：
<class 'tuple'> <class 'dict'>
abc 123

3. 函数返回

1.类型

　　1.函数里可以没有return语句

2. 函数没return——函数返回值为None

3. 函数有return——函数执行结果

2. 值的数量

　　1.一个——可以为一个变量

　　2.多个——可以为多个变量，每个变量用逗号分隔，以元组方式返回

3. 状态

　　 1.遇到return语句，函数停止执行，并返回执行结果。

　　 2.return指定函数的结束

　　 3.可以返回任意数据类型

def abc(a, b):
    c = a+b
    return a, b, c   # 返回多个变量


num1, num2, resu = abc(3, 2)  # 返回几个要接几个
print(num1, num2, resu)

4. 变量

1. 全局　　

　　定义在函数外部，变量全局有效

2. 局部

　　定义在函数内部，函数执行时分配内存空间，执行完释放。

　　函数外面不能调用局部变量

name = "全局变量"  # name 在函数外，哪里都有他份


def in_or_out():
    name = "局部变量"
    print("这是in", name)  # name 在函数内部有效执行完不关他的事


in_or_out()

print("这是out", name)

output:
这是in 局部变量
这是out 全局变量

3. 作用域

　　程序变量可用的范围

5. 其他函数

　　1.嵌套

　　函数里嵌套一个函数

#嵌套函数
name = "123"


def change_name():
    name = "456"

    def change_name2():
        name = "789"
        print("第3层打印", name)

    change_name2()  # 调用内层函数
    print("第2层打印", name)


change_name()
print("最外层打印", name)

2. 匿名

　　不需要显式的指定函数名

#1.这段代码 显式函数
def calc(x, y):
    return x**y


print(calc(2, 5))


#2.换成匿名函数
calc2 = lambda x, y: x**y
print(calc2(2, 5))

2. 高阶

　　2.1一个函数，它的参数接收了另一个函数作为其参数

# 第一种情况：函数名可以用作参数
def func():  
    print('func')


def func2(f):    # 1.定义一个函数   3.func2这个函数称高阶函数
    f()
    print('func2')
    
    
func2(func)    # 2. func2的参数是函数名func

def add(x, y, f):      # 1、一个函数 add()。
    return f(x) + f(y)  # 3、这个add()函数称为高阶函数。


res = add(3, -6, abs)   # 2、add()它的参数接收了另一个函数abs作为其参数。
print(res)

   2.2一个函数，它的返回值是另一个函数。

# 第二种情况：函数的返回值是另一个函数
def func():       # 1.定义一个函数 3.func这个函数称高阶函数
    def func3():
        return 'a'
    return func3   # 2.这个函数的返回值是另一个函数


func3 = func()
print(func3())

3. 递归

一个函数在内部调用自身本身，这个函数就是递归函数。

def calc(n):
    print(n)
    if int(n/2) == 0:
        return n
    return calc(int(n/2))  # 在函数的内部调用自身


calc(10)

#递归应用1：
#现有一个需求：需要把一个数除5次并把第5次结果的值返回
#递归的返回值：
def calc2(n, count):
    print(n, count)
    if count < 5:
        return calc2(n/2, count+1)   # 返回前面几层数据
    else:
        return n     # 返回最里层数据


res = calc2(188, 1)
print(res)

4. 内置

Python预先加载好的