内置函数，作用域，闭包，递归

##内置函数
min([1,2,3])
max([1,2,3])
sum([1,2,3],2)#从2开始加
bin(5)  #转换为2进制
oct(16) #转换为8进制
hex(15)  #转化为16进制
ord('a')#97
ord('A')#65
chr(65)#'A'



#补充
enumerate([1,2,3])
list(enumerate([1,2,3]))#返回一个枚举对象（索引，值）索引可以自定义
dict(enumerate(['a','b','c'],2))#{2: 'a', 3: 'b', 4: 'c'}


filter(None,[1,2,3])#<filter object at 0x000001E052827FD0>
list(filter(lambda x:x>1,[1,2,3]))
'''
给定一个过滤的函数当参数，过滤可迭代对象
'''
list(map(lambda x:x+1,[1,2,3,4]))#[2, 3, 4, 5]
list(map(str,[1,2,3,4]))#['1', '2', '3', '4']

#配对
list(zip([1,2,3])) #[(1,), (2,), (3,)]
list(zip([1,2,3],['a','b','c']))#[(1, 'a'), (2, 'b'), (3, 'c')]
list(zip([1,2,3],['a','b','c'],(11,22,33)))

##函数内变量的作用域
x=1         #全局变量
def fun():
     global y
     y=2   #局部变量
     global x
     x+=1
     print(x,y)

def fun1():
     a=1
     a+=1
     print(a)
##lianxi
a=10
def f1():
     global a
     a+=1
     print(a)
def f2():
     global a
     a=1
     print(a)
##nonlocal   当局部里层想修改局部外层时
def fun2():
     q=1      #局部外层 
     print('局部外层',q)
     def fun3():
          w=22
          nonlocal q
          q+=1
          print(q)
          print('局部里层',w)
     fun3()

##闭包         嵌套函数    
def fun4(a):
     print(a)
     def fun5():
          print(a,11)
     return fun5       #调用不执行

##回调函数  
def fun6():    
     print('第一个函数')
def fun7(a):    #把上一个函数体当成参数
     a()
     print('第二个函数')

##递归   调用自己
def age(n):
     if n==1:
          return 18
     else:
          return age(n-1)+2
#阶乘
# 5！=5*4*3*2*1
def jiec(n):
     if n==1:
          return 1
     else:
          return jiec(n-1)*n

 #1.定义一个函数，输入一个序列(序列元素是同种类型)，判断序列是顺序还是逆序，顺序输出UP，逆序输出DOWN，否则输出None

a=[2,1,4,3,5,8,7]

def paixu(a):
    li=sorted(a)
    if li ==a:
        print('up!')

    elif sorted(a,reverse=True)==a:
        print('DOWN!')
    else:
        print('None')

#2.写一个函数，对列表li = [9,8,3,2,6,4,5,7,1]，进行从小到大的排序。最后返回li

def bublesSort2(li):
    for i in range(len(li)):
        for j in range(len(li)-1):
            if li[j]>li[j+1]:
                li[j],li[j+1]=li[j+1],li[j]

        print(li)

 闭包

class A:
    def __del__(self):
        print("被销毁了")

def func():
    a=A() #a是在函数调用的时候实例哈
    #函数调用结束的时候，里面的对象被销毁

func()
input()

执行结果：
被销毁了

事例二

class A:
    def __del__(self):
        print("被销毁了")

def outer():
    a=A() #a是在函数调用的时候实例哈
    def inner(): #inner也是在outer里面定义的，在outer结束的时候，inner也被销毁
        print(a)
    return input
x=outer()
del x #销毁函数inner

input()