Day3-1 函数

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

特性:

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

语法:

1 def calc(x, y):
2     print(x*y)
3 
4 
5 calc(5,9)

函数参数

形参变量

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

实参。

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

默认参数

默认参数必须在位置参数的后面.否则程序会报错.

1 def stu_reg(name,age,country='cn',course):
2     print(name,age,country,course)
3 
4 # countr ='cn'就是一个默认参数.

关键参数:

正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可(指定了参数名的参数就叫关键参数)，但记住一个要求就是，关键参数必须放在位置参数(以位置顺序确定对应关系的参数)之后.

stu_reg(‘alex’,course =’py’,country =’CN’,age =22) 
#  调用时,course,age就是关键参数.关键参数必须放在位置参数后面.

非固定参数

若你的函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数.

def alert(msg,*users): # 当传递的参数不止一个的时候可以用非固定参数.在参数前面加个*即可,会把传入的参数变成一个元组形式.一般使用*args
    for u in users:
        print(msg,u)


alert('警报!!!','alex','ago','shanshan','jack')

def alert(msg,*users): # 当传递的参数不止一个的时候可以用非固定参数.在参数前面加个*即可,会把传入的参数变成一个元组形式.
    for u in users:
        print(msg,u)


alert('警报!!!',*('alex','ago','shanshan','jack'))
'''由于*users会把我们传进去的参数变成一个元组.因此我们可以直接传一个元组或者列表,但是如果直接['alex','ago','shanshan','jack']
,这样传进去.那么就会被当做元组的第一个元素就变成了(['alex','ago','shanshan','jack']).效果如下:
警报!!! ['alex', 'ago', 'shanshan', 'jack']
那么,如果我们一定要这样传参数电话,可以在列表或者元组前面加一个*即可.效果如下:
警报!!! alex
警报!!! ago
警报!!! shanshan
警报!!! jack
'''

关于非固定参数的位置:

def alert(msg,*users,age): 
    for u in users:
        print(msg,u)
alert('警报来了.','jack', 'rain', 22) #这个传参会报错的.非固定参数会把后面所有传进来的参数都拿给自己用了.那么这样就少了一个age的参数.

alert('警报来啦!','jack','rain',age = 22)
#这样不会报错的.因为age已经变成一个关键参数了.

传参:

def info (name,*args,**kwargs):
    print(name,args,kwargs)


info('Nick',22,'50w',address ='china', tel ='13899990000')
#输出如下:
# Nick (22, '50w') {'address': 'china', 'tel': '13899990000'}

#kwargs 是以字典的形式来存储参数.

kwagrs 传参数方法:

dic = {'kg':'65'}
def info(name,*args,**kwargs):
    print(name,args,kwargs)

info('Nick',dic)
#如果这样传参的话,和之前的一样.dic里的参数会被当成元组的一个元素.输入如下:
# Nick ({'kg': '65'},) {}   后面的**kwargs没有传进来.是空的.
# 那么如果一定要传进来的话只需要在参数前加**即可
info('Nick',**dic)
#效果如下:
#Nick () {'kg': '65'}

返回值:

函数外部的代码要想获取函数的执行结果，就可以在函数里用return语句把结果返回.

 1 def reg_user(name,password): # 当密码大于8位时,返回True,否则返回False.函数遇到return就会停止执行函数.return后面的语句不会再执行.
 2     print(name,password)
 3     if len(password) >= 8:
 4         return True
 5     else:
 6         return  False
 7 
 8 reg_user_status = reg_user('Nick','12345678')
 9 
10 if reg_user_status:   #根据返回值来判断是否注册成功.
11     print('注册成功!')
12 else:
13     print('注册失败,密码位数小于8位.')
　　如果return name,password 会返回一个元组形式的返回值
　　('Nick','12345678')

注意

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

局部变量:

1.在函数内部定义的变量就是局部变量,只能在函数内部调用.在程序开始定义的变量是全局变量,整个程序都可以用.

2.全局变量的作用域是整个程序,局部变量的作用域是定义该变量的函数.

3.当全局变量和局部变量名称一样时.在各自的作用域生效.

4.当只有一个全局变量,没有局部变量是.局部变量会调用全局变量.

 1 name = 'Jack Ma'
 2 def print_name():
 3     name = 'Nick guo'    #在函数里面定义的这个name变量就是局部变量,只能在函数内使用.通过id查看内存地址就能看出来2个name是不一样的.
 4     print(id(name))
 5     print(name)
 6 
 7 print_name()
 8 print(name)
 9 print(id(name))
10 #输出如下:
11 #20446128
12 #Nick guo
13 #Jack Ma
14 #19817344

name = 'Jack Ma'
def print_name():
    print(name)

print_name()

#没有局部变量时,会调用全局变量.

修改变量:

name = 'Jack Ma'
def print_name():
    global name   #global的作用就是在函数里声明全局变量.global前面不能声明变量.否则程序会报错.一般情况下不使用global
    name = 'Nick guo'
    print(id(name))
    print(name)

print_name()
print(name)
print(id(name))
#输入如下:
#23788464
#Nick guo
#Nick guo
#23788464

关于修改:

如函数外部的变量是一个可变的类型,我们可以修改其中的一个元素,但是不能直接重新进行赋值操作.

1 list =['a','b','c','d','e']
2 def print_letter():
3     # list = ['a','b','c','D','E']  这种方式会报错.
4     list[1] = 'B'
5     print(list)
6 
7 print_letter()
8 #输出如下
9 #['a', 'B', 'c', 'd', 'e']   发现b被更改成了B.之前我们学的不是说在函数内不能修改全局变量吗? 注意,我们可以更改list里面的元素值,但是不能直接更改整个列表.

函数变量的查找顺序:

 1 age =19
 2 def func():
 3     age =30
 4     print(age)             # 向上查找变量age,所以age=30
 5     def func1():
 6         print(age)         #
 7     age = 88
 8     func1()               #程序由上而下执行.在调用func1之前,定义了一个age=88. 所以func1里age=88
 9 
10 
11 func()

1 age =19
2 def func():
3     def func1():
4         print(age)
5     func1()
6     age =88             # 这样定义age=88,会报错.因为已经定义了一个age=19.在调用函数后,又定义了一个age=88,程序无法分辨出应该调用哪个age.所以出错了.
7 
8 func()
9 print(age)

 1 ge =19
 2 def func():
 3     global age        #global的作用就是在函数中修改全局变量.
 4     def func1():
 5         print(age)
 6     func1()
 7     age =88             # 如果一定要使用age=88.可在函数前加上global age 即可.但是age=19会被改成age=88
 8 
 9 func()
10 print('全局age:', age)

作用域

在python中,一个函数就是一个作用域.其变量就是放在函数的作用域中.根据作用域来确定变量属于哪个函数.代码(函数)定义完成后,作用域就已经生成,不论在什么地方调用该函数.都会回到定义的作用域中执行.

匿名函数

def calc(x,y):
    print(x+y)

lambda x,y:x+y  # 声明一个匿名函数.x,y相当于形参.x+y相当于要执行的语句.

匿名函数一般是和其他函数配合使用.

高阶函数

定义:一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。或者返回一个函数也称为高阶函数.

def func1(x,y):
    return x+y

def calc(x):        # 接收一个函数作为参数,就称之为高阶函数.
    return x


print(calc(func1))
#输出如下:
# <function func1 at 0x0040C9C0>

def func1(x,y):
    return x+y

def calc(x):        
    return abs,x    # 返回值中包含一个函数的函数也是高阶函数.

print(calc(func1(3,-7)))
# 输出如下:
#(<built-in function abs>, -4)   #是一个元组类型的返回值.