day3 函数

 

函数

　　位置参数一定要在前面 

　　形参和实参

　　位置参数

　　关键词参数

　　函数默认参数

　　　　默认参数特点：调用函数的时候，默认参数非必传 　　

　　参数组

　　局部变量

 

特性:

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

定义一个函数：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None

def func_test():
    print("I'm a function.")

func_test()
func_test()
func_test()

C:Userscongcong.duAppDataLocalProgramsPythonPython35python.exe C:/Users/congcong.du/PycharmProjects/test/day3/func.py
I'm a function.
I'm a function.
I'm a function.

2.函数参数

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

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

def func_test(x,y):#x,y为形参
    res = x+y
    return res
z = func_test(2,4) #2,4为x,y的实参
print(z)

3.默认参数

def test(x,y,z=9):
    print(x)
    print(y)
    print(z)
    print("------------")

test(1,2,3) #位置参数
test(1,z=8,y=2)#位置参数一定要在关键字参数前面
test(1,2) #默认参数特点：调用函数的时候，默认参数非必传


C:Userscongcong.duAppDataLocalProgramsPythonPython35python.exe C:/Users/congcong.du/PycharmProjects/test/day3/func.py
1
2
3
------------
1
2
8
------------
1
2
9
------------

4.参数组*args，传字典 **kwargs

#参数组
#若你的函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数。
#*args 接收位置参数，不接受关键字参数，转化为元组
def test1(name,*args):
    print(name)
    print(args)
test1("alex",1,2,3,4,5,5)

C:Userscongcong.duAppDataLocalProgramsPythonPython35python.exe C:/Users/congcong.du/PycharmProjects/test/day3/func.py
alex
(1, 2, 3, 4, 5, 5)

print("=========字典=======")
#传字典 **kwargs ：将关键字参数，转换为字典的方式
def test2(**kwargs):
    print(kwargs)
    print(kwargs["name"])
test2(name="alex",age=8,sex="man")
test2(**{'age': 8, 'name': 'alex', 'sex': 'man'})


#混和
def test3(name,age=18,**kwargs):
    print(name)
    print(age)
    print(kwargs)
test3("alex", sex="man")
test3("alex",1,sex="man",hobby="tsl")
test3("alex",sex="man",hobby="tsl",age=1)

print("---------------------")

def test4(name,age=18,*args,**kwargs):
    print(name)
    print(age)
    print(args)
    print(kwargs)
test4("alex",34,1,2,3,sex="man", hobby="tsl") #关键字参数，一定要在最后一个位置参数后main
test4("alex",age=34,sex="man",hobby="tsl")

5.局部变量

局部变量只在他的作用域内其起作用，也可以声明为全局变量，不过因为写代码长的时候随便声明可能会乱，所以不推荐。

def change_name(name):
    print("before change:",name)
    name = "里面的局部变量"
    print("after change:", name)
name=('外面的全局变量')
change_name(name)
print("在外面看看name改了么?",name)
'''
before change: 外面的变量
after change 里面的变量
在外面看看name改了么? 外面的变量
'''

print("===========全局/局部变量=======")
sex = "m"
def test5(n):
    #global age #如果要在函数内改全局变量，用global声明
    sex = "g" #局部变量改不了全局的变量
    print("before change:", n,sex)
    n = "Alex Li" #这个函数就是这个变量的作用域
    age = 20
    print("after change:", n,age,sex)
name = "alex"
test5(name)
#print(name,age,sex)   #age局部变量不能在函数外使用
print(name,sex)

函数内是可以修改全局列表的

print("======函数修改列表====")
names = ["alex","jack","rain"]
def change_list():
    names[0]= "ALEX"
    print(names)
change_list()
print(names)

6.递归函数

#函数内部调用自己。
#1.必须有一个明确的结束条件,最大递归次数999.
#2.每次进入更深一层递归时，问题规模相比上次递归应有减少
#3.效率不高,递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

print("========递归函数=========")
#函数内部调用自己。1.必须有一个明确的结束条件,最大递归次数999.
#2.每次进入更深一层递归时，问题规模相比上次递归应有减少
#3.效率不高
def test6(n):
    print(n)
    if int(n/2) > 0:
        return test6(int(n/2))
    print("-->",n)

test6(10)

6.高阶函数

print("========高阶函数=========")
#变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。
#abs 转化为正数的函数
def add(x,y,f):
    return f(x)+f(y)

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