草根学Python（六） 函数

前言

前天创了个 Python 微信讨论群，觉得没人进的，哈哈，想不到还真有小伙伴进群学习讨论。若是想进群，能够加我微信： androidwed ，拉进群，就不贴微信群二维码了，一是会失效，二影响文章。

目录

草根学Python（六） 函数

1、Python 自定义函数的基本步骤

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

自定义函数，基本有如下规则步骤：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()
• 任何传入参数和自变量必须放在圆括号中间。圆括号之间能够用于定义参数
• 函数的第一行语句能够选择性地使用文档字符串（用于存放函数说明）
• 函数内容以冒号起始，而且缩进
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的 return 至关于返回 None。

语法示例：

def functionname( parameters ):
   "函数_文档字符串"
   function_suite
   return [expression]复制代码

实例：

1. def 定义一个函数，给定一个函数名 sum
2. 声明两个参数 num1 和 num2
3. 函数的第一行语句进行函数说明：两数之和
4. 最终 return 语句结束函数，并返回两数之和

def sum(num1,num2):
    "两数之和"
    return num1+num2

# 调用函数
print(sum(5,6))复制代码

输出结果：

11复制代码

2、函数传值问题

先看一个例子：

# -*- coding: UTF-8 -*-
def chagne_number( b ):
    b = 1000

b = 1
chagne_number(b)
print( b )复制代码

最后输出的结果为：

1复制代码

这里可能有些人会有疑问，为啥不是经过函数chagne_number更改了 b
的值吗？为啥没有变化，输出的结果仍是 1 ，这个问题不少编程语言都会讲到，原理解释也是差很少的。

这里主要是函数参数的传递中，传递的是类型对象，以前也介绍了 Python 中基本的数据类型等。而这些类型对象能够分为可更改类型和不可更改的类型

在 Python 中，字符串，整形，浮点型，tuple 是不可更改的对象，而 list ， dict 等是能够更改的对象。

例如：

不可更改的类型：变量赋值 a = 1，其实就是生成一个整形对象 1 ，而后变量 a 指向 1，当 a = 1000 其实就是再生成一个整形对象 1000，而后改变 a 的指向，再也不指向整形对象 1 ，而是指向 1000，最后 1 会被丢弃

可更改的类型：变量赋值 a = [1,2,3,4,5,6] ，就是生成一个对象 list ，list 里面有 6 个元素，而变量 a 指向 list ，a[2] = 5则是将 list a 的第三个元素值更改,这里跟上面是不一样的，并非将 a 从新指向，而是直接修改 list 中的元素值。

指向问题

这也将影响到函数中参数的传递了：

不可更改的类型：相似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是 a 的值，没有影响 a 对象自己。好比在 fun（a）内部修改 a 的值，只是修改另外一个复制的对象，不会影响 a 自己。

可更改的类型：相似 c++ 的引用传递，如 列表，字典。如 fun（a），则是将 a 真正的传过去，修改后 fun 外部的 a 也会受影响

所以，在一开始的例子中，b = 1,建立了一个整形对象 1 ，变量 b 指向了这个对象，而后经过函数 chagne_number 时，按传值的方式复制了变量 b ，传递的只是 b 的值，并无影响到 b 的自己。具体能够看下修改后的实例，经过打印的结果更好的理解。

# -*- coding: UTF-8 -*-
def chagne_number( b ):
    print('函数中一开始 b 的值：{}' .format( b ) )
    b = 1000
    print('函数中 b 赋值后的值：{}' .format( b ) )


b = 1
chagne_number( b )
print( '最后输出 b 的值：{}' .format( b )  )复制代码

打印的结果：

函数中一开始 b 的值：1
函数中 b 赋值后的值：1000
最后输出 b 的值：1复制代码

固然，若是参数中的是可更改的类型，那么调用了这个函数后，原来的值也会被更改，具体实例以下：

# -*- coding: UTF-8 -*-

def chagne_list( b ):
    print('函数中一开始 b 的值：{}' .format( b ) )
    b.append(1000)
    print('函数中 b 赋值后的值：{}' .format( b ) )


b = [1,2,3,4,5]
chagne_list( b )
print( '最后输出 b 的值：{}' .format( b )  )复制代码

输出的结果：

函数中一开始 b 的值：[1, 2, 3, 4, 5]
函数中 b 赋值后的值：[1, 2, 3, 4, 5, 1000]
最后输出 b 的值：[1, 2, 3, 4, 5, 1000]复制代码

3、函数返回值

经过上面的学习，能够知道经过 return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的 return 语句返回 None。

具体示例：

# -*- coding: UTF-8 -*-

def sum(num1,num2):
    # 两数之和
    if not (isinstance (num1,(int ,float)) or isinstance (num2,(int ,float))):
        raise TypeError('参数类型错误')
    return num1+num2

print(sum(1,2))复制代码

返回结果：

3复制代码

这个示例，还经过内置函数isinstance()进行数据类型检查，检查调用函数时参数是不是整形和浮点型。若是参数类型不对，会报错，提示 参数类型错误,如图：

检查函数参数是否正确

固然，函数也能够返回多个值，具体实例以下：

# -*- coding: UTF-8 -*-

def division ( num1, num2 ):
    # 求商与余数
         a = num1 % num2
         b = (num1-a) / num2
         return b , a 

num1 , num2 = division(9,4)
tuple1 = division(9,4)

print (num1,num2)
print (tuple1)复制代码

输出的值：

2.0 1
(2.0, 1)复制代码

认真观察就能够发现，尽管从第一个输出值来看，返回了多个值，其实是先建立了一个元组而后返回的。回忆一下，元组是能够直接用逗号来建立的，观察例子中的 ruturn ，能够发现实际上咱们使用的是逗号来生成一个元组。

4、函数的参数

一、默认值参数

有时候，咱们自定义的函数中，若是调用的时候没有设置参数，须要给个默认值，这时候就须要用到默认值参数了。

# -*- coding: UTF-8 -*-

def print_user_info( name , age , sex = '男' ):
    # 打印用户信息
    print('昵称：{}'.format(name) , end = ' ')
    print('年龄：{}'.format(age) , end = ' ')
    print('性别：{}'.format(sex))
    return;

# 调用 print_user_info 函数

print_user_info( '两点水' , 18 , '女')
print_user_info( '三点水' , 25 )复制代码

输出结果：

昵称：两点水 年龄：18 性别：女
昵称：三点水 年龄：25 性别：男复制代码

能够看到，当你设置了默认参数的时候，在调用函数的时候，不传该参数，就会使用默认值。可是这里须要注意的一点是：只有在形参表末尾的那些参数能够有默认参数值，也就是说你不能在声明函数形参的时候，先声明有默认值的形参然后声明没有默认值的形参。这是由于赋给形参的值是根据位置而赋值的。例如，def func(a, b=1) 是有效的，可是 def func(a=1, b) 是 无效 的。

默认值参数就这样结束了吗？尚未的，细想一下，若是参数中是一个可修改的容器好比一个 lsit （列表）或者 dict （字典），那么咱们使用什么来做为默认值呢？咱们可使用 None 做为默认值。就像下面这个例子同样：

# 若是 b 是一个 list ，可使用 None 做为默认值
def print_info( a , b = None ):
    if b is None :
        b=[]
    return;复制代码

认真看下例子，会不会有这样的疑问呢？在参数中咱们直接 b=[] 不就好了吗？也就是写成下面这个样子：

def print_info( a , b = [] ):
    return;复制代码

对不对呢？运行一下也没发现错误啊，能够这样写吗？这里须要特别注意的一点：默认参数的值是不可变的对象，好比None、True、False、数字或字符串，若是你像上面的那样操做，当默认值在其余地方被修改后你将会遇到各类麻烦。这些修改会影响到下次调用这个函数时的默认值。

示例以下：

# -*- coding: UTF-8 -*-

def print_info( a , b = [] ):
    print(b)
    return b ;

result = print_info(1)

result.append('error')

print_info(2)复制代码

输出的结果：

[]
['error']复制代码

认真观察，你会发现第二次输出的值根本不是你想要的，所以切忌不能这样操做。

还有一点，有时候我就是不想要默认值啊，只是想单单判断默认参数有没有值传递进来，那该怎么办？咱们能够这样作：

_no_value =object()

def print_info( a , b = _no_value ):
    if b is _no_value :
        print('b 没有赋值')
    return;复制代码

这里的 object 是python中全部类的基类。 你能够建立 object 类的实例，可是这些实例没什么实际用处，由于它并无任何有用的方法， 也没有任何实例数据(由于它没有任何的实例字典，你甚至都不能设置任何属性值)。 你惟一能作的就是测试同一性。也正好利用这个特性，来判断是否有值输入。

二、关键字参数

在 Python 中，能够经过参数名来给函数传递参数，而不用关心参数列表定义时的顺序，这被称之为关键字参数。使用关键参数有两个优点 ：

1、因为咱们没必要担忧参数的顺序，使用函数变得更加简单了。

2、假设其余参数都有默认值，咱们能够只给咱们想要的那些参数赋值

# -*- coding: UTF-8 -*-

def print_user_info( name , age , sex = '男' ):
    # 打印用户信息
    print('昵称：{}'.format(name) , end = ' ')
    print('年龄：{}'.format(age) , end = ' ')
    print('性别：{}'.format(sex))
    return;

# 调用 print_user_info 函数

print_user_info( name = '两点水' ,age = 18 , sex = '女')
print_user_info( name = '两点水' ,sex = '女', age = 18 )复制代码

输出的值：

昵称：两点水 年龄：18 性别：女
昵称：两点水 年龄：18 性别：女复制代码

三、不定长参数

有时咱们在设计函数接口的时候，可会须要可变长的参数。也就是说，咱们事先没法肯定传入的参数个数。Python 提供了一种元组的方式来接受没有直接定义的参数。这种方式在参数前边加星号 * 。若是在函数调用时没有指定参数，它就是一个空元组。咱们也能够不向函数传递未命名的变量。

例如：

# -*- coding: UTF-8 -*-

def print_user_info( name , age , sex = '男' , * hobby):
    # 打印用户信息
    print('昵称：{}'.format(name) , end = ' ')
    print('年龄：{}'.format(age) , end = ' ')
    print('性别：{}'.format(sex) ,end = ' ' )
    print('爱好：{}'.format(hobby))
    return;

# 调用 print_user_info 函数
print_user_info( '两点水' ,18 , '女', '打篮球','打羽毛球','跑步')复制代码

输出的结果：

昵称：两点水 年龄：18 性别：女 爱好：('打篮球', '打羽毛球', '跑步')复制代码

经过输出的结果能够知道，*hobby是可变参数，且 hobby其实就是一个 tuple （元祖）

可变长参数也支持关键参数，没有被定义的关键参数会被放到一个字典里。这种方式便是在参数前边加 **,更改上面的示例以下：

# -*- coding: UTF-8 -*-

def print_user_info( name , age , sex = '男' , ** hobby ):
    # 打印用户信息
    print('昵称：{}'.format(name) , end = ' ')
    print('年龄：{}'.format(age) , end = ' ')
    print('性别：{}'.format(sex) ,end = ' ' )
    print('爱好：{}'.format(hobby))
    return;

# 调用 print_user_info 函数
print_user_info( name = '两点水' , age = 18 , sex = '女', hobby = ('打篮球','打羽毛球','跑步'))复制代码

输出的结果：

昵称：两点水 年龄：18 性别：女 爱好：{'hobby': ('打篮球', '打羽毛球', '跑步')}复制代码

经过对比上面的例子和这个例子，能够知道，*hobby是可变参数，且 hobby其实就是一个 tuple （元祖），**hobby是关键字参数，且 hobby 就是一个 dict （字典）

四、只接受关键字参数

关键字参数使用起来简单，不容易参数出错，那么有些时候，咱们定义的函数但愿某些参数强制使用关键字参数传递，这时候该怎么办呢？

将强制关键字参数放到某个*参数或者单个*后面就能达到这种效果,好比：

# -*- coding: UTF-8 -*-

def print_user_info( name , *, age , sex = '男' ):
    # 打印用户信息
    print('昵称：{}'.format(name) , end = ' ')
    print('年龄：{}'.format(age) , end = ' ')
    print('性别：{}'.format(sex))
    return;

# 调用 print_user_info 函数
print_user_info( name = '两点水' ,age = 18 , sex = '女' )

# 这种写法会报错，由于 age ，sex 这两个参数强制使用关键字参数
#print_user_info( '两点水' , 18 , '女' )
print_user_info('两点水',age='22',sex='男')复制代码

经过例子能够看，若是 age , sex 不适用关键字参数是会报错的。

不少状况下，使用强制关键字参数会比使用位置参数表意更加清晰，程序也更加具备可读性。使用强制关键字参数也会比使用 **kw 参数更好且强制关键字参数在一些更高级场合一样也颇有用。

5、匿名函数

有没有想过定义一个很短的回调函数，但又不想用 def 的形式去写一个那么长的函数，那么有没有快捷方式呢？答案是有的。

python 使用 lambda 来建立匿名函数，也就是再也不使用 def 语句这样标准的形式定义一个函数。

匿名函数主要有如下特色：

• lambda 只是一个表达式，函数体比 def 简单不少。
• lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
• lambda 函数拥有本身的命名空间，且不能访问自有参数列表以外或全局命名空间里的参数。

基本语法

lambda [arg1 [,arg2,.....argn]]:expression复制代码

示例：

# -*- coding: UTF-8 -*-

sum = lambda num1 , num2 : num1 + num2;

print( sum( 1 , 2 ) )复制代码

输出的结果：

3复制代码

注意：尽管 lambda 表达式容许你定义简单函数，可是它的使用是有限制的。 你只能指定单个表达式，它的值就是最后的返回值。也就是说不能包含其余的语言特性了， 包括多个语句、条件表达式、迭代以及异常处理等等。

匿名函数中，有一个特别须要注意的问题，好比，把上面的例子改一下：

# -*- coding: UTF-8 -*-

num2 = 100
sum1 = lambda num1 : num1 + num2 ;

num2 = 10000
sum2 = lambda num1 : num1 + num2 ;

print( sum1( 1 ) )
print( sum2( 1 ) )复制代码

你会认为输出什么呢？第一个输出是 101，第二个是 10001，结果不是的，输出的结果是这样：

10001
10001复制代码

这主要在于 lambda 表达式中的 num2 是一个自由变量，在运行时绑定值，而不是定义时就绑定，这跟函数的默认值参数定义是不一样的。因此建议仍是遇到这种状况仍是使用第一种解法。