Python 函数

函数：完成某一功能

完成某一种功能的代码块

如何自己定义一个函数：

def(定义：define)

语法：

def function_name(arguments):

statement1

statement2

statement3

return value

1.使用关键字def

2.function_name:一般是小写，如果包含多个单词，使用_连接

3.(arguments):可以没有，也可以有(一个或者多个)

4.返回值：return

a.return 可以返回一个值，也可以返回多个值；如果返回多个值，用逗号隔开

b.执行了return,return之后的语句不再执行，直接跳出函数

c.需要有返回值的，使用return;如果不需要返回的，就不写

上边是定义了一个函数：定义一个函数不代表去执行这个函数；用函数之前肯定是要先定义的

执行函数/调用函数：

function_name(传入的参数)

def print_123():     # print_123是函数名
    print("123,23254,grt")


print_123()

data = 2
data1 = data

function_name = print_123
function_name()

print(print_123, type(print_123))

print("*" * 80)


def function_return_multi():
    print(123)
    return 1, 2, 3


def function_return_single():
    print(123)
    return 1


# result = function_return_multi()
# print(result, type(result))
data1, data2, data3 = function_return_multi()
print(data1, data2, data3)     # => data1, data2, data3 = (1, 2, 3)

result = function_return_single()
print(result, type(result))

print("*" * 80)


# a = 1
# b = 2
# a, b = b, a
# (a, b) = (b, a)
# a, b = (b, a)  # => (b, a) => b, a
# a, b = b, a

函数的参数：

什么是形参：形式参数

在定义函数阶段，定义的函数的参数，这里边参数叫做参数

什么是实参：实际参数

再调用阶段传入的实际参数，叫实参

在函数参数里面，等号两边不加空格

# def print_arg(arg1):
#    print(arg1)
    
    
# print_arg(1)


def print_arg2(arg1=2):  # arg1 = 2
    print(arg1)


print_arg2(1)  # arg1 = 1

def function_return_multi():
    print(123)
    return 1, 2, 3


def function_return_single():
    print(123)
    return 1


# result = function_return_multi()
# print(result, type(result))
data1, data2, data3 = function_return_multi()
print(data1, data2, data3)     # => data1, data2, data3 = (1, 2, 3)

result = function_return_single()
print(result, type(result))

1.如果参数有默认值， 那么这个参数可以传，也可以不传

2.默认值的参数必须非默认值参数之后

位置参数：没有默认值的参数

关键字参数：有默认值的参数

传参的方式：

以位置参数的方式去传参：根据参数的顺序去匹配

以关键字参数的方式去传参：第一个关键字之后的必须都是关键字参数传参

关键字传参是根据key去查找,不在乎顺序

形参定义的时候都是位置参数，传参的时候可以以位置参数也可以以关键字参数去传参

形参定义的时候是关键字参数，传参的时候可以以位置参数也可以以关键字参数传参

# a = 1
# b = 2
# a, b = b, a
# (a, b) = (b, a)
# a, b = (b, a)  # => (b, a) => b, a
# a, b = b, a

# def print_arg(arg1):
#     print(arg1)
#
#
# print_arg(1)


def print_arg2(arg1=2):  # arg1 = 2
    print(arg1)


print_arg2(1)  # arg1 = 1
print_arg2()
print("*" * 80)


def print_arg3(arg1, arg2):
    print(arg1, arg2)


print_arg3(1, 2)
print_arg3(1, arg2=2)
print_arg3(arg1=1, arg2=2)


def print_arg4(arg2, arg1=3):
    print(arg1, arg2)
# print_arg4(arg1=3, arg2) 【×】 non_default parameters follows default parameters 默认值参数应该放在非默认值之后


def print_arg5(arg1, arg2, arg3):
    print(arg1, arg2, arg3)

print_arg5(1, 2, 3)
print_arg5(1, arg2=2, arg3=3)
# print_arg5(1, arg2=2, 3) 【×】 positional argument after keyword argument 关键字参数之后，必须都是关键字参数
print_arg5(1, arg3=3, arg2=2)
print_arg5(arg1=1, arg2=2, arg3=3)


def print_arg6(arg1=1, arg2=2, arg3=3):
    print(arg1, arg2, arg3)

print_arg6(4, 5, 6)
print_arg6(4, arg2=5, arg3=6)
print_arg6(arg1=4, arg3=6, arg2=5)

特殊的参数：

args : arguments一个或多个位置参数

  : 但传入多个值得时候，args代表多个值

    会把多个值打包成一个元组 args=这个元组

kwargs ：keyword argument一个或多个关键字参数

当传入多个关键字参数 kwargs，会把多个关键字参数打包成一个字典

注意： *args, kwargs,只是解释器给我们提供的一个建议名称

如果把一个函数定义成 def function_name(args, **kwargs):

有什么作用： 再不确定参数个数的情况下，可以使用这种方式 Python函数中的参数未确定类型

def print_args7(arg1, *args):
    print(arg1, *args)
    # print(type(*args))
    print(args, type(args))


print_args7(1, 2, 3, 4, 5, 6)


def print_arg8(arg1, arg2, *args, **kwargs):
    print(arg1, arg2, *args)
    print(kwargs, type(kwargs))


print_arg8(1, 2, 3, 4, 5, 6, value=10, vlue2=11, value3=12)