Python基础之-----------函数

---恢复内容开始---

函数：在其他的语言中，我们也经常听到函数的概念，那么什么是函数呢？在Java中叫做method；

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

作用：函数能提高应用的模块性，和代码的重复利用率。

特性：1、代码一致性，2、代码复用性，3、代码可扩展性；

二：

2.1函数的创建：

 在Python中，创建函数要用：def

 def 函数名（参数列表）：
 　　函数体

def hello():
    print('hello')
hello()#调用hello函数

2.2 函数名的命名规则：

1、函数名必须是下滑线，字母开头，包含任意字母，下划线，数字，但是不能使用任何的标点符号；

2、函数名是区分大小写的；

3、函数名字不能是保留字；

2.3形式参数，和实参：

形式参数：是不存在的，虚拟的参数，他存在的目的是为了，在函数调用的时候接收实际的参数，形参的个数数据类型应该与实参一一对应；

实际参数：调用函数的传给函数的参数，可以是常量，变量，表达式，函数 传给形参

区别：形式参数是虚拟的不占用内存空间，只有在调用的时候才会分配给内存空间，实参，是具体的，分配内存空间，只有实参传给形参，形参不能传给实参；实参的传递是单向传输的；

2.4：函数的参数：

必备参数；

不定长参数；

默认参数；

关键字参数；

1、必备参数：必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样；

def person(name,age):                       
    print('i am %s 年龄 %d'%(name,age))       
person('wing',12)                           

2、默认参数：默认参数是在开始的时候参数就有了默认值；

　　如下sex，在开始就有默认值：‘女’，如果后边的代码没有传入sex的参数，会默认给出参数值‘女’

def info(name,age,sex='女'):        
                                   
    print('Name:%s'%name)          
    print('age:%s'%age)            
    print('Sex:%s'%sex)            
    return                         
                                   
info('wing',18)                    
info('mimi',40,'男') 

执行结果：

Name:wing
age:18
Sex:女
Name:mimi
age:40
Sex:男

3、不定长参数：不定长参数没有明确的参数的个数，这样的函数能够处理比声明的时候更多的参数，这种参数就是不定长参数；

       且：加了星号（*）的变量名会存放所有未命名的变量参数。而加(**)的变量名会存放命名的变量参数

def add(*args):      
    sum=0            
    for i in args:   
        sum+=i       
    return sum       
print(add(1,2,3,4,5))
print(add(1,2,9,0))  

#**参数：
def information(**kwargs):                                  
    print(kwargs)                                           
    for i in kwargs:                                        
        print('%s:%s'%(i,kwargs[i]))                        
    return                                                  
information(name='hhhhh',age=12,sex='nv',notion='china')    

4.不定长参数，*args **kwargs和必须参数的位置是有要求的；

def function（必须参数，*args,**kwargs）不然位置出现错乱，是会报错的；

def info(name,*args,**kwargs):#def info(name,**kwargs,*args):报错             
                                                                            
    print('Name:%s'%name)                                                   
                                                                            
    print('args:',args)                                                     
    print('kwargs:',kwargs)                                                 
                                                                            
    return                                                                  
                                                                            
info('lele',18,sex='nv',intion='chin',muqin='xuxu')                         

执行结果： 

 Name:lele
  args: (18,)
kwargs: {'sex': 'nv', 'intion': 'chin', 'muqin': 'xuxu'}

5.高阶函数：

条件：1.满足一个或者多个函数作为输入，

　　　2.输出一个函数；

def add(x,y,f):              
    return f(x) + f(y)       
re=add(3,-1,abs)             
print(re)                    
                             

三：函数的返回值：

要获取函数的执行结果，必须使用return返回；

1.函数遇到return就会返回，结束运行，遇到return就代表函数的结束，然后返回值；

2.如果函数中没有return，则默认会给出return，返回值为None；

3.return多个对象，解释器会把这多个对象组装成一个元组作为一个一个整体结果输出；

四：作用域：

Python中作用域分为4种：

1.L，local，局部作用域，即函数中定义的变量；

2.E，enclosing，嵌套的父级函数的局部作用域，即包含此函数的上级函数的局部作用域，但不是全局的；

3.G，globa，全局变量，就是模块级别定义的变量；

4.B,    built-in，系统固定模块里面的变量，比如int, bytearray等。 搜索变量的优先级顺序依次是：作用域局部>外层作用域>当前模块中的全局>python内置作用域，也就是LEGB。

x=int(2.6) #int built-in                   
g_count =0 #global                         
def f():                                   
    o=1             #enclosing             
    def inner():                           
        i=2              #local            
        print(o)                           
    #print(i)   找不到                        
    inner()                                
f()                                        
#print(o)找不到                               
                                           
                                           

注意：在Python中，只有类，模块，函数，才会有，新的作用域的概念，其他的代码块是不会有新的作用域的概念的；

if 2>1:
    x = 1
print(x)  # 1

#if并没有引入一个新的作用域，x仍处在当前作用域中，后面代码可以使用

def xue():
    x = 2
print(x) # NameError: name 'x' is not defined

s=1                                                                                                       
def f():                                                                                                  
    print(s)                                                                                              
    s=5                                                                                                   
f()                                                                                                       
                                                                                                          
# 错误的原因在于print(s)时,解释器会在局部作用域找,会找到s=5(函数已经加载到内存),但s使用在声明前了,所以报错:                                          
# local variable 's' referenced before assignment.如何证明找到了s=5呢?简单:注释掉s=5,s=1                               
# 报错为:name 's' is not defined                                                                             
#同理                                                                                                       
x=2                                                                                                       
def f2():                                                                                                 
    x+=2 #local variable 'x' referenced before assignment.                                                
f2()                                                                                                      

4.2当一个函数的作用域想要修改外部作用域的时候，这时候就要用到gobal了，和nonlocal，当修改的变量是全局作用域的时候，就要用到gobal了；

count = 1                 
                          
def outer():              
    global count          
    print(count)          
    count = 0             
    print(count)          
outer()                   
#1                        
#0                        

4.3：global关键字声明的变量必须在全局作用域上，不能嵌套作用域上，当要修改嵌套作用域（enclosing作用域，外层非全局作用域）中的变量怎么办呢，这时就需要nonlocal关键字了；

def outer():
    count = 10
    def inner():
        nonlocal count
        count = 20
        print(count)
    inner()
    print(count)
outer()
#20
#20

（1）变量查找顺序：LEGB，作用域局部>外层作用域>当前模块中的全局>python内置作用域；

（2）只有模块、类、及函数才能引入新作用域；

（3）对于一个变量，内部作用域先声明就会覆盖外部变量，不声明直接使用，就会使用外部作用域的变量；

（4）内部作用域要修改外部作用域变量的值时，全局变量要使用global关键字，嵌套作用域变量要使用nonlocal关键字。nonlocal是python3新增的关键字，有了这个 关键字，就能完美的实现闭包了。 

4.4递归：

函数的内部可以调用其他的函数，如果函数自己调用自己，这种就是递归；

def fun(n):                                    
    res=n                                      
    for i in range(1,n) :                      
        res*=i                                 
    return res                                 
print(fun(4))                                  
                                               
#****************递归                            
def f(n):                                      
    if n==1:                                   
        return 1                               
    return n*f(n-1)                            
print(f(3))                                    
                                               

4.4.2斐波那契数列：

#**************递归*********************
def fibo(n):#n可以为零，数列有［0］
 
    if n <= 1:
        return n
    return(fibo(n-1) + fibo(n-2))
 
print(fibo(3))

递归：

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

每次进入深层次的递归的时候，问题都会比上一次的递归应用有所减少；

递归效率不高，递归层次过多会导致栈溢出(在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返     回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。)

五：函数式编程

函数式编程中的函数这个术语不是指计算机中的函数，而是指数学中的函数，即自变量的映射。也就是说一个函数的值仅决定于函数参数的值，不依赖其他状态。比如y=x*x函数计算x的平方根，只要x的平方，不论什么时候调用，调用几次，值都是不变的。

1、函数式编程简单易懂；

其余的不在赘述；