python函数基础

python函数

• 函数的基本定义
• 函数参数
• 返回值
• 局部变量和全局变量
• 嵌套函数
• 匿名函数
• 高阶函数
• 递归

函数的基本定义

引子

现在你的老板让你写一个监控程序,24小时全年午无休的监控你们公司网站服务器的运行状况,当cpu\memory\disk等指标的使用量超过阈值时即发送报警邮件:

while True：
    if cpu利用率 > 90%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接

    if 硬盘使用空间 > 90%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接

    if 内存占用 > 80%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接

那么当你的同事看到这个代码的时候,就发现了代码的重复性比较高,每次报警都要重写一段发邮件的代码,一个劲的copy and paste根本就不符合高端程序员的气质,其次如果以后想修改发邮件的代码,比如加上群发功能,那么就需要在所有代码上都要修改一遍.

你也看出来了这个问题,你也不想去写重复代码,但又不知道怎么写,此时你的同时笑着和你说,这个很简单,只要把重复的代码提出出来,放在一个公共的地方,起个名字,以后谁想用这个代码,就通过这个名字就可以调用了.,如下:

def 发送邮件(内容):
    # 发送邮件提醒
    连接邮件服务器
    发送邮件
    关闭连接

while True:
    if cpu利用率 > 90%:
        发送邮件('CPU报警')
    if 硬盘使用空间 > 90%:
        发送邮件('硬盘报警')
    if 内存占用 > 80%:
        发送邮件('内存报警')

基本定义

函数是什么?

函数一词来源于数学，但编程中的「函数」概念，与数学中的函数是有很大不同的，编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做subroutine(子过程或子程序)，在Pascal中叫做procedure(过程)和function，在C中只有function，在Java里面叫做method。

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

函数的特征

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

语法定义

def sayhi():  # sayhi函数名
    print('hello world')

sayhi()  # 调用函数

函数参数

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

实参
可以是常量\变量\表达式\函数等,无论实参是那种类型的量,再进行函数调用时,他们都必须有确定的值,以便把这些值传送给形参.因此应预先用赋值,输入等方法使参数获得确定值.

def cacl(x,y):  # 此时的x,y是形参
    res = x**y
    return res

c = cacl(2,5)  # 此时的2,5是形参
print(c)

默认参数

看如下代码:

def stu_register(name,age,country,course):
    print('-----注册学生信息-----')
    print('姓名:',name)
    print('年龄:',age)
    print('国家:',country)
    print('课程:',course)

stu_register('老王',22,'CHINA','PYTHON')
stu_register('小明',18,'CHINA','JAVA')
stu_register('康康',19,'CHINA','C++')

运行结果如下:

-----注册学生信息-----
姓名: 老王
年龄: 22
国家: CHINA
课程: PYTHON
-----注册学生信息-----
姓名: 小明
年龄: 18
国家: CHINA
课程: JAVA
-----注册学生信息-----
姓名: 康康
年龄: 19
国家: CHINA
课程: C++

这时候我们发现了一个问题,我们发现country这个参数的值都是CHINA,就像我们在注册网站的时候,像国家这种信息,你不填写的话,那么默认是CHINA,这就是通过默认参数实现的,把country变成默认参数非常简单.

def stu_register(name,age,course,country='CHINA'):

这样,这个参数在调用时不指定,那么默认就是CHINA了,如果指定的话,就是你自己指定的值了.举个例子看看:

# 默认参数--如果用户指定了参数值，则使用用户指定的值，否则使用默认参数的值。
def stu_register(name,age,course,country='CHINA',):
    print('-----注册学生信息-----')
    print('姓名:',name)
    print('年龄:',age)
    print('国家:',country)
    print('课程:',course)

stu_register('老王',22,'PYTHON')
stu_register('小明',18,'JAVA','JAPAN')  # 指定了country = JAPAN

那么我们看一下运行结果:

-----注册学生信息-----
姓名: 老王
年龄: 22
国家: CHINA
课程: PYTHON
-----注册学生信息-----
姓名: 小明
年龄: 18
国家: JAPAN
课程: JAVA

那么,为什么默认参数要放置在参数的最后一个位置呢?让我们来看下:

def stu_register(name,age,country='CHINA',course):  # 如果写成这样的话,那么会立即报错,根本就不会运行,因为将实参传递给形参时,不知道CHINA是传给谁的
    print('-----注册学生信息-----')
    print('姓名:',name)
    print('年龄:',age)
    print('国家:',country)
    print('课程:',course)

stu_register('康康',19,'CHINA','C++')

关键参数

正常情况下,给函数传参数要按顺序,不想按顺序就可以用关键参数,只需指定参数名就可以了(指定参数名的参数就叫做关键参数),注意:关键参数必须放在位置参数之后(以位置顺序确定对应关系的参数)
举个例子看一下:

def stu_register(name,age,course='python',country='CHINA'):  # 设置两个默认参数
    print('-----注册学生信息-----')
    print('姓名:',name)
    print('年龄:',age)
    print('国家:',country)
    print('课程:',course)

stu_register('王佳',course='LIUNX',age = 22)

但是不可以这样调用:

stu_register('小明',course='java ',22,country='JAPAN')
也不可以这样
stu_register('小明',22,23,country='JAPAN')  # 这句话等于将22 23传递给了age,但是不能传递两个值

非固定参数

若你的函数中不确定要传入多少参数,就可以使用非固定函数,举个例子来说,文章开头的邮件报警,现在我不想只对一个人发邮件,我想对整个运维部的人发送报警邮件,那么这个时候使用非固定参数最合适不过了:

def students(name,age,*args):  # *args 会把多传入的参数变成一个元组形式
    print(name,age,args)  # 打印name,age,args

students('小明',22,'PYTHON','CHINA')  # 小明 22 ('PYTHON', 'CHINA')

原来,*args所接受的参数是用元组的形式保存的

那么现在还有一个**kwargs

def stu(name,age,*args,**kwargs):
    print(name,age,args,kwargs)

stu('肖亚飞',22)  # 肖亚飞 22 () {}
# 让我们看看args和kwargs的差别在哪?
stu('肖爸爸',23,'python','linux')  # 肖爸爸 23 ('python', 'linux') {}
stu('肖爸爸',23,'python','linux',addr = 'Henan',music = '蝴蝶')  # 肖爸爸 23 ('python', 'linux') {'addr': 'Henan', 'music': '蝴蝶'}

总结:

   1.*args必须放在**kwargs之前
   2.*args 没有key值，**kwargs有key值
   3.使用*args和**kwargs可以非常方便的定义函数,同时可以加强扩展性,以便日后的代码维护 

返回值

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

def student(name,age,course='PYTHON',country='CN'):  # 设置了course和country两个默认参数
    print('-----注册学生信息-----')
    print('姓名:',name)
    print('年龄:',age)
    print('国家:',country)
    print('课程:',course)

    if age > 20:  # 判断如果age大于20
        return False  # 返回False
    else:
        return True

result = student('张三',22)  # 函数外部的代码想要获取函数的执行结果,就需要使用一个变量来进行接受
if result:  # 如果result = True
    print('恭喜注册成功!')
else:  # 如果result = Flase
    print('年纪太大!')

看一下运行结果:

-----注册学生信息-----
姓名: 张三
年龄: 22
国家: CN
课程: PYTHON
年纪太大!   

注意

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

局部变量和全局变量

name = 'xiaoyafei'
def change_name(name):  # 定义一个函数,传递Name参数
    print('修改前:',name)
    name = '肖亚飞'
    print('修改后:',name)

change_name(name)
print('在外面看修改过了吗?',name)

输出结果为:

修改前: xiaoyafei  # 没修改之前的
修改后: 肖亚飞  # 在函数里修改过的
在外面看修改过了吗? xiaoyafei  

不用传name参数,在函数里面还是可以调用外面的变量

name = "xiaoyafei"
def change_name():
    name = '肖亚飞'
    print("修改后:",name)
change_name()
print("在外面看:",name)

运行结果为:

修改后: 肖亚飞
在外面看: xiaoyafei

那么,为啥我明明修改过了,为啥在外面还是没修改呢?让我们看看name变量的空间地址:

name = "xiaoyafei"
def change_name():
    name = '肖亚飞'
    print("函数内,id:",id(name))
change_name()
print("函数外,id:",id(name))

结果如下:

函数内,id: 1388194004688
函数外,id: 1388193784688

要是不放大你的眼睛还真的看不清楚呢,内存空间地址不同,所以两个name是没有关系的,那么为啥一个函数里能定义两个甚至更多相同的变量呢?

• 在函数中定义的变量称为全局变量,在程序的一开始定义的变量称为全局变量
• 全局变量的作用域是整个程序,局部变量的作用是定义该变量的函数
• 当全局变量和局部变量相同时,在定义局部变量的函数内,局部变量起作用;在其他地方全局变量起作用

作用域

作用域,程序设计概念,通常来说,一段代码中所用到的名字并不总是有效/可用的,而限定这个名字的可用性的代码范围就是这个名字的作用与.

如何在函数里修改全局变量

name = '肖亚飞'

def change_name():
    global name  # global的作用就是在函数里声明全局变量name,意味着最上面的name = '肖亚飞'即使不写,程序最后面也可以print name
    name = 'xiaoyafei'
    print('函数里修改:',name)

change_name()  # 调用函数
print('函数外:',name )

运行结果如下:

函数里修改: xiaoyafei
函数外: xiaoyafei