函数式编程与内置函数
函数作用域：
def test1():
print('in the test1')
def test():
print('in the test')
return test1() res = test()
print(res()) =========因为test中没有return值，所以默认为NONE.
name = 'alex'
def foo():
name='xtjiayou'
def bar():
print(name)
return bar
a = foo()
print(a)
#return bar与return bar()不同，第一个是返回函数的内存地址，第二个是返回
xtjiayou
None name = 'alex'
def foo():
name='linhaifeng'
def bar():
print(name)
return bar
a = foo()
print(a)
a() #a()执行bar内存地址不所存储的代码 ===========
<function foo.<locals>.bar at 0x000002067F719840>
linhaifeng
注意：以上面代码为准foo()()相当于执行了a =foo() a()的作用。依次类推若有多层return 函数名(没有括号)，可以使用多个括号，进行执行内存地址中代码。
示例：
def foo():
name = 'xtznb'
print(name)
def bar():
name = 'xtcnb'
print(name)
def tt():
print(name)
return tt
return bar
r1 = foo()
r2 = r1()
r3 = r2()
==============#或者把后三句改为r1 = foo()()()
xtznb
xtcnb
xtcnb
匿名函数：不应该独立存在，应该与其他函数共同使用。
定义方法：lambda 形式参数： 代码
#利用赋值语句，进行引用匿名函数，但一般不这么用。
func = lambda x:x+1
print(func(10)) name = 'alex'
def change_name():
return name+'_sb' fo = lambda x:x+'_sb'
fo(name)
==========>>alex_sb 匿名函数和自定义函数作用一样，但更简洁，只能使用一行代码。
编程方法论：面向过程、函数式、面向对象
函数式编程：编程语言定义的函数 + 数学意义的函数
函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。
而函数式编程（请注意多了一个“式”字）——Functional Programming，虽然也可以归结到面向过程的程序设计，但其思想更接近数学计算。
我们首先要搞明白计算机（Computer）和计算（Compute）的概念。
在计算机的层次上，CPU执行的是加减乘除的指令代码，以及各种条件判断和跳转指令，所以，汇编语言是最贴近计算机的语言。
而计算则指数学意义上的计算，越是抽象的计算，离计算机硬件越远。
对应到编程语言，就是越低级的语言，越贴近计算机，抽象程度低，执行效率高，比如C语言；越高级的语言，越贴近计算，抽象程度高，执行效率低，比如Lisp语言。
函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此，这种函数是有副作用的。
函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！
Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。
高阶函数：满足1.函数接受的参数是一个函数名 2.返回值中包含函数
#返回值中包含函数
def foo():
print('from foo')
return bar
def bar():
print('from bar') n = foo()
n()
def handle():
print('from handle')
return handle()
handle()
======================
from foo
from bar
from handle
函数尾调用：在函数最后一步调用另外一个函数（最后一行不一定是函数的最后一步）
def test(x):
if x > 1:
return True
elif x == 1:
return False
else:
return True
n = input('please a number')
print(test(int(n,10))) #尾调用示例 True
- map函数依次处理每个列表元素
- filter函数依次筛选列表的每一个值，最后得一个列表
- reduce函数把两个完整的序列压缩到一起
map函数
注意
num_l = [1,2,3,4,5,6]
def add_one(x):
return x+1
def reduce_one(x):
return x-1
def pf(x):
return x**2
def map_test(func,array): ret = []
for i in num_l:
res = add_one(i)
ret.append(res)
return ret
print(map_test(reduce_one,num_l)) #终极版本
def map_test(func,array):
ret=[]
for i in num_l:
res=func(i)
ret.append(res)
return ret print(map_test(lambda x:x+1,num_l)) map内置高级函数用法
num_l=[1,2,3,4,5]
print(list(map(lambda x:x+1,num_l)))
msg='linhalifneg'
print(set(map(lambda x:x.upper(),msg)))
filter函数
#过滤函数的功能
movie_people = ['alex','wupe_sb','xsss_sb','sql_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) #filter函数格式：filter(过滤方法,可迭代变量)
#过滤方法可以是匿名函数
movie_people = ['alex','wupe_sb','xsss_sb','sql_sb'] res = filter(lambda n:not n.endswith("_sb"),movie_people)
print(list(res)) =======>>['alex']
reduce函数
from functools import reduce 从此模块中导入reduce函数
#可以起到reduce作用
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))
#终极版的reduce功能
numl=[1,2,3,100] lambda x,y:x*y,numl
def multi(x,y):
return x*y num_l=[1,2,3,100] 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)) #指定起始值，在进行运算 注意：init不是替代第一个而是被添加到第一个
num_l=[1,2,3,100] def reduce_test(func,array,init=100):
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)) #reduce函数 注意：reduce（某功能函数，可迭代变量，起始值）
from functools import reduce
num_l=[1,2,3,100]
print(reduce(lambda x,y:x*y,num_l,2))
内置函数
bool() #转换为布尔值 空，None，0为假值
int() #转换为整型
float() #转换为浮点型数据
len() #测试字符串长度或者统计可迭代对象的元素个数
list() #转换为列表
tulple() #转换为元组
dict() #转换为字典
set（） #转换为集合
str() #转换为字符串型
例如：dic={'name':'alex'}
dic_str=str(dic） ===》‘{‘name’：‘Alex’}’ hex() #十进制转16进制
oct() #十进制转8进制
id() #打印对象的内存地址
input() #输入字符
isinstance() #判断值与类型是否一致 globals() #打印全局变量
locals() #打印局部变量 abs() #绝对值函数
all() #若一个为假即为假，全真即为真 注意只能有一个参数，可以是列表
any() #任意一个为真即为真
chr() # 把ASCII码值转为对应的字符 chr(97) ====>>A
ord() #与chr()正好相反，通过字符转换为ASCII码值
pow(x,y) #x的y次幂，若是3个参数则对第三个进行取余运算。
round(3.5)#四舍五入函数，===》4
reversed()#反转序列，前面加上个可迭代对象才能看出来
sorted() #排序，默认升序，注意：；不同类型不能排序 max() #取最大值 ha=[1,2,199,-1] max（ha）===>>199
min() #取最小值
age_dic = {'age1':18,'age2':81,'age3':11,'age4':28,'age5':180}
print(max(age_dic.values()))
#不同类型不能进行比较,字典不能比较，因为它是无序的
l=['a10','b12',100]
print(list(max(l))) #拉链函数,产生生一个内存对象，可利用列表、元组等可迭代对象进行输出,注意一一对应输出
zip(('a','b','c'),(1,2,3)) =======》[('a',1),('b',2),('c',3),]
例如：若要使字典中key与value一一对应
p={'name':'alex','age':18,'gender':'none'}
print(list(zip(p.keys(),p.values())))
===>>[('name', 'alex'), ('age', 18), ('gender', 'none')]
dir(byte('我是gbk编码',encoading='gbk')) #打印某一对象中有哪些属性与方法
help() #打印帮助信息，用于查看函数是干什么的
slice(初始，结束，步长) #定义切片，可读性好
li='hello'
s = slice(2,5，2)) ====>lo
s.start s.stop s.step =====>> 2 5 2
frozenset() #返回一个冻结的可迭代对象，冻结后序列不能再添加或删除任何元素
divmod(10,3)==>(3,1) #多用于分页，结果左侧表示一共多少页，右侧表示剩下多少条记录
eval() #1.提取出字符串中的数据结构， 2.把字符串表达式进行运算
express='1+2*(3/3-1)-2'
print(eval(express)) ====》-1.0
#把字符串转换为字节形式，必须进行编码，也可以进行解码。注意：utf-8编码使一个字符等于3个字节，gbk 一个字符等于两个字节，ASCII码不能编码中文
bytes('你好'，encoading="utf-8") #解码:用什么编码就用什么解码 默认解码是gbk
bytes('hello，boy!',encoading='utf-8').decode('utf-8')
hash() #进行哈希运算，可哈希的数据类型即不可变数据类型，不可变哈希类型即可变数据类型。不管输入数据多大，哈希值都定长，不可根据哈希值逆推回字符串。注意：哈希可用于判定软件木马，当下载一个软件包时产生一个哈希值，当安装时又产生一个，两个相互对比可判断是否被添加了木马或其他信息。
max、min函数高级用法
1.max函数处理的是可迭代对象，相当于一个for循环去除每个元素进行比较，注意：不同类型之间不能进行比较
2.每个元素间进行比较，都是从第一个位置依次比较。
people=[
{'name':'王八','age':1000},
{'name':'龟','age':10000},
{'name':'九千岁','age':9000},
{'name':'alex','age':18}
] print(max(people,key=lambda dic:dic['age'])) ret=[]
for item in people:
ret.append(item['age'])
print(ret)
max(ret)
sum函数：求和函数 例如:sum(range(5)) sum(可迭代对象)
locals() 打印局部变量，以字典形式
vars([object]) 返回是字典形式，若没有参数相当于locals（）函数，若有参数（str、int。。。）则将其所以方法存入字典形式 _import_() 导入模块，模块就是py文件
#test.py
def sya_hi():
print('hello,handsome young man!')
import test
tst.say_hi()
_import_('test') #按字符串样式导入模块
import（） #不能调用字符类型模块