python之函数

什么是函数?它有什么作用?

函数是一个整体,你可以把你经常用的代码定义成一个函数,当你去调用这个函数的时候,就相当于用了整个函数里面的代码,里面的代码就是封装代码。注意,函数是一个整体,所以里面的变量是局部变量,在外面是用不了的,比如说我在函数里面设置a=5,在函数外面我们就用不了这个变量a

定义方法及调用方法如下:

1
2
3
def zhouyu(): #定义一个zhouyu的函数
    print("i am zhouyu"#zhouyu函数内的封装代码
zhouyu() #调用zhouyu这个函数

执行结果

python之函数


这个是没有参数的函数,一般情况下,函数里面可能有一些数是有变化的,这个数是就是参数,这个数可以由上面代码的结果,或者用户输入的值传到这个函数里面,代替这个参数让函数变得更可用。比如:

1
2
3
4
def sum_2_nums(a,b):
    sum1 = + b
    print("%d + %d = %d"%(a,b,sum1))
sum_2_nums(100,200)

从上面的代码可以看出,我们定义了一个函数sum_2_nums,这个函数有两个参数,一个是a,一个是b,(注意:参数一般是写在函数的括号里面的)这两个参数就可以在封闭代码上应该了,如上面代码的第二行就可以知道a,b这两个参数被应用了,下面我们看第四行代码,可以看到这个函数被调用了,与之前调用的不同的是这个函数被调用的时候,还加上了两个数字,一个是100,一个是200,其实可以是这样的,我们调用这个函数的时候,代码就会去找有没有这个函数,如果有,就会执行这个函数,很显然,是有这个函数的,而且这个函数需要我们提供两个参数,一个为a,一个为b,那么我们在调用这个函数的时候,就得提供两个参数,如上代码,我们提供的参数就是100和200函数就会把a=100,b=200放入到这个函数代码中去执行,就会出现以下结果:

python之函数

像上面的情况来说,a,b就是形参,而100,200就是实参,形参其实就是一个形象的参数,就是虚拟的,而实参就是实实在在的参数,比如100,200就是实际的参数。

如果你把上面代码的100,200换成别的,那a和b的值也会随着变化。

下面说return这个的作用

return就是把一个方法的执行结果返回出来,比如下面我们想获取sum1的结果,可以通过return获取

1
2
3
4
def sum_function(a,b):
    sum1 = + b
    return sum1
print(sum_function(100,200))

如果你没有加入return sum1的话,你去执行这个代码,sum_function(100,200)这个方法的结果是空的,也就是None,就什么都没有打印出来,因为这个函数没有返回任何数据。当然,也有另外一种方法,就是把这个sum1定义成一个全局变量,可以通过以下代码:

1
2
3
4
5
def new_sum(number):
    global sum2
    sum2 = number + 3
new_sum(50)
print(sum2)

执行结果是

python之函数

global其实就是声明一个全局变量,这样我们就可以在外面应这个变量啦

有同学可能会说,那我要它的返回值干嘛,请看下面,如果new_sum想要拿到上一个方法的结果来当成我这个方法的变量,怎么办,因为函数里面的变量是局部变量,在外面是获取不到的,所以我们通过返回值来获取我们想要的东西:

1
2
3
4
5
6
7
8
def sum_function(a,b):
    sum1 = + b
    return sum1
def new_sum(number):
    sum2 = number + 3
    print(sum2)
= sum_function(100,200)
new_sum(a)

当上面的代码执行到第7行代码的时候,就会去调用sum_function这个函数,并传入了两个数值,100和200.这时候就会去执行sum_function这个函数,因为这个函数里面有return,所以就会去return出来的值赋给了a,这样a就有值了,然后再把a的值赋给了new_sum这个函数

注意返回值可以多个,但是return只能有一个,因为方法在执行的时候,看到return它就不执行下面的代码,直接退出方法啦,那如果我们想返回多个值怎么办呢,返回值可以为任何类型,比如元组,字典,列表。这样的话,我们就可以把多个值放在字典或者元组或者列表里面

代码如下:

1
2
3
4
5
6
7
def sum_function(a,b):
    sum1 = + b
    = {a,b,sum1}
    return d
= sum_function(100,200)
print(a)
print(type(a))

这样我们返回的就是一个set的数据类型

python之函数

如果你想返回一个列表,可以用以下方法代码如下:

1
2
3
4
5
6
def sum_function(a,b):
    sum1 = + b
    return {a,b,sum1}
= sum_function(100,200)
print(a)
print(type(a))

python之函数

字典也是同理

如果你默认返回多个值的话,方法会把它封装成一个元组如下代码:

1
2
3
4
def sum_function(a,b):
    sum1 = + b
    return a,b,sum1
print(sum_function(100,200))

python之函数

下面说一下函数的嵌套

下面代码是把把print_line函数嵌套在print_5_line函数上

1
2
3
4
5
6
7
8
def print_line():
    print("-"*50)
def print_5_line():
    = 1
    while i <= 5:
        print_line()
        = + 1
print_5_line()

python之函数

上面的执行结果就可以说明函数是可以嵌套的。

下面说一下缺省参数,缺省参数就是参数有默认的值,如果你没有给这个参数值,这个参数就用它默认的值。如下代码中,zhouyu函数有两个形参a和b,也就是说我们去调用它的时候要传入两个参数,那为什么代码去调用zhouyu的时候只传入一个参数却没有报错呢,因为b=12是缺省参数,也就是说,如果只传入一个参数,那么b就会使用默认值也就是12,所以执行结果是sum = 13。

1
2
3
4
def zhouyu(a,b=12):
    sum1 = + b
    print("sum = %d" %sum1)
zhouyu(1)

如果你调用zhouyu的时候传入两个参数,那b=12就不生效啦,如下:

1
2
3
4
def zhouyu(a,b=12):
    sum1 = + b
    print("sum = %d" %sum1)
zhouyu(1,22)

执行结果是sum = 23

这里要注意一下,缺省参数只能放在最后,不能放在中间或者前面,如下面代码,一定会报错的:

1
2
3
4
def zhouyu(a=12,b):
    sum1 = + b
    print("sum = %d" %sum1)
zhouyu(1,22)

如果你有三个参数呢最后两个是缺省参数,然后你只想让第三个参数不要用默认值,用你传入的值,怎么办呢,可以看看下面代码:

1
2
3
4
def zhouyu(a,b=12,c=22):
    sum1 = + + c
    print("sum = %d" %sum1)
zhouyu(1,c=33)

从上面代码可以看出b的默认值是12,c的默认值是22,那如果你想改变c的值而不改变b的值的话,你可以在传入参数的时候写上c=33,这样c就不会应用默认值22,而用33,像这种我们就称c=33是命名参数

这里我们是明确知道我们想要传入几个参数,那么,如果我们不知道自己想传入几个参数怎么办呢

1
2
3
4
5
def long_argue(a,b,*argue):
    print(a)
    print(b)
    print(argue)
long_argue(1,2,3,4)

上面代码中,*argue是用来接收多余的参数的,我们可以看看执行结果

python之函数

上面的代码中,把多余的3,4传入到argue这个参数里面,变成了一个元组,那么它有什么用呢,比如说,我们想让很多个值相加,可是不知道大概有多少个值,就可以通过这个来实现。如下代码:

1
2
3
4
5
def long_argue(a,b,*argue):
    for in argue:
        sum1 = sum1 + i
    sum1 = sum1 + + b
long_argue(1,2,3,4)

由上面的代码就可以知道,把多余的3,4传入给了argue,这样argue就是一个元组啦,如果要让他们想加的话,就得把元组里面的值一个一个的取出来,并让它们相加,然后再让结果去加上a,b这样就可以实现多个值相加啦。

下面还有一种,就是在*argue后面加上**kwargue这个参数,那么它又是什么意思呢,可以看看下面代码的解释:

1
2
3
4
5
6
def long_argue(a,b,*argue,**kwargue):
    print(a)
    print(b)
    print(argue)
    print(kwargue)
long_argue(1,2,3,4)

执行结果如下:

python之函数

上面可以知道,其实我们的*argue是用来接收一些数值或字符串的,并把这些数据变成元组,而**argue是用来接收命名参数(什么是命名参数可以看看上面红色字体部分,有相关的解释),并把这些命名参数变成字典。

如果我们有一个元组和一个字典,现在想把元组和字典都传递到函数中,应该怎么做呢,可以看看以下代码:

1
2
3
4
5
6
7
8
def long_argue(a,b,*argue,**kwargue):
    print(a)
    print(b)
    print(argue)
    print(kwargue)
= (44,55,66)
= {'name':'zhouyu','age':22}
long_argue(11,22,*A,**B)

如果你不在第8行代码中,A和B前面加上*号的话,传入参数的时候就会默认把A和B看成一个整体,也就是字符串,然后把这两个字符串都传入到*argue这个参数里面去,就变成了元组的值。而上面代码就是把*A拆成一个个数字,也就是44,55,66的数值,然后传递给*argue,把B拆成"name"="zhouyu","age"=22,然后传入了B,像这种过程,我们称这为拆包


本文转自 周子琪 51CTO博客,原文链接:http://blog.51cto.com/izhouyu/1966099


上一篇:《Spring Cloud 微服务实战》| 每日读本书


下一篇:Linux(RHEL7及CentOS7)的时间设置篇(timedatectl,date,hwclock)-系统管理(2)