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:定义返回值

define_

 #函数
 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)

define_test1

当一个函数\过程没有使用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()

func_test2

四、函数返回值

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

返回值数=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) #放到一个元组里返回

func_test3

五、函数调用

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)  #报错，关键参数不能写在位置参数之前

func_test4

 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

func_test5

 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")

func_test6

 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)

jububianliang

七、递归特性:

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)

duigui_

八、函数式编程介绍　　

函数是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)

gaojie_func