函数式编程与内置函数
函数作用域：
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（） #不能调用字符类型模块