http://www.cnblogs.com/linhaifeng/articles/6113086.html#_label11
# 函数的作用域只跟函数声明时定义的作用域有关,跟函数的调用位置无任何关
name = 'alex'
def foo():
name='linhaifeng'
def bar():
# name='wupeiqi'
print(name)
return bar #返回的是地址
a=foo()
print(a) #打印内存地址
a() #bar() #执行bar()函数
结果
<function foo.<locals>.bar at 0x00000000028C98C8>
linhaifeng
name='alex'
def foo():
name='lhf'
def bar():
name='wupeiqi'
print(name)
def tt():
print(name)
return tt
return bar
bar=foo()
tt=bar()
print(tt)
tt()
以上几个等效于foo()()()
匿名函数
# lambda x:x+1
# 关键字 lambda 等效于x是形参,x+1是返回值表达式
def calc(x):
return x+1
res=calc(10)
print(res)
print(calc)
print(lambda x:x+1) # 打印出来是地址
func=lambda x:x+1
print(func(10)) #计算输出
name='alex' #修改成name='alex_sb'
def change_name(x):
return name+'_sb'
res=change_name(name)
print(res)
name='alex' #修改成name='alex_sb'
# 关键字+形参+子代码 加载完直接释放掉,想要保存下来就要弄个名字
func=lambda x:x+'_sb'
res=func(name)
print('匿名函数的运行结果',res)
name1='alex'
name2='sbalex'
name1='supersbalex'
def test(x,y,z):
return x+1,y+1 #-----> 返回会自动加括号变成元祖形式 (x+1,y+1)
print(test(1,2,3)) #等效于print
lambda x,y,z:(x+1,y+1,z+1) #返回多个值要自己加上元祖的括号
编程的方法论 流派
- 面向过程:根据业务逻辑从上到下一步步写垒代码
- 函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可 了解一下
- 面向对象:对函数进行分类和封装,让开发“更快更好更强...”
https://blog.csdn.net/letunihao/article/details/51232359
高阶函数
1。函数接收的参数是一个函数名 2#返回值中包含函数
把函数当作参数传给另外一个函数,也就是函数接收的参数是一个函数名
def foo(n): #n=bar
print(n)
def bar(name):
print('my name is %s' %name)
foo(bar) #输出地址
foo(bar('ddd')) #输出 my name is ddd None
返回值中包含函数
def bar():
print('from bar')
def foo():
print('from foo')
return bar
n=foo()
n()
def hanle():
print('from handle')
return hanle
h=hanle()
h() #h是函数地址,h()是执行函数
def test1():
print('from test1')
def test2():
print('from handle')
return test1() #这里是return test1()的返回值
1不可变:不用变量保存状态,不修改变量
2函数即变量
函数名可以当参数传递,返回值可以是函数名
3尾调用方法解决问题
在函数的最后一步调用进入另外一个函数(最后一行不一定是函数的最后一步 例如if语句中),
最后一步状态不用保存在堆栈中
注意,这个不是尾调用
def bar(n):
return n
def foo(x) :
return bar(x)+1 #这里是先执行bar(x)后的值再加1,最后一步不是调用其他函数
map函数
num_l=[1,2,10,5,3,7]
num1_l=[1,2,10,5,4,9]
得到列表值的平方
def map_test(array):
ret=[]
for i in array:
ret.append(i**2)
return ret
ret=map_test(num_l)
rett=map_test(num1_l)
print(ret)
print(rett)
num_l=[1,2,10,5,3,7]
#lambda x:x+1
def add_one(x): #先定义好处理逻辑的函数
return x+1
lambda x:x-1
def reduce_one(x):
return x-1
#lambda x:x**2
def pf(x):
return x**2
def map_test(func,array): #把处理列表的逻辑处理函数和列表一起传给函数
ret=[]
for i in num_l:
res=func(i) #add_one(i)
ret.append(res)
return ret
print(map_test(add_one,num_l)) #把处理列表的逻辑处理函数和列表一起传给函数
print(map_test(lambda x:x+1,num_l)) #写成匿名函数的形式,就不用先声明定义逻辑函数
print(map_test(reduce_one,num_l))
print(map_test(lambda x:x-1,num_l))
print(map_test(pf,num_l))
print(map_test(lambda x:x**2,num_l))
终极版本
def map_test(func,array): #func=lambda x:x+1 arrary=[1,2,10,5,3,7]
ret=[]
for i in array:
res=func(i) #add_one(i)
ret.append(res)
return ret
print(map_test(lambda x:x+1,num_l))
内置函数map
res=map(lambda x:x+1,num_l) #一个逻辑函数,+可迭代对象 将对象for循环给函数,
# 最后得到结果也是可迭代对象可以加list变成列表
print('内置函数map,处理结果',res) # res打印出来的是地址
for i in res:
print(i)
print(list(res)) #以列表的形式显示
print('传的是有名字的函数',list(map(reduce_one,num_l)))
msg='linhaifeng'
print(list(map(lambda x:x.upper(),msg)))
#结果['L', 'I', 'N', 'H', 'A', 'I', 'F', 'E', 'N', 'G'] 内部for循环变成一个一个
filter函数
movie_people=['sb_alex','sb_wupeiqi','linhaifeng','sb_yuanhao'] # 过滤掉开头sb的人
def filter_test(array):
ret=[]
for p in array:
if not p.startswith('sb'): #取反逻辑用not
ret.append(p)
return ret
res=filter_test(movie_people)
print(res)
movie_people=['alex_sb','wupeiqi_sb','linhaifeng','yuanhao_sb']
def sb_show(n):
return n.endswith('sb')
def filter_test(func,array): #处理的函数也是传进来的
ret=[]
for p in array:
if not func(p):
ret.append(p)
return ret
res=filter_test(sb_show,movie_people)
print(res)
终极版本
movie_people=['alex_sb','wupeiqi_sb','linhaifeng','yuanhao_sb']
def sb_show(n):
return n.endswith('sb')
--->lambda n:n.endswith('sb')
def filter_test(func,array):
ret=[]
for p in array:
if not func(p):
ret.append(p)
return ret
res=filter_test(lambda n:n.endswith('sb'),movie_people)
print(res)
filter函数
第一个参数也是一个函数,有名或者匿名函数都可以,
第二个参数可以是列表,字符串 ,字典等可迭代对象
将第二个参数可迭代对象for循环的方式传给第一个函数处理,
以True
保留以列表形式保存 False 去掉 ,注意可以在函数上取反not
movie_people=['alex_sb','wupeiqi_sb','linhaifeng','yuanhao_sb']
print(filter(lambda n:not n.endswith('sb'),movie_people))
打印出来的是一个内存地址,要list才能显示
res=filter(lambda n:not n.endswith('sb'),movie_people)
print(list(res))
print(list(filter(lambda n:not n.endswith('sb'),movie_people)))
reduce函数
from functools import reduce #先导入模块才能用reduce
num_l=[1,2,3,100]
res=0
for num in num_l:
res+=num
print(res)
num_l=[1,2,3,100]
def reduce_test(array):
res=0
for num in array:
res+=num
return res
print(reduce_test(num_l))
num_l=[1,2,3,100]
def multi(x,y):
return x*y
lambda x,y:x*y
def reduce_test(func,array):
res=array.pop(0)
for num in array:
res=func(res,num)
return res
print(reduce_test(lambda x,y:x*y,num_l))
num_l=[1,2,3,100]
def reduce_test(func,array,init=None):
if init is None:
res=array.pop(0)
else:
res=init
for num in array:
res=func(res,num)
return res
print(reduce_test(lambda x,y:x*y,num_l,100))
#reduce函数
from functools import reduce #先导入模块才能用reduce
num_l=[1,2,3,100]
print(reduce(lambda x,y:x+y,num_l,1))#函数,对象,初始值1
print(reduce(lambda x,y:x+y,num_l))
小结
## map()处理序列中的每个元素,得到的结果是一个‘列表’,该‘列表’元素个数及位置顺序与原来一样
#filter遍历序列中的每个元素,判断每个元素得到布尔值, 如果是True则留下来,
# 把列表中的值筛选一遍得到另一个列表
people=[
{'name':'alex','age':1000},
{'name':'wupei','age':10000},
{'name':'yuanhao','age':9000},
{'name':'linhaifeng','age':18},
]
print(list(filter(lambda p:p['age']<=18,people)))
#reduce:处理一个序列,然后把序列进行合并操作 得到一个值
from functools import reduce
print(reduce(lambda x,y:x+y,range(100),100))
print(reduce(lambda x,y:x+y,range(1,101)))
内置函数
print(abs(-1)) #取绝对值
print(abs(1))
print(all([1,2,'1'])) #后边跟一个序列,把序列中每一个元素拿出来做布尔运算 所有True才为真,
print(all([1,2,'1',''])) #只能给一个参数序列
print(all('')) #if the iterable is empty, return True.
print(any([0,''])) #f
print(any([0,'',1]))
print(bin(3)) # 十进制转二进制 ob11
空,None,0的布尔值为False,其余都为True
print(bool(''))
print(bool(None))
print(bool(0))
name='你好'
print(bytes(name,encoding='utf-8')) # 输出编码b'\xe4\xbd\xa0\xe5\xa5\xbd' ,一个中文字符用utf8表示用3个字节,把字符串做编码
print(bytes(name,encoding='utf-8').decode('utf-8')) #decode('utf-8')用utf8做解码 输出 你好
print(bytes(name,encoding='gbk')) #gbk一个中文两个字节
print(bytes(name,encoding='gbk').decode('gbk')) #编码,解码要同一种
print(bytes(name,encoding='ascii')) #ascii不能编码中文
print(chr(46))
print(dir(dict)) #打印某一个对象内置的方法
print(divmod(10,3)) #10除以3取商得余,以元祖形式 用来分页功能,分第几页第几条
加 enumerate
dic={'name':'alex'} #字典转换str
dic_str=str(dic)
print(dic_str) #输出{'name': 'alex'}这个是str的形式,并不是字典
d1=eval(dic_str) #1把字符串中的数据结构提取出来
print(d1['name']) # 输出 alex
可hash的数据类型即不可变数据类型,不可hash的数据类型即可变数据类型 ,
检验前后数据的hash值是否改变,验证数据是否被更改
print(hash('12sdfdsaf3123123sdfasdfasdfasdfasdfasdfasdfasdfasfasfdasdf'))
print(hash('12sdfdsaf31231asdfasdfsadfsadfasdfasdf23'))
name='alex'
print(hash(name))
print(hash(name))
print('--->before',hash(name)) # 检验前后数据的hash值是否改变,验证数据是否被更改
name='sb'
print('=-=>after',hash(name)) #输出 --->before -2837957294456996021
# =-=>after 3576902207639659919
print(help(all)) #打印函数的用法
print(bin(10))#10进制->2进制
print(hex(12))#10进制->16进制
print(oct(12))#10进制->8进制
print(isinstance(1,int)) #判断对象的类型是否正确
print(isinstance('abc',str))
print(isinstance([],list))
print(isinstance({},dict))
print(isinstance({1,2},set))
name='哈哈哈哈哈哈哈哈哈哈哈哈哈哈啊哈粥少陈'
print(globals()) #打印全局变量
print(__file__) #打印在对应全局变量下的地址
def test():
age='1111111111111111111111111111111111111111111111111111111111111'
# print(globals())
print(locals()) #打印当前级别的局部变量
test()
l=[1,3,100,-1,2]
print(max(l))
print(min(l))