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

1.常见的内置函数

常见的内置函数:查看内置函数：print(dir(__builtins__))

常见函数

type 查看对象类型len 求长度min 求最小值max 求最大值sorted 排序reversed 反向sum 求和

print 打印

help 帮助

id 查看对象内存地址

range 从起始值到结束值按照一定步长的序列

进制转换函数:bin() 转换为二进制oct() 转换为八进制hex() 转换为十六进制ord() 将字符转换成对应的ASCII码值chr() 将ASCII码值转换成对应的字符

补充：1）enumerate() #返回一个可以枚举的对象2）filter() #过滤器3）map() #加工。对于参数iterable中的每个元素都应用fuction函数，并返回一个map对象4）zip() #将对象逐一配对

example:

li =[1,2,3,4]

sum(li)#10

abs(-12)#绝对值 12

round(1.4)#四舍五入 1

round(1.445,2)#保留两位小数 1.45

bin(5)#二进制 0101

oct(8)#八进制 %o

hex(10)#16进制 A

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

ord('A')

chr(65)#将ASCII码值转换成对应的字符

#1.enumerate #返回一个可以枚举的enumerate对象 (index,value)

li = ['a','c','b']

list(enumerate(li))# 通过list转换成列表 [(0, 'a'), (1, 'c'), (2, 'b')]

dict(enumerate(li))#也可以通过dict转成字典 {0: 'a', 1: 'c', 2: 'b'}

#注意 集合 ，字典，是无序的，没用索引。 通过enumerate可以返回（伪索引，value）

se = {1,2,3,'asd',5}

list(enumerate(se))# [(0, 1), (1, 'asd'), (2, 2), (3, 3), (4, 5)]

dict(enumerate(se))# {0: 1, 1: 'asd', 2: 2, 3: 3, 4: 5}

#2.filter() #过滤器,生成一个当参数传入函数结果为True的可迭代对象

li =[1,2,3,6,7,8]

deftest(x):

returnx>5

list(filter(test,li))#[6, 7, 8]

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

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

# 3.map() #加工

li =[1,2,3,6,7,8]

list(map(str,li))#把各个元素转换成字符串 ['1', '2', '3', '6', '7', '8']

#每一个元素加一个 1

list(map(lambdax:x+1,li))# [2, 3, 4, 7, 8, 9]

# zip() #将对象逐一配对，按照短序列来生成

li2 =[1,2,3]

tu = ('a','b','c','e')

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

dict(zip(li2,tu))# {1: 'a', 2: 'b', 3: 'c'}

2.函数内变量的作用域

变量的作用域与其定义的方式有关：局部变量： 变量在函数内部定义，则变量的作用域在函数内部全局变量：变量在函数外部定义的，则变量的作用域是全局

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

使用global情况：全局变量可以在函数内部访问，但是不能改变如果在函数内部想修改全局变量，可以用 global 来修饰变量局部变量只能在局部进行访问和修改。如果在函数外部，想访问局部变量，也可以用 global，将局部变量声明为全局变量使用nonlocal的情况：当里层局部，需要修改外层局部时，需要使用nonlocal。 (如嵌套函数)总结：global ：函数中，需要修改全局变量时，用globalnonlocal：当里层局部，需要修改外层局部时，需要使用nonlocal。（局部调用局部，使用nonlocal）

'''

全局变量可以在函数内部访问，但是不能改变

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

'''

a = 10#全局变量

deftest1():

b = 5#局部变量

print('局部访问全局变量 a:',a)#局部可以访问，全局变量

#a +=1 #全局变量可以在函数内部访问，但是不能改变

deftest2():

globala#全局声明

a +=1

print('内部修改全局变量 a:',a)

deftest3():# global 只对当前函数起作用

#global a

a +=1

print('teat3修改全局 a',a)

'''

局部变量只能在局部进行访问和修改。

如果在函数外部，想访问局部变量，也可以用 global，将局部变量声明为全局变量

'''

deftest4():

globalb

b = 4

b+=1

a = 21

print('局部变量 b:',b)

## 使用nonlocal的情况

#内嵌函数

deftest5():

c = 2

print('局部外层 c',c)

deftest6():

d = 5

print('局部里层 d',d)

test6()

# nonlocal

c = 11

deftest7():

c = 2#声明外层(非全局)变量

print('局部外层 c',c)

deftest8():

d = 5

print('局部里层 d',d)

nonlocal c

#global c

c += 1#当里层局部，需要修改外层局部时

print('当里层局部，需要修改外层局部 C ',c)

test8()

3.内嵌函数和闭包

内嵌函数：

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

闭包：

一个闭包就是你调用了一个函数A，这个函数A返回了一个函数B给你。这个返回的函数B就叫做闭包。(但是B函数，一定要是嵌套在函数A里面) 。你在调用函数A的时候传递的参数就是自由变量。

总结：

一个函数里面嵌套一个函数，调用外面这个函数，就返回里面嵌套的函数。

example:

deftest9(name):

deftest10(age):

print('name',name,'age',age)

returntest10

f10 = test9('jianeng')

f10 (18)

问题：以下函数算不算闭包呢？

deftest12():

print('12')

deftest13():

print('13')

deftest14():

print('14')

returntest14()

returntest13()

4.递归函数

递归：函数调用自己本身

递归的核心：1）递归推导式2）递归终止条件

不过虽然递归很方便，但是尽量少用，以防栈溢出，而且会计算效率不高。

'''

例题：有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。

问第4个人岁数，他说比第3个人大2岁。

问第三个人，又说比第2人大两岁。

问第2个人，说比第一个人大两岁。

最后问第一个人，他说是10岁。

请问第五个人多少岁？

'''

' n1 n2 n3 n4 n5 '

# 10 n1 +2 n2 +2 n3 +2 n4+2

#for 循环

defage(n):

age = 10

foriinrange(1,n):

age = age +2

print('最后一个人，是%s 岁'%age)

### 递归

defage2(n):

ifn == 1:

return10

else:

returnage2(n-1) +2

##要计算age2(n)的值，程序会先去计算age2(n-1)的值，要计算 age2(n-1)的值，程序要计算age2(n-2)的值...直到n==1的时候，程序算出了age2(1)的值，再把值拿到age2(2)里面...以此类推，算出age2(n)

### 阶层 1！=1*1 2！=2*1 3！=3*2*1 4！=4*3*2*1

# 1！ 2！ =2*1！ 3！=3*2！ 4！ =4 *3！

#推导式 ： n! = n * (n-1) !

#终止条件： n == 1 return 1

defjie(n):

ifn ==1:

return1

else:

returnjie(n-1) *n