内置函数，变量的作用域，闭包及递归

##内置函数

bin()转换为二进制
oct()转换为八进制
hex()转换为十六进制

ord('a')    #将字符转换为对应的ASCII码
97

chr(65)     #将ASCII码值转化为对应的字符    
'A'

sum([1,2,3])
6

sum([1,2,3],2)
8

二、补充几个内置函数

　　1、enumerate（） 返回一个枚举对象 传参时放一个可迭代参数，返回一个枚举对象，输入list（enumerate（））

enumerate([1,2,3])
<enumerate object at 0x01730FD0>   返回一个枚举对象

list (enumerate([1,2,3]))    #前面返回的是索引，后面返回列表值
[(0, 1), (1, 2), (2, 3)]


可以自定义初始索引
list (enumerate([1,2,3],3))
[(3, 1), (4, 2), (5, 3)]

dict(enumerate(['a','b','c']))
{0: 'a', 1: 'b', 2: 'c'}

dict(enumerate(['a','b','c'],2))
{2: 'a', 3: 'b', 4: 'c'}

dict(enumerate([4,5,6],2))
{2: 4, 3: 5, 4: 6}                      #总结：返回一个枚举对象，（索引，值）索引可以自己定义，还可以变成字典形式

 

filter 过滤器     function表示函数

用来筛选，类似漏斗，传参时前面放入function or None ，后面放入可迭代对象

结果返回一个过滤对象，需要通过list dict 等转化为结果

help(filter)
filter(function or None, iterable) --> filter object

filter(None,[1,2,3])
<filter object at 0x0133A530>

list(filter(None,[1,2,3]))
[1, 2, 3]

def guolv(a):
    return a>1

list(filter(guolv,[1,2,3]))
[2, 3]

 list(filter(lambda x: x>1,[1,2,3]))
[2, 3]  #条件为x>1 ,筛选出x>1的对象
返回一个过滤对象 输出[2,3]

总结：第一个参数是给定一个过滤的函数当参数，过滤所需要的可迭代对象。

 

map 全体加工

对于每个对象进行函数加工，返回一个map对象，前面放入一个function

后面放入一个可迭代对象*iterable(将可迭代对象解包)

map(None,[1,2,3,4])
<map object at 0x01742470>

list(map(lambda x:x+1,[1,2,3,4]))
[2, 3, 4, 5]

list(map(lambda x:x>1,[1,2,3,4]))
[False, True, True, True]

list(map(str,[1,2,3,4]))
['1', '2', '3', '4']

总结：给定一个加工的函数当参数，过滤可迭代对象

 

zip 匹配

将一个个可迭代对象一一配对，返回一个zip对象，可输入多个可迭代对象

zip([1,2,3])
<zip object at 0x010F09B8>

list(zip([1,2,3]))    ##也是一一配对，不过是假装你有对象
[(1,), (2,), (3,)]

list(zip([1,2,3],['a','b','c']))
[(1, 'a'), (2, 'b'), (3, 'c')]

总结：将对象一一配对

 

 

变量的作用域，闭包及递归

局部变量:变量在函数的内部定义，则变量的作用域在函数内部

全局变量：变量在函数外部定义的，则变量的作用域是全局

 

x=1    #全局变量
def fun()：
    y=2    #局部变量,局部变量不能修改全局变量
    print(x,y)

fun()
1 2


x=1
def fun():
    y=2
    global x #授权的意思，声明为全局变量
    x+=1
    print(x,y)
    
fun()
2,2



x=1
def fun():
    global y
    y=2
    global x
    x+=1
    print(x,y)
    

fun()
2 2 

 global:用来在函数或其他局部作用域中，声明全局变量，（作用于全局）

使用global情况：全局变量可以在内部访问，但是不能改变

如果在函数内部，想修改全局变量，可以用golbal来修饰变量

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

a=10
def f1():
    global a
    a+=1
    print(a)
    
f1()
11

def f2():
    global a
    a=1
    print(a)

    
f2()
1

nonlocal：用来在函数或其他作用域中，声明外层（非全局变量）作用于局部

事业nonlocal情况：当里层局部需要修改外层局部时，需要使用nonlocal（如嵌套函数）

 

def fun2():
    q=1
    print('局部外层',q)        输出局部外层q
    def fun3():
        w=22
        nonlocal q          #nonlocal当局部里层想修改局部外层时，声明下q
        q+=1
        print(q)
        print('局部里层',w)
    fun3()                        内嵌函数执行时需要调用
        

fun2()
局部外层 1
2
局部里层 22



def fun2():
    q=1
    print('局部变量',q)
    def fun3():
        w=22
        print(q)
        print(w)
    fun3()




fun2()
局部变量 1
1
22

def fun2():
    q=1
    print('局部外层',q)
def fun3():
    w=22
    print(q)
    print('局部里层',w)
fun3()
 

fun2()
局部外层 1
1
局部里层 22

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

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

返回的函数B就叫比高。（但是B函数一定要嵌套在函数A里面，你在调用函数A的时候传递的参数

就是自由变量

def fun4(a):
    print(a)
    def fun5(b):
        print(a,b)
    return fun5    #调用不执行


fun4(1)
1
<function fun4.<locals>.fun5 at 0x01108A08>  #不调用返回函数体
fun4(1)(2)
1
1 2
g=fun4(1)
1
g(2)
1 2


闭包：嵌套函数，如果最后的return fun5加上() #就是调用了，F5之后  输入1会报错

 

def fun4(a):
    print(a)
    def fun5():
        print(a,11)
    return fun5()


fun4(1)
1
1 11

 

 

 

#回调函数

 

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

结果：    
fun7(fun6)
第一个函数
第二个函数

运行过程：先调用第一个函数，输出第一个函数的内容，然后在输出第二个函数

 

 

 

#递归函数：#调用自己

核心：递归推导式，递归条件终止

例题：已知第一个人10岁，然后每个人一次比前面一个人大两岁，问第五个人的岁数

def age(n):
    if n==1:
        return 18
    else:
        return age(n-1)+2

    
age(5)
26

 

def jiec(n):
    if n==1:
        return 1
    else:
        return jiec(n-1)*n



jiec(5)
120

 

转载于:https://www.cnblogs.com/changshen/p/8628764.html