Python学习之路8——函数介绍

　　1、函数是什么？

在学习函数之前，一直遵循面向过程编程，即根据业务逻辑从上到下实现功能，其往往用一长段代码来实现指定功能。

开发过程中最常见的操作就是粘贴复制，也就是将之前实现的代码块复制到现需功能处。

这样最后的程序会变得特别冗长，有没有什么办法把这些相同的代码块做一些处理？

让程序的代码显得简便明朗，这就引出了今天要学习的内容：函数。

定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可。

特性：减少重复代码、使程序变的可扩展、使程序变得易维护。

   2、定义函数

def 函数名(参数):
     
    ....
    函数体
    ....
    return 返回值
 
函数名()

 　　函数组成：函数名、参数、函数体、返回值，接下来进行详细介绍。

　  3、普通参数

学习函数参数前，我们先认识下形参和实参的区别：

• • 形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。

　　　　　  形参只在函数内部有效。

　　　　　  函数调用结束返回主调用函数后则不能再使用该形参变量。

• • 实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。

　　　　　  应预先用赋值，输入等办法使参数获得确定值。

#！/user/bin/env ptyhon
# -*- coding:utf-8 -*-
# Author: VisonWong

# 函数的普通参数
# name 叫做函数func的形式参数，简称：形参
def func(name):  # 定义函数 函数名func
    print(name)

#  'vison' 叫做函数func的实际参数，简称：实参
func("vison")  # 执行函数

　　4、默认参数

　　默认参数的应用环境。

#！/user/bin/env ptyhon
# -*- coding:utf-8 -*-
# Author: VisonWong

# 函数默认参数
def stu_register(name, age, country, course):  # 定义函数
    print("----注册学生信息------")
    print("姓名:", name)
    print("age:", age)
    print("国籍:", country)
    print("课程:", course)

stu_register("张三", 22, "CN", "Python")  # 执行函数
stu_register("赵四", 21, "CN", "Linux")
stu_register("王五", 25, "CN", "JAVA")

　　输出结果:

E:PythonPythonLearingvenvScriptspython.exe E:/Python/PythonLearing/func.py
----注册学生信息------
姓名: 张三
age: 22
国籍: CN
课程: Python
----注册学生信息------
姓名: 赵四
age: 21
国籍: CN
课程: Linux
----注册学生信息------
姓名: 王五
age: 25
国籍: CN
课程: JAVA

Process finished with exit code 0

　　 通过上面代码发现country 这个参数基本都 是"CN"。

　　 在网站上注册用户，国籍默认是中国，这就是通过默认参数实现的，把country变成默认参数。

def stu_register(name,age,course,country="CN"):

　　这样，这个参数在调用时不指定，那默认就是CN，指定了的话，就用你指定的值。

#！/user/bin/env ptyhon
# -*- coding:utf-8 -*-
# Author: VisonWong

# 指定默认参数
def stu_register(name, age, course, country="CN"):  # 定义函数
    print("----注册学生信息------")
    print("姓名:", name)
    print("age:", age)
    print("国籍:", country)
    print("课程:", course)

stu_register("张三", 22, "Python")  # 不指定country参数值
stu_register("赵四", 21, "Linux", "US")  # 指定country参数值

　　输出结果：

E:PythonPythonLearingvenvScriptspython.exe E:/Python/PythonLearing/func.py
----注册学生信息------
姓名: 张三
age: 22
国籍: CN
课程: Python
----注册学生信息------
姓名: 赵四
age: 21
国籍: US
课程: Linux

Process finished with exit code 0

　　注意：定义函数默认参数必须放在非默认参数之后。

　5、关键字参数

　　正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可。

　　但记住一个要求就是，关键字参数必须放在位置参数之后。

#！/user/bin/env ptyhon
# -*- coding:utf-8 -*-
# Author: VisonWong

# 关键字参数
def stu_register(name, age, course, country="CN"):  # 定义函数
    print("----注册学生信息------")
    print("姓名:", name)
    print("age:", age)
    print("国籍:", country)
    print("课程:", course)

stu_register( 'vison',course= "Python",age=22)  # 不指定country参数值

　　输出结果：

E:PythonPythonLearingvenvScriptspython.exe E:/Python/PythonLearing/func.py
----注册学生信息------
姓名: vison
age: 22
国籍: CN
课程: Python

Process finished with exit code 0

　6、非固定参数

　　非固定参数 *args。

#！/user/bin/env ptyhon
# -*- coding:utf-8 -*-
# Author: VisonWong

def stu_register(name, *args):  # *args 会把多传入的参数变成一个元组形式
    print(name, args, type(args))  # 打印传入args的类型

stu_register("vison", "18", "CN", "Python")

　　输出结果：

E:PythonPythonLearingvenvScriptspython.exe E:/Python/PythonLearing/func.py
vison ('18', 'CN', 'Python') <class 'tuple'>

Process finished with exit code 0

　　输入列表参数。

#！/user/bin/env ptyhon
# -*- coding:utf-8 -*-
# Author: VisonWong

def stu_register(name, *args):  # 测试*args传入list参数
    print(name, args, type(args))  # 打印传入args的类型


info_list = ["18", "CN", "Python"]
stu_register("vison", info_list)

　　输出结果：

E:PythonPythonLearingvenvScriptspython.exe E:/Python/PythonLearing/func.py
vison (['18', 'CN', 'Python'],) <class 'tuple'>

Process finished with exit code 0

　　总结：

　　由上面代码可以看出，*args会把多传入的实参变成一个元组的类型；

　　即使传入的是list类型也会变成元组，成为元组中的一个元素；

　　另函数中有*args与其他形参的时候，*args一定要写到其他形参的后面，否则传入的实参都会被传入到*args当中打印成元组；

　　还有如果没有多出传入的实参即*args没有值的时候，*args为空，不会报错。

　　非固定参数 **kwargs 。

#！/user/bin/env ptyhon
# -*- coding:utf-8 -*-
# Author: VisonWong

def stu_register(name, *args, **kwargs):  # **kwargs 会把多传入的参数变成一个dict形式
    print(name, args, type(args))  # 打印args的类型
    print(kwargs, type(kwargs))  # 打印kwargs的类型

stu_register("viosn", 28, "CN", "Python", sex="Male", province="HeNan")

 　　输出结果：

1 E:PythonPythonLearingvenvScriptspython.exe E:/Python/PythonLearing/func.py
2 viosn (28, 'CN', 'Python') <class 'tuple'>
3 {'sex': 'Male', 'province': 'HeNan'} <class 'dict'>
4 
5 Process finished with exit code 0

　　传入列表和字典。

# -*- coding:utf-8 -*-
# Author: VisonWong

def stu_register(name, *args, **kwargs):  # **kwargs 会把多传入的参数变成一个dict形式
    print(name, args, type(args))  # 打印args的类型
    print(kwargs, type(kwargs))  # 打印kwargs的类型


info_list = [28, "CN", "Python", ]  # 定义列表
info_dict = {"sex": "Male", "province": "HeNan"}  # 定义字典
stu_register("vison", info_list, info_dict)  # 传入列表和字典

　　输出结果：

E:PythonPythonLearingvenvScriptspython.exe E:/Python/PythonLearing/func.py
vison ([28, 'CN', 'Python'], {'sex': 'Male', 'province': 'HeNan'}) <class 'tuple'>
{} <class 'dict'>

Process finished with exit code 0

　　看完上面的第一段代码，

　　**kwargs会把多出的a=b这种类型的实参打印成字典的类型（要区分开与关键参数的区别，关键参数的实参有对应的形参）；

　　但是第二段代码为毛下面把字典传入函数后，打印的**kwargs为空值呢？!  

　　是这样的，传入的字典会被当成一个元素传入函数，所有被当成多余的实参传入到了*args里面，所以**kwargs的值才为空；那么有什么办法可以把字典传入到**kwargs呢？

# -*- coding:utf-8 -*-
# Author: VisonWong

def stu_register(name, *args, **kwargs):  # **kwargs 会把多传入的参数变成一个dict形式
    print(name, args, type(args))  # 打印args的类型
    print(kwargs, type(kwargs))  # 打印kwargs的类型


info_list = [28, "CN", "Python", ]  # 定义列表
info_dict = {"sex": "Male", "province": "HeNan"}  # 定义字典
stu_register("lzl",*info_list,**info_dict)     #传入列表和字典

　　输出结果：

E:PythonPythonLearingvenvScriptspython.exe E:/Python/PythonLearing/func.py
lzl (28, 'CN', 'Python') <class 'tuple'>
{'sex': 'Male', 'province': 'HeNan'} <class 'dict'>

Process finished with exit code 0

　　把定义好列表info_list、info_dict，分别用*inf_list和**info_dict的方式传入到*args、**kwargs当中，解决了第二块代码中的问题

　　总结：

　　*args必须放到**kwargs前面（规定）；位置参数一定要放到关键参数之前（规定）；默认参数不能跟*args、**kwargs一块存在（会报错）。

　　7、return返回值

#！/user/bin/env ptyhon
# -*- coding:utf-8 -*-
# Author: VisonWong

# ruturn 返回值
def func(name, age):
    print(name)
    print(age)


result = func("Vison", 28)  # 赋值变量result函数func执行的返回值
print(result)             # 函数不声明return，返回值为None
                          # 函数在赋值变量result的时候也进行了打印

　　输出结果：

E:PythonPythonLearingvenvScriptspython.exe E:/Python/PythonLearing/func.py
Vison
28
None

Process finished with exit code 0

　　添加返回值。

# -*- coding:utf-8 -*-
# Author: VisonWong

def func(name, age):
    print(name)
    return "best"  # 执行return返回值
    print(age)


result = func("Vison", 28)  # 赋值变量result函数func执行的返回值
print(result)                # 函数返回值为best
                             # age没有打印，表明函数执行到return后，函数结束

　　输出结果：

E:PythonPythonLearingvenvScriptspython.exe E:/Python/PythonLearing/func.py
Vison
best

Process finished with exit code 0

　　结论：、

　　如果不执行return，函数的默认返回值为None；当函数执行到return时，函数结束执行。

　8、局部变量

#！/user/bin/env ptyhon
# -*- coding:utf-8 -*-
# Author: VisonWong

name = "Alex Li"  # 定义变量name

def change_name(name):
    print("before change:", name)
    name = "金角大王,一个有Tesla的男人"  # 函数内部更改变量
    print("after change", name)  # 打印更改后的变量name

change_name(name)
print("在外面看看name改了么?", name)  # 现在看看name变量有没有被更改

　　输出结果：

E:PythonPythonLearingvenvScriptspython.exe E:/Python/PythonLearing/func.py
before change: Alex Li
after change 金角大王,一个有Tesla的男人
在外面看看name改了么? Alex Li

Process finished with exit code 0

　　总结：

　　函数内部对变量进行更改后，生效范围仅限于函数内部，对外部变量没有影响，这种变量称为局部变量；

　　函数内部也可以让变量全局生效，需要加参数global，这种情况很少用。

　9、递归函数　

　　定义：如果一个函数在内部调用自身本身，这个函数就是递归函数

递归特性:

• •  必须有一个明确的结束条件
  •  每次进入更深一层递归时，问题规模相比上次递归都应有所减少
  •  递归效率不高，递归层次过多会导致栈溢出

　　　　　　在计算机中，函数调用是通过栈（stack）这种数据结构实现的。

　　　　　　每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。

　　　　　　由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

　　利用函数编写一个斐波那契数列。

#！/user/bin/env ptyhon
# -*- coding:utf-8 -*-
# Author: VisonWong

def func(n1,n2):        #获取斐波那契数列100之前的数字
    if n1 > 100:
        return
    print(n1)
    n3 = n1 + n2
    func(n2,n3)
func(0,1)

　　输出结果：

E:PythonPythonLearingvenvScriptspython.exe E:/Python/PythonLearing/func.py
0
1
1
2
3
5
8
13
21
34
55
89

Process finished with exit code 0

　获取斐波那契数列第20个数字并返回给调用者。

#！/user/bin/env ptyhon
# -*- coding:utf-8 -*-
# Author: VisonWong

def func(count,n1,n2):        #获取斐波那契数列第20个数字并返回给调用者
    if count == 20:
        return n1
    n3 = n1 + n2
    r = func(count + 1,n2,n3)
    return r                   #不断返回结果给上一层调用函数
ret = func(1,0,1)
print(ret)

　　输出结果：

E:PythonPythonLearingvenvScriptspython.exe E:/Python/PythonLearing/func.py
4181

Process finished with exit code 0

　10、函数式编程

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

函数就是面向过程的程序设计的基本单元。

而函数式编程（请注意多了一个“式”字）——Functional Programming，虽然也可以归结到面向过程的程序设计，但其思想更接近数学计算。

我们首先要搞明白计算机（Computer）和计算（Compute）的概念。

在计算机的层次上，CPU执行的是加减乘除的指令代码，以及各种条件判断和跳转指令，所以，汇编语言是最贴近计算机的语言。

而计算则指数学意义上的计算，越是抽象的计算，离计算机硬件越远。

对应到编程语言，就是越低级的语言，越贴近计算机，抽象程度低，执行效率高，比如C语言；越高级的语言，越贴近计算，抽象程度高，执行效率低，比如Lisp语言。

 

函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。

而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此，这种函数是有副作用的。

 

函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！

Python对函数式编程提供部分支持。

由于Python允许使用变量，因此，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);

　　这就是函数式编程。

　11、匿名函数

　　匿名函数就是不需要显式的指定函数。

#这段代码
def calc(n):
    return n**n
print(calc(10))
  
#换成匿名函数
calc = lambda n:n**n
print(calc(10))

　　匿名函数主要是和其它函数搭配使用如下：

#！/user/bin/env ptyhon
# -*- coding:utf-8 -*-
# Author: VisonWong

res = map(lambda x:x**2,[1,5,7,4,8])
for i in res: 
    print(i)

　　输出结果：

E:PythonPythonLearingvenvScriptspython.exe E:/Python/PythonLearing/func.py
1
25
49
16
64

Process finished with exit code 0

　　加入列表。

#！/user/bin/env ptyhon
# -*- coding:utf-8 -*-
# Author: VisonWong

calc = map(lambda n,x,y:n*10000+x*100+y,[1,5,7,4,8],[2,2,2,2,2],[3,3,3,3,3])
for i in calc:
    print(i)

 　　输出结果：

E:PythonPythonLearingvenvScriptspython.exe E:/Python/PythonLearing/func.py
10203
50203
70203
40203
80203

Process finished with exit code 0

　　关于map函数的用法看下面两个例子。

#！/user/bin/env ptyhon
# -*- coding:utf-8 -*-
# Author: VisonWong

def abc(a, b, c):
    return a*10000 + b*100 + c

list1 = [11,22,33]
list2 = [44,55,66]
list3 = [77,88,99]

calc = map(abc,list1,list2,list3)
for i in calc:
    print(i)

　　输出结果：

E:PythonPythonLearingvenvScriptspython.exe E:/Python/PythonLearing/func.py
114477
225588
336699

Process finished with exit code 0

　　某种意义上实现了并行计算。

#！/user/bin/env ptyhon
# -*- coding:utf-8 -*-
# Author: VisonWong

list1 = [11,22,33]
list2 = [44,55,66]
list3 = [77,88,99]

calc = map(lambda x,y,z:[x,y,z],list1,list2,list3)

for i in calc:
    print(i)

　　输出结果：

E:PythonPythonLearingvenvScriptspython.exe E:/Python/PythonLearing/func.py
[11, 44, 77]
[22, 55, 88]
[33, 66, 99]

Process finished with exit code 0

　　12、高阶函数

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

#！/user/bin/env ptyhon
# -*- coding:utf-8 -*-
# Author: VisonWong

def add(x, y, f):
    return f(x) + f(y)


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

　 13、内置函数