〖Python〗-- 函数

【函数】

函数在计算机中解释为ubroutine（子进程或子过程）

　函数定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可

　语法定义：

　　　不带参数：

def sayhi(): #函数名

　　　　　　　　　　print("hello , world!")

　　　　　　　　sayhi() #调用函数

  　　带参数：

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

　　　　　　#改成用函数写
　　　　　　def calc(x,y):
    　　　　　　res = x**y
    　　　　return res #返回函数执行结果

　　　　　　c = calc(a,b) ＃结果赋值给c变量
　　　　　　print(c)

　　　　函数特性：

　　　　　　1减少重复代码

　　　　　　2提高代码可扩展性

　　　　　　3使程序变的易维护

　　参数

　　　　必须参数

　　　　　　必须以参数定义的顺序传入函数，调用的时候也必须按顺序全部调用

　　　　def f(name,age):

   　　 　　print(‘I am %s,I am %d‘%(name,age))

　　　　f(‘ShengXin‘,18)
　　　　f(‘alvin‘,16)

　　　　关键字参数

　　　　　　所谓的关键字参数，类似于字典的键值对，通过关键字调用函数，就相当于通过键找值。

　　　　def f(name,age):

    　　　　print(‘I am %s,I am %d‘%(name,age))

　　　　# f(16,‘alvin‘) #报错
　　　　f(age=16,name=‘alvin‘)

　　　　默认参数

　　　　　　在关键字参数的基础上，某些参数给默认值，不修改的话，显示默认值，不修改无需再调用，会自动显示

　　　　def print_info(name,age,sex=‘male‘):  #默认参数放在最后

   　　　　 print(‘Name:%s‘%name)
  　　　　  print(‘age:%s‘%age)
 　　　　   print(‘Sex:%s‘%sex)
　　　　    return

　　　　print_info(‘Shengxin‘,18)    #sex不给值,显示默认值
　　　　print_info(‘铁锤‘,40,‘female‘)  #修改sex的值，显示修改后的值

　　　　不定长参数

　　　　　　在用户输入参数不确定个数的情况下，使用不定长参数，分类如下：

　　　　　　*kwargs

　　　　　　　　 多传入的参数以元组的形式保存

　　　　　　def stu_register(name,age,*args): # *args 会把多传入的参数变成一个元组形式
　　　　　　    print(name,age,args)

　　　　　　stu_register("ShengXin",22)
　　　　　　#输出
　　　　　　#ShengXin 22 () #后面这个()就是args,只是因为没传值,所以为空

　　　　　　stu_register("Jack",32,"CN","Python")
　　　　　　#输出
　　　　　　# Jack 32 (‘CN‘, ‘Python‘)

　　　　　　**kwargs

　　　　　　　　多传入的参数以字典形式保存

　　　　　　def stu_register(name,age,*args,**kwargs): # *kwargs 会把多传入的参数变成一个dict形式
 　　　　　　   print(name,age,args,kwargs)

　　　　　　stu_register("Shengxin",22)
　　　　　　#输出
　　　　　　#Alex 22 () {}#后面这个{}就是kwargs,只是因为没传值,所以为空

　　　　　　stu_register("Jack",32,"CN","Python",sex="Male",province="ShanDong")
　　　　　　#输出
　　　　　　# Jack 32 (‘CN‘, ‘Python‘) {‘province‘: ‘ShanDong‘, ‘sex‘: ‘Male‘}

　　局部变量

　　　　在函数中重新定义函数外的同名函数，函数值在函数内部生效，作用域为函数，所定义的变量是局部变量

　　　　name = "Shengxin" #全局变量

　　　　def change_name(name):
   　　　　 print("before change:",name)
   　　　　 name = "changed name"  　　 #局部变量
  　　　　  print("after change", name)

　　　　change_name(name)

　　　　print("在外面看看name改了么?",name)

　　返回值

　　　　return

　　　　　　在函数中，return会结束本层执行，并返回结果

　　　　　　函数的默认返回值为:none

　　递归

　　　　在函数中调用函数本身

　　　　def calc(n):
 　　　　   print(n)
　　　　    if int(n/2) ==0:
 　　　　       return n
 　　　　   return calc(int(n/2))

　　　　calc(10)

　　　　特性：

　　　　　　必须有一个明确的结束条件

　　　　　　每次进入下一层递归时，计算规模应该减少

　　　　　　递归函数执行效率低，过多的递归会导致栈溢出

　　匿名函数

　　　　在python中使用lambda来创建匿名函数

　　　　格式：

　　　　　　lambda arg1,arg2... : <expression>

　　　　　　　　#算一个数的平方　　　　def calc(n):
 　　　　   return n**n
　　　　print(calc(10))

　　　　#换成匿名函数
　　　　calc = lambda n:n**n
　　　　print(calc(10))

　　　　作用：

　　　　　　匿名函数主要是和其它函数搭配使用

　　　　res = map(lambda x:x**2,[1,5,7,4,8])
　　　　for i in res:
  　　　　  print(i)

　　函数式编程

　　高阶函数

　　　　函数名可以作为参数输入

　　　　函数名可以作为返回值

　　　　def add(x,y,f):
 　　　　   return f(x) + f(y)

　　　　res = add(3,-6,abs)
　　　　print(res)

　　内置函数

　　　　python内置的函数

作用域

　　python中的作用域分4种情况：

• L：local，局部作用域，即函数中定义的变量；
• E：enclosing，嵌套的父级函数的局部作用域，即包含此函数的上级函数的局部作用域，但不是全局的；
• G：globa，全局变量，就是模块级别定义的变量；
• B：built-in，系统固定模块里面的变量，比如int, bytearray等。 搜索变量的优先级顺序依次是：作用域局部>外层作用域>当前模块中的全局>python内置作用域，也就是LEGB。

  x = int(2.9)  # int built-in
  
  g_count = 0  # global
  def outer():
      o_count = 1  # enclosing
      def inner():
          i_count = 2  # local
          print(o_count)
      # print(i_count) 找不到
      inner()
  outer()
  
  # print(o_count) #找不到