函数定义：函数是指将一组语句的集合通过一个名字（函数名）封装起来，要想执
行这个函数，只需调用其函数名即可。
特性：
减少重复代码 使程序变的可扩展 使程序变得易维护
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）这种数据结构实现的，每当进入一个函数调用，
栈就会加一层栈帧，每当函数返回，栈就会减少一层栈帧，由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）