函数

函数定义：函数是指将一组语句的集合通过一个名字（函数名）封装起来，要想执

行这个函数，只需调用其函数名即可。

特性：

减少重复代码   使程序变的可扩展    使程序变得易维护

def sayhi():#函数名

　　print("Hello, I'm nobody!")

sayhi()　　#调用函数

#函数基本用法

def calc(x,y):

    res = x**y
    print(res)

calc(5,10)
calc(2,10)



#函数默认参数
参数可以让你的函数更灵活，不只能做死的动作，还可以根据调用时传参的不同来决定函数内部的执行流程

形参变量
只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此形参只在函数内部有效。函数
调用结束返回主调用函数后则不能再使用该形参变量

实参
可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，
以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

#函数默认参数，参数位置要一一对应,位置参数要放最后面。

def stu_register(name,age,course,country='CN'):
    print("registriation info....")
    print(name,age,country,course)

stu_register("Alex",22,"python")
stu_register("Jack",22,"python")
stu_register("Rain",22,"python",'korean')

#关键参数
正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，但记住一个要求就是，关键参数必须
放在位置参数（以位置顺序确定对应关系的参数）之后

调用可以这样
stu_register('王山炮',course='py',age=22,country='JP')

例：

def stu_register(name,age,course,country='Cn'):
    print("registriation info....")
    print(name,age,country,course)

stu_register("Alex",23,course='python')

#非固定参数
#报警，1个运维人员

def send_alert(msg,*users):
    for u in users:
        print('报警发送给',u)

#如果参数中出现 *user,传递的参数就可以不再是固定个数，传过来的
# 所有参数打包元祖
#方式一：
# send_alert('别他么狼了','alex','xxx','xxx')
# send_alert('别他么狼了','alex',)
# send_alert('别他么狼了','alex','xxx')
# send_alert('别他么狼了','alex','xxx','iiii')

#方式二： 传递列表或元组，要在列表前加个 * 号
# 带*号的形参如果在前面，实参对应的位置后面的要赋值，否则会被带*号的形参全截走。
send_alert('别他么狼了',*['alex','xxx','iii'])

例：
def func(name,*args,**kwargs):

    print(name,args,kwargs)
#传列表
func('Alex',22,'tesla','500w',addr='山东',num=12442323)

#传字典加两个*
d = {'degree':'primary school'}
func('peiqi',**d)

#返回值
函数外部的代码要想获取函数的执行结果，就可以在函数里用return 语句把结果返回
注意：函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为
return 语句代表着函数的结束
如果未在函数中指定return,那这个函数的返回值为None
return 代表函数的结束，后面再多代码，都不会在执行
def stu_register(name,age,course):

    print(name,age,course)
    if age > 22:
        return False
    else:
        return name,age　　#想返回多个值，可以在后面加逗号。返回的是一个元组。

status =stu_register('peiqi',29,'安保')
print(status)

#局部变量
定义在函数外部一级代码的变量，叫全局变量，全局能用。
局部变量 就是指定义在函数里的变量
在函数内部，可以引用 全局变量
如果，全局和局部都有一个变量叫name 函数查找变量的顺序是由内而外的。

# name = "Black girl"
# def change_name():
#     global name     #在函数中修改全局变量
#     name = "黑色的姑娘"
#     age = 25
#     print("在",name,"里面...",id(name))
#
#
# change_name()
# print(name)

#在函数里修改列表数据

# names= ['Alex','Black Gril','Peiqi']
#
# def change_name():
#     del names[2]
#     names[1]= "黑姑娘"
#     print(names)
#
# change_name()
# print(names)

#嵌套函数
# def func1():
#
#     print('alex')
#
#     def fuc2():
#         print('eric')
#     fuc2()
#
# func1()
#======>   1、函数内部可以再次定义函数。
#======》 2 、执行需要被调用

age = 19
def func1():
    print('alex')
    age = 73

    def fuc2():
        print('eric')
    fuc2()

#作用域
#python中函数就是一个作用域

定义完成后，作用域已经生成，作用域链向上查找
函数名可以当返回值

作用域
#python中函数就是一个作用域，局部变量放置在其作用域中
#定义完成后，作用域已经生成，作用域链向上查找
age = 18
def func1():
    age =73
    print('alex')
    def func2():
        age = 84
        print('eric')
        return func2
val =func1()
print(val)

#匿名函数

# def calc(x,y):
#     if x < y:
#         return x*y
#     else:
#         return x/y
#
# func = lambda x,y:x*y if x < y else x/y #声明一个匿名函数
# #匿名函数不支持复杂的运算，最多支持三元运算
#
# print(calc(16,8))
# print(func(16,8))

data = list(range(10))
print(data)

# for index,i in enumerate(data):
#     data[index] =i*i
# print(data)

def f2(n):
    return n*n
print(list(map(lambda x:x*x,data)))

#1、节省代码量
# 2、看着更高级

#高阶函数
#变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数

def func(x,y):
    return x+y

def calc(x):
    return x*x
n = func 
calc(n)

#递归

#递归
# def calc(n):
#     n = int(n/2)
#     # print(n)
#     return n
#
# r1=calc(10)
# r2=calc(r1)
# r3 =calc(r2)
# print(r3)
import sys
# sys.setrecursionlimit(10000)#改限制层 为10000层，一般1000层是不改的。
print(sys.getrecursionlimit())

def func():
    pass

def calc(n):
    n = int(n/2)
    print(n)
    calc(n)
calc(10)

#递归就是用同样的逻辑重复多次可以用递归

#递归执行过程分析
递归执行完后，再一层一层退出去。

#递归的返回值

def calc(n,count):
    print(n,count)
    if count < 5:
      return  calc(n/2,count+1) #递归的返回值,return 缺一不可
    else:
        return  n       #递归的返回值 return缺一不可

res =calc(188,1)
print('res',res)

#递归特性：
必须有一个明确的结束条件
每次进入更深一层递归时，问题规模都应会有所减少
递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，
栈就会加一层栈帧，每当函数返回，栈就会减少一层栈帧，由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）