关于python:Python从入门到精通十一Python的函数的方方面面收藏下来保证有用

您好，我是码农飞哥，感谢您浏览本文，欢送一键三连哦 。
本文次要介绍 Python 的函数，函数的定义，应用，可变参数等等都有具体介绍。
干货满满，倡议珍藏，须要用到时常看看。小伙伴们如有问题及须要，欢送踊跃留言哦~ ~ ~。

[TOC]

前言

后面几个章节提及了好多 Python 函数，比方：print()，range()，len()函数等等。这些都是 Python 的内置函数，能够间接应用。当然，除了间接应用内置函数外，Python 也反对自定义函数，行将一段有法则的，可重复使用的代码定义成函数。从而达到一次编写，屡次调用的目标。

函数定义

函数是依照固定格局封装组织的能够重复使用的代码段。它能进步利用的模块性和代码的反复利用率。
函数定义的语法格局是：

def  函数名（参数列表）:
     代码块
    [return [返回值]]

函数名：其实就是一个合乎 Python 语法的标识符，函数名最好能体现该函数的性能，比方: save_user。
形参列表：设置该函数能够接管多少个参数，多个参数之间用逗号（,）宰割。须要留神的是没有参数的话，也须要留一对空的 ()
[return[返回值]]：整体作为函数的可选参数，用于设置该函数的返回值。也就是说，一个函数，
能够有返回值，也能够没有返回值。

函数调用

调用函数的语法格局是：

[返回值]= 函数名([形参值])

函数名即指的是要调用的函数的名称，形参值指的是当初创立函数时要求传入的各个形参的值。
如果该函数有返回值，咱们能够通过一个变量来接管该值，当然也能够不接管。须要留神的是，函数有多少个形参，那么调用的时候就须要传入多少个值 ，
且程序必须和创立函数时统一。即使该函数没有参数，函数名后的小括号也不能省略。
举个栗子吧：

def my_abs(x):
    """
    返回绝对值
    :param x:
    :return:
    """
    if not isinstance(x, (int, float)):
        raise TypeError('传入的数据类型不对')
    if x >= 0:
        return x
    else:
        return -x

调用代码是：

    x = my_abs(-3)
    print(x)
    print(my_abs.__doc__)

运行后果是：

3

    返回绝对值
    :param x:
    :return:

这是一个获取绝对值的函数，其函数名是 my_abs，通过函数名能够让人大抵明确函数的作用。形式参数是 x。通过__doc__能够查看函数的阐明文档。其返回值是解决后的值。
明天仍然是码农飞哥学习的一天。

函数值传递和援用传递（形参和实参的介绍）

介绍函数值传递和援用传递之前首先须要理解两个概念。

1. 形式参数（简称形参）：在定义函数时，函数名前面括号中的参数就是形式参数，能够将形参设想成剧本中的角色。
2. 理论参数（简称实参）：在调用函数时，函数名前面括号中的参数称为理论参数，也就是函数的调用者给函数的参数，能够将实参设想成演角色的演员。
   函数参数传递形式分为两种：别离是值传递和援用传递：
3. 值传递：实用于实参类型为不可变类型（字符串，数字，元组）
4. 援用（地址）传递：实用于实参类型为可变类型（列表，字典）
   值传递和援用传递的区别是：函数参数进行值传递时，若形参产生扭转，不会影响实参的值。而利用传递的话，扭转形参的值，实参的值也会一起扭转 。仍然是举例说明：
   函数 param_test 会将形参 obj 变成 obj+obj。如果是值传递则调用函数 param_test 之后，实参的值不变。如果是援用传递的话则调用 param_test 之后，实参的值也会变成 obj+obj。

def param_test(obj):
    obj += obj
    print('形参值为:', obj)


print('******* 值传递 *****')
a = '码农飞哥'
print('a 的值为：', a)
param_test(a)
print('实参的值为:', a)

print("******* 援用传递 *****")
b = [1, 2, 3]
print('b 的值为：', b)
param_test(b)
print('实参的值为：', b)

运行后果是：

******* 值传递 *****
a 的值为：码农飞哥
形参值为: 码农飞哥码农飞哥
实参的值为: 码农飞哥
******* 援用传递 *****
b 的值为：[1, 2, 3]
形参值为: [1, 2, 3, 1, 2, 3]
实参的值为：[1, 2, 3, 1, 2, 3]

Python 地位参数

地位参数，有时也被称为必备参数，指的是 必须依照正确的程序将实参传到函数中，换句话说，调用函数时传入实参的数量和地位必须和定义函数时保持一致。如果不统一的话，则在程序运行时 Python 解释器会报 TypeError 异样。举个例子，上面演示调用函数事参数传入的数量不对的状况。

def girth(width , height):
    return 2 * width+height
#调用函数时，必须传递 2 个参数，否则会引发谬误
print(girth(3))

运行之后间接报 Traceback 谬误。

Traceback (most recent call last):
  File "/Volumes/Develop/Python_learn/PycharmProjects/python_demo_1/demo/function/locate_fun.py", line 6, in <module>
    print(girth(3))
TypeError: girth() missing 1 required positional argument: 'height'

传入参数的地位不对的状况，本例中本想传入 name 的值为码农飞哥，age 的值为 18。后果入参程序不对导致失去的后果不对。

def print_info(name, age):
    print('姓名 =' + name + "年龄 =" + str(age))
    
print_info(18,'码农飞哥')

那么怎么解决这种状况呢？有两种形式：

1. 严格依照形参的数量和地位入参。
2. 依照关键字参数入参，所谓的关键字参数就是指应用形参的名字来确定输出的参数值。通过此形式制订函数实参时，不再须要与形参的地位完全一致，只有将参数名写正确即可。还是以下面的函数为例：
   利用关键字参数来调用函数的话则是这样写：

def print_info(name, age):
    print('姓名 =' + name + "年龄 =" + str(age))
print_info(age=18,name='码农飞哥')

运行后果是：

姓名 = 码农飞哥 年龄 =18

能够看出关键字参数入参时，不须要保障入参的程序跟形参的程序保持一致。

默认参数设置

后面介绍的地位参数，就是说调用函数时必须要传入该参数。然而有些场景下咱们并不想传入所有的参数。这种状况下就能够应用默认参数了。不过须要留神的是：指定有默认值的形式参数必须在所有没默认值的参数的最初，否则会产生语法错误。其语法格局是：

def 函数名(...，形参名，形参名 = 默认值)：代码块

上面给出一个示例，该函数是记录学生的信息，有两个有默认值的参数，别离是 age 和 city。它们都被置于函数的形参列表最初处。

def enroll(name, gender, age=6, city='Beijing'):
    print('name:', name)
    print("gender:", gender)
    print("age:", age)
    print("city:", city)

print(enroll('张三', '一年级'))
print('**************************')
print(enroll('李四', '二年级', 7))

运行后果是：

name: 张三
gender: 一年级
age: 6
city: Beijing
None
************************** 
name: 李四
gender: 二年级
age: 7
city: Beijing
None

从下面代码能够看出：1. 能够不必传入有默认值的参数。2. 如果传入默认的参数，则会笼罩掉默认值。

可变参数

Python 函数可变参数（*args,**kwargs）, 又称为不定长参数，即传入函数中的理论参数能够是任意多个，Python 定义能够变参数，次要有以下两种模式：

1. 在形参前增加一个 *，格局是*args。示意创立一个名为 args 的空元组，该元组能够承受任意多个外界传入的非关键字实参。 必须以非关键字参数的模式给一般参数传值，否则 Python 解释器会把所有参数都优先传给可变参数。
2. **kwargs示意创立一个名为 kwargs 的空字典，该字典能够承受任意多个以关键字参数赋值的实参。举个🌰，上面就是依据传入的值求和。

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n
    return sum

print(calc(10, 9))

运行的后果是：19。
再举个例子呗：

def record(str, **kwargs):
    print('str=', str)
    print('kwargs=', kwargs)


record('测试', name='码农飞哥', age=20)
record('测试 2')

运行后果是：

str= 测试
kwargs= {'age': 20, 'name': '码农飞哥'}
str= 测试 2
kwargs= {}

从下面代码能够看出，可变参数能够不必传入，不传的话则会创立一个空元组或者空字典。

逆向参数收集

Python 不仅有可变参数，将多个参数打包到一个元组或者字典中，还反对逆向参数收集，即间接将列表，元组，字典作为函数参数。不过 调用函数时要对实加入上 * 号。就像上面这样：

def param_test(name, age):
    print('name=', name)
    print('age=', age)

data = ['码农飞哥', 18]
param_test(*data)

运行后果是：

name= 码农飞哥
age= 18

return 函数返回值

一个函数能够有返回值，也能够没有返回值，有返回值的语法结构是：

return [返回值]

返回值能够指定，也能够省略不写。如果不写的话就默认为是 None，即空值。

Python 函数返回多个值的办法

通常状况下，一个函数只有一个返回值，实际上 Python 也是如此，
只不过 Python 函数能以返回列表或元组的形式，将要返回的多个值保留到序列中，从而间接实现返回多个值的目标。

1. 在函数中，提前将要返回的多个值存储到一个列表或元组中，而后函数返回该列表或元组

2. 函数间接返回多个值，之间用逗号（,）分隔，Python 会主动将多个值封装到一个元组中，其返回值仍是一个元组。上面就举例说明下：

   def multi_return():
    return_tuple = ('张三', 12)
    return return_tuple
   
   
   def multi_return2():
    return '张三', 12
   
   
   print(multi_return())
   
   result = multi_return2()
   print('multi_return2 返回值是 =, 类型是 =', result, type(result))
   

   运行后果是

('张三', 12)
multi_return2 返回值是 =, 类型是 = ('张三', 12) <class 'tuple'>

总结

本文具体介绍了 Python 中的函数，从函数的定义说到函数的调用。重点介绍了形参和实参的相干知识点。总的来说 Python 的函数能够没有入参，能够没有返回值。能够传入可变参数。当传入的参数是不可变类型时则是值传递，当传入的参数是可变类型时则是援用传递。

我是码农飞哥，再次感谢您读完本文 。
全网同名【码农飞哥】。不积跬步，无以至千里，享受分享的高兴
我是码农飞哥，再次感谢您读完本文。