Python函数

Python内建函数

函数

数学定义

• y=f(x),y是x的函数，x是自变量。y=f(x0，x1，，，xn)

python函数

• 有若干语句组成的语句块、函数名称、参数列表构成，它是组织代码的最小单元
• 完成一定的功能

函数的作用

• 结构化编程对代码的最基本的封装，一般按照功能组织一段代码
• 封装的目的为了复用，减少冗余代码
• 代码更加简介美观、可读易懂

函数的分类

• 内减函数，如max() reversed()等
• 库函数、如math.ceil()等
• 自定义函数，使用def关键自定义

函数定义

def 函数名(形参):
    函数体(代码块)
    [return 返回值]

• 函数名就是标识符，命名要求一样
• 语句块必须缩颈，约定4个空格
• Python的函数若没有return语句，会隐式返回一个None值
• 定义中的参数列表称为形式参数，只是一种符号表达（标识符），简称形参

函数调用

• 函数定义，只是声明了一个函数，它不能被执行，需要调用执行
• 调用的方式，就是函数名后加上小括号，如有必要在括号内填上参数
• 调用时写的参数就是实际参数，是实实在在传入的值，简称实参

def add(x,y): #函数定义
    result = x + y #函数体
    return result #返回值
out = add(5,6)  #函数调用，可能有返回值，使用变量接受这个返回值
print(out) #print；函数加上括号也是调用
11  #打印到屏幕上的值

上面代码解释：

• 定义一个函数add，及函数名是add，接受2个参数
• 该函数计算的结果，通过返回值返回，需要return语句
• 代用时，通过函数名add后加2个参数，返回值可使用变量接收
• 函数名也是标识符，返回值也是值
• 定义需要在调用前，也就是说调用时，已经被定义过了，否则抛NameError异常
• 函数是可调用对象，callable()

函数参数:

函数在定义是要约定好形式参数，调用时也提供足够的实际参数，一般来说，形参和实参个数要一直(可变参数除外）。

传参方式

1、位置传参
定义时def f(x,y,z)，调用使用（1,3,5），按照参数定义顺序传入实参

2、关键字参数
定义是def f(x,y，z)，调用使用f(x=1,y=3,z=5),使用形参的名字来传入实参的方式，如果使用了形参名字，那么传入参数顺序就可以和定义的顺序不同

要求位置参数必须在关键字参数之前传入，位置参数是按位置对应的

def f(x,y,z):
    pass
f(y=5,z=6,2)#这个输入属于错误的

参数缺省值

缺省值也成为默认值，可以在函数定义时，为形参增加一个缺省值，其作用：

• 参数的模拟任职可以在为传入足够的参数的时候，对没有给定的参数赋值为默认值
• 参数非常多的时候，并不需要用户没出都输入所有的参数，简化函数调用

def f(x=5,y=6,z=9):
    return x+y+z
f(6)

可变参数

需求：写一个函数，可以对多个数累加求和

def sum_(iterable):
    sum_ = 0
    for x in iterable:
        sum +=x
    return sum
print(sum([1,3,45]))
49
print(sum(range(4)))
6

• 使用可变参数方法：

def sum_(*nums):
    sum_ = 0
    for x in nums:
        sum += x
    return sum
print(sum(1,2,3))
6

1、可变位置参数

• 在形参前使用*表示该形参是可变位置参数，可以接受多个实参
• 它将手机来的实参组织到一个tuple中

2、可变关键字参数

• 在形参前使用**表示该形参是可变关键字参数，可以接受多个关键字参数
• 它将收集来的实参的名称和值，组织到一个dict中

总结：

• 有可变参数和可变关键字参数
• 可变位置参数在形参钱使用两个**
• 可变关键字参数在形参钱使用两个型号**
• 可变位置参数和可变关键字参数都可以手机若干个实参，可变位置参数手机形成一个tuple，可变关键字参数手机形成一个dict
• 混合使用参数的时候，普通参数需要放到参数列表前面，可变参数要放到参数列表的后面，可变位置参数需要在可变关键字参数之前

def fn(x,y,*args,**kwargs):
    print(x,y,args,kwargs,sep='\n',end='\n\n')
    
fn(3,5,7,9,10,a=1,b='abc')
3
5
(7, 9, 10)
{'a': 1, 'b': 'abc'}
-----------------------------
fn(4,5)
4
5
()
{}
-----------------------------
fn(3,4,b='c',a='b ')
3
4
()
{'b': 'c', 'a': 'b '}
--------------------------------
fn(7,9,y=5,x=3,a=1,b='abc') #因为普通参数已经将9传给了位置形参y，后面的位置参数又将普通参数传给y所以不可以多次赋值
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-5-907a91eb40b4> in <module>
----> 1 fn(7,9,y=5,x=3,a=1,b='abc')

TypeError: fn() got multiple values for argument 'y'
------------------------------------
fn(x=3,y=4,4,5)  #位置参数要写在关键字参数之前
  File "<ipython-input-6-265139d8e74d>", line 1
    fn(x=3,y=4,4,5)
              ^
SyntaxError: positional argument follows keyword argument

keyword-only参数

在python3之后，新增了keywrod-only参数
keyword-only参数；在形参定义是，在一个*星号之后，或一个可变位置参数之后，出现的普通参数，就已经不是普通的参数了，称为keyword-only参数。

def fn(**kwargs,x):
    print(x,kwargs,sep='\n',end='\n\n')
    
  File "<ipython-input-10-2e6c8509b5e8>", line 1
    def fn(**kwargs,x):
                    ^
SyntaxError: invalid syntax
keyword-only不能写在可变关键字之后因为都会被可变关键字参数所截断。这种语法不存在

keyword-only参数另一种形式
*星号后所有的通参数都成了keyword-only参数

参数的混合使用

def fn(*args,x=5):
    print(x)
    print(args)
fn()
5
()
--------------------------
fn(5)
5
(5,)
--------------------------
fn(x=6)
6
()
----------------------------
fn(1,2,3,x=10)
10
(1, 2, 3)

def fn(y,*args,x=5):
    print('x={},y={}'.format(x,y))
    print(args)
fn() #不传入参数报错，因为普通参数没有接收到形参接收到的值，所以报错
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-16-945456d3fdd9> in <module>
      2     print('x={},y={}'.format(x,y))
      3     print(args)
----> 4 fn()
      5 

TypeError: fn() missing 1 required positional argument: 'y'
        
-------------------------------------------------------------
fn(5,6)
x=5,y=5
(6,)
-----------------------------------
fn(1,2,y=3,x=10) #y不可以接受多个值，y已经接收到了1
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-19-ca712b8f6fdb> in <module>
----> 1 fn(1,2,y=3,x=10)

TypeError: fn() got multiple values for argument 'y' 

参数规则

参数列表参数一般顺序是：普通参数、缺省参数、可变位置参数、keyword-only参数（可带缺省值）、可变关键字参数。

def connect(host='localhost',port='3306',user='admin',password='admin',**kwargs):
    print(host,port)
    print(user,password)
    print(kwargs)
    
connect(db='cmdb')
localhost 3306
admin admin
{'db': 'cmdb'}
--------------------------------------------
connect(host='192.168.1.123',db='cmdb')
192.168.1.123 3306
admin admin
{'db': 'cmdb'}
-----------------------------------------
connect(host='192.168.1.123',db='cmdb',password='mysql')
192.168.1.123 3306
admin mysql
{'db': 'cmdb'}

注意：

• 代码应该易读易懂

• 按照书写规范传参数

• 定义最常用参数普通参数，可不提供缺省值，必须由用户提供，注意这些参数的顺序，最常用的先定义

• 将必须使用名称的才能使用的参数，定义为keyword-only参数，要求必须使用关键字传参

• 如果函数有很多函数，无法逐一定义，可使用可变参数，如果需要知道这些参数的意义，则使用可变关键字参数收集。

参数解构

def add(x,y):
    return x+y
--------------------------------------------
add(4,5)
9
--------------------------------------------
add((4,5))
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-11-38eece99e0be> in <module>
----> 1 add((4,5))
      2 

TypeError: add() missing 1 required positional argument: 'y'
--------------------------------------------------
t =4,5
add(t[0],t[1])
9
---------------------------------
add(*(4,5))
9
----------------------------------
add(*range(4,6))
9
--------------------------------------------------------
add(*{'a':10,'b':11})  #遇到字典一个*的时候按照keys来处理
'ab'
--------------------------------------------------------
add(**{'a':10,'b':11})  #使用两个**时候表示使用关键字传参，而形参的关键字为x和y
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-19-c73998831612> in <module>
----> 1 add(**{'a':10,'b':11})

TypeError: add() got an unexpected keyword argument 'a'
---------------------------------------------------------
add(**{'y':10,'x':11})  
21

参数解构：

• 在给函数提供实参的时候，可以在可迭代对象钱使用*或者**来进行解构的时候，提取出其中所有元素作为函数的实参
• *解构成为位置传参
• 使用**解构成关键字传参
• 提取出来的元素数目要和参数的要求匹配

def add(*iterable):
        result = 0
        for i in iterable:
            result += i
        return result
--------------------------------
    add(*[1,2,3])
6
---------------------------------
add(*range(8))
28