Python基础第六天

---恢复内容开始---

函数

一：函数定义

def test():
    x=3
    y=2*x+1
    return y
a=test( )   #运行test，并将结果放在a中。
print(a)

def:定义函数的关键字

test:函数名

（）：内可定义形参

return:定义返回值

二：函数的返回值

      当一个函数/过程没有使用return显示的定义返回值时，python解释器会隐式的返回None，

       返回值=1，返回object

       返回值>1,返回tuple

def test01():
      msg='hello The little green frog'
      print(msg)

def test02():
     msg='hello WuDaLang'
     print(msg)
     return msg

t1=test01()
t2=test02()

print(t1)
print(t2)

hello The little green frog
hello WuDaLang
None
hello WuDaLang

三：函数参数：位置参数   关键字参数  默认参数

def calc(x,y):
     res = x**y
     return res
 c = calc(2,3)
 print(c)         #关键字参数




def test(x,y,z):
     print(x)
     print(y)
     print(z)
 test(y=1,x=3,z=4)     #位置参数

位置参数，必须一一对应，缺一行不行多一行也不行
关键字参数，无序一一对应，缺一行不行多一行也不行
test(1,y=2,3)报错
test(1,3,y=2)报错
test(1,3,z=2,y=4)报错
位置参数必须在关键字参数左边

参数组：**字典  *列表

#*args 处理的是位置参数，处理成列表
def test(x,*args):#*args   以元祖传给args
    print(x)
    print(args)
# test(1,2,3,4,5)
# test('alex',{'name':'alex'})
test(1,*['x','y','z'])
test(1,*('x','y','z'))

#**kwargs 处理的是关键字参数
def test(x,**kwargs):
    print(x)
    print(kwargs)
test(1,y=2,z=3)

def test(x,*args,**kwargs):
    print(x)
    print(args)
    print(kwargs)
test(1,y=2,z=3)

四：局部变量和全局变量

      在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。

当全局变量与局部变量同名时：在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

name = 'lhf'
def change_name():
    name = '随后绝对是'
    print('change_name', name)
change_name()

#如果函数的内容无global关键字，优先读取局部变量，可以全局变量，无法对全局变量重新赋值，但是对于变量是可变类型，可以对内部元素进行操作。
#如果函数中有global关键字，变量本质就是全局变量，可读取可赋值。

########全局变量变量名大写，局部变量变量名小写
有关函数的内容有无global关键字--有无声明局部变量例子：

#函数的内容无global关键字----有声明局部变量
NAME =['gh','hj']
def ghjhjk():
    NAME ='TY'
    print('i am',NAME)
ghjhjk()
#函数的内容无global关键字----无声明局部变量
NAME =['gh','hj']
def ghjhjk():
    NAME.append('rtyu')
    print('i am',NAME)
ghjhjk()
#函数的内容有global关键字
NAME =['gh','hj']
def ghjhjk():
    global NAME
    NAME =['内牛满面']
    print('i am',NAME)
ghjhjk()

NAME ='海风'
def huangwei():
    name = '黄伟'
    print(name)
    def liuyang():
        name ='刘洋'
        print(name)
        def nulige():
            name = '胡志华'
            print(name)
        print(name)
        nulige()
    liuyang()
    print(name)
huangwei()

name = '刚娘'
def weihou()：
    name = '陈卓'
    def weiweihou():
        global name
        name = '冷静'
    weiweihou()
    print(name)

print(name)
weihou()
print(name)

name = '刚娘'

def weihou():
    name = '陈卓'
    def weiweihou():
        nonlocal name
        name = '冷静'
    weiweihou()
    print(name)

print(name)
weihou()
print(name)

五：函数递归

   在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

  递归特性:

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

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

3. 递归效率不高

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)

def calc(n):
    print(n)
    if int(n/2) ==0:
        return  n
    return calc(int(n/2))
calc(10)

ls =[]

def test(n):
    n =int(n/2)
    ls.append(n)
    if int(n/2) ==1:
        return  ls
    test(n)

print(test(5))

六：作用域

def test1():  #函数名相当于内存地址，加括号test（）相当于运行
    print('in the test1')  #没有返回值时，返回None
def test():
    print('in the test')
    return  test1
res=test()
print(res())


in the test
in the test1
None

# 例一：
name='alex'

def foo():
    name='lhf'
    def bar():
        print(name)
    return bar

func=foo()  #执行foo 将结果“返回bar”给func
func()   #执行func即执行bar

# 例二：
name='alex'

def foo():
    name='lhf'
    def bar():
        name='wupeiqi'
        def tt():
            print(name)
        return tt
    return bar

func=foo()
func()() #运行tt

七：匿名函数

#这段代码
def calc(n):
    return n**n
print(calc(10))
 
#换成匿名函数
calc = lambda n:n**n
print(calc(10))

lambda 匿名函数（形参名）：函数表达式（处理逻辑）{ps:一般为return返回最终结果}

name='alex'
def change_name(x):
    return name+'_sb'
res=change_name(name)
print(res)

f=lambda x:x+'_sb'
res=f(name)
print('匿名函数的运行结果',res)

 下一集：函数式编程。。。