函数补充

递归函数

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

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

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

print(fib(11))

匿名函数（lambda）

• 格式：

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

def add(x,y,z):
    return x+y+z

print(add(1,2,3))
等效于：

f=lambda x,y,z:x+y+z
print(f(1,2,3))

高阶函数

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

def pow(x):
    return x**2

def add(a,b,func):
    return func(a)+func(b)

a_value=add(-9,5,pow)
print(a_value)

filter函数

f1=filter(lambda sr:not sr.endswith("ty"),li)
print(list(f1))

功能：

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

调用格式：

• filter(function,sequence)

  • function—>可以是自定义的函数，也可以匿名函数

  • sequence—>列表，元组，字符串

map映射

功能

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

格式

• map(function,iterable1,iterable2)
  • funciton 的参数可以不止一个
  • iterable1，iterable2就是传入function的参数

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

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))

结果：
[2, 3, 4, 5, 6]
[4, 8, 14, 22, 32]

reduce函数

• 功能:

  • 对一个序列进行压缩运算，得到一个value。
  • python2中，reduce()是内置函数，而现在，python3中，它被移植到functools模块中。
  • from functions import reduce

• 格式：

  • reduce(function,iterable,[initial])
    • function必须要传入两个参数
    • Iterable—>列表/元组

apply

功能

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

zip

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

注：

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

格式：

zip(iterable1,iterable2,…)

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

回文数：

#回文数
def filter(n):
    str_x = str(x)

    return str_x == str_x[::-1]

print(filter(121))
结果：
True

print(list(filter(lambda x:str(x)==str(x)[::-1],range(1,1000))))

结果：
[1,2,...,252,262,...,989,999]

global

a=6688
def foo():
    global a
    print("foo(),修改前a:\t",a)
    a=666
    print("foo(),修改后a:\t", a)

def bar():
    print("bar(),a:\t",a)

foo()
bar()

a=6688
def foo():
    a = 666
    def inner_foo():
        global a
        print('1',a)
        a=888
        print('2',a)
    inner_foo()
    print('3',a)

print('4',a)
foo()
print('5',a)

结果：
4 6688
1 6688
2 888
3 666
5 888