5 - Python 中函数的内置函数学习：位置参数、关键字参数、默认参数、可变参数、return

一、函数

1.含义

• 把具有独立功能的代码块组织为一个小模块，在需要的时候调用
• 两个步骤:
  • 定义函数 一 封装独立的功能　　
  • 调用函数 — 享受封装的成果　　
• 提高编写的效率、代码的重用
• 让程序更小、模块化

2.小知识

• F7 和 F8：在调试时, F7(断点会进入函数体内)和F8(断点不会进入函数体内部, 会一口气执行完)
• pass：相当于空行，用来站位
• Ctrl +q 查看函数的注释信息
  • 函数调用用，鼠标在函数名处是：按Ctrl +q 查看函数的注释信息　
• Ctrl + P print(item)　　查看括号当中数据的参数　　　　

二、内置函数的学习

1.函数的定义

案例1：将字符串的左右两侧的空格清除

def str_to_strip(a_str):    # 形式参数: 形参
    """
    将字符串的左右两侧的空格清除
    :param a_str:形式参数: 形参
    :return:
    """
    print(a_str.strip())


# 调用函数
str_to_strip("     Wanting       ")  # 实际参数: 实参

# 函数只能在定义了之后,才能使用

示例2：计算两个数相乘

• 当函数执行结束之后, 会返回到函数调用处
• 函数的调用, 没有传参数, 实参
• 在调试时, F7(断点会进入函数体内)和F8(断点不会进入函数体内部, 会一口气执行完)

def multi_two_num2(first_num, second_num):    # 定义函数, 没有参数, 形参
    """
    计算两个数相乘
    :return:
    """
    result = first_num * second_num
    print("{} * {} = {}".format(first_num, second_num, result))


# 当函数执行结束之后, 会返回到函数调用处
multi_two_num2(42, 2)     # 函数的调用, 没有传参数, 实参
# 在调试时, F7(断点会进入函数体内)和F8(断点不会进入函数体内部, 会一口气执行完)
print("程序会继续往下执行!")

位置参数：位置参数, 实参与形参是一一对应的, 并且个数保持一致

def fn_hello_1(greeting, name):
    """
    greeting for somebody function
    :param greeting: 问候语
    :param name: 问候的人
    :return:
    """
    print("{}, {}!".format(greeting, name))


fn_hello_1("Hello", "三高")   # 位置参数:实参与形参是一一对应的, 并且个数保持一致

关键字参数

• name="三高":关键字参数, 不需要一一对应,按照参数名来赋值。个数要与形式参数保持一致,
• 实参才有关键字参数这种说法
• "Hello"：位置参数要放在关键字参数的前面，不能放到后面

def fn_hello_2(greeting, name, age, sex, score, height, weight):    # 7个形参
    """
    greeting for somebody function
    :param greeting: 问候语
    :param name: 问候的人
    :return:
    """
    print("{}, {}!\nage: {}".format(greeting, name, age))


fn_hello_2("Hello", name="三高", sex="不详", age=80, score=30, weight=200, height=130)   # 关键字参数

默认参数

• 如果在函数调用时, 没有传参数, 那么会使用默认参数
• 如果在函数调用时, 有传参数, 那么不会使用默认参数
• 在函数定义是, 默认参数要放在非默认参数的后面

def fn_hello_4(name, greeting="吃了吗?", punctuation="!"):     # 在函数定义是, 默认参数要放在非默认参数的后面
    """
    greeting for somebody in function4
    :param greeting: 问候语
    :param name: 问候后人
    :param punctuation: 标点
    :return:
    """
    print("{} {}{}".format(greeting, name, punctuation))


fn_hello_4("小明")                   # 如果在函数调用时, 没有传参数, 那么会使用默认参数
fn_hello_4("小明", "good morning!")   # 如果在函数调用时, 有传参数, 那么不会使用默认参数
fn_hello_4("小明", greeting="good morning!")     # 位置参数要放在关键字参数的前面，不能放到后面

可变参数 == 不定长参数、动态参数

• 在函数定义的时候, 才有可变参数的概念
• 1个* 为可变参数，只接收位置参数, 会保存到一个元祖当中："杨哲"
• 2个* 也是可变参数，只接收关键字参数, 保存到一个字典当中：time=10
• *args 在前，**kwargs 在后

def print_param_2(*args, **kwargs,):
    """
    print parameter function
    :param args: 1个* 为可变参数，将形参接收到的所有位置参数, 会保存到一个元祖中："杨哲"
    :param kwargs: 2个* 也是可变参数，把所有的关键字参数, 保存到字典当中：time=10
    :return:
    """
    print("params值为: {}\n类型为: {}".format(args, type(args)))
    print("kwargs值为: {}\n类型为: {}".format(kwargs, type(kwargs)))


print_param_2("杨哲", "幻景", "阿登", None, True, [100, 200], time=10, name="可优", age=20)

执行结果：
params值为: ('杨哲', '幻景', '阿登', None, True, [100, 200])
类型为: <class 'tuple'>
kwargs值为: {'time': 10, 'name': '可优', 'age': 20}
类型为: <class 'dict'>

return:

一个函数return之后， 那么函数体中 return 后面所有语句都不会被执行，当遇到 return，程序就会跳出函数

一个函数如果不使用return关键字来指定返回到函数调用处的值, 那么默认返回None

示例：计算任意个数的整数和

def sum_count_1(*args, **kwargs):
    """
    计算任意个数的整数和
    :param args: 接受位置参数, 保存为元祖
    :param kwargs: 接受关键字参数，保存为字典
    :return:
    """
    result = 0
    for i in args:
        result += i

    for i in kwargs.values():
        result += i

    return result   # 一个函数return之后, 那么函数体中return后面所有语句都不会被执行, 当遇到return, 程序就会跳出函数
    one_var = 10    # 不会执行


# 一个函数如果不使用return关键字来指定返回到函数调用处的值, 那么默认返回None
one_result = sum_count_1(1, 2, 3, 4, 5, 6, num1=7, num2=8, num3=9)
print(one_result)

练习题：

1.什么是函数？函数的有什么作用？

什么是函数：

• • 具有独立功能的代码块 组织为一个小模块，在需要的时候调用

函数的作用：

• • 提高编写的效率、代码的重用；
  • 让程序更小、模块化

2.函数有哪几种参数类型，分别有什么特点？

位置参数

• • 形参与实参一一对应

关键字参数

• • 为参数指定名称

默认参数

• • 为参数指定默认值
  • 将常见的值设置为参数的缺省值，从而简化函数的调用

可变参数

• • 一个函数能够处理的参数个数 是不确定的
  • 参数名前增加 一个 * 可以接收 元组
  • 参数名前增加 两个 * 可以接收 字典

3.在函数调用时，位置参数和关键字参数的顺序

• 位置参数在前，关键字参数在后

4.函数的可变参数是什么？有哪几种？为什么要使用可变参数？

• 一个函数能够处理的参数个数，是不确定的
• 参数名前增加一个 * （*args）可以接受 元祖
• 参数名前增加 两个 * （**kwargs）可以接受 字典

5.将两个变量的值进行交换(a= 100, b = 200)

a.交换之后，a = 200，b= 100

b.使用你能想到的所有方法来实现

a, b = 100, 200

# 方法一:重点
a, b = b, a

# 方法二:重点
temp = a
a = b
b = temp

# 方法三:重点
a = a + b  # a=100+200
b = a - b  # b=100+200一200
a = a - b  # a=100+200- 100

# 方法四:
a = a * b  # a=100*200
b = a // b  # b=100*200//200
a = a // b  # a=100*200//100

# 方法五:
a = a ^ b
b = a ^ b
a = a ^ b

# 方法六:
a ^= b
b ^= b
a ^= b

6.编写如下程序，输入键盘数字键(0~9)，返回数字键上方字符

• a.定义如下字典：num_str_dic = {'1': '!', '2': '@', '3': '#', '4': '$','5': '%', '6': '^', '7': '&', '8': '*', '9': '(', '0': ')'}
• b.例如：键盘输入5，程序输出%
• c.键盘输入0~9之间的数字，程序正常输出字符之后，退出程序
• d.如果输入的内容不在0~9之间，则继续提示输入

num_str_dic = {'1': '!', '2': '@', '3': '#', '4': '$','5': '%', '6': '^', '7': '&', '8': '*', '9': '(', '0': ')'}

# 方法一：
while True:     # 判断用户输入的是否为真
    user_input = input("请输入要转换的数字键(0~9): ")     # 接受为int类型
    if user_input in num_str_dic:       # 判断输入的内容是否在字典中0-9
        str_values = num_str_dic[user_input]        # 输入的是0-9之间的数，输入的值为key 去字典内获取值
        print("{} 上方的符号为 {}".format(user_input, str_values))        # 获取值后打印出来
        break
    else:       # 用户输入的为假，则提示，然后重新出入
        print("你输入的{}，不在0~9范围内！".format(user_input))


# 方法二：
user_input = input("请输入要转换的数字键(0~9): ")
while not num_str_dic.get(user_input):      # get 输入的值如果不存在返回None,not None 为真 继续执行向下执行
    # 继续执行，提示用户输入错误，重新输入
    print("你输入的{}，不在0~9范围内！".format(user_input))
    user_input = input("请输入要转换的数字键(0~9): ")
print("{} 上方的符号为 {}".format(user_input, num_str_dic[user_input]))

7.编写如下程序，从键盘输入一个用户名和密码，判断是否正确，如果正确则打印登录系统成功，否则显示用户名或密码错误。

• a.定义一个函数，接收用户输入的用户名和密码作为参数
• b.正确的账号，用户名为 lemon，密码为 best

# 方式一：简单
def login(name, pwd):
    """
    用户登录
    :param name: 用户名
    :param pwd: 密码
    :return: 
    """
    if name == "lemon" and pwd == "best":
        print("恭喜你，登录成功")
    else:
        print("用户名或尼玛不正确！")


username = input("请输入你的用户名：")
password = input("请输入你的密码：")
login(username, password)

# 方式二：
def login():
    """
    用户登录
    """
    while True:
        username = input("请输入你的用户名：")
        password = input("请输入你的密码：")
        if username == "root" and password == "1234":
            print("恭喜你，登录成功！")
        else:
            print("用户名或密码不正确！")
        option = input('y代表继续，n代表退出：')
        if option == 'y':
            continue
        elif option == 'n':
            break


login()

8.编写如下程序，将用户输入的所有数字相乘之后对20取余数

• a.用户输入的数字个数不确定
• b.用户输入的每个数字之间以逗号分隔，例如：10,1,2,13,20
• b.请使用函数来实现

def num_count(*args):
    """
    将用户输入的所有数字相乘之后对20取余数
    :param args:接收后为元祖
    :return:
    """
    num = 1
    for value in args:  # for 循环遍历
        num *= value
    print("计算结果为：{}".format(num % 20))


# 方法一：
str_num = input("请输入需要计算的数字（以逗号分隔）：")
list_num = str_num.split(",")  # 为列表，将用户输入的所有数字使用逗号进行分割
new_list_num = []
for item in list_num:
    new_list_num.append(int(item))      # 需要转化为int类型

num_count(*new_list_num)  # 调用函数，*将列表拆包，拆成位置参数的形式

# 方法二：
str_num = input("请输入需要计算的数字（以逗号分隔）: ")
list_num = str_num.split(",")  # 将用户输入的所有数字使用逗号进行分割
new_list_num = []
for item in list_num:
    item = item.strip()
    if item.replace(",", "", 1).isdigit():      # 判断是否是int类型
        new_list_num.append(float(item))
    else:
        print("输入的{}参数有误，忽略此参数的计算！".format(item))

num_count(*new_list_num)  # 调用函数，将列表拆包

9.编写如下程序，求圆的面积

• a.传入一个圆的半径，将其面积返回
• b.函数中的Π，可以导入import math，通过math.pi来获取（也可以直接使用3.14）

import math


def circle_area(r):
    """
    计算圆的面积
    :param r:
    :return:
    """
    area = math.pi * (r ** 2)  # 计算圆的面积
    area = round(area, 3)  # 四舍五入，保留三位小数
    print("半径为{}的圆，面积为{}".format(r, area))


circle_radius_str = input("请输入圆的半径：")
circle_radius_flt = float(circle_radius_str)  # 将字符串转化为浮点类型
circle_area(circle_radius_flt)

10.继续完成剪刀石头布游戏

• a.提示用户输入要出的拳 —— 石头（1）／剪刀（2）／布（3）
• b.电脑随机出拳
• c.比较胜负，显示用户胜、负还是平局
• d.使用函数来封装

import random


def game(user_player, computer_player):
    """
    定义随机出拳
    :param user_player: 用户出拳
    :param computer_player: 电脑出拳
    :return: 
    """
    # 用户胜的情况：
    # 用户出石头（1），电脑出剪刀（2）
    # 用户出剪刀（2），电脑出布（3）
    # 用户出布（3），电脑出石头（1）
    if (user_player == 1 and computer_player == 2) or \
            (user_player == 2 and computer_player == 3) or \
            (user_player == 3 and computer_player == 1):
        print("欧耶！电脑弱爆了！！！")
    elif computer_player == user_player:
        # 用户平局的情况：
        #  用户出石头（1），电脑出石头（1）
        # 用户出剪刀（2），电脑出剪刀（2）
        # 用户出布（3），电脑出布（3）
        print("心有灵犀，要不咋再来一盘！")
    else:
        print("不行，我要和你决战到天亮！")


computer = random.randint(1, 3)  # 电脑随机出拳
user = int(input("请输入你要出的拳：\n石头（1）／剪刀（2）／布（3） "))
game(user, computer)


# 方法二： 


def game(user_player, computer_player):
    # 用户胜的情况： 
    # 用户出石头（1），电脑出剪刀（2） 
    # 用户出剪刀（2），电脑出布（3） 
    # 用户出布（3），电脑出石头（1） 
    user_win_tup = ((1, 2), (2, 3), (3, 1))
    if (user_player, computer_player) in user_win_tup:
        print("欧耶！电脑弱爆了！！！")
    elif computer_player == user_player:
        print("心有灵犀，要不咋再来一盘！")
    else:
        print("不行，我要和你决战到天亮！")


computer = random.randint(1, 3)
user = int(input("请输入你要出的拳：\n石头（1）／剪刀（2）／布（3） "))
game(user, computer)

11.将用户输入的所有数字相乘之后对20取余数

• a.用户输入的数字个数不确定
• b.用户可能使用关键字参数的形式输入相乘的数字，例如：10,1,2,13,20,num1=21,num2=45等等
• c.请使用函数来实现

def num_count(*args, **kwargs):
    """
    将用户输入的所有数字相乘之后对20取余数
    :param args:
    :return:
    """
    num = 1
    for value in args:
        num *= value
    for dict_val in kwargs.values():
        num *= dict_val

    print("计算结果为：{}".format(num % 20))


def is_int_or_float(num_str):
    """
    判断是否为整数或浮点类型
    :param num_str:
    :return:
    """
    if num_str.replace(".", "", 1).isdigit():
        return True
    else:
        return False


str_num = input("请输入需要计算的数字（以逗号分隔）: ")
list_num = str_num.split(",")  # 将用户输入的所有数字使用逗号进行分割
new_list_num = []  # 定义一个空列表用于添加位置参数
new_dict_num = {}  # 定义一个空字典用于添加关键字参数
for item in list_num:
    item = item.strip()  # 清除左右空格
    if is_int_or_float(item):  # 判断是否为数字类型
        new_list_num.append(float(item))
    elif "=" in item:
        item_list = item.split("=")  # 以等号进行分割
        dict_key, dict_value = item_list  # 分开key、value
        dict_key = dict_key.strip()
        dict_value = dict_value.strip()
        if is_int_or_float(dict_value):
            new_dict_num[dict_key] = float(dict_value)
        else:
            print("输入的{}={}参数有误，忽略此参数的计 算！".format(dict_key, dict_value))
    else:
        print("输入的{}参数有误，忽略此参数的计算！".format(item))

num_count(*new_list_num, **new_dict_num)  # 调用函数，将列表拆包

*******请大家尊重原创，如要转载，请注明出处：转载自：https://www.cnblogs.com/shouhu/，谢谢！！*******