Python函数

在Python中，函数的定义格式： 

# 定义的格式：
def 函数名（参数）:
    # 代码
    return 返回值

以上代码：

1.def 为固定格式。

2.函数名：和变量的命名方式一样，使用字母，数字，下划线组成，不能用数字开头，不能使用Python中的内置关键字。要做到见名知意。

3.参数：位置参数，动态参数（*args），默认参数，动态参数（**kwargs），定义函数的时候，可以有参数，也可以没有参数，也可以有多个参数，参数包含在小括号里面

4.小括号后面跟上一个 :

5.冒号下面的代码缩进，为函数体

6.return ：结束函数，并返回一个或者多个数据。return可不写

函数可以理解为：将一些代码封装到一个代码块儿中，来实现某些特定的功能，在使用的时候，不必重复的写代码，只需要通过函数名加括号的方式来调用。 如：

# 打印一个列表中或者元组中的每一个元素

def my_print(s):
    for i in s:
        print(i)

li = [1,2,3,4]
my_print(li)

上面代码：定义了一个函数 函数名字：my_print 这个函数用来打印列表，或者元组或者字符串中的每一个元素。在调用的时候， 使用，my_print() ，并将需要打印元素的字符串，或者列表，添加到括号里面就可以，不必每次都编写代码，来打印不同的字符串，或者列表元组。

Python中给我们准备了很多的内置函数，可以直接拿来使用就可以，但是有些函数，需要我们自己定义编写。

关于函数的参数：

1.形式参数：我们在定义函数的时候，在函数名后括号中的参数，为形式参数。可以为空，也可以定义多个参数。形参

2.实际参数：我们在调用函数的时候，实际传进去的参数，为实参

def my_print(s):
    for i in s:
        print(i)

li = [1,2,3,4]
my_print(li)

上面的代码：s 是我们在定义的时候的参数，为形参，在执行 my_print(li)  的时候，传进去的参数，li 为实参

对于实际参数：还可以有 位置参数，动态参数(*args)，默认参数，动态参数(**kwargs)，在定义的时候，也要按照前面的顺序进行定义

位置参数：按照位置进行参数的传递

# 计算一个数值的平方
def power(x):
　　return x ** 2
num = power(2)
print('num = %d' %num)

上面的代码，如果要计算 3 的平方，只要在调用函数的时候，传入一个 3 就可以，形参一个，在传入实际参数的时候也只能是一个。现在，要计算一个数的 N 次方

# 计算一个数值n次方
def power(x,n):
    return x ** n

num = power(2,3)
print('num = %d' %num)

如果我们要计算 2 的 3次方，在传入参数的时候，必须将 2 放到第一个位置，3 放到第二个位置。如果要计算 3 的 4 次方，也必须按照位置，先传入 3 再传入 4 。

这样：按照一定顺序传入的参数，叫做位置参数。

默认参数：

如果我们在计算一个数字的 N 次方的时候，计算 平方的时候比较多，如果每次都写入 power(2,2)，比较麻烦。这个时候可以使用默认参数

# 计算一个数值的n次方
def power(x,n=2): # 
    return x ** n

num = power(2)
print('num = %d' %num)

上面的代码，第一个参数没有变化，第二个参数 n=2 ，表示，这个参数是一个默认参数，在传入的时候，如果不传入实际参数，那么 默认传入一个2 ，如果指定的实参，就按照是实参传入。默认参数也叫做关键字参数。

在一个函数定义的时候，如果有位置参数，关键字参数，那么必须将位置参数放到关键字参数的前面。但是在调用的时候，可以都按照关键字参数来调用 如：

def power(x,n=2):
    return x ** n

num = power(n=3,x=4)
print('num = %d' %num)

关于关键字参数如果是可变数据类型的情况

def func(k,dic = {}):
    dic[k] = 'hello'
    print(dic)

print(func(1)) # 打印出的结果为：{1:'hello'}
print(func(2)) # 打印出的结果为：{1:'hello',2:'hello'}

如果默认参数是一个可变数据类型，如果在调用的时候，没有对默认参数进行赋值，那么，形参和实参都共同使用形参中的资源。

动态参数：使用 *args 做为形参， 按照位置传值

# 计算一系列数字的和
def my_sum(*args):
    sum = 0
    for i in args:
        sum += i
    print('args传入实参后的表现形式：',args)
    return sum
print(my_sum(1,2,3,4))

打印结果为：

args传入实参后的表现形式 (1, 2, 3, 4)
10

从结果可以看出：参数 args 接收的是一个tuple，将我们传入的参数，组成一个元组，传入 args.。如果现在有了一个元组或者是列表，我们在调用的时候，可以在实参的前面加上一个  * 号 如：

# 计算一系列数字的和
def my_sum(*args):
    sum = 0
    for i in args:
        sum += i
    #print('args传入实参后的表现形式：',args)
    return sum
li = [1,2,3,4]
print(my_sum(*li))

动态参数: **kwargs  按照关键字传值

def func(**kwargs):
    print('kwargs在传入实参后的表现形式：',kwargs)
    for k,v in kwargs.items():
        print('%s = %s'%(k,v))

func(name='jack' ,age=19, address='beijing')

打印结果

kwargs在传入实参后的表现形式： {'name': 'jack', 'age': 19, 'address': 'beijing'}
name = jack
age = 19
address = beijing

从结果中可以看到，参数使用关键字的形式传递进入后，组成一个字典，并用kwargs接收，如果有一个现有的字典，在调用函数传递字典的时候，可以在字典名前加上 ** 两个星。

关于函数的返回值：

1.没有返回值。在没有在函数最后写 return 的情况下，默认返回一个 None。如果在函数的结尾处 只写return，默认也是返回一个 None

2.返回一个数值，在return后面写上就可以了

3.返回多个值，同样在return后面写上就可以，值与值之间使用逗号隔开，但是在接收返回值的时候，可以使用一个变量来接收，也可以使用多个同返回值数量相同的变量来接收。不能多，也不能少，返回的多个值会被组织成一个元组