Python3函数

http://www.cnblogs.com/linhaifeng/articles/6113086.html

函数参数

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

2.实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

3.位置参数和关键字（标准调用：实参与形参位置一一对应；关键字调用：位置无需固定）

 

• #位置参数，必须一一对应，缺一不行多一也不行
• 关键字参数，无须一一对应，缺一不行多一也不行
• 混合使用位置参数和关键字参数时，关键字参数一定要放到后面，并且关键字参数不能与位置参数相同

 

def prt(x, y, z):
    print(x)
    print(y)
    print(z)


# prt(0, 1)
prt(2, 0, 4)  # 传递的参数数量满足函数需求
# prt(x=1, 2, 4)    # SyntaxError: positional argument follows keyword argument
# prt(2 , 3, y=3)   # TypeError: prt() got multiple values for argument 'y'
prt(1, 2, z=3)  # 位置参数和关键字参数混合使用
prt(0, z=0, y=2)  # 关键字参数无需按照传入顺序
prt(z=2, x=1, y=123)  # 采用关键字进行传值

 

4.默认参数

def prt(x, y=1, z=None):
    print(x)
    print(y)
    print(z)


prt(1)        #结果为1 1 None
prt(1,2)    #结果为1 2 None
prt(1,2,4)    #结果为 1 2 4

 

5.参数组

×args的使用：

# *args会将多余的参数保存到元组中
def prt(x, *args):
    print(x)
    print(args)
    print()


prt(1)  # 结果为: 1 ()
prt(1, 2)  # 结果为: 1 (2, )
prt(1, 2, 4)  # 结果为: (2, 4)
prt(2, ['a', 'b'])  # 结果为:2 (['a', 'b'],)
prt(2, *['a', 'b'])  # 结果为:2 ('a', 'b')
prt(2, *('a', 'b',))  # 结果为:2 ('a', 'b')
prt(1, {'name': 'alex'})  # 结果为:1 ({'name': 'alex'},)

×kwargs的使用：

# **kwargs参数，接收的是字典，所以可以用关键字方法传递参数
def prt(x, **kwargs):
    print(x)
    print(kwargs)
    print()


prt(1)  # 结果为: 1 {}
prt(1, k1=2, k2=3)  # 结果为: 1 {'k1': 2, 'k2': 3}
# prt(1, 2, k=4)  # TypeError: prt() takes 1 positional argument but 2 were given
# prt(1, x=2, k=4)  # TypeError: prt() got multiple values for argument 'x'

×args和×kwargs同时使用：

# *args与**kwargs同时使用，可以接收万能参数，但是也必须遵守位置和关键字参数规则，因此*args必须放在**kwargs前面。
def prt(x, *args, **kwargs):
    print(x)
    print(args)
    print(kwargs)
    print()


# prt(1, 1, 2, 1, 1, 11, 1, x=1, y=2, z=3) #TypeError: prt() got multiple values for argument 'x'
prt(1, 1, 2, 1, 1, 11, 1, y=2, z=3)  # 结果为: 1 (1, 2, 1, 1, 11, 1) {'y': 2, 'z': 3}
prt(1, *[1, 2, 3], **{'y': 1})   # 结果为: 1  (1, 2, 3) {'y': 1}

 函数递归调用：

　　递归函数：在函数内部，可以调用其他函数。如果在调用一个函数的过程中直接或间接调用自身本身。

　　编写递归函数需要注意点：

• 必须有明确的结束条件，否则可能无限进行调用，进而导致内存溢出，可以采用if语句进行判断
• 每次进入更深一层递归时，问题规模比上一层递归要减少
• 递归的效率不高，主要原因是每一层的返回都在等下一层的调用结果，最后一层拿到结果后将结果返回给上层函数，这样会产生不必要的等待。
• 递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

堆栈扫盲http://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html 

尾递归优化：http://egon09.blog.51cto.com/9161406/1842475

递归代码示例：

• 数字二分查找

data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]


def binary_search(dataset, find_num):
    print(dataset)

    if len(dataset) > 1:
        mid = int(len(dataset) / 2)
        if dataset[mid] == find_num:  # find it
            print("找到数字", dataset[mid])
        elif dataset[mid] > find_num:  # 找的数在mid左面
            print("\033[31;1m找的数在mid[%s]左面\033[0m" % dataset[mid])
            return binary_search(dataset[0:mid], find_num)
        else:  # 找的数在mid右面
            print("\033[32;1m找的数在mid[%s]右面\033[0m" % dataset[mid])
            return binary_search(dataset[mid + 1:], find_num)
    else:
        if dataset[0] == find_num:  # find it
            print("找到数字啦", dataset[0])
        else:
            print("没的分了,要找的数字[%s]不在列表里" % find_num)


binary_search(data, 66)

•  递归问路

import time
person_list = ['alex', 'wupeiqi', 'yuanhao', 'linhaifeng']


def ask_way(person_list):
    print('-' * 60)
    if len(person_list) == 0:
        return '没人知道'
    person = person_list.pop(0)
    if person == 'linhaifeng':
        return '%s说:我知道,老男孩就在沙河汇德商厦,下地铁就是' % person
    print('hi 美男[%s],敢问路在何方' % person)
    print('%s回答道:我不知道,但念你慧眼识猪,你等着,我帮你问问%s...' % (person, person_list))
    time.sleep(3)
    res = ask_way(person_list)
    # print('%s问的结果是: %res' %(person,res))
    return res


res = ask_way(person_list)

print(res)

 高阶函数

满足俩个特性任意一个即为高阶函数

1.函数的传入参数是一个函数名

2.函数的返回值是一个函数名

map函数：

map函数接收2个参数，第一个参数为处理方法，第二个参数为可迭代对象

处理方法可以是自定义函数，也可以是lambda匿名函数。

list1 = [1, 4, 5, 6, 7]
list2 = [x ** 2 for x in list1]
print(list2)
x = lambda x: x ** 2

print(list(map(x, list1)))

y = lambda item: item.upper()
name = 'aaabbbccc'
print(set(map(y, name)))
print(list(map(y, name)))
print(tuple(map(y, name)))