Python基础-函数

Python

• 01.定义函数

1.python中，定义一个函数要使用def关键字
2.python中函数可以什么都不做，即空函数
3.和其他语言不一样，比如c++的函数申明和定义可以自不同文件，但是python的声明和定义都是一个。

#定义了一个加法的函数
def myadd(x,y):
    return x+y

print(myadd(10,20))
print('hello','world')

#定义一个空函数
def nop():
    pass


//程序执行结构
30
hello world
[Finished in 0.1s]

从结果来看，定义了一个"模板"函数，不仅支持整型的加法，还支持字符串的"加法"，但是并不是说Python的函数没有参数的检查，它支持相同类型且支持+操作的类型。

• 02.函数参数


a.位置参数
b.默认参数
c.可变参数
d.关键字参数


1.位置参数
#x，y就是位置参数，函数有且只有两个参数，并且必须通过两个参数调用
def myadd(x,y):
    return x+y

2.默认参数
#实例一：
#这里count就是默认参数，默认值为2，再调用时不写第二个参数就会默认为2
def power(number,count=2):
    res =1
    while count>0:
        count-=1;
        res*=number
    return res


print(power(3))     #默认是2
print(power(3,3))   #此时是3


--------------------------------------------------------


#实例二：
def Add(x,y=10,z=20):
    return x+y+z

#（1）此时不给y，z，那么就会使用默认值
print(Add(0))

#（2）此时想把y改为20
print(Add(0,20))

#（3）但是只能按照顺序缺省，不能直接跳过y给z进行赋值
#想给z赋值为30
print(Add(0,30))

#（4）但是可以只当参数进行赋值
print(Add(0,z=30))

#程序执行结果
30
40
50
40
[Finished in 0.1s]

3.可变参数
#a.什么是可变产生呢？c语言中的printf就是一个
#b.当我们也不知道用户参数个数时，可以使用可变参数来满足要求

#定义一个可变参数的函数
def myprint(*name_list):
    for name in name_list:
        print(name,end="")
    print() 

#调用时应该传递一个列表或者元组
l= ['嘉文四世','格雷弗斯','李青','艾希']
myprint(l)

#程序结果
['嘉文四世', '格雷弗斯', '李青', '艾希']
[Finished in 0.1s]

4.关键字参数
#可变参数允许传入若干参数，这些参数会自动组装成一个tuple，而关键字参数则允许你传入任意个含参数名的参数，这些关键字再内部会自动组装成一个dict

def info(name,sex,**kw):
    print('name',name,'sex',sex,'other',kw)


info('格雷弗斯','男',age=18,hoby='射击')

#程序结果
name 格雷弗斯 sex 男 other {'age': 18, 'hoby': '射击'}
[Finished in 0.1s]

• 03.函数返回值


a. python返回值和C++一样都用return关键字
b. python可以一次接受多个返回值
c. python有没有返回值决定于return是否返回，而不是定义时指定


#定义多返回值的函数
def Getpoint():
    return 10,20,30

#(1)：接受两个返回值（顺序和return顺序相同）
x,y,z=Getpoint()
print(x,y,z)

#(2)：指向接受一个参数时
_,_,z =Getpoint()
print(z)

#(3)：如果返回一个多个数，但是只想要最后一个怎么办呢
*_,z=Getpoint()
print(z)

#(4)：返回多个值的时候返回的其实是一个tuple
print(type(Getpoint()))

#程序执行结果
10 20 30
30
30
<class 'tuple'>
[Finished in 0.1s]

---

• 04.函数递归

1.递归这个概念大家并不陌生，在C/C++中都有这样的概念，典型的就是汉诺塔问题，下面就用上述来进行一个实例

#汉诺塔问题
def move(n,a,b,c):
    if n == 1 :
        print(a + '->' + c)
    else:
        move(n-1, a, c, b)
        move(1, a, b, c)
        move(n-1,b, a, c)

move(3, 'A', 'B', 'C')

#程序结果
A->C
A->B
C->B
A->C
B->A
B->C
A->C
[Finished in 0.1s]

#思路：
     当只有一个盘子的时候从a移动到c，当不止一个盘子的时候
     先将n-1个盘子借助c移动到b,再将a的最后一盘子借助b移动
     到c，最后将b上的n-1个盘子借助a移动到c


#斐波那契数
def Fibonacci(n):
    if n <= 1:
        return n
    return Fibonacci(n-1)+Fibonacci(n-2)

print(Fibonacci(3))
print(Fibonacci(4))
print(Fibonacci(5))

#程序结果
2
3
5
[Finished in 0.1s]

思路：
    第0个和第1个数都是等于自身，这是初始化，后面的每个数都等于它前两个数相
    加。

• 05.装饰器（高级函数）

1. 在我的理解就是一个函数在执行完自身函数逻辑后调用了别的函数，这样就在原来函数的基础上加上别的功能，达到了丰富函数的效果
2. 举个例子：

import time 
def extren(fun):
    def decorador():
        print('[LOG] '+'['+str(time.ctime())+']'+ ' ',end="")
        return fun()
    return decorador

@extren
def Log():
    print('['+__name__+']')

#调用
Log()

#程序执行结果
[LOG] [Tue Jul 24 12:24:29 2018] [__main__]
[Finished in 0.1s]


#上面调用Log()就相当于 =  extren(Log)

如有错误，可以私信我，我会改正的，这里表示感谢 ！

总结一下近期的自己，只想送自己一句话：加油，好吗？