函数编程精要-优快云博客

函数

编程语言中函数定义：函数是逻辑结构化和过程化的一种编程方法。先定义一个数函数，然后按照这个数学模型用编程语言去实现它。

def test(x):
    "The function definitions"
    x+=1
    return x
#def :定义函数的关键字
#test:函数名
#():内可定义形参
#"": 文档描述
#x+=1：函数体，泛指代码块或程序处理逻辑
#return：定义返回值

#代码的重复利用
#打印日志及时间
import time
def logger():
    time_format='%Y-%m-%d %X'
    time_current=time.strftime(time_format)
    with open('a.txt','a+') as f:
        f.write('%s end ation\n' %time_current)

def text1():
    print('in the text1')
    logger()

def text2():
    print('in the text2')
    logger()

def text3():
    print('in the text3')
    logger()

text1()
text2()
text3()

函数返回值：
返回值为0:返回None
返回值为1：返回object
为什么要有返回值：
后面的其他程序逻辑需要根据返回值的结果来进行不同的操作

def hanshu():
   return 5,6,'sss',{'ff','gg'}['r','t']
 
 m=hanshu()
 #结果返回  ：
 5,6,'sss',{'ff','gg'}['r','t']

形参：形式参数，不是实际存在的，是虚拟变量。在定义函数和函数体的时候使用形参，目的是在函数调用时接收实参，实参个数，类型与实参相对应
实参：实际参数，调用函数时传给函数的参数，可以是常量，变量，表达式，函数，传给形参
区别：形参是虚拟的，不占用内存空间，形参变量只要在被调用时才分配内存单元，实参是一个变量，占用内存空间，数据传输单向，实参传给形参，不能形参传给实参。

关键字参数是不能写在位置参数前面

def test(x,y):
    print(x)
    print(y)
 test(y=2,x=1)#与形参顺序无关关键字调用
 test(1,2)  #与形参一一对应，位置调用
 #关键子调用和位置一起调用，按照位置的来，关键字参数是不能写在位置参数前面

默认参数特特点：
调用函数时，默认参数非必须传递
用途：1 默认安装值
2

参数组：
参数个数不固定，可接收多个实参
*args接收n个位置参数，转换成元组形式

def text(*args)

test(1,2,3,4,5)

或者
test(*[1,2,3,4,5])#args=tuple([1,2,3,4,5])

def test(x,*args)

接收字典：
功能，**kwargs 把n个关键字参数转换成字典的方式
def test2(kwargs):
print(kwargs)
test2(name=‘ss’,age=1,sex=‘n’) #关键字参数
test2（name=‘aa’,age=5,sex=‘s’)
test2({‘name’:‘aa’,‘age’:8}

def test2(**kwargs):
     print(kwargs)
     print(kwargs['name'])
     print(kwargs['sex'])
     print(kwargs['age'])

test2(name='aa',sex='d',age =4)

#跟位置参数一起调用
def test3(name,**kwargs):
    print(name)
    print(kwargs)

test3('bb') #不需要指定后面的返回值： bb  {}
test3('cc',s='3')

#跟默认参数一起
def test4(name,age=1,**kwargs):  #参数组一定放到最后   def test4(name,**kwargs,age=1)错误写法
    print(name)
    print(age)
    print(kwargs)

test4('dd',sex='v',data='ee')
test('dd',3,sex='v',data='ee')

def test5(name.age=3,*args,**kwargs):
    print(name)
    print(age)
    print(kwargs)
    print(args)
 test('dd',age=3,sex='v',data='ee',s=33)

局部变量和全局变量：
局部变量：只在函数体内生效，这个函数就是这个变量的作用域，然后释放，只是针对字符，数字，变量是集合，字典，数组中是可以改变的
全局变量：在函数体内是改变不了的，如果硬改： global 加上这个关键字在函数体内改一个全局变量，程序都调用这个函数，变量，不容易找到出错区

递归：在函数内部，可以调用其他函数，如果一个函数在内部调用自身本身，这个函数就是递归函数
递归特性：
1 必须有一个明确的结束条件
2 每次进入更深一层递归时，问题规模相比上次递归够应有所减少
3 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈这种数据结构实现，每当进入一个函数调用，栈就会加一层栈帧，每当函数
返回，栈就会减一层栈帧，由于栈的大小不适宜无限的，所以递归调用的次数过多会导致栈溢出

ef calc(n):
    print(n)
    if int(n/2)==0:
        return n
    return calc(int(n/2))

calc(10)

匿名函数：不需要显式的指定函数，主要是和其他函数搭配使用

#原求值几次方
def  locals(n):
    return n**n
print(locals(10))
#改为匿名函数
locals=lambda n:n**n
print(locals(10))

#搭配使用
res=map(lambda x:x**2,[1,3,7,4,8])
for i in res:
    print(i)

函数式编程：

函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。
函数式编程，可以归结到买你想过程的程序设计，但是其思想更接近数学计算
在计算机的层次上，CPU执行的是加减乘除的指令代码，以及各种条件判断和跳转指令，所以汇编语言是最贴近计算机语言
计算则是数学意义上的计算，越是抽象的计算，离计算机硬件越远
‘对应到编程语言，就是越低级的语言，越贴近计算机。抽象程度低，执行效率高，比如C语言，越高级的语言越贴近计算，抽象程度越高，执行效率越低，比如ISP语言
函数式编程就是抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用，而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出结果，因此，这种函数是有副作用的。

函数式编程中的函数这个术语不是指计算机中的函数（实际上是Subroutine），而是指数学中的函数，即自变量的映射。也就是说一个函数的值仅决定于函数参数的值，不依赖其他状态。比如sqrt(x)函数计算x的平方根，只要x不变，不论什么时候调用，调用几次，值都是不变的。
函数式编程"是一种"编程范式"（programming paradigm），也就是如何编写程序的方法论。
主要思想是把运算过程尽量写成一系列嵌套的函数调用
Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言
　
var result = subtract(multiply(add(1,2), 3), 4);
再演进:
add(1,2).multiply(3).subtract(4)
高阶函数：
变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数
def add(x,y,f):
return f(x) + f(y)

res = add(3,-6,abs)
print(res)