Python学习笔记_week3_函数

一、介绍

1、面向对象（华山派）--->类（独门秘籍）--->class（定义的关键字）

2、面向过程（少林派）--->过程--->def

3、函数式编程（逍遥派）--->函数--->def

二、函数的定义：

1、初中数学：y=2x+3

2、编程语言中的函数定义：函数是逻辑结构化和过程化的一种编程方法。

def test(x):
    "The function definitions"
    x+=1
    return x
def :定义函数的关键字
test:函数名
():内可定义形参
"":文档描述(非必要,但强烈建议写上)
x+=1:泛指代码块或程序处理逻辑
return:定义返回值

#函数
def func1():
    '''testing1'''
    print('in the func1')
    return 0

#过程(没有返回值的函数,但python中隐式的返回None,所以python中区别不大了)
def func2():
    '''testing2'''
    print('in the func2')

x=func1()
y=func2()
print(x,y)

当一个函数\过程没有使用return显示的定义返回值时，python解释器会隐式的返回None，所以在python中即便是过程也可以算作函数。

函数式编程：先定义一个数学函数，然后按照这个数学模型用编程语言去实现它。

三、为什么要用函数

没有函数的编程只是在写一个逻辑（功能），想脱离函数，重用逻辑，唯一的方法就是拷贝。

函数的三大优点：

1、代码重用

2、保持一致性

3、可扩展性

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 action\n'%time_current)

def test1():
    print('in the test1')
    logger()
def test2():
    print('in the test2')
    logger()
def test3():
    print('in the test3')
    logger()
test1()
test2()
test3()

四、函数返回值

为什么要有返回值：我想要整个函数执行的结果

返回值数=0：返回None

返回值数=1：返回object

返回值>1：返回tuple

'''def test1():
    print('in the test1')
    return 0
    # print("test end") # 碰到return，终止程序运行返回0,所以不会被打印
x=test1()
print(x)'''

def test1():
    print('in the test1')
def test2():
    print('in the test2')
    return 0
def test3():
    print('in the test3')
    return 1,'hello',['alex','wupeiqi'],{'name':'alex'}
x=test1()
y=test2()
z=test3()
print(x)
print(y)
print(z) #放到一个元组里返回

五、函数调用

test()执行，()表示调用函数test，()内可以有参数也可以没有

参数：

1、形参和和实参。形参：形式参数，不是实际存在，是虚拟变量。在定义函数和函数体的时候使用形参，目的是在函数调用时接受实参（实参个数，类型应与实参一一对应）；

　　　　　　　      实参：实际参数，调用函数时传给函数参数，可以是常量、变量、表达式、函数，传给形参。

　　　　区别：形参是虚拟的，不占用内存空间，形参变量只有在被调用时才分配内存单元，实参是一个变量，占用内存空间，数据传送单向，实参传给形参，不能形参传给实参。

2、位置参数和关键字

3、默认参数。特点：调用函数时候，默认参数非必须传递

　　　　　　  用途：1、默认安装值；2、默认端口号

4、参数组。*args,**kwargs

def test(x,y):
    print(x)
    print(y)
test(1,2) #与形参一一对应，位置参数调用
test(y=1,x=2) #与形参顺序无关，关键字调用
# test(3,x=1) 报错，多个值给x
# test(x=2,3)  #报错，关键参数不能写在位置参数之前

def test(x,y=2):
    print(x)
    print(y)
test(1)  #默认参数，不赋值就是2，赋值就为赋的值

def test(x,soft1=True,soft2=True):#默认安装值
    pass
def conn(host,port=3306):#默认端口号
    pass

def test(*args):  #接受N个位置参数，转化成元组的形式
    print(args)
test(1,2,3,4,5,6)  # 参数组，实参数目不固定，形参用*定义

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

def test1(x,*args):
    print(x)
    print(args)
test1(1,2,3,4,5,6,7) #与位置参数结合起来

def test2(**kwargs):  # **kwrgs，接受n个关键字参数，转换成字典的方式
    print(kwargs)
    print(kwargs["name"])
    print(kwargs["age"])
    print(kwargs["sex"])
test2(name="alex",age=8,sex='F')
# test2(**{"name":"alex","age":8})

def test3(name,**kwargs):
    print(name)
    print(kwargs)
test3("alex",age=18,sex='m')

def test4(name,age=18,**kwargs): #参数组往后放
    print(name)
    print(age)
    print(kwargs)
test4("alex",sex='m',hobby="tesla",age=3)

def test5(name,age=18,*args,**kwargs):
    print(name)
    print(age)
    print(args)
    print(kwargs)
test5("alex", age=34,sex='m',hobby="tesla")

def logger(source):
    print("from %s" % source)
def test5(name,age=18,*args,**kwargs):
    print(name)
    print(age)
    print(args)
    print(kwargs)
    logger("TEST5")
test5("alex", age=34,sex='m',hobby="tesla")

六、全局与局部变量

在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。

全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。

当全局变量与局部变量同名时：

在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

'''school="Oldboy edu." #全局变量
def change_name(name):
    global school
    school="Mage Linux"
    print("before change",name,school)
    name="Alex li" #这个函数就是这个变量的作用域，这个变量只在这个函数里生效。局部变量。
    age=23
    print("after change",name)
name="alex"
change_name(name)
print(name)
print(school)'''

'''def change_name():
    global name # 别用！用了就被开除
    name="alex"
change_name()
print(name)'''

school="Oldboy edu"
names=["Alex","Jack","Rain"]
def change_name():
    names[0]="jinjiaodawang"  #除了简单的字符串和整数不能改，其他列表，字典等都可以改
    print(names)
change_name()
print(names)

 

七、递归特性:

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

堆栈扫盲http://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html 

# def calc(n):
#     print(n)
#     return calc(n+1)
# calc(0)   #递归999次，栈溢出，报错

def calc(n):
    print(n)
    if int(n/2) >0:
        return calc(int(n/2))
    print("-->",n)
calc(10)

八、函数式编程介绍　　

函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。

函数式编程中的函数这个术语不是指计算机中的函数（实际上是Subroutine），而是指数学中的函数，即自变量的映射。也就是说一个函数的值仅决定于函数参数的值，不依赖其他状态。比如sqrt(x)函数计算x的平方根，只要x不变，不论什么时候调用，调用几次，值都是不变的。

 

Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。Haskell、Erlang等是函数式编程语言（纯函数式编程，想学别在python中学。）。

一、定义

简单说，"函数式编程"是一种"编程范式"（programming paradigm），也就是如何编写程序的方法论。

主要思想是把运算过程尽量写成一系列嵌套的函数调用。举例来说，现在有这样一个数学表达式：

　　(1 + 2) * 3 - 4

传统的过程式编程，可能这样写：

　　var a = 1 + 2;

　　var b = a * 3;

　　var c = b - 4;

函数式编程要求使用函数，我们可以把运算过程定义为不同的函数，然后写成下面这样：

　　var result = subtract(multiply(add(1,2), 3), 4);

这段代码再演进以下，可以变成这样

add(1,2).multiply(3).subtract(4)

这基本就是自然语言的表达了。再看下面的代码，大家应该一眼就能明白它的意思吧：

merge([1,2],[3,4]).sort().search("2")

因此，函数式编程的代码更容易理解。

要想学好函数式编程，不要玩py,玩Erlang,Haskell, 好了，我只会这么多了。。。

九、高阶函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

def add(a,b,f):
    return f(a)+f(b)
res=add(3,-6,abs)
print(res)