函数基础

1.函数的语法：

def 函数名（参数1，参数2，参数3，...）

'''注释'''

函数体

return 返回的值

说明：

return也可以返回多个值，以逗号分割，返回的值为元祖

例子：

def test(x):
    x = x + 1
    return x

print(test(4))

def test(x,y):
    x = x + 1
    y=y*2
    return x,y

print(test(4,5))
#输出结果：(5, 10)

2.函数的位置参数：必须一一对应，缺一行少一行都不行

def test(x,y):
    x = x + 1
    y=y*2
    return x,y

print(test(4,5))

3.函数的关键字参数：无须一一对应，缺一行少一行也不行

def test(x,y):
    x = x + 1
    y=y*2
    return x,y

print(test(y=5,x=4))

4.位置参数必须在关键字参数的左边

def test(x,y,z):
    x = x + 1
    y=y*2
    z=z
    return x,y,z

print(test(4,5,z=9))

5.函数的参数可以是列表、字典

def test(x,*arg,**kwargs):
    print(x)
    print(arg)    #打印结果为元祖
    print(kwargs) #打印结果为字典

test(1,2,3,4,(5,6),[7,8],t=3,f=9)
#输出结果：
# 1
# (2, 3, 4, (5, 6), [7, 8])
# {'f': 9, 't': 3}

test(1,*[7,8],**{'t':3,'f':9})
#输出结果：
# 1
# (7, 8)
# {'f': 9, 't': 3}

test(1,2,3,4,(5,6),[7,8],{'t':3,'f':9},**{'t':3,'f':9})
#输出结果：
# 1
# (2, 3, 4, (5, 6), [7, 8], {'t': 3, 'f': 9})
# {'t': 3, 'f': 9}

6.函数无return，返回结果为None

def food():
    haha=('i like milk')
v=food()
print(v)
#输出结果：None

7.函数返回值为函数，实际返回的是函数的内存地址

def food():
    haha=('i like milk')
    return food
v=food()
print(v)
#输出结果：<function food at 0x000002C9380F8E18>

8.全局变量和局部变量

编码规范：

全局变量大写

局部变量小写

优先读取局部变量，能读取全局变量，无法对全局变量重新赋值，但是对于可变类型，可以对内部元素进行操作。

name=['lili','hanmeimei','lucy']
def foo():
    name.append('mike')
    print('新增成员:mike')
foo()
print('name=',name)
#输出结果：
#新增成员:mike
#name= ['lili', 'hanmeimei', 'lucy', 'mike']

如果函数中有global关键字，变量本质上就是全局的那个变量，可读取可赋值

globla：定义全局变量

haha='1234'
def food():
    global  haha
    haha=('i like milk')
    return haha
v=food()
print(v)
#输出结果：i like milk

nonlocal：指定上一级变量

haha='1234'
def food():
    haha='i like milk'
    def tar():
        nonlocal haha
        print(haha)
    return tar
v=food()()     #food()返回结果为tar的内存地址，food()()调用tar函数
print(v)
#输出结果：
# i like milk   #print(haha)的结果
# None

9.风湿理论：函数既变量

定义变量或者函数，都是先在内存中加载，加载完成后，后续调用时，无关定义的先后顺序

递归函数

1.python中的递归效率低，需要在进入下一次递归时保留当前的状态

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

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

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

5.递归调用应该包含两个明确的阶段：回溯，递推

回溯就是从外向里一层一层递归调用下去，回溯阶段必须要有一个明确地结束条件，每进入下一次递归时，问题的规模都应该有所减少（否则，单纯地重复调用自身是毫无意义的）

递推就是从里向外一层一层结束递归

例如：

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

print(calc(10))

输出结果：

res= 1 -->第3层的res返回值
res= 1 -->第2层的res返回值
res= 1 -->第1层的res返回值
1 -->return n

原文地址：https://www.cnblogs.com/lijinping716/p/11404252.html

python-函数