0724_递归函数

递归函数

在一个函数体的内部，调用函数本身，就被称为递归函数

def func(n):
    print(n)
    if int(n/2) == 0:
        return n
    return func(int(n/2))

print(func(10))

10
5
2
1

用递归函数写1，1，2，3，5，8

def fibonacci(n):
    if n == 1:
        return 1
    if n == 2:
        return 1
    else:
        return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(6))

匿名函数(lambda)

• 格式

lambda para1, para2, ... , paraN : expression using paras

高阶函数

高阶函数：把一个函数名,以实参的形式，传递给这个函数的形参，这个函数就成为高阶函数

def add(a, b, c):
    return c(a) + c(b)
a_value = add(9, 1, abs)
print(a_value)
# 10


def pow(x):
    return x**2
def add(a, b, func):
    return func(a) + func(b)

a_value = add(-9, 1, pow)
print(a_value)
# 82

filter函数

f1 = filter(lambda sr: not sr.endswith('ty'),li)

功能：-

• 过滤吊序列中不符合函数条件的元素。当序列中需要保留的元素可以用某些函数描述时，就应该想到filter函数。

调用格式：

• filter（function， sequence）
  • function —> 可以是自定义的函数，也可以匿名函数
  • sequence —> 列表，元组，字符串

li = ['zhejiang', 'university', 'city', 'college']
ret = []
for i in li:
    if not i.startswith('c'):
        ret.append(i)
print(ret)
# ['zhejiang', 'university']

li = ['zhejiang', 'university', 'city', 'college']
def filter_test(para):
    ret = []
    for i in li:
        if not i.startswith('c'):
            ret.append(i)
    return ret
print(filter_test(li))
# ['zhejiang', 'university']

li = ['zhejiang', 'university', 'city', 'college']
def start_sr(sr):
    return sr.startswith('c')

def end_sr(sr):
    return sr.endswith('ty')

def filter_test(func, para):
    ret = []
    for i in para:
        if not func(i):
            ret.append(i)
    return ret

print(filter_test(start_sr, li))
print(filter_test(end_sr, li))
#  ['zhejiang', 'university']
#  ['zhejiang', 'college']

map 函数(映射)

功能：

• 求一个序列或者多个序列进行函数映射后的值。(用list()强转)
  • 格式

map(function,iterable1,iterable2)

• function的参数可以不止一个，
• iterable1，iterrable2就是传入function的参数

li=[1,2,3,4,5]
res=map(lambda x:x+1,li)
print(list(res))
# [2, 3, 4, 5, 6]

x=[1,2,3,4,5]
y=[2,3,4,5,6]
res=map(lambda x,y:x*y + 2,x,y)
print(list(res))
# [4, 8, 14, 22, 32]

x=[1,2,3,4,5]
y=[2,3,4,5,6]
def f(x,y):
    return x*y+2
res=map(f,x,y)
print(list(res))
# [4, 8, 14, 22, 32]

reduce函数

• 功能

  • 对一个序列进行压缩运算，得到一个value

  • python2中，reduce（）是内置函数，而在python3中，被移植到functools 模块中

  • from functools import reduce
    

• 格式

  • reduce (function, iterable, [initial])
    

    • function 必须要传入两个参数
    • Iterable —> 列表/元组

from functools import reduce
y = [2, 3, 4, 5, 6]
z = reduce(lambda x, y: x+y, y)

print(z)
# 20  (2+3+4+5+6)


from functools import reduce
y = [2, 3, 4, 5, 6]
z = reduce(lambda x, y: x*y, y)

print(z)
#  720  阶乘

from functools import reduce
y = [2, 3, 4, 5, 6]
z = reduce(lambda x, y: 10*x+y, y)

print(z)
# 23456

apply

• 功能
  • pandas 中， 应用对象是pandas中的DataFrame 或者Series
  • 直接对DaraFrame或者Series应用函数
  • 对pandas中groupby之后的聚合对象应用apply

import numpy as np
import pandas as pd

a = np.random.randint(low=0, high=4, size=(2, 4))
print(a)
data = pd.DataFrame(a)
print(data)
[[1 0 0 0]
 [0 1 3 0]]

   0  1  2  3
0  1  0  0  0
1  0  1  3  0

zip函数

功能

• 将可迭代对象作为参数，将对象中对应的元素打包成一个个元组，返回由这些元组构成的对象
• 长度不一样时，以长度短的为准

注：

利用*号操作符，与zip相反，进行解压。

格式

zip(iterable1,iterable2,…)

• iterable—>两个或多个可迭代序列（字符串，列表，元组，字典）
  • py2,由元组组成的列表
  • py3,返回的是一个对象，如果要得到一个列表，需要强转

a=[1,2,3]
b=[4,5,6]
c=[4,5,6,7,8]
ziptest1=zip(a,b)
print(list(ziptest1))
#[(1, 4), (2, 5), (3, 6)]

a=[1,2,3]
b=[4,5,6]
c=[4,5,6,7,8]
ziptest1=zip(b,a)
print(list(ziptest1))

#[(4, 1), (5, 2), (6, 3)]

输出1000内回文数
print(list(filter(lambda x: str(x) == str(x)[::1], range(1, 1000))))

test1=zip(a,b)
print(list(ziptest1))
#[(1, 4), (2, 5), (3, 6)]

a=[1,2,3]
b=[4,5,6]
c=[4,5,6,7,8]
ziptest1=zip(b,a)
print(list(ziptest1))

#[(4, 1), (5, 2), (6, 3)]

```python
输出1000内回文数
print(list(filter(lambda x: str(x) == str(x)[::1], range(1, 1000))))