函数

函数

程序而言，函数就是对程序逻辑进行结构化，或者过程化的一种编程方法

Built-in function 内置函数—>BIF

函数的定义

• 函数代码块以 def 关键词开头，后接函数标识符名称和小括号 ()
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数
• 函数的第一行语句可以选择性地使用文档字符串(用于存放函数说明)
• 函数内容以冒号起始，并且缩进
• return [表达式] 结束函数，选择性的返回一个值。不带表达式的return相当于返回 None。

其中参数列表和返回值不是必须的,return后也可以不跟返回值,甚至连 return也没有。

对于return后没有返回值的和没有return语句的函数都会返回None值

有些函数可能既不需要传递参数,也没有返回值。

没有参数时,包含参数的圆括号也必须写上,圆括号后也必须有“:”。

声明函数的一般形式：

def function_name(arg1,arg2,...,argn):
  '''statements'''
  func_statements
  return value

函数调用

定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。

def printme(str):
    print(str)
    return

# 调用函数
printme("ABC")
printme("DEF")

函数参数种类

形参和实参

• 形参

  • 只有在调用时才分配内存单元，调用结束后，即释放所分配的内存单元，因此，形参只在内部有效，函数调用结束返回主调用函数后则不能再使用该形参变量

• 实参

  • 实参是一个确定的值，能够传递给形参

只传递实参，默认参数

关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值

def usr_manage(name, age, job, hobby='Trip'):
    print('用户管理系统'.center(16, '-'))
    print('\tName:\t', name)
    print('\tAge:\t', age)
    print('\tJob:\t', job)
    print('\tHobby\t', hobby)

usr_manage('tom', 23, 'sutdent')
usr_manage('lcuy', 22, 'IT', 'read')

默认值参数

调用函数时，默认参数的值如果没有传入，则被认为是默认值。

def usr_manage(name, age, job='IT', hobby='Trip'):
    print('用户管理系统'.center(16, '-'))
    print('\tName:\t', name)
    print('\tAge:\t', age)
    print('\tJob:\t', job)
    print('\tHobby\t', hobby)

usr_manage('tom', 23, 'sutdent')
usr_manage('lcuy', 22, 'IT', 'eat')
usr_manage('jack', 22,hobby='coding',job='student')

默认值参数，关键字参数，必须放置于位置参数之后

不定参数

一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。

在python中不定参数主要是指*args和**kwargs两个变量

它们两个主要是用于函数定义，我们可以将不定数量的参数传递给一个参数

• *args用来接收任意非键值对的参数并返回元组

• **kwargs将参数以字典的形式导入

函数引用

def bar():
    print('bar()')

def foo():
    print('foo()')
    bar()

内嵌函数

作用域

bar()整个函数都处于外部foo()函数的作用域里（foo()是我们可以从外部访问的一个对象区域），除了在foo()内部，其他地方无法对bar()进行调用

def foo():
    def bar():
        print('bar() called.')
    print('foo() called.')
    bar()

foo()
bar()

foo() called.
bar() called.

NameError: name 'bar' is not defined

变量作用域

作用域的产生

• 就作用域而言，python和c有很大的差别，只有当变量在module,class,函数中定义的时候，才会有作用域的概念
• 在作用域中定义变量，一般只在作用域内有效，需要注意的是，在if-elif-else,for-else,while-else,try-except(else-finally)等关键字的语句块中不会产生作用域

作用域的类型

python 中，使用一个变量时并不要求需要预先声明它，但在真正使用的时候，他必须绑定到某个内存对象（被定义，赋值）。这种变量名的绑定将在当前作用域引入新的变量，同时，屏蔽外层作用域中的同名变量

• 局部作用域（locale—L)

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

• 嵌套作用域（enclosing—E)

• E也包含在def关键字中，E和L是相对的，E相对于亘上层的函数而言也是L,与L的区别在于，对于一个函数而言，L是定义在定义在此函数内部的局部作用域

• 主要为了实现python的闭包，而增加的实现

• 全局作用域（Global—G)

  • 即在模块层次中定义的变量，模块顶层申明的变量具有全局作用域，从外部来看，模块的全局变量就是一个模块对象的属性。

• 内置作用域（bulit-in—B)

  • 系统固定模块中定义的变量

搜索变量名的优先级：局部作用域>嵌套作用域>全局作用域>内置作用域

全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。

a=6688
def foo():
    a=666
    print('foo(),修改前a:\t',a)
    b= 888
    print('foo(),修改后a:\t',b)

def bar():
    # a=6888
    print('bar(),a:\t',a)
foo()
bar()


#foo(),修改前a:	 666
#foo(),修改后a:	 888
#bar(),a:	 6688

递归函数

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

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

print(f(10))

# 55

匿名函数

格式

• lambda para1,para2,…,paraN:expression using paras

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

<class 'function'>
6

高阶函数

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

def pow(x):
    return x ** 2


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


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

过滤函数

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

功能：

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

• filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 **list()**来转换。

• 接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

调用格式：

filter(function,sequence)

• function :可以是自定义的函数，也可以匿名函数
• sequence: 列表，元组，字符串

li = ['economy', 'industry', 'city', 'chemistry']
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 li:
        if not func(i):
            ret.append(i)

    
    return ret


print(filter_test(start_sr, li))
print(filter_test(end_sr, li))


['economy', 'industry']
['economy', 'industry', 'chemistry']

map映射

功能：

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

格式：

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

x = [1, 2, 3, 4, 5]
ret = []
for i in x:
    ret.append(i + 1)
print(ret)

def pow(x):
    return x**2

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


print(map_test(pow, x))


[2, 3, 4, 5, 6]
[1, 4, 9, 16, 25]

reduce函数

功能：

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

• python2中，reduce()是内置函数，而python3中，他被移植到functools模块中

• from functools import reduce

格式：

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

from functools import reduce

b = [2, 3, 4, 5, 6]
z = reduce(lambda a, b: a + b, b)


print(z)

# 20

zip函数

功能：

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

格式：

• zip(iterable1,iterable2,….)
  • itterable—>两个或者多个可迭代序列（字符串，列表，元组，字典）