day8

1,函数的返回值

返回值=0，返回none
返回值=1，返回object
返回值>1,返回tuple

def test1():
    msg = "test01"
    print(msg)

def test2():
    msg = "test02"
    print(msg)
    return msg

def test3():
    msg = "test03"
    print(msg)
    return 1,4,34

t1 = test1()
t2 = test2()
t3 = test3()
print(t1)
print(t2)
print(t3)

test01
test02
test03
None
test02
(1, 4, 34)

2.位置参数必须一一对应，缺一不行，多一不行，位置参数必须在关键字参数的左边

def test(x,y,z):
    print(x)
    print(y)
    print(z)
#t1 = test(1,2,3)
#t2 = test(x=1,y=2,z=3)
t3 = test(1,2,z=3)

3.默认参数，提前在形参位置赋值

def handle(x,type="nimabi"):
    print("x")
    print(type)
handle(3)

def handle(x,type="nimabi"):
    print("x")
    print(type)
handle(3,10)

4.**字典，*列表

#args可变长参数//不知道传入参数的个数
#当做列表传入
#加*相当于把数据类型中的元素遍历一遍传入给args

def test(x,*args):
    print(x)
    print(type(args),args)
    print(args[0])
test(1,[2,3,4,5,6])
1
<class 'tuple'> ([2, 3, 4, 5, 6],)
[2, 3, 4, 5, 6]
def test(x,**kwargs):
    print(x)
    print(kwargs)

test(1,y=3,z=3)
1
{'y': 3, 'z': 3}

def test(x,*args,**kwargs):
    print(x)
    print(args,args[-1])
    print(kwargs,kwargs['y'])
test(1,*[1,2,3],**{'y':1})
1
(1, 2, 3) 3
{'y': 1} 1

5.运用函数的好处，节省重复代码，把函数封装起来，需要时直接调用

 

6.全局变量：没有任何缩进，在任何位置都能调用
局部变量：在子程序里面定义的

在函数变量中的查找，先要在自己家中找，再去外面一层去查找

全局变量用大写，局部变量用小写####默认的规则

nonlocal:指的是上一级的变量

函数即变量
将函数当作变量放在内存中
在局部变量可以对全局变量进行修改

name = 'haifeng'
def huangwei():
    name = "huangwei"
    print(name)
    def liuyang():
        name = "liuyang"
        print(name)
        def nulige():
            name = "nulige"
            print(name)
        nulige()
    liuyang()
    print(name)

print(name)
huangwei()
print(name)

haifeng
huangwei
liuyang
nulige
huangwei
haifeng

def action():
    print("in the action")
    logger()
def logger():
    print("in the logger")

action()

in the action
in the logger

name = "alex"

def chang_name():
    name = "alex2"
    def chang_name2():
        name = "alex3"
        print("第3层打印",name)

    chang_name2()
    print("第2层打印",name)

chang_name()
print("最外层打印",name)
第3层打印 alex3
第2层打印 alex2
最外层打印 alex

7.递归：
必须有一个明确的结束条件
每次进入一层递归，问题的规模会减小

递归执行的效率不高，递归层次过多会造成内存溢出

persion_list = ["alex","wupeiqi","yuanhao","linhaifeng"]
def ask_way(persion_list):
    print('-'*60)
    if len(persion_list) == 0:
        return "没人知道"
    persion = persion_list.pop(0)
    if persion == "linhaifeng":
        return "%s说：我知道在哪里"%persion
    print("%s你知道在哪里不？"%persion)
    print("%s我不知道，我帮你问下%s"%(persion,persion_list[0]))
    res = ask_way(persion_list)
    return res
res = ask_way(persion_list)
print(res)