引言

这篇文章介绍 python 中函数的基本知识。

文章目录

0×1. 自定义函数
0×2. 给函数增加文档阐明
0×3. 函数的作用域
0×4. 带参数的函数

0×1. 自定义函数

在任何编程语言中，函数的作用都是雷同的，它能够将一些须要反复执行的语句组合起来，不便在须要的时候调用他们，python 中应用 def 关键字来创立一个函数，请看上面的实例：

#!/usr/bin/env python3
#coding=utf-8
dect={"one":1,"two":2,"three":3}

#创立函数，函数名为 in_dect，中括号中为空代表不接管传入参数，函数执行过程中遇到 return 会完结执行，将 return 后的值返回给调用者
#------
def in_dect():
    """依据字典传入键返回值"""
    try:
        count=dect[num]
    except KeyError as err:
        count=0
    return count
#------

#将 num 设置成 dect 字典中不同的键，在 print 中调用方才创立的函数，in_dect() 函数会依据 num 键返回对应的值，如果传入的键不存在，则触发 KeyError 异样，返回 0
num="one"
print(in_dect())
num="two"
print(in_dect())
num="xxx"
print(in_dect())

#程序输入
1
2
0

0×2. 给函数增加文档阐明

咱们能够应用 ” 三引号 ” 给每个函数增加一段性能阐明，在 python 中，通过 ” 函数名.__doc__” 可能打印出这段阐明文字，请看上面的实例：

#!/usr/bin/env python3
#coding=utf-8

#------
def sayhello():
    """打印出 hello world"""
    """www.qingsword.com"""
    print("hello world!")
#------

sayhello()  #间接调用函数
print(sayhello.__doc__) #打印出函数中的阐明信息

#程序输入
hello world!
打印出 hello world

#留神下面的输入，__doc__只可能打印出函数中第一个 "三引号" 所蕴含的阐明信息 

0×3. 函数的作用域

函数中的变量名称和全局中的变量名称能够雷同，函数的变量名称只作用与函数外部，请看上面的实例：

#!/usr/bin/env python3
#coding=utf-8

#------
def re_list():
    lst=[1,2,3]
    return lst
#------

lst=["a","b","c"]
print(lst,re_list())

#在下面的程序中，re_list() 函数中蕴含了一个变量名称 lst，全局中也有一个雷同名称的变量，但两者互不烦扰，函数中的变量的作用域仅限函数自身，当函数被调用时创立，函数执行实现后被回收，上面是程序输入
['a', 'b', 'c'] [1, 2, 3]

0×4. 带参数的函数

能够在自定义的函数括号中定义变量来接管传入数据，请看上面的实例：

#!/usr/bin/env python3
#coding=utf-8

#------
def re_dect_value(dect,k):
    return dect[k]
#------

d={"a":1,"b":2,"c":3}
k="a"

#调用函数时，将 d 和 k 传递给函数，函数定义时，括号中蕴含了两个参数，这相当于将函数参数中的 dect 指向了 d 所援用的内存区域的数据（列表数据），k 同理，所以这个函数的 return 语句返回的值，实际上就等价与 d[k]
print(re_dect_value(d,k))

#程序输入：1

能够应用判断语句来判断传递给函数的参数的数据类型，通过数据类型判断调用不同的函数区块执行，如果不携带参数，则应用默认值所指向的区块执行，请看上面的实例：

#!/usr/bin/env python3
#coding=utf-8

#choose_def 函数，用于确定传入的数据是哪种类型，依据不同类型调用不同函数执行，如果不传入参数，则应用默认值（即 typ="default",idx=0）def choose_def(typ="default",idx=0):
    if type(typ)==type([]):
        print(c_dect(typ,idx))
    elif type(typ)==type(""):
        print(c_str(typ,idx))
#------
def c_dect(d,idx):
    return d[idx]
#------
def c_str(s,idx):
    return s[idx]
#------

lst=[1,2,3,4]
s="www.qingsword.com"
i=2
choose_def(lst,i)
choose_def(s,i)
choose_def()

#程序输入
3
w
d

#在下面的程序中，最初一次调用选择函数时没有携带参数，python 会应用定义函数时设定的默认值（如果有），程序判断出 "default" 是一个字符串，所以调用字符串函数 c_str()，因为默认的 idx 是 0，所以打印出 "default" 第一个字符 d

#像 choose_def() 这种携带默认值参数的函数，如果咱们只想批改其中一个参数，其余的参数依照默认值，能够应用上面的办法调用
choose_def(idx=3)
#这样的调用办法仅指定了 idx 的值，typ 并没有设定，它将应用默认值 

除了应用类型判断外，还能够应用字符串判断，通过每个类型判断所返回的字符串，来判断传入的参数属于那种类型，对下面的程序中的 choose_def 函数做出一点点批改，执行后果雷同：

# 将 type() 判断后返回的值转化成字符串，与对应的字符串值比拟
def choose_def(typ="default",idx=0):
    if str(type(typ))=="<class'list'>":
        print(c_dect(typ,idx))
    elif str(type(typ))=="<class'str'>":
        print(c_str(typ,idx))

当传递了一个谬误的数据给函数时，除了应用 try 捕捉异样外，还可能应用 raise 关键字来被动抛出异样，批改 choose_def() 函数，在开端增加上面的语句：

def choose_def(typ="default",idx=0):
    if str(type(typ))=="<class'list'>":
        print(c_dect(typ,idx))
    elif str(type(typ))=="<class'str'>":
        print(c_str(typ,idx))
    else:
        raise TypeError("谬误的参数:%s"%typ)

#向函数传递一个谬误的参数，整数
choose_def(123)

#当程序执行 if 判断时发现没有类型可能匹配传入的整型，所以跳转到 else 执行上面的 raise 语句，当 raise 语句被执行时，会立即终止程序的执行，并抛出一个异样，这个异样是咱们被动抛出的，上面是这个异样的显示信息，其中的中文内容是咱们自定义的

builtins.TypeError: 谬误的参数:123

再来看一个实例，创立一个函数，承受两个数值，返回这两个数值相加后的后果：

#!/usr/bin/env python3
#coding=utf-8

#------ 如果输出的字符不是数值，if 判断会匹配到 else 从而被动抛出一个异样
def a_plus(x,y):
    """返回 x + y 的值"""
    if is_Num(x) and is_Num(y):
        return float(x)+float(y)
    else:
        raise TypeError("输出的数值谬误：%s,%s"%(x,y))

#------ 用来判断输出的是否为数值数据，不论是浮点数，整数或迷信计数法，应用 float() 转换时都不会报错，而其余的字符就会引发 ValueError 异样返回 False，如果不报错，返回 True
def is_Num(x):
    """判断键盘输入的是否为数字"""
    try:
        float(x)
    except ValueError:
        return False
    else:
        return True
#------
     
x=input("第一个数：")
y=input("第二个数：")
print("相加后果：%.2f"%a_plus(x, y))

#程序输入
第一个数：1.2
第二个数：1.3333
相加后果：2.53

第一个数：abc
第二个数：111
builtins.TypeError: 输出的数值谬误：abc,111

除了可能返回单个值外，函数还能一次返回多个值，在返回多个值的时候，这些值实际上是以元组的模式返回的，例如：

#!/usr/bin/env python3
def my_def(x,y,z):
    """返回多个值的函数"""
    return x,y,z

#能够应用一个变量承受这些返回值，实际上 x 就指向了一个元组
x=my_def(1,2,3)
print(x)

#也能够用多个变量别离指向元组中的单个元素
a,b,c=my_def(1,2,3)
print(a)
print(b)
print(c)

#程序输入
(1, 2, 3)
1
2
3

Ps：可能有点敌人会问，那么如果函数没有 return 语句呢？在没有 return 语句的函数执行实现后，返回一个 None。

最初给出一个二元一次方程组求解的实例：

#!/usr/bin/env python3
#coding=utf-8

import math

def quadratic(a,b,c):
    """二元一次方程组公式法求解"""
    #当传入的为一个非数值数据时，能够应用异样捕捉 try，或上面的办法抛出异样
    if not isinstance(a,(int,float)) or not isinstance(b,(int,float)) or not isinstance(c,(int,float)):
        raise TypeError("谬误的参数传入，a,b,c 只能是整数或小数：%s,%s,%s"%(a,b,c))
    #求出判别式
    disc=b**2-4*a*c
    #判别式的三种状况
    if disc<0:
        return "方程无解"
    elif disc==0:
        return "方程有惟一解："+str(-b/2*a)
    else:
        #math 模块的 sqrt() 函数用于开方
        result1=(-b+math.sqrt(disc))/2*a
        result2=(-b-math.sqrt(disc))/2*a
        return "方程两个解别离为：%s，%s"%(str(result1),str(result2))
         
print(quadratic(4,8,4))
print(quadratic(2,6,4))
print(quadratic(2,3,3))

#程序输入
方程有惟一解：-16
方程两个解别离为：-4.0，-8.0
方程无解

#如果输出一个谬误的值，就会抛出错误信息
print(quadratic("a",3,3))
TypeError: 谬误的参数传入，a,b,c 只能是整数或小数：a,3,3