07 内置函数、作用域、闭包、递归

回顾

• 1. 函数定义
     def fun_name():
     block
• 2. 参数：
  • 1. 不需要传参
  • 2. 必备参数
  • 3. 默认参数
  • 4. 不定长 *arg **kwarg
• 3. return :
  • 1. 返回函数的运行结果
  • 2. 函数结束标志
• 4. lambda: 匿名函数

一、内置函数 python 自带

type()           #查看类型
max()           #取最大值
min()           #取最小值
print()         #打印
len()           #计算长度
sorted()      #排序
reversed()  #反转
help()         #查看帮助
id()            #查看内存地址
range()      #范围
sum()        #求和
abs()          #取绝对值
round()      #四舍五入

进制转换

bin()      #进制转换
oct()      #八进制转换
hex()     #十六进制转换
ord()     #将字符转成ASCII
chr()      #将ASCII转换成字符

补充

enumerate()    #返回一个可以枚举的对象  (inex 索引，value 值) 
li = ['a','c','b']              # 可以转成列表
list(enumerate(li))
#output:[(0, 'a'), (1, 'c'), (2, 'b')]
di = {'a':1,'b':2}
dict(enumerate(di))    # 可以转成字典
#output: {0: 'a', 1: 'b'}

注意 集合，字典是无序的，没有索引。 返回：伪索引，value

se = {1,2,3,'ad',5}
di = {'a':1,'b':2}
list(enumerate(se))
#output:[(0, 1), (1, 2), (2, 3), (3, 5), (4, 'asd')]
list(enumerate(di))            # 返回 ：伪索引，字典 key
#output:[(0, 'a'), (1, 'b')]

filter()     #过滤器
li = [1,2,3,6,7,8]
def test(x):
    return x>5
list(filter(test,li))   # 函数，要过虑的对象
#output:[6,7,8]

map()   # 加工
li = [1,2,3,6,7,8]
list(map(str,li))            #每一个元素转换成字符串str
#output:['1','2','3','6','7','8']
list(map(lambda x:x+1,li)) #每一个元素加1
#output:[2,3,4,7,8,9]

zip() # 将对象逐一配对
li2 = [1,2,3]
tu = ('a','b','c','e')       # 'e'就放在那里不会配对输出 
list(zip(li2,tu))
#output: [(1, 'a'), (2, 'b'), (3, 'c')]
list(zip(tu,li2))
#output:[('a', 1), ('b', 2), ('c', 3)]
dict(zip(li2,tu))           # 可以转换成字典    
#output:{1: 'a', 2: 'b', 3: 'c'}

lambda 凡是可以用到函数地方，都可以用 lambda

list(filter(lambda x:x>5,li))
#output:[6,7,8]

li = dir(__builtins__)     #计算共有多少个内置函数       用 li 接收 内置函数列表
li.index('abs')               # 获取 abs 索引
li[80:]                           # 切片                                          
len(li[80:])                    # 计算长度
#output: 73

二、函数内变量的作用域

global 全局变量

全局变量可以在函数内部访问，但是不能改变
如果在函数内部想修改全局变量，可以用global 来修饰变量

a = 10 #全局变量
def test():
    b = 5 #局部变量
    print('局部访问全局变量 a：',a)   # 局部可以访问，全局变量
    a+=1

def test():
    global a   # 全局声明  
    a+=1
    print('内部修改全局变量 a:',a)

def test():   #blobal 只对当前函数起作用    
    a+=1
    print('内部修改全局变量 a:',a)
a
#output:11

局部变量只能在局部进行访问和修改。
如果在函数外部，想访问局部变量，也可以用 global， 将局部变量声明为全局变量

def test():
    global b   # 全局声明
    b = 4
    b+=1
    print('局部变量 b:',b)
b
#output:5

使用nonlocal的情况

def test():
    c = 2        #声明外层 (非全局)变量
    print('局部外层 c:',c)
    def test1():
        d = 5
        print('局部里层 d:',d)
        nonlocal c # 当里层局部需要修改外层局部时
        c +=1   

内嵌函数和闭包

内嵌函数：在函数内部定义函数，就是函数里面嵌套函数

def test():
    c = 2
    print('局部外层 c:',c)
    def test1():
        nonlocal c
        d = 5
        c+=1
        print('局部里层 d:',d)
    test1()    

闭包：一个闭就是你调用了一个函数A，这个函数A返回了一个函数B给你。这个返回的函数B就叫做闭包。

（但是B函数，一定要是嵌套在函数A里面）。你在调用函数A的时候传递的参数就是自由变量
总结：一个函数里面嵌套一个函数，调用外面这个函数，就返回里面嵌套的函数。

def test(name):             # name 参数 自由变量
    def tset1(age):
        print('name',name,'age',age)
    return test10
# 装饰器本身就是一个闭包

递归函数

函数调用自己本身

'''
例题：有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。
       问第4个人岁数，他说比第3个人大2岁。
       问第三个人，又说比第2人大两岁。
       问第2个人，说比第一个人大两岁。
       最后问第一个人，他说是10岁。
       请问第五个人多少岁？
'''
递归的核心：
    1.递归推导式
    2.递归终止条件
n1：10      n2：n1 + 2      n3：n2 + 2     n4：n3+2     n5：n4+2

# for 循环
def age(n):
    age =10
    for i in range(1,n):
        age = age + 2
    print('最后一个人，是%s岁' % age)

# 递归
def age(n):
    if n==1:
        return 10
    else:
        return age(n-1) +2

阶层

'''
1! =1*1    2! = 2*1   3!  = 3*2*1    4!   = 4*3*2*1 
1!              2*1!              3*2!             4*3!
'''
# 推导式： n! = n *(n-1)!
# 终止条件：n ==1  return  1
def factorial(n):
    if n==1
        return 1
    else:
        return factorial(n-1)*n
factorial(5)
#output: 120