Python从入门到精通之Seventh!

函数浅析:可以减少代码重用，保持一致性，可扩展性，易维护性。

定义方法：def 函数名（形参)：

　　　　　 '''功能注释'''

　　　　　代码块

打印函数名时，会出现函数的内存地址。两个函数名相同时，最后一个会覆盖之前的所有函数。

过程：没有返回值的函数就是过程，默认返回None。

总结：

　　返回值数=0，返回None

　　返回值数=1，返回object

　　返回值数>1，返回tuple

函数一旦运行至return，则整个函数结束。函数参数必须一一对应，否则报错。

def test(x,y,z):
    print(x)
    print(y)
    print(z)
#位置参数，必须一 一对应
test(1,2,3)
#关键字参数，无需一 一对应
test(y=2,x=1,z=3)
#位置参数必须在关键字参数左侧，并且一 一对应
test(1,2,z=3)
#参数可无，令其为None
def handle(x,type=None):
    print(x)
    print(type)
#默认参数，可以修改。
def handle(x,type="mysql"):
    print(x)
    print(type)
handle('hello','sqlite')

参数组：** 字典、 * 列表

#参数组，**代表 字典  *代表 列表
#列表形式传值
def test(x,*args)
    print(x)
    print(args)
test(1,2,3,4,5)    
  =====》1
        （2，3，4，5）

test(1,{'name','alex'})
  =====》1
        （{'name','alex'}）
#加上*，会依次传给args，若是*后是字典，则会以列表形式遍历keys。
test(1,*['x','y','z'])
  =====》1
        ('x','y','z')
#字典形式传值
def test(x,**kwargs)
    print(x)
    print(kwargs)
test(1,y=2,z=3)
  ====》1
       {'y':2,"z":3}

*args不可放在**kwargs后面，但是可以放到**kwargs前面。

def test(x,*args,**kwargs):
    print(x)
    print(args,args[-1])
    pirnt(kwargs,kwargs.get('y'))

test(1,*[1,2,3],**{'y':1})

====>1
　　　(1,2,3) 3
　　　{'y':1} 1

全局变量与局部变量

当变量前加一个 global时，局部变量会变成全局变量。

name = 'alex'

def change_name():
    global name        #定义全局
    name = 'haha'
    print('change your name,'name)
def as_df():
    print('as_df',name)
=======>change your name haha  
              as_df haha

如果局部变量在global上方，则会报错。

def hu():
    name = 'hangtian'
    print(name)
    def xu():
        name = '刘禅'
        print(name)
        def tian():
            name = 'sky'
            print(name)
        print(name)
        tian()
    xu()
    print(name)

hu()
=========>>
hangtian
刘禅
刘禅
sky
hangtian

nonlocal指的是上一级变量

#nonlocal，指定上一级变量
name = "gangniang"

def weihou():
    name = 'hh'
    def weiweihou(): #外部的不能拿到内部的
        nonlocal name  
        name = '冷静'
    weiweihou()
    print(name)

print(name)
weihou()
print(name)
==========>>
gangnian
冷静
gangnian

前向引用，风湿理论：函数即变量

name = 'gangnian'

def weihou():
    name = 'hh'
    def weiweihou(): #外部的不能拿到内部的
        nonlocal name #拿到上一级的变量
        name = '冷静' #对上一级变量进行修改
    weiweihou()
    print(name)

print(name)
weihou()
print(name)

#会报错，根据风湿理论分析：函数即变量
def a():
    print(1234)
    bar()
a()
def bar():
    print(123)

递归：

递归特性：

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

2.每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3.递归效率不高，递归次数过多会导致栈溢出（在计算机中，函数调用是通过栈（stake）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

import time

person_list=['alex','haha','sky','XT']
def ask_way(person_list):

    if len(person_list)==0:
        return "根本没有人知道路"
    person = person_list.pop(0)

    if person == 'XT':
        return "%s说：我知道，向前走，之后左拐,就会看到出口" %person
    print('h i,帅哥[%s],敢问路在何方' %person)
    print('%s回答道：我不知道，但念及你慧眼识珠，你等着，我给你问问%s' %(person,person_list[0]))
    time.sleep(4)
    res = ask_way(person_list)
    return res

res = ask_way(person_list)
print(res)

====================
h i,帅哥[alex],敢问路在何方
alex回答道：我不知道，但念及你慧眼识珠，你等着，我给你问问haha
h i,帅哥[haha],敢问路在何方
haha回答道：我不知道，但念及你慧眼识珠，你等着，我给你问问sky
h i,帅哥[sky],敢问路在何方
sky回答道：我不知道，但念及你慧眼识珠，你等着，我给你问问XT
XT说：我知道，向前走，之后左拐,就会看到出口