Python从入门到精通之eighth!

函数式编程与内置函数

函数作用域：

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（） #不能调用字符类型模块