攻克python3-函数

函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

1.函数的定义

def test():                     #函数
    print("in the test")
    return 0

def test1():                    #过程
    print("in the test1")

x=test()
y=test1()
print(x)
print(y)

2.使用函数的意义

import  time
def logger():
    time_format = '%Y-%m-%d %X'
    time_current = time.strftime(time_format)
    with open('a.txt','a+') as f:
        f.write('%s end action
' %time_current)

def test1():
    print('in the test1')
    logger()
def test2():
    print('in the test2')
    logger()
def test3():
    print('in the test3')
    logger()

test1()
test2()
test3()

a.保存一致性
b.可扩展性
c.重复代码

3.函数的返回值

def test1():
    print("in the test1")
    pass                    #没有返回值

def test2():
    print("in the test2")
    return 0                #返回整形

def test3():
    print("in the test3")
    return "a"              #返回字符

def test4():
    print("in the test4")
    return "phk"            #返回字符串

def test5():
    print("in the test4")
    return [1,2,3,4]        #返回列表

def test6():
    print("in the test6")
    return (1,2,3,4)        #返回元组

def test7():
    print("in the test7")
    return {"name":"phk","age":22}     #返回字典

def test8():
    print("in the test4")
    return 0, 'hello', ['a', 'b', 'c'], {'name': 'alex'}    #返回混合值
    
a=test1()
b=test2()
c=test3()
d=test4()
e=test5()
f=test6()
g=test7()
h=test8()               #返回时，是将混合值作为一个元组
print(a,b,c,d,e,f,g,h)

a.return值数=0  返回none
b.return值数=1  返回本值
c.return值数>1  返回由值组成的元组

4.函数参数

def test1(x,y):
    print(x)
    print(y)

#test1(1,2)  #位置参数，实参与形参一一对应
#test1(y=2,x=1) #关键字参数  位置可以不必需对应
#test1(y=2,1)    #关键字参数与位置参数混用，关键字参数不能再位置参数前面
test1(1,y=2)     #上面的会报错
#位置参数与关键字不能多，不能少

#输出结果
1
2


def test2(x,y=2):   #默认参数
    print(x)
    print(y)

#test2(1)    #默认参数不必需写
#test2(1,3)
test2(1,y=3)

#输出结果
1
3


def test3(*args):           #参数组参数 不限制参数限制,接受N个位置参数，转换成元组的形式
    print(args)

test3(1,2,4,5,4,5,6)
#test3(*[1,2,3,4,5,6])   #args=([1,2,3,4,5,6])

#输出结果
(1, 2, 4, 5, 4, 5, 6)


def test4(x,*args):         #位置参数与参数值参数混用
    print(x)
    #print(y)
    print(args)

test4(1,21,3,4)

#输出结果
1
(21, 3, 4)


def test5(x=1,*args):      #默认参数与参数组参数混用
    print(args)
    print(x)

test5(2,2,3,4)
# test5(*([1,2,3,4]))       #结果显示如果默认参数在参数组参数前面，默认参数会夺取参数组参数的第一个参数，会修改当前默认参数，反之，不会，如果需要修改默认参数内容，需要采用关键字参数修改,建议将默认参数放置参数值参数后面

#输出结果
(2, 3, 4)
2


def test6(x,y,z=2,*args):
    print(x)
    print(y)
    print(args)
    print(z)

test6(1,2,1,2,3,4,5)

#输出结果
1
2
(2, 3, 4, 5)
1


def test7(**kwargs):    #接受N个关键字参数，转换成字典
    print(kwargs)

test7(name="phk",age=22)

#输出结果
{'name': 'phk', 'age': 22}


def test8(x,y,z=6,*args,**kwargs):          #多种参数混合使用
    print(x)
    print(y)
    print(args)
    print(z)
    print(kwargs)

test8(1,2,34,5,6,7,name="phk",age=22)

#输出结果
1
2
(5, 6, 7)
34
{'name': 'phk', 'age': 22}

5.局部变量与全局变量

school="old boy"
names=["wr",'gcc']
def change_name(name):
    global school               #global 允许函数修改全局变量 如果没有全局变量，则将这个变量变成全局变量（建议不要用global）
    print("修改前：",name,school,names)
    name='jcy'                  #局部变量，这个函数就是这个变量的作用域
    school='hut'
    names[1]="zxq"              #如果全局变量是列表，字典，集合是在函数内部可以修改，字符串，整形不能修改
    print("修改后：",name,school,names)


name='phk'
change_name(name)
print(name)
print(school)
print(names)

6.递归

def case(n):
    print(n)
    if int(n/2)>0:
        return case(int(n/2))
    print("-->",n)

case(10)

递归的特点：
a.必须有一个明确的结束条件
b.每进入更深层的递归，递归的问题规模应比上一层少
c.递归效率不高

7.高阶函数

#高阶函数                       #一个函数作为另一个函数的参数
def func(x,y,f):
    return f(x)+f(y)

n=func(1,-3,abs)
print(n)

#输出结果
4