Python 函数

一、函数的基本语法及特性

函数定义：

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

特性:

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

语法定义：

# def 函数名（参数）：
#     函数体
#     。。。
#     返回值


# def hanshu():   #定义函数用关键字def
#     print("函数DEMO")
# hanshu()   #调用函数

二、函数参数

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

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

 (

形参：形式参数，不是实际存在，是虚拟变量。在定义函数和函数体的时候使用形参，目的是在函数调用时接收实参（实参个数，类型应与实参一一对应）

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

区别：形参是虚拟的，不占用内存空间，.形参变量只有在被调用时才分配内存单元，实参是一个变量，占用内存空间，数据传送单向，实参传给形参，不能形参传给实参

)

# def school_list(name,age,sex):  #nameagesex 为形参
#     print("name:",name)
#     print("age:",age)
#     print("male:",sex)
#
# # 调用函数school_list
# school_list('xiaoming',45,'male')  #'xiaoming',45,'male' 为实参默认参数

必备参数

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

def f(name,age):
 
    print('I am %s,I am %d'%(name,age))
 
f('yang',18)
f('xin',16)

关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

def f(name,age):
 
    print('I am %s,I am %d'%(name,age))
 
# f(16,'xin') #报错
f(age=16,name='alvin')

 默认参数（缺省参数）

如果要解决这个问题就可以给函数的值指定一个默认值，指定函数的默认值需要在def这一行指定，制定之后，当调用这个函数的时候就不需要输入函数值了

def school_list(name, age, sex='male'):  #sex='male'关键参数（默认参数），关键参数必须在位置参之后

非固定参数：*args和**kwargs

# def school_list(name, age, *args):  #非固定参数*args  会把多传入的参数变成一个元组形式
#     print(name,age,args)
# school_list('xiaoming', 45, 'args', '安徽念书')  #xiaoming 45 ('args', '安徽念书')

# def school_list(name,*args,**kwargs):  #*kwargs 会把多传入的参数变成一个dict形式
#     print(name,args,kwargs)  
# school_list('xiaoming', age=23)  #xiaoming () {'age': 23}

三、全局变量和局部变量

  • 在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
  • 全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。
  • 当全局变量与局部变量同名时：
  • 在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

局部变量

# name = "xiaopang"
# def school_list(name):
#     print(name)
#     name = "erpang"
#     print(name)
#
# #调用
# school_list(name)
# print("在外面看看name改了吗?:",name)
# # xiaopang
# # erpang
# # 在外面看看name改了吗?: xiaopang

四、作用域

在Python中，只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如if、try、for等）是不会引入新的作用域的
python中的作用域分4种情况：
  • L：local，局部作用域，即函数中定义的变量；
  • E：enclosing，嵌套的父级函数的局部作用域，即包含此函数的上级函数的局部作用域，但不是全局的；
  • G：global，全局变量，就是模块级别定义的变量；
  • B：built-in，系统固定模块里面的变量，比如int, bytearray等。 搜索变量的优先级顺序依次是：作用域局部>外层作用域>当前模块中的全局>python内置作用域，也就是LEGB。
局部名称空间--->全局名称空间--->内置名称空间

global关键字 

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了，当修改的变量是在全局作用域（global作用域）上的，就要使用global先声明一下，代码如下：

count = 10
def outer():
    global count
    print(count) 
    count = 100
    print(count)
outer()
#10
#100

 nonlocal关键字 

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新增的关键字，有了这个 关键字，就能完美的实现闭包了。 

五、返回值

要想获取函数的执行结果，就可以用return语句把结果返回

注意:

  1. 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束
  2. 如果未在函数中指定return,那这个函数的返回值为None 

补充（高阶函数）：

         高阶函数是至少满足下列一个条件的函数:

  • 接受一个或多个函数作为输入
  • 输出一个函数
def add(x,y,f):
    return f(x) + f(y)
 
res = add(3,-6,abs)
print(res)
###############
def foo():
    x=3
    def bar():
        return x
    return bar　

 六、 递归

定义：在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

# 实例 累加
# def fact(n):
#     result = n
#     for i in range(1,n):
#         result += i
#     return  result
#
# print(fact(100))
#递归  累加
# def fact(n):
#     if n == 2:
#        return 2
#     return n + fact(n-1)
# print(fact(5))
#实例(斐波那契数列)
# def f(n):
# #     before = 0
# #     after = 1
# #     for i in range(1,n-1):
# #         ret = before + after
# #         before = after
# #         after = ret
# #     return ret
# # print(f(10))

# def f(n):
# #     if n <= 1:
# #         return n
# #     return (f(n-1) + f(n-2))
# # print(f(4000))  #maximum recursion depth exceeded in comparison

递归函数的优点:    是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

递归特性:

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

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

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

 七、内置函数

内置函数：https://docs.python.org/3.5/library/functions.html#func-memoryview

重要的内置函数：

#filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果
 自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。（常用于对列表的筛选）
# sun = ['a','b','c','d']
# def fun(s):
#     if s != 'c':
#         return s
# res = filter(fun,sun)  #返回的时一个对象，是一个对象的地址
# print(list(res))  #可以通过列表，元组等打印出来

# str = ['a', 'b', 'c', 'd']
# def fun1(s):
#     if s != 'a':
#         return s
#
#
# ret = filter(fun1, str)
#
# print(list(ret))  # ret是一个迭代器对象

# map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。（对于list的每个元素挨个调用的函数方式挨个处理）
# sun = ['a','b','c','d']
# def fun(s):
#         return s + "happy"
# res = map(fun,sun)
# print(list(res))  #['ahappy', 'bhappy', 'chappy', 'dhappy']

# sun = ['a','b','c','d']
# def fun(s):
#         return s + "happy"
# res = map(fun,sun)
# print(list(res))

# reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，（对列表的元素从头开始，两个两个处理）
  reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。reduce(f, [1, 3, 5, 7, 9], 100)=reduce(函数，列表，参数)
# from functools  import  reduce
# def add(x,y):
#     return  x*y
# print(add(2,3))

# lambda匿名函数 lambda x: x * x 
# fun = lambda  x,y : x+y
# print (fun(3,4))

 小结：1.filter（）主要用于对列表的筛选 2.map（）主要通过对list的单个元素处理 3. reduce（）对列表的元素从头开始，两个两个处理

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/070727sun/p/10813682.html