返回列表中最大的和第二大的元素，不允许使用Python内置的排序和最大函数。
冒泡排序
# 冒泡排序
def item(ls):
	n = 0
	while n < len(ls):

		for i in range(len(ls) - 1):
			if ls[i] > ls[i + 1]:
				ls[i], ls[i + 1] = ls[i + 1], ls[i]
		n += 1
	return ls[-1], ls[-2]
print(item([321, 5345, 3466, 31, 213, 3223, 3, 423]))


# 第二种方法
# 先默认将第一个和第二个数比较赋值给第一大和第二大
# 从第三个数开始 跟第一大比较  如果有更大的 把之前最大值赋值给第二大值
def find_max_two(items:list):
    first,second = (items[0],items[1]) if items[0]>=item[1]\
    	else (items[1],items[0])
    for _ in range(2,len(items)):
        if items[_]>first:
            second = first
            first = items[_]
        elif items[_]>second:
            second = items[_]
    return first,second

C++ 不允许返回一个完整的数组作为函数的参数。但是，您可以通过指定不带索引的数组名来返回一个指向数组的指针。

如果您想要从函数返回一个一维数组，您必须声明一个返回指针的函数，如下：

int * myFunction() { . . . }

另外，C++ 不支持在函数外返回局部变量的地址，除非定义局部变量为 static 变量。例如：

#include <iostream>

using namespace std;

int a[10] = { 10,20 };

char *GetCharArr()

{

    static char sss[20] = { 0 };

    sprintf_s(sss, "ABABXX%d", a[0]);

    cout << sss << endl;

    return sss;

}

int main()

{

    char *xxx;

    xxx = GetCharArr();

    printf("当前的字符串是：%s", xxx);

    system("PAUSE");

    return 0;

}



另一个例子：

#include <iostream>

#include <ctime>

#include <cstdlib>

using namespace std;

// 要生成和返回随机数的函数

int *getRandom()

{

    static int  r[10];

    // 设置种子

    srand((unsigned)time(NULL));

    for (int i = 0; i < 10; ++i)

    {

        r[i] = rand();

        cout << r[i] << endl;

    }

    return r;

}

// 要调用上面定义函数的主函数

int main()

{

    // 一个指向整数的指针

    int *p;

    p = getRandom();

    for (int i = 0; i < 10; i++)

    {

        cout << "*(p + " << i << ") : ";

        cout << *(p + i) << endl;

    }

    return 0;

}

我的个人网站 www.ryzeyang.top

内容概览

入门python的学习笔记四 之 python3 函数式编程—高阶函数，返回函数，匿名函数，装饰器，偏函数的使用



廖雪峰老师的Python教程 第四弹之函数式编程—高阶函数，返回函数，匿名函数，装饰器，偏函数 fighting 😆
函数式编程

函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！

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

高阶函数（Higher-order function）
特点：

变量可以指向函数 即 函数本身也可以赋值给变量 x=abs x(-10) #10
函数名也是变量 abs = 10 abs(-10) # TypeError: 'int' object is not callable

注：由于abs函数实际上是定义在import builtins模块中的，所以要让修改abs变量的指向在其它模块也生效，要用import builtins; builtins.abs = 10


传入函数

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

def add(x, y, f):
    return f(x) + f(y)
print(add(-5, 6, abs))    
# 11   



map/reduce，filter,sorted

map/reduce的概念： Google论文“MapReduce: Simplified Data Processing on Large Clusters”

这四个用法同es6.


map()函数接收两个参数，一个是函数，一个是Iterable 返回一个Iterator
def f(x):
    return x**2
a=map(f,[x for x in range(10)])
print(next(a)) # 0
print(list(a)) # [1, 4, 9, 16, 25, 36, 49, 64, 81]

把这个list所有数字转为字符串：
print(list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))) 
# ['1', '2', '3', '4', '5', '6', '7', '8', '9']



reduce() 把结果继续和序列的下一个元素做累积计算:reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

序列[1, 3, 5, 7, 9]变换成整数13579：
from functools import reduce
    def fn(x,y):
        return x*10+y
    print(reduce(fn,[1,3,5,7,9])) #13579

str转换为int：
from functools import reduce

DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}

def char2num(s):
    return DIGITS[s]

def str2int(s):
    return reduce(lambda x, y: x * 10 + y, map(char2num, s))
print(str2int('0123456789'))     # 123456789



filter() 接收一个函数和一个序列 ，返回的是一个Iterator

过滤出符合条件的数
def is_odd(n):
return n % 2 == 1
list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))



sorted() 接收一个序列和一个函数 sorted([36, 5, -12, 9, -21])

按绝对值大小排序：
sorted([36, 5, -12, 9, -21], key=abs)
# [5, 9, -12, -21, 36]

要进行反向排序，不必改动key函数，可以传入第三个参数reverse=True：
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
def by_name(t):
    return t[0]
L2 = sorted(L, key=by_name,reverse=True)
print(L2)    



返回函数
函数作为返回值

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。

可变参数的求和(立刻返回计算结果):
def calc_sum(*args):
    ax = 0
    for n in args:
        ax = ax + n
    return ax

返回求和的函数：
def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum
f = lazy_sum(1, 3, 5, 7, 9)
f() #25

闭包（注意！）

返回闭包时牢记一点：返回函数不要引用任何 循环变量，或者后续 会发生变化的变量。

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count() 
# f1() 9
# f2() 9
# f3() 9
# 全部都是9！原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9。

def count():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
    return fs
for fn in count():
    print(fn())
# 1 4 9

匿名函数

关键字lambda表示匿名函数，冒号前面的x表示函数参数。

匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果

list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))

lambda x: x * x ` #等于
def f(x):
    return x * x


用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：

# 把匿名函数赋值给一个变量，再利用变量来调用该函数
f = lambda x: x * x
f(5)
#25
# 匿名函数作为返回值返回
def build(x, y):
    return lambda: x * x + y * y

装饰器

在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）

本质上，decorator就是一个返回函数的高阶函数

看看下面的代码，瞬间明白，这个不就是Spring 的 aop思想吗，这用法像java的注解 哈哈
@log
def now(a,b,*,age):
    print('2015-3-25')

def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__) # __name__获取函数对象的名字
        print( args)
        print( kw)
        return func(*args, **kw)
    return wrapper

now('1','1',age=12)
# call now():
# ('1', '1')
# {'age': 12}
# 2015-3-25


把@log放到now()函数的定义处，相当于执行了语句：

now = log(now)

wrapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以接受任意参数的调用。在wrapper()函数内，首先打印日志，再紧接着调用原始函数。

def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

@log('execute')
def now():
    print('2015-3-25')
#  等于 now = log('execute')(now)
now()
# execute now():
# 2015-3-25



剖析：  now = log(‘execute’)(now)

首先执行log(‘execute’)，返回的是decorator函数，再调用返回的函数，参数是now函数，返回值最终是wrapper函数。

函数也是对象，它有__name__等属性

所以最后会出现 now.__name__ #'wrapper' 的情况

这样子会导致有些依赖函数签名的代码执行错误

但是Python内置的functools.wraps 就是用来 把原始函数的__name__等属性复制到对应的函数中

如：
@functools.wraps(func)
    def wrapper(*args, **kw):

修改后运行now.__name__。结果为 #now
偏函数
偏函数是参数固定的函数，即有默认值的函数

Python的functools模块提供了很多有用的功能，其中一个就是偏函数（Partial function）,


functools.partial就是帮助我们创建一个偏函数的，

它可以帮我们固定函数的参数，返回一个新的函数

可以接收函数对象、*args和**kw这3个参数

如 int 函数
import functools
int2 = functools.partial(int, base=2)
int2('1000000')
# 64

如 max函数
import functools
# 实际上会把10作为*args的一部分自动加到左边 √ （廖老师的课程真给力 ☆(￣▽￣)/$:*）
max2 = functools.partial(max, 10)
max2(5, 6, 7)
# 10

函数的返回值返回值概念

函数自身的处理数据或执行结果，需要被二次使用或其他程序调用时，需要将数据返回出来

如何拿到返回值

关键字：return 要返回的数据

return的功能

可以让函数返回指定的值

可以立即结束当前函数

一个函数中可以写无数个，但是只能执行一次return，一次只能返回一个数据，不允许返回多个数据

返回到哪

返回到函数的执行语句

函数名()，既是在执行函数，也是在拿返回值

注意：一个函数如果没有return，那么返回的是undefined；如果有return，那么返回值就是return后面的值

可以返回哪些数据

所有数据

当返回函数时，形成了闭包（后期概念）

什么时候需要返回值？

功能性函数（打印表格，改颜色）

可以有，但是没有必要有返回值

处理数据的函数（补零，计算器，计算圆的面积）

一般都有，返回数据

作用域：谁作用的哪个区域

谁：数据（变量）

哪个：如何划分，函数就是一个区域

全局

不属于任何一个函数

全局作用域中的变量，叫全局变量

全局作用域中的函数，叫全局函数

生命周期：一直存在

耗性能，但是方便

少用全局

局部：

任何一个函数内部都是局部作用域

局部作用域中的变量，叫局部变量

局部作用域中的函数，叫局部函数

生命周期：朝生暮死

节省内存，不方便

函数的参数（形参）：是当前函数的局部变量

匿名函数

利用匿名函数解决全局耗性能，局部不方便的问题

(function(){})()

变量的读写规则：当全局和局部的变量名重复时

读的规则：

向上级作用域查找，找到了，就使用，同时，停止查找；找到顶级作用域，都没有，报错

写（设置，赋值）的规则：

向上级作用域查找，找到了，就写入，同时，停止查找；找到顶级作用域，都没有，会默认在顶级作用域声明这个变量，然后使用

注意：声明变量时，必须加声明关键字，不加声明关键字，可能能执行，但是不规范