4.1 Python3 进阶 - 函数

>>返回主目录

源码

# 函数返回值：return语句
# 没有return的函数
def print_str():
    print('没有返回值，仅执行函数内代码块')


# 有return但无表达式的函数
def print_str_return():
    print('没有返回值，仅执行函数内代码块')
    return


# 有return且返回一个表达式的函数
def sum_number():
    a1, b1 = 1, 2
    total = a1 + b1
    return total


# 有return且返回多个表达式的函数
def get_fruits():
    apple = "Apple"
    banana = "Banana"
    orange = "Orange"
    return apple, banana, orange

源码

# 函数调用
# 带有返回值的函数调用。通常将函数调用结果作为一个值处理
print_test = sum_number()
print('函数sum_number的返回值是：', print_test)

# 没有返回值的函数调用。通常将函数调用作为一条语句来处理
print_str()
print('函数print_str的返回值是：', print_str())

源码

# 函数参数：限定位置参数
def fun1(a2, b2,  /):
    print(a2, b2)
fun1(1, 2)
# 调用时不允许使用关键字参数进行调用，例如：
# 错误：
# fun1(1, b2=2)

源码

# 函数参数：位置参数
def sum_two_numbers(number_a, number_b):
    total = number_a + number_b
    return total


sum_total_1 = sum_two_numbers(3, 5)
print('任意两个数的和是：', sum_total_1)

源码

# 函数参数：关键字参数
# 与上个函数相同，可直接使用
def sum_two_numbers(number_a, number_b):
    total = number_a + number_b
    return total


sum_total_2 = sum_two_numbers(number_b=3, number_a=6)
print('任意两个数的和是：', sum_total_2)

源码

# 函数参数：可变参数（*参数名）
def add_test(a3, *args):
    print(f'a的值是：{a3}')
    print(f'args的值是：{args}')
    result = 0
    for x in args:
        result += x
    print('累加结果是：', result)
    return result


# 请大家思考以下函数调用结果：
# add_test(3)
# add_test(3, 2, 5, 99, 22)
# add_test([1, 3, 5])
# add_test(*(1, 3, 5))
# add_test(6, [1, 3, 5])
# add_test(6, *[1, 3, 5])
# add_test(6, 7, [1, 3, 5])
# add_test(6, 7, *[1, 3, 5], 8)
add_test(*[1, 3, 5], 8)

源码

# 函数参数：关键字可变参数（**参数名）
def average_score(*args, **kwargs):
    print('args is:', args)
    print('kwargs is:', kwargs)
    result = 0
    for key, value in kwargs.items():
        result += value
        print(f'{key}: {value}')
    result = result / len(kwargs)
    print("Average score is ", result)
    return result


# 请大家思考以下函数调用结果：
# average_score()
# average_score(Lili=100, Lucy=95, Poly=80)
# average_score(**{'Lili': 90, 'Lucy': 100, 'Poly': 70})
average_score(1, 2, **{'Lili': 90, 'Lucy': 100, 'Poly': 70})

源码

# 函数参数：序列解包参数练习
# 练习：回答函数输出结果
str_1 = 'test'
list_1 = ['Python', 'Java']
dict_1 = {'a': 1, 'b': 2, 'c': 3}
dict_2 = {**{'d': 5}}  # 实际就是{'d': 5}


def parameter_test(*args, **kwargs):
    print('parameter_test args is:', args)
    print('parameter_test kwargs is:', kwargs)


# parameter_test(str_1)
# parameter_test(*str_1)
# parameter_test(*list_1)
# parameter_test(dict_1)
# parameter_test(*dict_1)
# parameter_test(**dict_1)
# parameter_test(dict_2)
# parameter_test(**dict_2)
# parameter_test(*list_1, dict_1, d=5)
parameter_test(*list_1, d=6, **dict_1, e=7)

源码

# 函数参数：命名（限定）关键字参数
# 这里*号分割符后面的city、job是命名关键字参数
def person_info(name, age, *, city, job):
    print(name, age, city, job)


person_info('Portos', 18, city='ShenZhen', job='Engineer')


# 例外：如果参数中已经有一个可变参数的话，前面讲的星号分割符就不要写了
# args是变长参数，而city和job是命名关键字参数
def person_info(name, age, *args, city, job):
    print(name, age, args, city, job)


person_info('Portos', 18, city='ShenZhen', job='Coder')

源码

# 函数参数：多种类型参数混用
dct1 = {'kw1': 0, 'kw2': 2}
dct2 = {'n': 3, 'kw3': 5, 'kw4': 6}
def func_1(a4, b4, c4, /, m, n=7, *, kw1, kw2, kw3, **kwargs):
    print(f'a={a4}, b={b4}, c={c4}, m={m}, n={n}, kw1={kw1}, kw2={kw2}, kw3={kw3}, kwargs={kwargs}')
func_1(1, *(2, 3, 4), **dct1, **dct2)  # 调用函数

源码

# 实参：不可变类型和可变类型
def double_1(x):
    print('double_1函数内部变量x的地址：', id(x))
    x = x * 2
    print('函数内部的值', x)
    print('double_1函数内部修改x值后的地址：', id(x))


a5 = 50
print('调用函数前实参a5的地址：', id(a5))
double_1(a5)
print('调用函数后实参a5的值是：', a5)


# 对于可变类型实参，例如列表、字典、集合等，函数调用时，传递的是实参所指对象，此时形参和实参指向同一对象，函数内部对形参的修改，可能会影响到实参，例如：
def double_2(x):
    print('double_2函数内部变量x的地址：', id(x))
    x[1] = x[1] * 2
    print('函数内部的值', x)
    print('double_2函数内部修改x值后的地址', id(x))

b5 = [1, 2, 3]
print('调用函数前实参b5的地址：', id(b5))
# double_1(b5)  # 实参变量值不变
double_2(b5)  # 实参变量值改变
print('调用函数前实参b5的地址用函数后实参b5的地址：', id(b5))

源码

# 文档字符串：函数说明
def day_learn_python(day, plan, *learn_time, state='finished', **learn_content):
    """
    :param day: 固定参数，定义当天日期
    :param plan: 固定参数，表示当天是否学习python
    :param learn_time: 不定长参数，每天学习的时间 learn_time 离散的数字 每一个数字对应学习的内容
    :param state: 默认参数，学习计划是否完成，对应默认的参数为“finished”，如果输入参数“unfinished”
    :param learn_content: 关键字可变参数，每天学习的内容不定
    :return:返回当天日志，以及完成的情况
    """
    datetime = 0
    for time in learn_time:
        datetime = int(time) + datetime
    print(f'''
    learn day : {day},
    is learn python today: {plan},
    is plan finished : {state},
    daily learn time : {datetime},
    other : {learn_content}
    ''')
    return day, state


day1, state1 = day_learn_python('20210520', 'learn python', 1, 2, state='finished', learn_content1='python function',
                                learn_content2='python class')
day2, state2 = day_learn_python('20210521', 'learn python', 2, 3, learn_content1='python list',
                                learn_content2='python tuple')
print(f'日志信息如下，日期：{day1}，完成情况：{state1}')
print(f'日志信息如下，日期：{day2}，完成情况：{state2}')

>>返回主目录