函数式编程

1、关键字参数

def print_area(width,height):
    are=width*height
    print("{0}*{1}长方形的面积{2}".format(width,height,are))

print_area(320,100)
print_area(width=300,height=200)
print_area(45,height=100)
# print_area(width=56,89)
#发生错误。调用函数时，一旦其中一个参数用了关键字形式传递，那么其后的
#所以参数都必须采用关键字参数形式传递。
print_area(height=100,width=200)

2、默认参数

def mack_coffice(name="卡布基罗"):
    return "制作一{}杯咖啡".format(name)

coffice1=mack_coffice("巴西咖啡")   （1）
cofice2=mack_coffice()  （2）
print(coffice1)
print(cofice2)
输出结果：

制作一巴西咖啡杯咖啡
制作一卡布基罗杯咖啡

其中（1）传递了参数没有使用默认参数。（2）使用默认参数

3、可变参数（python可变参数有两种，在参数前面加*或者**，*可变参数在函数中被组装成一个元组，**可变参数在函数中被组装为一个字典）

def sum(*numbers,multiple=1):
    total=0
    for number in numbers:
        total+=number
    return total*multiple

print(sum(100,200,300))
print(sum(200,100))
print(sum(200,100,multiple=2))（1）
double_tuple=(100,200) #元组或者列表（2）
print(sum(300,*double_tuple)) （3）

输出结果：

600
300
600
600

注意：1、如果已经有一个元组变量（2），能否传递给可变变量？这需要使用对元组撤包（3）在元组前面加上（*）

这里将（2）撤包为100,200形式。另外（2）也可以是列表；

2、*可变参数不会最后一个参数时，后面的参数需要采用关键字参数形式传递（1）

**可变参数

def show_info(sep=":",**info):
    print("-----info----")
    for key,value in info.items():
        print("{0}{2}{1}".format(key,value,sep))

print(show_info('->',name='fkk',age=18,sex=True))（1）
print(show_info(name='fcc',student_on=12,sep="-"))（2）
stu_dict={'name':'fkk','age':18} #创建字典
print(show_info(**stu_dict,sex=True,sep=',')) （3）

输出结果：

-----info----
name->fkk
age->18
sex->True
None
-----info----
name-fcc
student_on-12
None
-----info----
name,fkk
age,18
sex,True
None

注意：1、**可变参数，必须在正规参数之后，如果本列函数定义改为shpw_info(**info,sep=':')形式会发生错误

2、（1）第一个参数‘->’是传递给sep，其后的参数name='fkk',age=18,sex=True，是传递给info。这种参数形式事事上就是关键字参数

，注意建不要用引号包裹起来。

3、（2）sep也采用关键字参数传递，这种sep参数可以放在参数列表的任何位子。其中的关键字参数被收集到info的字典中

4、（3）其中字典对象stu_dict，传递时stu_dict前面加上（**）双星号在这里表示将stu_dict撤包为key=value对的形式

函数返回

python函数返回值也比较灵活，主要有三个形式，无返回，单一返回，多返回
无返回值函数
所谓无返回值，事试实上是返回None None表示没有意义的依据

def show_info(sep=":",**info):  （1）
    print("-----info----")
    for key,value in info.items():
        print("{0}{2}{1}".format(key,value,sep))
        return #return None或省略  （2）
注意：（1）中只是为了输出一些信息，不需要返回数据，因此可以省略return。如果一定要使用return 见（2）使用return 或return None。
本列中加return 是多此一举。但是有，return或，return None是必要的。

def sum(*numbers,multiple=1):
    if len(numbers)==0:
        return  #return None 或省略
    total=0
    for number in numbers:
         total+=number
    return total*multiple

print(sum(10,20))
print(sum(multiple=2))

输出好结果：

30
None

多返回值函数

def positi(dt,spend):
    posx=spend[0]*dt
    posy=spend[1]*dt
    return (posx,posy)

move=positi(60,(12,13))

print("物体移动{0},{1}".format(move[0],move[1]))

输出
物体移动720,780

函数变量作用域
1、变量可以在模块中创建，作用域是整个模块，称为全局变量。
2、变量也可以在函数中创建，默认情况下作用域是整个函数，称为局部变量

x=2 （1）
def print_value():
    print("函数中x={}".format(x))（2）

print_value()
print("全局变量x={0}".format(x))

函数中x=2
全局变量x=2

注意：（1）创建全局变量x，全局变量作用域是整个模块，所以在print_value函数中也可以访问变量x见（2）

#创建全局变量

x=2

def print_value():
    #创建局部变量
    x=10  （1）
    print("函数中x={}".format(x))

print_value()
print("全局变量x={0}".format(x))

输出

函数中x=10
全局变量x=2

注意：（1）这会函数中创建x变量，函数中的x变量与全局变量x命名相同，在函数作用域内会屏蔽全局x变量

--------------------------------------------------------------------------------------------------------------------------------------------------------

python 提供这种可能，通过在函数中将变量声明为global的，可以把变量作用域变成全局的

#创建全局变量
x=2
def print_value():
    global x
    x=10
    print("函数中x={}".format(x))

print_value()
print("全局变量x={0}".format(x))

输出

函数中x=10
全局变量x=10

---------------------------------------------------------------------------------------------------

生成器

在一个函数中使用return 关键字返回数据，但是有时候也可以使用yield关键字返回数据。yield关键字的函数返回的是

一个生成器（generator）对象，生成器对象是一种可迭代对象

def sq(num):
    n_list=[]
    for i in range(1,num+1):
        n_list.append(i*i)
    return n_list

for i in sq(5):
    print(i,end=" ")

输出结果

1 4 9 16 25

更好的解决方法

def sq(num):
    for i in range(1,num+1):
        yield i*i  （1）

for i in sq(5): （2）
    print(i,end=" ")

注意：（1）使用了yield关键字返回平方数，不需要return关键字了，（2）行调用函数sq返回的是生成器对象
生成器对象是可以迭代对象，可迭代的对象通过__next__（）方法获取元素，代码第二行for循环能够遍历可迭代对象，就是隐式的调用生成器的__next__()方法获取元素

def sq(num):
    for i in range(1,num+1):
        yield i*i

a=sq(5)
print(a.__next__())
print(a.__next__())

执行结果一样

 嵌套函数

函数还可以定义在另外的函数体中，称为“嵌套函数”

def calculate(n1,n2,orp):
    multi=2

    def add(a,b):
        return (a+b)*multi

    def sub(a,b):
        return (a-b)*multi

    if orp=="+":
        return add(n1,n2)
    else:
        return sub(n1,n2)

print(calculate(10,9,'+'))

 add(10,5)  报错

sub(10,5)  报错

----------------------------------------------------------------------------------------------------------

函数试编程基础

与面向对象编程一样，是一种编程规范，函数试编程，也称为面向函数的编程

python并不是彻底的函数试编程语言，但是还是提供了一些函数试编程必备的技术，主要有函数类型，Lambda表达式

他们是函数试编程的基础

函数类型：任何一个函数都有函数类型，但是函数调用时，就创建了函数类型实例。及函数对象

它可以赋值给一个变量，也可以作为参数传递给一个函数，还可以作为函数返回值使用。

def calculate(orp):
    multi=2

    def add(a,b):
        return (a+b)*multi

    def sub(a,b):
        return (a-b)*multi

    if orp=="+":
        return add
    else:
        return sub
f1=calculate('+')
f2=calculate('-')
print("10+5={}".format(f1(10,5)))
注意：calculate函数返回的是函数对象，所以放放
f1是add（）函数对象
f2是sub（）函数对象
--------------------------------------------------------------
Lambda表达式
本质上未匿名函数，匿名函数也是函数，也有函数类型，也可以创建函数对象
lambda表达式语法：lambda 参数列表： lambda体

def calculate(orp):
    
    if orp=="+":
        return lambda a,b:(a+b)
    else:
        return lambda a,b:(a-b)
f1=calculate('+')
f2=calculate('-')
print("10+5={}".format(f1(10,5)))