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