python函数

range()函数

1、给一个数字类型参数，range会遍历从0到参数减1的数字。要特别注意，range默认从0开始，到参数减1，也就是左闭右开的规则

for i in range(10):
    print(i)

2、可以指定遍历的区间：

for i in range(1,10):
    print(i)

3.还可以指定步长，就像切片一样

for I in range(1,10,2):
    print(I, end=' ')

>>>
1 3 5 7 9

4、如果使用负数步长，那么你的区间设定就要从大到小；如果你的区间设定是从大到小，那么你就需要使用负数步长，这和列表的切片特性是一样样的

for I in range(10,1,-2):
    print(I ,end='')
>>>
10,8,6,4,2

python 递归函数

如果一个函数在内部调用了自身，这个函数就被称为递归函数。

高斯求和 使用递归函数来写

def sum_num(n):
    if n<=0:
        return 0
    return n+sum_num(n-1)

print(sum_num(10))

>>>
55
分析一下代码，当n小于等于0的时候，直接给出和值为0，这句不能省。当n大于0时，结果是n加上sum_number(n-1)。这里的sum_number(n-1)又是一次sum_number函数的调用，不过参数的值变成了n-1，要得到sum_number(n)的值就必须等待sum_number(n-1)的值被计算出来，同样要得到sum_number(n-1)的值必须等待sum_number(n-2)的值，如此一路推算下去，直到sum_number(0)，因为if语句的存在，它不需要等待sum_number(-1)的计算了，而是直接给出结果0。然后程序一路返回，直到回到最初的sum_number(n)，并给出最终结果

递归最核心的思想是：每一次递归，整体问题都要比原来减小，并且递归到一定层次时，要能直接给出结果！

使用递归函数需要注意防止递归深度溢出，在Python中，通常情况下，这个深度是1000层，超过将抛出异常。在计算机中，函数递归调用是通过栈（stack）这种数据结构实现的，每当进入一个递归时，栈就会加一层，每当函数返回一次，栈就会减一层。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出

python匿名函数 lambda 

当我们在创建函数时，有些时候，不需要显式地定义函数，直接传入匿名函数更方便，匿名函数用好了，会有画龙点睛的效果，没用好，就容易“画虎不成反类犬”，需要我们在平时的代码过程中，多学、多看、多琢磨

Python语言使用lambda关键字来创建匿名函数。所谓匿名，即不再使用def语句这样标准的形式定义一个函数。

其形式通常是这样的：lambda 参数: 表达式

例如：lambda x: x * x 它相当于下面的函数：

def f(x):
    return x * x

关键字lambda表示匿名函数，冒号前面的x表示函数参数，冒号后面 x*x是执行代码

匿名函数只能有一个表达式，不用也不能写return语句，表达式的结果就是其返回值。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数

>>> target = lambda x:x**2
>>> target
<function <lambda> at 0x10b0c28c0>
>>> target(3)
9
>>> 

也可以把匿名函数作为别的函数的返回值返回。

def add(a,b):
    return lambda x,y:x+y

print(add(2, 3))
>>>
<function add.<locals>.<lambda> at 0x10383ee18>

lambda 表达式通常会跟python 的内置函数搭配使用 如：filter、map、reduce

• filter函数
• filter（function，指定的序列）

>>> l=filter(lambda x:x%2==0,list(range(10)))
>>> type(l)
<class 'filter'>
>>> list(l)
[0, 2, 4, 6, 8]

1、按照定义的函数过滤掉序列中函数返回值是False的元素
2、这里的function必须是一个返回布尔值的函数或lambda表达式，list为输入function函数的参数列表，且只能有一个列表
3、filter() 函数返回值不会改变原序列的类型，因为它只是起过滤作用，所以原序列是什么类型，filter之后还是什么类型

• map 函数
• map函数根据提供的函数对指定的序列做映射
• map(function,指定的序列)

>>> m=map(lambda x:x*2,tuple(range(10)))
>>> m
<map object at 0x10b1ded90>
>>> tuple(m)
(0, 2, 4, 6, 8, 10, 12, 14, 16, 18)
>>> list(m)
[]
>>> tuple(m)
()
>>> m=map(lambda x:x*2,tuple(range(10),tuple(range(5))))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: tuple expected at most 1 arguments, got 2

1、说明map中只能多一个序列进行操作
2、map出来的元素调用了一次之后在次调用是空,如： （）、[]
3、map函数返回值是一个序列

• reduce函数
• reduce函数会对参数序列中元素进行累积
• reduce(function,指定的序列,[或者是整型数字])

>>> from functools import reduce
>>> r = reduce(lambda x,y:x+y,list(range(50)))
>>> r
1225
>>> r = reduce(lambda x,y:x+y,list(range(50)),10)    #可以对两个参数累积，算上lambda是三个参数，所以reduce()函数中参数个数可以是 2 个 ，最多只能 3个
>>> r
1235
>>> r = reduce(lambda x,y:x+y,list(range(50)),10,10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: reduce expected at most 3 arguments, got 4
>>> 
注意：
1、function必须是有2个参数的函数
2、reduce 函数返回值是一个值
3、python3中reduce函数不在是内建函数，需要从functools 模块中导入 reduce函数

• sorted 函数
• 对列表、元祖、字典 进行排序

>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> sorted(a,reverse=True)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> d=dict([('name','Tom'),('age',23),('salary','30K')])
>>> d
{'name': 'Tom', 'age': 23, 'salary': '30K'}
>>> sorted(d,key=lambda x:x[0])
['age', 'name', 'salary']
>>> sorted(d,key=lambda x:x[0],reverse=True)
['salary', 'name', 'age']
>>> 

1、lambda表达式中的 x 表示字典中的一个元素，在这里，表示一个key:value的键值对，x只是临时起的一个名字，你可以使用任意的名字；x[0]表示键值对里的 键key，x[1]表示键值对的 值value；
2、sorted() 排序中默认使用reverse=False 从小到大排序，当设置了 reverse=True 表示从大到小排序