2 python第三章函数

def 定义一名字
函数 定义：函数是指将一组语句的集合通过一个名字（函数名）封装起来，要执行这个函数，只需调用这个函数即可

   def  say():#函数名
       print("hellio ,I'm nobody")
   syhai() #调用函数

特性：
减少代码重复
保持程序的可扩展
使程序变得可维护

可以带参数`

#下面这段代码
a,b=5,8
c=a**b
print(c)

#改成用函数写
def calc(x,y)#形参
   res = x**y
   return res#返回函数执行结果
c = calc(a,b)#实参
print(c)

参数的作用可以让你的函数更灵活，不只能做死的动作，还可以根据调用时传参不同来决定函数内部的执行流程
形参变量
只有在被调用时才分配内存单元，因此，形参只在函数内部有效，函数调用结束返回主调用函数后不能在使用该形参变量
实参
可以是常量，变量，表达式，函数等，无论实参是何种类型的量，在进行函数调用时，它们必须有确定的值，以便把这些值传送给形参，因此应预先用赋值，输入等办法使参数获得确定的值
默认参数

def stu_register(name,age,country,course):
   print("-------学生注册信息-------")
   print("姓名：",name)
   print("年龄：",age)
   print("国籍：",country)
   print("课程：",course)
stu_register('alex',22,'cn','python')
stu_register('jack',24,'cn','python')
stu_register('rain',22,'cn','python')
stu_register('小河',22,'cn','python')

关键参数
给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可（指定了参数名的参数就叫关键参数），要求：关键参数必须放在位置参数之后

#调用可以这样
stu_register('小河',age=22,country='cn',course='python')

但绝不可以这样

stu_register('小河',course='cn',22,country='python')

当然也不可以这样

stu_register('小河',22,age=22,course='python')

非固定参数

#报警 1个运维人员
#def send_alert(msg,user):
def send_alert(msg,*users，age):#元组['alex'，'xxxx']---->('alex'，'xxxx')
    for u in users：
       print('报警',u)
#报警 10个运维人员
#方式一：
send_alert('报警','alex')
send_alert('报警','alex'，'xxxx','iii','uuu')
send_alert('报警','alex'，'xxxx','ooo','uuu')
send_alert('报警','alex'，'xxxx',)
#方式二：
send_alert('报警',*['alex'，'xxxx'])

send_alert('报警','alex'，'xxxx',age=22)#users带一个会报错

如果参数中出*users ,传递的参数就可以不再是固定个数，传过来的所有参数打包元组

非固定参数2

def func(name,*args,**kwargs):
    print(name,args,kwargs)
d={'degree':'primary school'}
#func('alex',22,'tessla','400w',addr='山东',number=1394752)
func('alex',**d)

函数-返回值
函数外部的代码要想获取函数的执行结果，就可以在函数里用return语句把结果返回

def stu_register(name,age,country,course):
   print("-------学生注册信息-------")
   print("姓名：",name)
   print("年龄：",age)
   print("国籍：",country)
   print("课程：",course)
   if age>22:
      return False#可以返回任何东西
   else:
      return Turn
status=stu_register('alex',22,'cn','python')
if status:
   print('注册成功')
else:
   print('too old to be a student')

注意：
函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为return语句代表着函数的结果
如果未在函数中指定return，那这个函数的返回值为None
局部变量

name = '小明'
def change_name():
    name = 'jack'
    print('new name',name,id(name))
#def fun()
#    name ='cc'#局部里面永远不会引用到fun里的name
change_name()
print(name,id(name))

ps: name里面改了外面改了，实际上两个name 时完全独立的，只是在里面重新定义了个name

#可以看出两个name的内存地址时不一样的
new name jack 2728775222416
小明 2728775360160

注意：
定义在函数外面的一级代码，叫全局变量，全局变量全局能用，但也要符合上下顺序
局部变量就是指定义在函数里面的变量，只能在局部生效
在函数内部可以引用全局变量
如果全局和局部都有一个变量，叫name，函数查找变量的顺序时由内而外的。

#在函数里修改全局变量name    建议不要用
name = '小明'
def change_name():
    global name  # global一定要放上面
    name ='kk'
    print('new name',name)
change_name()
print(name)

在函数里修改列表数据

name = ['小明','hh','jj']
def change_name():
    name [1]='cc'
    print('new name',name,id(name))
change_name()
print(name,id(name))

输出结果

new name ['小明', 'cc', 'jj'] 1599107195464
['小明', 'cc', 'jj'] 1599107195464

字典 列表集合 对象 类 都可以修改
字符串 数字 不可以修改
嵌套函数

def func():
    print('alex')

    def func2():
        print('jack')
    func2()
func()

结果

alex
jack

1.函数内部可以再次定义函数
2.执行需要被调用

age =19

def func():
    age=77
    print(age)

    def func2():
      #  age=99
        print(age)
    func2()
func()

输出 77
99

age是一层一层往上找的

age=19
def func():
    age=77
    def func2():
        print(age)
    func2()
func()

输出 77

age=19
def func():
    def func2():
        print(age)
    age=77
    func2()
func()

输出 77

age=19
def func():
    global age
    def func2():
        print(age)
    func2()
    age=77
func()
print(age)

输出 19
77

age=19
def func():
    global age
    def func2():
        print(age)
    age=77
    func2()
func()
print(age)

输出 77
77
作用域
在python中一个函数就是一个作用域（JavaScript类似）
c#或java 中的作用域{}
代码定义完成后，作用域已经生成，作用域链向上查找

age =18

def func1():
    age =74
    def func2():
        print(age)
    return  666

val = func1()
print(val)

结果

666

返回函数名

age =18

def func1():
    age =74
    def func2():
        print(age)
    return  func2

val = func1()
print(val)

结果

<function func1.<locals>.func2 at 0x000001D5FB64C6A8>

val()实际上等于func2()

age =18

def func1():
    age =74
    def func2():
        print(age)
    return  func2

val = func1()
val()

结果 74
函数名可以当作返回值
匿名函数

def calc(x,y):
   return x**y
print(lambda x,y:x*y) #声明一个匿名函数

返回
<function <lambda> at 0x00000234F49CC6A8>

def calc(x,y):
    if x<y:
        return x*y
    else:
        return x/y
# print(lambda x,y:x*y)
func=lambda x,y:x*y if x<y else x/y #声明一个匿名函数
print(calc(16,8))
print(func(16,8))

返回值 2.0
2.0
举例

data = list(range(1,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, 3, 4, 5, 6, 7, 8, 9]
[1, 4, 9, 16, 25, 36, 49, 64, 81]

作用 ：1.节省代码量 2.看着高级
跟其他方法搭配着使用
高阶函数
变量可以指向函数，
函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数称之为高阶函数

def f(x,y):
    return x+y
def calc(x):
    return x
# f= lambda x,y:x*y
f = calc(f)
print(f(4,8))

结果 12

def func2(x, y):
    return abs,x,y
res = func2(3,-9)
print(res)

#结果
(<built-in function abs>, 3, -9)

满足一下任一条件：
接受一个或多个函数作为输入
return 返回另一个函数