python--函数（def）

函数（def）

1. global：全局变量
2. nonlocal：将此变量提升到上一级

函数的作用：

1.减少重复代码量。

2.可统一维护。

3.可重复调用。

杂货

单个打印

a,b,c = [1,2,3]    

print(a)

print(b)

print(c)

 

a,*_,e = [1,2,3,4,5,6]     #取第一个和最后一个

print(a)

print(e)

 

函数中return,返回多个值是返回的元祖。

def bar(x,y):
    '返回值'
    print('from the bar ...')
    return 1,2,3,4,5,6,7,[1,2,3,4],{1,2,3,4,5}

a,*_,e,f = bar(1,3)  #解压的返回值是一一对应的
print(a)
print(e)
print(f)

　　

 

*args **kwargs  

第一个是得到的一个元祖，第二个是得到的一个字典

def foo(name,age):  #定义一个函数，加上两个形参
    print(name)    #打印形参
    print(age)
def bar(*args,**kwargs):   #定义一个函数，这个两个形参是，位置参数 
    foo(*args,**kwargs)    #调用foo函数，定义两个实参，  

bar(1,2)            #通过遍历，解析两个实参

　　

---

 

 函数的调用方式

 ps.先定义后调用。。。

# #定义好两个函数    正确的方式
# def foo():
#     print('111')
#     bar()
# 
# def bar():
#     print('from the bar')
# #-------------------------------------
# #在调用
# foo()

#定义好两个函数     错误的方式

def foo():
    print('111')
    bar()
#调用函数，当函数执行的时候，是先走到foo()函数，bar()是不会执行的
foo()
def bar():
    print('from the bar')

　　

 

1.函数的书写方法：

def t():
    name = "lt"
    print("我是谁：",name)
t()

 

函数快捷写法：
# t = lambda x:x+1
# print(t(2))

 

2.函数嵌套

方法：

　　def t():
　　　　....
　　　　def tt():
　　　　　　....
　　　　　　def ttt():
　　　　　　　　....

　　

def huangwei():
    name = '黄伟'
    print(name)
    def liuyang():
        name = "刘洋"
        print(name)
        def nulige():
            name = '努力哥'
            print(name)
        print(name)
        nulige()
    liuyang()
    print(name)
huangwei()

 

3.函数递归

 

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

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

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

 

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

res=calc(10)
print(res)

 

import time
per = ['lt',  'liu', 'zhang','yang']
def res(per):
    print('-'*60)
    if len(per) == 0:
        return "没人知道"
    person = per.pop(0)
    if person == 'yang':
        return "%s说：我知道，就在北京市朝阳区" %person
    print('你好，%s,请问你知道在哪里吗 ？' %person)
    print('%s说：我不知道，我可以帮你问问%s...'%(person,per))
    time.sleep(3)
    v = res(per)
    print('%s问的结果是：%s'%(person,v))
    return v
v = res(per)
print(v)

 

4.作用域

name = 'yang'
def foo():
    name = 'liu'
    def bar():
        # name = 'li'
        def tt():
            print(name)
        return tt()
    return bar
r = foo()  #bar：这是获取内存地址
r()        #这是相当于读取bar里面的函数，运行tt函数的print

name = 'yang'
def foo():
    name = 'liu'
    def bar():
        # name = 'li'
        def tt():
            print(name)
        return tt
    return bar()
r = foo()  #r:是tt函数的
print(r)   #读取tt函数的内存
r()        #打印tt函数的print

 

5.匿名函数

#函数retrue返回值
def res(x):
    return x+1
print(res(10))



#匿名函数
name = 'yang'
te = lambda x:name+'___'
r = te(name)
print(r)

 

6.闭包

#闭包：定义在内部的函数，且引用外部作用域不能引用全局作用域的称之为闭包

#第一种
def foo():
    x = 1
    y = 2
    def bar():
        print(x)
        y
    return bar
f = foo()
f()
print(f.__closure__) #查看我闭包内的变量地址，
print(f.__closure__[1].cell_contents)#通过下标的方式把我的下标读取出来


#第二种

def foo(x):
    def bar():
        print('form the bar')
        print(x)
    print('form the foo....')
    return bar
f = foo(2)
f()

　　

检测是不是闭包

x =1
def foo():
    def bar():
        print('form the bar')
        print(x)
    print('form the foo....')
    return bar
f = foo()
print(f.__closure__)   #是不是闭包，可以用.__closure__测试

　　

函数式、面向过程、面向对象


内置函数：
map()

#处理序列中的每个元素，得到的结果是一个‘列表’，该‘列表’元素个数及位置与原来一样

# num = [1,2,5,4,8,6,11,7]
# def map_test(func,array): #func:函数  #array:可迭代对象
#     li = []
#     for i in array:
#         str = func(i)
#         li.append(str)
#     return li
# print(map_test(lambda x:x+1,num))

num = 'yangxiangshishui'
# #map（）：内置函数
# print(list(map(lambda x:x*2,num)))
res=map(lambda x:x.upper(),num)
#只能使用一次
print('内置函数map，处理结果',res)
# for i in res:
#     print(i)
print(list(res))

 

filter()

#filter遍历序列中的每个元素，判断每个元素得到布尔值，如果是True则留下来

# people=[
#     {'name':'alex','age':1000},
#     {'name':'wupei','age':10000},
#     {'name':'yuanhao','age':9000},
#     {'name':'linhaifeng','age':18},
# ]
# print(list(filter(lambda p:p['age']<=18,people)))

   函数的用法
# pop = ['li_sb', 'sb_liu_sb', 'sb_zhang_sb', 'yang']
# def  re(n):
#     return n.endswith('sb')
# def mo(func,array):
#     li = []
#     for i in array:
#         if not  func(i):
#             li.append(i)
#     return li
# print(mo(lambda n:n.endswith('sb'),pop))
      使用filter()方法
#filter()内置函数：取反，如需取正需在not
# print(list(filter(lambda n:not n.endswith('sb'),pop)))

 

 

reduce（）

#reduce:处理一个序列，然后把序列进行合并操作

from functools import reduce
print(reduce(lambda x,y:x+y,range(100),100))
print(reduce(lambda x,y:x+y,range(1,101)))

1.
# num = [1,5,4,7,6,3]
# def nums(array):
#     li = 0
#     for i in array:
#         li+=i
#     return li
# print(nums(num))
2.
# num = [1,5,2]
# def test(x,y):
#     return x*y
# def nums(func,array):
#     li = array.pop(0)
#     for i in array:
#         li=func(i,li)
#     return li
# print(nums(test,num))

3.
# num = [2,5,4]
# # lambda x,y:x*y
# def nums(func,array):
#     li = array.pop(1)
#     for i in array:
#         li=func(i,li)
#     return li
# print(nums(lambda x,y:x*y,num))
4.
# num = [2,5,4]
# # lambda x,y:x*y
# # nums(func,array,init)
# # 第一个参数是传的算法的函数
# #第二个参数是可迭代的对象
# #第三个参数是被+-*/的数。不被写死，可随意定义数值
# def nums(func,array,init):
#     if init is None:     #判断init是否为None
#         li = array.pop(1)  #是None的话，就取数组中的下标为1的数为基数
#     else:
#         li=init            #不是None即可定义数值
#     for i in array:        #遍历数组，
#         li=func(i,li)       #func(i,li)：将函数的x,y写进来
#     return li              #得到结果返回值
# print(nums(lambda x,y:x*y,num,2))

5.
#reduce（）内置函数的前提，需要引入下面语句
# from functools import reduce
# num = [2,5,4]
# print(reduce(lambda x,y:x*y,num,2))