python3.5------day4--function

函数

函数的作用：

1、减少重复代码

2、扩展性强

3、使程序变的可维护

函数的定义：

def test():
    print("I‘m yao")

#def 是固定的，test为函数名一对小括号不可不少

函数的调用：

def test():
    print("I‘m yao")

test()  # 函数的调用
# 结果：
I‘m yao

形参：

def test(x, y):
    print("I‘m yao")
    print(x*y)

test(5,6)  # 函数的调用

实参：

关键字参数：

默认参数

参数组

函数的各种参数总结：

1、形参和实参是一 一对应的

2、关键字参数和形参的位置无关

3、关键字参数和实参同时出现，关键字参数永远放在实参的右边。

4、形参和默认参数同时出现，默认参数永远写在最右边

5、参数组永远放在最右边

嵌套式函数：

def test(x, y, z):
    print(x, y, z)
    def test1(a, b):
        print(a, b)
    test1(4, 5)  # 调用嵌套函数
test(1, 2, 3)    # 调用第一层函数

递归函数：

def fun(x):
    if x // 2 > 0:
        fun(x//2)
    print(x)  #  x是个列表，一次打印
fun(10)
# 结果:
1
2
5
10

递归函数的特性：

1、必须有一个明确的结束调教

2、每次进入更深一层递归时，文图规模相比上次递归都应该有所减少

3、递归效率不高，递归层次过多会导致栈溢出。

函数的返回值：

作用：

1、一旦你的函数开始调用并开始执行，那你函数的外部程序就没有办法再控制函数的执行过程，此时玩不程序只能等待函数的执行结果。为什要等待函数的结果，因为外部程序要根据函数的执行结果来判断下一步该怎么走，这个结果就是以return的形式返回给外部程序。

2、return代表着函数的结束

3、return可以返回任意数据类型

4、对于用户来讲，函数可以返回任意数量的值，但对于python本身来讲，函数只能返回一个值，如果return后有多个值，那么结果返回也是一个值，这个值是以元组的形式存在的。

高阶函数：

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

示例:

def add(x,y,z):
    return z(x) + z(y)
test = add(3, -6, abs)  # abs函数是绝对值
print(test)

内置函数：

局部变量和全局变量

局部变量：

在子程序中定义的变量是局部变量，在程序一开始定义的变量称为全局变量，全部变量的作用域是整个程序，局部变量的作用域是定义该变量的子程序，当全局变量与局部变量同名时，再多定义局部变量的子程序内，局部变量起作用，其他地方那个全局变量起作用。

全局变量：

在整个过程中都生效的变量叫做全局变量

示例：

x = ‘xiaofeng‘   # 全局变量
def case():
    print(x)
    y = ‘oldboy‘  # 局部变量，出了这个函数就不能调用了
    print(y)

case()
print(x)
print(y)
# 结果
"C:\Program Files\Python35\python.exe" D:/python_progream/python_s15/day4/function_1.py
Traceback (most recent call last):
  File "D:/python_progream/python_s15/day4/function_1.py", line 40, in <module>
    print(y)
NameError: name ‘y‘ is not defined  # 因为y不是全局变量
xiaofeng
xiaofeng

匿名函数：

test = lambda x, y:(x + y)  # lambda定义匿名函数
print(test(3, 5))
# 结果
8

二分查找

data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]

def binary_search(dataset, find_num):
    print(dataset)

    if len(dataset) > 1:
        mid = int(len(dataset) / 2)
        if dataset[mid] == find_num:  # find it
            print("找到数字", dataset[mid])
        elif dataset[mid] > find_num:  # 找的数在mid左面
            print("\033[31;1m找的数在mid[%s]左面\033[0m" % dataset[mid])
            return binary_search(dataset[0:mid], find_num)
        else:  # 找的数在mid右面
            print("\033[32;1m找的数在mid[%s]右面\033[0m" % dataset[mid])
            return binary_search(dataset[mid + 1:], find_num)
    else:
        if dataset[0] == find_num:  # find it
            print("找到数字啦", dataset[0])
        else:
            print("没的分了,要找的数字[%s]不在列表里" % find_num)

binary_search(data, 66)

三元运算+map函数

da = map(lambda n: n*2 if n > 5 else n, range(10))
for i in da:
    print(i)
# 结果
0
1
2
3
4
5
12
14
16
18

三元运算示例

# 三元运算
a = 4
b = 5
d=a if a>10 else b
# 结果
5

函数式编程：

函数是python内建支持的一种封装，我们通过大段代码拆成函数，通过一层层的函数调用，就可以把复杂任务分解成简单的的任务，这种分解可以称为面向过程的设计。函数就是面向过程设计的基本单元。

函数式编程中的函数这个术语不是指计算机中的函数（实际上是Subroutine），而是指数学中的函数，即自变量的映射。也就是说一个函数的值仅决定于函数参数的值，不依赖其他状态。比如sqrt(x)函数计算x的平方根，只要x不变，不论什么时候调用，调用几次，值都是不变的。

Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。

一、定义

简单说，"函数式编程"是一种"编程范式"（programming paradigm），也就是如何编写程序的方法论。

主要思想是把运算过程尽量写成一系列嵌套的函数调用。举例来说，现在有这样一个数学表达式：

(1 + 2) * 3 - 4

    结果：5

传统的过程式编程，可能这样写：

    var a = 1 + 2;

    var b = a * 3;

    var c = b - 4;

函数式编程要求使用函数，我们可以把运算过程定义为不同的函数，然后写成下面这样：

var result = subtract(multiply(add(1,2), 3), 4);

这段代码再演进以下，可以变成这样

add(1,2).multiply(3).subtract(4)

这基本就是自然语言的表达了。再看下面的代码，大家应该一眼就能明白它的意思吧：

merge([1,2],[3,4]).sort().search("2")

因此，函数式编程的代码更容易理解。

要想学好函数式编程，不要玩py,玩Erlang,Haskell, 好了，我只会这么多了。。。

内置参数：