python函数和递归

python函数入门

def MyFirstFunction(name):
    print(name + '我爱你！')
MyFirstFunction('小甲鱼')
# 小甲鱼我爱你！

函数的返回值

def add(num1, num2):
    return num1 + num2
print(add(5, 6))
# 11

def back():
    return [1, '小甲鱼', 3.14]
back()
# [1, '小甲鱼', 3.14]
def back():
    return 1, '小甲鱼', 3.14
back()
# (1, '小甲鱼', 3.14)

函数文档

def MyFirstFunction(name):
    'name是形参'
    #因为他只是一个形式，占据一个参数的位置
    print('传递进来的' + name + '叫做实参，因为他是具体的参数值！')
MyFirstFunction('小甲鱼')
# 传递进来的小甲鱼叫做实参，因为他是具体的参数值！
MyFirstFunction.__doc__
# 'name是形参'

函数参数

• 形参和实参
• 关键字参数

def SaySome(name, words):
    print(name + '->' + words)
SaySome('小甲鱼','让编程改变世界')
# 小甲鱼->让编程改变世界
SaySome('让编程改变世界','小甲鱼')
# 让编程改变世界->小甲鱼
SaySome(words = '让编程改变世界',name = '小甲鱼')
# 小甲鱼->让编程改变世界

• 默认参数

def SaySome(name='小甲鱼', words = '让编程改变世界'):
    print(name + '->' + words)
SaySome()
# 小甲鱼->让编程改变世界
SaySome('苍井空')
# 苍井空->让编程改变世界

• 收集参数
  类似于java的可变参数

def test(*params):
    print('参数的长度是:',len(params))
    print('第二个参数是:',params[1])
test(1,'小甲鱼',2,3.14,4,5,6)
# 参数的长度是: 7
# 第二个参数是: 小甲鱼

def test(*params, exp):
    print('参数的长度是:',len(params), exp)
    print('第二个参数是:',params[1])
test(1,'小甲鱼',2,3.14,4,5,6)

Traceback (most recent call last):
  File "<pyshell#29>", line 1, in <module>
    test(1,'小甲鱼',2,3.14,4,5,6)
TypeError: test() missing 1 required keyword-only argument: 'exp'

test(1,'小甲鱼',2,3.14,4,5,exp = 6) #如果使用了收集参数，后面必须用关键字参数，否则会报错
# 参数的长度是: 6 6
# 第二个参数是: 小甲鱼

函数变量的作用域

• 局部变量
• 全局变量

def discounts(price, rate):
    final_price = price * rate
    old_price = 50  #python生成一个新的局部变量
    print('修改后old_price的值是1:', old_price)
    return final_price
old_price = float(input('请输入原价:')) #全局变量
rate = float(input('请输入折扣率:'))
new_price = discounts(old_price, rate)
print('修改后old_price的值是2:', old_price)
print('打折后价格是:', new_price)

# 请输入原价:100
# 请输入折扣率:0.8
# 修改后old_price的值是1: 50
# 修改后old_price的值是2: 100.0
# 打折后价格是: 80.0

def MyFun():
    global count #用global关键字将count变量变成一个全局变量
    count = 10
    print(count)
MyFun()
# 10
print(count)
# 10

内嵌函数和闭包

def fun1():
    print('fun1()正在被调用...')
    def fun2():
        print('fun2()正在被调用...')
    fun2()  #只能在fun1()内部调用fun2()
fun1()
# fun1()正在被调用...
# fun2()正在被调用...

def FunX(x):
    def FunY(y):
        return x * y
    return FunY
i = FunX(8)
i
# <function FunX.<locals>.FunY at 0x00000075480461E0>
type(i)
# <class 'function'>
i(5)
# 40
FunX(8)(5)
# 40

如果在一个内部函数里：FunY(y)就是这个内部函数，对在外部作用域（但不是在全局作用域）的变量进行引用：x就是被引用的变量，x在外部作用域FunX里面，但不在全局作用域里，则这个内部函数FunY就是一个闭包。

再稍微讲究一点的解释是，闭包=函数块+定义函数时的环境，FunY就是函数块，x就是环境，当然这个环境可以有很多，不止一个简单的x。

def Fun1():
    x = 5
    def Fun2():
        nonlocal x #声明x不是一个局部变量，类似局部变量和全局变量的关系
        x *= x
        return x
    return Fun2()
Fun1()
# 25

lambda表达式

def ds(x):
    return 2 * x + 1
ds(5)
# 11
lambda x : 2 * x + 1
# <function <lambda> at 0x000000F79A26E048>
g = lambda x : 2 * x + 1
g(5)
# 11

def add(x, y):
    return x + y
add(3, 4)
# 7
lambda x, y : x + y
# <function <lambda> at 0x000000F79A26E048>
g = lambda x, y : x + y
g(3,4)
# 7

两个牛逼的BIF

#如果第一个参数为None，则筛选出第二个可迭代集合中的所有为True的值，作为一个集合返回
filter(None, [1, 0, False, True]) 
# <filter object at 0x000000F40AB15748>
list(filter(None, [1, 0, False, True]))
# [1, True]

def odd(x):
    return x % 2
temp = range(10)
#将第二个参数（集合）的每个元素作为输入，经过第一个参数（函数）加工后，产生一个集合，从这个集合中筛选所有为True的值，然后返回一个新的集合
show = filter(odd, temp)
list(show)
# [1, 3, 5, 7, 9]
list(filter(lambda x : x % 2, range(10)))
# [1, 3, 5, 7, 9]

#将第二个参数（集合）的每个元素作为输入，经过第一个参数（函数）加工后，返回一个新的集合
list(map(lambda x : x * 2, range(10))) 
# [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

递归

import sys
sys.setrecursionlimit(1000) #python设置递归深度为1000

#求阶乘
def factorial(n):
    if n == 1:
        return 1    #递归头
    else:
        return n * factorial(n - 1)  #递归体
number = int(input('请输入一个正整数:'))
result = factorial(number)
print('%d的阶乘是:%d' % (number, result))

# 请输入一个正整数:5
# 5的阶乘是:120

#斐波那契数列[迭代]
def fib(n):
    n1 = 1
    n2 = 1
    n3 = 1
    if(n < 1):
        print('输入有误！')
        return -1
    if n == 1 or n == 2:
        return 1

    while(n - 2) > 0:
        n3 = n2 + n1
        n1 = n2
        n2 = n3
        n -= 1
    return n3

result = fib(7)
if result != -1:
    print('总共有%d对小兔子诞生！' % result)

# 总共有13对小兔子诞生！

#斐波那契数列[递归]
def fib(n):
    if(n < 1):
        print('输入有误！')
        return -1
    if n == 1 or n == 2:
        return 1
    else:
        return fib(n - 1) + fib(n - 2)
result = fib(8)
if result != -1:
    print('总共有%d对小兔子诞生！' % result)

# 总共有21对小兔子诞生！

#汉诺塔[递归]
def hanoi(n, source, temp, dest):
    if n == 1:
        print(source, '-->', dest)
    else:
        #将前n-1个盘子从x移动到y上
        hanoi(n - 1, source, dest, temp)
        print(source, '-->', dest) #将最底下的一个盘子从x移动到z上
        #将y上的n-1个盘子移动到z上
        hanoi(n - 1, temp, source, dest)
hanoi(3, 'A', 'B', 'C') 

# A --> C
# A --> B
# C --> B
# A --> C
# B --> A
# B --> C
# A --> C