Python函数

1.调用一个函数，就是写出函数名加上（）

def MyFirstFunction():
        print('这是我的第一个函数')

def MySencondFunction(name):
        print(name + '哈哈')
MySencondFunction('charlin')

def add(sum1, sum2):
        result = sum1 + sum2
        print(result)
add(1, 2)

2.函数如何返回 用return

def ad(sum1, sum2):
    return sum1 + sum2
print(ad(1,5))

3. 参数 

形参是函数创建和定义的时候小括号里的参数，实参是函数调用过程中要传进来的参数

4. 函数文档  

函数名.__doc__和help（函数名） ，可看到文档里的字符串

5. 关键字参数 

一般的参数是位置参数，在调用的时候，如果不按照位置顺序传参，函数无法按照预期效果实现。用关键字参数可解决这一问题，即在传入实参时指定形参的变量名。

def SaySome(name, words):
    print(name + '->' + words)

SaySome(words='编程', name='charlin')

6. 默认参数 

在定义时赋予默认值的参数，如果不给实参，程序会按照默认的参数输出，如果给出实参，输出实参

def SaySome1(name= 'charlin', words= '编程'):
    print(name + '->' + words)

SaySome1('owen')

7. 收集参数 

当编程人员本身都不知道函数需要多少参数时，可以利用收集参数。形式：函数名（*形参）。

def test(*params):
    print('参数的长度是：', len(params))
    print('第二个参数是', params[1])

test(1, '哈哈', 3.12, 3, 4, 5)  

8.如果在收集参数后面还需要指定其他参数，在调用的时候用关键字参数与来指定

def test1(*params, exp):
    print('参数的长度是：', len(params), exp)
    # print(exp = 10)
    print('第二个参数是', params[1])

test1(1, '哈哈', 3.12, 3, 4, 5, 7, 8, exp=10)

9.函数与过程 

 函数是有返回值，过程是没有返回值，Python严格来说是没有过程只有函数

def hello():
    print('hello owen!')

temp = hello()  # 有返回值
print(temp)  # 没有返回值输出none
print(type(temp))

10.全局变量和局部变量 

全局变量：函数体外定义的，在整个代码段都能访问到，局部变量不能直接改变全局变量的值

如果在函数体内直接改变全局变量的值，Python会自动在函数体内创建一个相同名字的局部变量代替，所有在局部变量输出的和全局变量输出的值会不一样。

def dis(price, rate):
    final_price = price * rate
    old_price = 50
    print('在局部变量中修改后old_price的值是：', old_price)
    return final_price

old_price = float(input('请输入原价：'))
rate = float(input('请输入汇率：'))
new_price = dis(old_price, rate)
print('全局变量old_price的值：',old_price)
print('打折后的值是:', new_price)

11. 如果要在函数体中修改全局变量的值，使用global关键字，要修改函数体的外部函数的值，用nonlocal

def myfun():
    global count
    count = 10
    print(count)
count = 5
myfun()
print(count)

12. 内嵌函数

Python的函数定义是可以嵌套的，允许在函数内部创建另一个函数，函数调用所有可见的函数

def fun1():
    print('fun1正在被调用...')
    def fun2():
        print('fun2正在被调用')
    fun2()

fun1()

13. 闭包：

在一个内部函数中，对在外部作用域的变量进行引用，那么内部函数就被认为是闭包

def funX(x):
    def funY(y):
        return x*y
    return funY

# s = funX(6)
# print(s(5))
print(funX(4)(5))

14. 匿名函数

lambda表达式 基本语法 冒号左边放原函数的参数，可以有多个参数，用逗号隔开，冒号右边是返回值

def ds(x):
    return 2 * x + 1
print(ds(5))

g = lambda x: 2 * x + 1
print(g(5))
f = lambda a, b: a + b
print(f(3, 4))

15.两个内置函数

filter过滤器 :可以把任何非true的内容给过滤掉

print(list(filter(lambda x : x % 2, range(10))))

map（）将序列的每一个元素作为函数的参数再加工，返回加工后的元素构成的新序列

print(list(map(lambda x : x * 2, range(10))))

16. 递归

函数自身调用自身，Python中默认递归深度为100层

def rec(n):
    result = n
    for i in range(1, n):
        result =result * i
    return result

number = int(input('请输入一个整数'))
print(rec(number))
print('%d 的阶乘是：%d'%(number, rec(number)))

斐波那契数列

def fab(n):
    if n<1:
        print('输入错误！')
    if n==1 or n==2:
        return 1
    else:
        return fab(n-1)+(n-2)
result = fab(20)
print('斐波那切数列结果是：%d'% result)  #注意没有逗号不能写成print('%d',% result)