Python基础之函数

1.函数定义、格式、参数

1)定义

　　函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需要调用其函数名即可。

2)一般格式

　　def 函数名(参数):

　　　　函数体

　　def为函数关键字，参数根据需求传入即可，hi()表示调用定义的函数。

def hi():
   print("hi")
hi()
结果：
hi

3)参数

　　形参：形式参数，在定义函数和函数体的时候使用形参。

　　实参：实际参数，调用函数时传给函数的参数，可以是常量，变量，表达式，函数，传给形参。

　　参数分类：必需参数、关键字参数、默认参数、不定长参数。

2.函数的参数

1)必需参数

　　必需参数需要按照函数声明时的顺序依次传入函数，数量也必须保持一致。

def fun(name,age):
    print("my name is %s,%s years."%(name,age))
fun('fox',22)
结果：
my name is fox,22 years.

2)关键字参数

　　关键字参数只是在调用的时候加上关键字，此时顺序可以颠倒，无需像必需参数一样顺序保持一致。

def fun(name,age):
    print("my name is %s,%s years."%(name,age))
fun(age=22,name='fox')
fun(name='fox',age=22)
结果：
my name is fox,22 years.
my name is fox,22 years.

3)默认参数

　　默认参数指给某个参数加上默认值，在调用传入时未重新指定值时就用默认值，重新指定就用新的值。

def fun(name,age,sex='M'):
    print("my name is %s,%s years,%s."%(name,age,sex))
fun('fox',22)
fun('fox',22,sex='Female')
结果：
my name is fox,22 years,M.
my name is fox,22 years,Female.

4)不定长参数

　　当传入的参数无法得知准确数量或者数量多的时候，可用(*args)充当形参，生成时不会被命名，此时传入的实参会组成以args命名的元组。

def fun(*args):
    print(args)
    print(type(args))
fun(1,'a',2,'b')
结果：
(1, 'a', 2, 'b')
<class 'tuple'>

*****分割线*****

def add(*args):
    sumb = 0
    for i in args:
        sumb += i
    print(sumb)
add(1,2,3,4,5)
结果：
15

　　(*args)生成时不会被命名，而(**kwargs)充当形参时，调用函数时，传入的实参可以被命名，此时传入的实参会组成以kwargs命名的字典，args和kwargs只是惯用写法，也可以重命名。

def fun(**kwargs):
    print(kwargs)
    print(type(kwargs))
fun(name='fox',age=22,sex='M',work='it')
结果：
{'sex': 'M', 'age': 22, 'work': 'it', 'name': 'fox'}
<class 'dict'>

*****分割线*****

def fun(**kwargs):
    for i in kwargs:
        print("%s:%s"%(i,kwargs[i]))
fun(name='fox',age=22,sex='M',work='it')
结果：
name:fox
work:it
age:22
sex:M

 3.高阶函数

　　至少满足下列其中之一的函数：

　　　　1)接收一个或者多个函数作为输入。

　　　　2)输出一个函数。

　　下列函数返回的是一个函数，此时我们调用foo()函数时，返回的不是结果numb,而是函数add()，调用f()时才是求和的结果。

def foo(*args):
    def add():
        numb = 0
        for i in args:
            numb += i
        return numb
    return add
f = foo(1,2,3,4)
f()
print(f)
print(f())
结果：
<function foo.<locals>.add at 0x000002B63B8EC400>
10

4.函数的返回值和作用域

1)函数的返回值

　　执行函数的返回值时，可以使用return语句。

　　函数在执行过程中遇到return语句时，就会停止执行并返回结果，即return代表着函数的终止。

　　如果未在函数中指定return，则返回值为None。

　　return有多个对象时，解释器会把多个对象组成一个元组作为一个整体输出。

2)函数的作用域

　　作用域分为四种情况：

　　　　local:局部作用域，即最里层函数的作用域。

　　　　enclosing:父级函数的局部作用域，里层函数的外一层，相对而言。

　　　　globa:全局变量，即模块级别的作用域。

　　　　built-in:系统固定模块的变量。

　　作用域的优先级顺序，局部作用域>父级局部作用域>全局变量>python内置作用域，python中只有模块、类、函数才会引入新作用域。

b_count = int(1) #python内置作用域
g_count = 2 #全局变量
def foo():
    e_count = 3 #父级函数的局部作用域
    def bar():
        l_count = 4 #局部作用域
    #print(l_count) #报错，找不到变量l_count
#print(e_count) #报错，找不到变量e_count

5.修改不同作用域的变量

1)global关键字

　　当在函数内需要修改的变量是全局变量global时，只需在修改前声明 global 变量名 即可，在局部作用域和父级函数局部作用域都可以使用。

a = 10
def foo():
    global a
    print(a)
    a = 100
    print(a)
foo()
结果：
10
100

2)nonlocal关键字

　　当函数内需要修改的变量是父级函数局部变量时，在修改前声明 nonlocal 变量名 即可。

def foo():
    a = 10
    def bar():
        nonlocal a
        print(a)
        a = 100
        print(a)
    return bar
f = foo()
f()
结果：
10
100

6.函数的执行过程

　　程序在逐句执行代码时，当遇到def关键字时会跳过该函数，继续往下执行，直到遇到有调用此函数时，重新回到def依次往下执行，故下列代码中，先输出的时3 10。

def foo(): # 1  3
    a = 10 # 4
    def bar(): # 5  8
        nonlocal a
        print(1,a) # 9
        a = 100 # 10
        print(2,a) # 11
    print(3, a) # 6
    return bar # 7
foo()() # 2
结果：
3 10
1 10
2 100

7.递归函数

1)定义

　　如果一个函数在内部调用自身，那么这个函数就是递归函数。

2)递归特性

　　必须有一个明确的结束条件。

　　每次进入更深层次的递归时，递归次数相继减少。

　　递归效率不高，但是逻辑清晰。

3)分别用递归函数和普通函数实现阶乘

　　正整数的阶乘是所有小于及等级该数的正整数的积，如5的阶乘为5*4*3*2*1，表示为5!；利用for循环时，第三行也可以改为 for i in range(1,numb+1)，即从1开始，numb结束遍历。

def fun(numb):
    count = 1
    for i in range(numb):
        count *= i+1
    print(count)
fun(4)
结果：
24

　　递归函数，当传入参数为1时，1*fun(0)超出阶乘的定义范围，则另外设置当numb为1时的值。

def fun(numb):
    if numb == 1:
        return 1
    return numb * fun(numb - 1)
print(fun(5))
结果：
120

4)分别用递归函数和普通函数实现斐波那契数列

　　斐波那契数列又叫黄金分割数列，是一组前两个数之和为第三个数的有迹可循的数列，即1，1，2，3，5，8，13，21，34...

def fun(numb):
    before = 0
    after = 1
    for i in range(numb-1):
        sum1 = after + before
        before = after
        after = sum1
    return sum1
print(fun(4))
结果：
3

　　递归函数，根据斐波那契数列性质可知，前两个之和等于第三个，目的是为了求传入的参数所对应的值，则可以求前两个数之和即为所求的值。

def fun(numb):
    if numb == 1:
        return 1
    if numb == 2:
        return 1
    return fun(numb - 1) + fun(numb - 2)
print(fun(4))
结果：
3

 8.内置函数

1)map()

　　map()是内置的高阶函数，它接收一个函数fun和一个列表list，并通过把函数fun依次作用在列表list的每个元素上，得到一个新的列表list并返回。

　　map()函数返回的是一个map对象，需要list将映射之后的map对象转换成列表。

　　map()函数是挨个的处理一个列表中的每一个元素。

lis = [1,2,3,4,5]
def fun(x):
   return x * x
ret = (map(fun,lis))
print(list(ret))
结果：
[1, 4, 9, 16, 25]

*****分割线*****

lis = ["aDFSsd","ADFfdsS","sDfDfY"]
def foo(lis):
    s1 = lis[0:1].upper() + lis[1:].lower()
    return s1
set = map(foo,lis)
print(list(set))
结果：
['Adfssd', 'Adffdss', 'Sdfdfy']

2)filter()

　　filter()是内置的另一个高阶函数，同样接收一个函数fun和一个列表list，函数fun的作用是对每个元素进行判断，返回True或False，filter()根据判断结果自动过滤掉不符合元素，返回符合条件的新的list。

　　filter()与map()类似，挨个处理列表中的每一个元素，map()是通过函数fun处理list中每个元素，filter()是通过函数fun删选每一个元素。

　　例如，要去除列表[3,6,7,8,15,34,75]中的奇数，保留偶数。

lis = [3,6,7,8,15,34,75]
def foo(x):
   if x % 2 == 0:
      return x
set = filter(foo,lis)
print(list(set))
结果：
[6, 8, 34]

3)reduce()

　　reduce() 是接收的参数和 map()类似，一个函数fun，一个list，但行为和 map()不同，reduce()传入的函数fun必须接收两个参数。

　　deduce()对list的每个元素反复调用函数fun，并返回最终结果值。

　　第一次调用是把list的前两个元素传递给fun,第二次调用时，就是把前两个list元素的计算结果当成第一个参数，list的第三个元素当成第二个参数，传入fun进行操作，以此类推，并最终返回结果。

from functools import reduce
lis = [1,2,3,4,5,6,7,8,9]
def fun(x,y):
   return x + y
print(reduce(fun,lis))
结果：
45

4)匿名函数

　　用lambda关键字标识，冒号':'左边表示函数接收的参数，右边表示函数的返回值，因在创建的时候无须命名则叫匿名函数。

fun = lambda a,b:a + b
print(fun(5,6))
结果：
11