一、介绍
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