python中的函数

函数，可读性强，复用性强，定义之后可以在任意地方调用，他执行某种行为，并且返回一个值

 

#函数实现斐波那契数列
enternum = int(input('输入想生成的数量\n'))
def test(num):#定义函数，并且带形参'num'
    result = [0,1] #定义初始的列表
    for i in range(num-2):#初始列表有2个值所以需要去掉，循环的次数就是想要生成的个数
        result.append(result[-2]+result[-1])#把列表中前两个数的值之和追加到后面
    return result#返回列表

c = test(enternum)#定义C接受函数的返回值
print(c)#打印出函数的返回值

输出：
输入想生成的数量
10
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
#===============================================================================
#函数的返回值

def test1():
    print('test1')

def test2():
    return 1,2,3


print(test1())#如果函数没有写返回值那就是none
print(test2())#有多个返回值的话返回的是一个元祖

a,b,c= test2()#利用拆包方法
print(a,b,c)

 

局部变量与全局变量

当函数定义变量的时候，函数内所声明的变量只在其函数内有效，与函数外具有相同名称的其他变量没有任何关系

如果局部变量与全局变量名字一眼，首先函数内的生效

#局部变量
a = 1
def func(a):
    print('我是全局的',a)
    a = 2
    print('我是函数内的',a)
func(a)
print('我是全局的,函数内的对我不生效',a)

输出
我是全局的 1
我是函数内的 2
我是全局的,函数内的对我不生效 1

global 语句

如果想把一个变量声名为全局的，则可以使用global语句

（不可变类型）str,int,float,tuple,bool需要用global声明

（可变类型）list,dict,set不需要用global声明

#全局变量
a = 1
def func():
    global a
    print('我是全局的',a)
    a =2
    print('在函数内我变成了',a)
func()
print('出了函数我变成了',a)

输出:
我是全局的 1
在函数内我变成了 2
出了函数我变成了 2

默认参数

对于一些参数，我们希望它的一些参数是可选的，如果用户不想要为这些参数提供值的话，这些参数就使用默认值

#默认参数
def func(a,b=1):#b是可选参数
    print(a*b)
c1 = func(3)
c2 = func(4,2)

输出:
3
8

函数之间的调用

#函数与函数的调用
money = 500
def test(consume):#入参为500的时候 该函数返回是0，即test(money)
    return money - consume

def test1(money):#调用了test(consume)函数，返回值是0+500
    return test(money) + money

money1 = test1(money)#调用test1函数，所以返回了500
print(money1)

输出:
500

 不定长参数：

#不定长参数
#1。加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数
#2。加了两个星号 ** 的参数会以字典的形式导入
#可选参数（参数组） 非必传，不限制参数个数，把参数放到一个list里，用*表示
def test1(*number):
    print(number)
test1()
test1(4)
test1(1,2,3)

#关键字参数衍生，非比传，不限制参数个数，把参数放到一个字典里
#传参的时候必须是用关键字的方式（key=value）
def test2(**kwargs):
    print(kwargs)
test2(mm='nihao',hh='buhao',mh='很好')




输出：
()
(4,)
(1, 2, 3)
{'mm': 'nihao', 'hh': 'buhao', 'mh': '很好'}

 参数拆包入参 适用于不定长参数

def test1(name,age,sex):
    print(name,age,sex)
l=['mm',18,'male']
def test2(name,age,sex):
    print(name,age,sex)
d={'name':'mm','age':18,'sex':'male'}
test1(*l)#拆成了'mm',18,'sex'
test2(**d)#拆成了name=mm,age=18,sex=male

 

lambda 来创建匿名函数，所谓匿名，即不再使用 def 语句这样标准的形式定义一个函数。

lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去

a=lambda x:x+1#  ':'前面是入参，后面是函数体
print(a(1))#结果是2

def test(n):
    return lambda a:a*n
t=test(3)#函数入参
print(t(2))#匿名函数入参，结果是6

 

 

关键参数

如果某个函数有许多参数，而我们只想指定其中的一部分，那么可以使用名字（关键字）而不是位置来给函数指定实参。----这被称作 关键字参数

　　　　　　　　　　　　　　　　　　　　　　　　　　　　

def func(a,b=5,c=10):
    print ('a is',a, 'and b is',b,'and c is',c)

func(3,7)
func(24,c=32)
func(c=23,a=14)

输出:
a is 3 and b is 7 and c is 10
a is 24 and b is 5 and c is 32
a is 14 and b is 5 and c is 23