python函数（上）

局部变量：

包含在def关键字定义的语句块中，即在函数中定义的变量。每当函数被调用时都会创建一个新的局部作用域。Python中也有递归，即自己调用自己，每次调用都会创建一个新的局部命名空间。在函数内部的变量声明，除非特别的声明为全局变量，否则均默认为局部变量。有些情况需要在函数内部定义全局变量，这时可以使用global关键字来声明变量的作用域为全局。局部变量域就像一个 栈，仅仅是暂时的存在，依赖创建该局部作用域的函数是否处于活动的状态。所以，一般建议尽量少定义全局变量，因为全局变量在模块文件运行的过程中会一直存在，占用内存空间。
注意：如果需要在函数内部对全局变量赋值，需要在函数内部通过global语句声明该变量为全局变量。

a = 6688


def foo():
    a = 666

    def inner_foo():
        global a
        print(a)
        a = 888
        print("1", a)

    inner_foo()
    print("2", a)


print("3", a)
foo()
print("4", a)

'''
3 6688
6688
1 888
2 666
4 888
'''

可变类型的全局变量

li = ['a', 'b']


def foo():
    li.append('c')
    print(li)


foo()

#['a', 'b', 'c']

列表是可变数据类型，数字和字符串是不可变数据类型。

递归函数

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

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

匿名函数（lambda）

格式：

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

f = lambda x="city", y="college", z="ZUCC": x + y + z
print(f("Zhejiang"))

#ZhejiangcollegeZUCC

高阶函数

把一个函数名，以实参的形式，传递给下颌骨函数的形参，这个函数就是高阶函数

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


a_value = add(-9, 1, abs)
print(a_value)

#10

li = ['Zhejiang', 'University', 'City', 'College']


def filter_test(para):
    ret = []
    for i in para:
        if not i.startswith("C"):
            ret.append(i)

    return ret


print(filter_test(li))

#['Zhejiang', 'University']

filter函数

li = ['Zhejiang', 'University', 'City', 'College']


def end(a):
    return a.endswith("ty")


def star(b):
    return b.startswith("C")


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


print(filter_test(end, li))
print(filter_test(star, li))

#['Zhejiang', 'College']
#['Zhejiang', 'University']

print(filter_test(lambda a: a.endswith("ty"), li))
print(filter_test(lambda b: b.startswith("C"), li))

print(list(filter(lambda a: not a.endswith("ty"), li)))# filter 内置函数
print(list(filter(lambda b: not b.startswith("C"), li)))
#三者结果相同

功能：

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

调用格式：

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

map 映射

功能：

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

格式：

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

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

#结果同上

用高阶函数显示和map一样的结果：

li = [1, 2, 3, 4, 5]


def f(x):
    return x * (x + 1) + 2


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


print(map_test(f, li))

#[4, 8, 14, 22, 32]