change在python是什么函数_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

嵌套函数

name = 'xiaoyafei'

def change_name():

name = 'xiaoyafei2'

def change_name2():

name = 'xiaoyafei3' # 如果在当前函数拥有name变量,则使用函数内的name变量,如果没有,则会去上一级去找name,一直找到全局变量

print('第3层打印:',name) # 第3层打印: xiaoyafei3

change_name2()

print('第2层的音:',name) # 第2层的音: xiaoyafei2

change_name()

print('第一层打印:',name) # 第一层打印: xiaoyafei

匿名函数

匿名函数就是不需要显示的指定函数名

匿名函数的声明

res1 = lambda x,y:x+y #声明一个匿名函数,有x和y两个参数,操作为x+y

print(res1) # at 0x0000021D32590D08>

常规函数和匿名函数:

# 常规函数

def cacl(x,y):

return x**y

res = cacl(2,3) # 如果想要使用函数的返回值,就需要定义一个变量来接收

print(res) # 8

# 匿名函数

res = lambda x,y:x**y

print(res(2,3)) # 8

匿名函数的优点:

使用python写一些脚本时,使用lambda可以省去自定义函数的过程,让代码更加精简

对于一些抽象的,不会被别的地方再重复使用的函数,有时候函数起个名字也是个难题,使用lambda不用考虑这些问题

使用lambda在某些时候让代码更容易理解

匿名函数的其余用法

data = list(range(10))

print(data) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 问题:用两种方法计算这些数的平方

# 常规操作

for index,i in enumerate(data):

data[i] = i*i

print(data) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 装逼操作

res = list(map(lambda x:x*x,data))

print(res) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

那么在方法2中的map()函数是啥意思?

map()会根据提供的函数对指定序列做映射

第一个参数functrion以参数序列中的每一个元素调用function函数,返回包含每次function函数返回值的新列表,可以不懂,下面就会讲,

今天不是看到map()函数,我还真不知道python2和python3中的map()有区别,让我们举个例子看一下map()函数的用法:

在python2中:

>>> def cacl(x): # 求一个数的平方

... return x**2

...

>>> map(cacl,[1,2,3,4,5]) # 在python2中返回的是列表

[1, 4, 9, 16, 25]

>>>

在python3中:

>>> def cacl(x):

... return x**2

...

>>> map(cacl,[1,2,3,4,5]) # python3中返回的是迭代器对象,何谓迭代器?晚点会在博客中说明

>>> res = map(cacl,[1,2,3,4,5])

>>> next(res) # 返回迭代器中的下一个值

1

>>> next(res)

4

map()函数在python2和python3中的区别:

在python2中返回的是列表

在python3中返回的是迭代器对象

map()是python内置的高阶函数,它接收一个函数cacl和一个list,并通过函数cacl依次作用于list的每个元素上,并且得到一个新的list并返回,由于list包含的元素可以是各种类型的,因此,map()不仅仅可以处理只包含数值的list,事实上它也可以处理包含任意类型的list,只要传入的函数cacl可以处理这种数据类型.

高级函数

变量可以指向函数,函数的参数能接受变量,那么一个函数就可以接收另一个函数作为参数,这种函数就被称为高阶函数.

接收一个或多个函数作为输入

return 返回另外一个函数

def func2(x,y):

return abs,x,y

res = func2(-1,10)

print(res) # (, -1, 10)

def cacl(x,y,f):

return f(x)+f(y)

res = cacl(-4,10,abs)

print(res) # 14