Skip to content
SRE运维进阶之路SRE运维进阶之路
github icon
    • 1 Python 简介

      • 1.1 初识Python
        • 1.2 Python 代码规范
          • 1.3 Python 虚拟环境
            • 1.4 使用 vscode 打造 python 开发环境
              • 1.5 pypi 配置国内镜像
              • 2 Python 基础

                • 2.1 Python基础语法
                  • 2.2 程序控制
                    • 2.3 Python数据类型

                      • 2.3.1 数值型
                        • 2.3.2 字符串 str
                          • 2.3.3 字节序列
                            • 2.3.4 列表 list & 元组 tuple
                              • 2.3.5 集合 set & 字典 dict
                            • 3 高级特性

                              • 3.1 线性结构特征 可迭代 & 切片
                                • 3.2 列表、集合、字典解析式
                                  • 3.3 生成器
                                    • 3.4 迭代器
                                    • 4 函数

                                      • 4.1 函数的定义 & 调用 & 返回值
                                        • 4.2 函数参数
                                          • 实参传参方式
                                            • 形参
                                              • 形参缺省值
                                                • 可变参数
                                                  • keyword-only参数
                                                    • positional-only参数
                                                      • 参数规则
                                                        • 参数解构
                                                      • 4.3 作用域
                                                        • 4.4 递归函数
                                                        • 5 函数式编程

                                                          • 5.1 高阶函数
                                                            • 5.2 返回函数
                                                              • 5.3 匿名函数
                                                                • 5.4 装饰器
                                                                  • 5.5 偏函数
                                                                  • 6 模块

                                                                    • 6.1 Python 模块常用的几种安装方式
                                                                      • 6.2 Python 的 setup.py 详解
                                                                      • 7 IO编程

                                                                        • 7.1 操作文件和目录
                                                                          • 7.2 序列化和反序列化
                                                                          • 8 异常、调试和测试

                                                                            • 8.1 异常处理
                                                                            • 9 面向对象编程

                                                                              • 9.1 类、实例和封装
                                                                                • 9.2 访问控制和属性装饰器
                                                                                  • 9.3 继承、多态和Mixin
                                                                                  • 10 进程和线程

                                                                                    • 10.1 多进程
                                                                                      • 10.2 多线程
                                                                                        • 10.2 线程同步
                                                                                        • 11 网络编程

                                                                                          • 11.1 SocketServer
                                                                                            • 11.2 TCP 编程
                                                                                            • 11 魔术方法
                                                                                              • 17 IO 模型
                                                                                                • python 实际工作中的实例
                                                                                                • 前端学习笔记

                                                                                                  4.2 函数参数

                                                                                                  author iconClaycalendar icon2021年6月9日category icon
                                                                                                  • Python
                                                                                                  timer icon大约 4 分钟

                                                                                                  此页内容
                                                                                                  • 实参传参方式
                                                                                                  • 形参
                                                                                                    • 形参缺省值
                                                                                                    • 可变参数
                                                                                                    • keyword-only参数
                                                                                                    • positional-only参数
                                                                                                    • 参数规则
                                                                                                    • 参数解构

                                                                                                  # 4.2 函数参数

                                                                                                  函数在定义是要定义好形式参数,调用时也提供足够的实际参数,一般来说,形参和实参个数要一致(可变参数除外)。

                                                                                                  # 实参传参方式

                                                                                                  1、位置传参

                                                                                                  定义时def f(x, y, z), 调用使用 f(1, 3, 5),按照参数定义顺序传入实参

                                                                                                  2、关键字传参

                                                                                                  定义时def f(x, y, z),调用使用 f(x=1, y=3, z=5),使用形参的名字来传入实参的方式,如果使用了形参名字,那么传参顺序就可和定义顺序不同

                                                                                                  要求位置参数必须在关键字参数之前传入,位置参数是按位置对应的

                                                                                                  切记:传参指的是调用时传入实参,就2种方式。

                                                                                                  下面讲的都是形参定义。

                                                                                                  # 形参

                                                                                                  # 形参缺省值

                                                                                                  缺省值也称为默认值,可以在函数定义时,为形参增加一个缺省值。其作用:

                                                                                                  • 参数的默认值可以在未传入足够的实参的时候,对没有给定的参数赋值为默认值
                                                                                                  • 参数非常多的时候,并不需要用户每次都输入所有的参数,简化函数调用

                                                                                                  # 可变参数

                                                                                                  需求:写一个函数,可以对多个数累加求和

                                                                                                  def sum(iterable):
                                                                                                  	s = 0
                                                                                                  	for x in iterable:
                                                                                                  		s += x
                                                                                                  	return s
                                                                                                  
                                                                                                  print(sum([1,3,5]))
                                                                                                  print(sum(range(4)))
                                                                                                  
                                                                                                  1
                                                                                                  2
                                                                                                  3
                                                                                                  4
                                                                                                  5
                                                                                                  6
                                                                                                  7
                                                                                                  8

                                                                                                  上例,传入可迭代对象,并累加每一个元素。

                                                                                                  也可以使用可变参数完成上面的函数。

                                                                                                  def sum(*nums):
                                                                                                  	sum = 0
                                                                                                  	for x in nums:
                                                                                                  		sum += x
                                                                                                  	return sum
                                                                                                  
                                                                                                  print(sum(1, 3, 5))
                                                                                                  print(sum(1, 2, 3))
                                                                                                  
                                                                                                  1
                                                                                                  2
                                                                                                  3
                                                                                                  4
                                                                                                  5
                                                                                                  6
                                                                                                  7
                                                                                                  8

                                                                                                  1、可变位置参数

                                                                                                  • 在形参前使用 * 表示该形参是可变位置参数,可以接受多个实参
                                                                                                  • 它将收集来的实参组织到一个 tuple 中

                                                                                                  2、可变关键字参数

                                                                                                  • 在形参前使用 ** 表示该形参是可变关键字参数,可以接受多个关键字参数
                                                                                                  • 它将收集来的实参的名称和值,组织到一个dict中

                                                                                                  总结:

                                                                                                  • 有可变位置参数和可变关键字参数
                                                                                                  • 可变位置参数在形参前使用一个星号*
                                                                                                  • 可变关键字参数在形参前使用两个星号**
                                                                                                  • 可变位置参数和可变关键字参数都可以收集若干个实参,可变位置参数收集形成一个tuple,可变关键字参数收集形成一个dict
                                                                                                  • 混合使用参数的时候,普通参数需要放到参数列表前面,可变参数要放到参数列表的后面,可变位置参数需要在可变关键字参数之前

                                                                                                  # keyword-only参数

                                                                                                  在Python3之后,新增了keyword-only参数。

                                                                                                  keyword-only参数:在形参定义时,在一个*星号之后,或一个可变位置参数之后,出现的普通参数,就已经不是普通的参数了,称为keyword-only参数。

                                                                                                  keyword-only参数,言下之意就是这个参数必须采用关键字传参。

                                                                                                  # positional-only参数

                                                                                                  Python 3.8 开始,增加了最后一种形参类型的定义:Positional-only参数。(2019年10月发布3.8.0)

                                                                                                  def fn(a, /):
                                                                                                  	print(a, sep='\n')
                                                                                                  fn(3)
                                                                                                  fn(a=4) # 错误,仅位置参数,不可以使用关键字传参
                                                                                                  
                                                                                                  1
                                                                                                  2
                                                                                                  3
                                                                                                  4

                                                                                                  # 参数规则

                                                                                                  参数列表参数一般顺序是:positional-only参数、普通参数、缺省参数、可变位置参数、keyword-only参数(可带缺省值)、可变关键字参数。 注意:

                                                                                                  • 代码应该易读易懂,而不是为难别人
                                                                                                  • 请按照书写习惯定义函数参数
                                                                                                  • 定义最常用参数为普通参数,可不提供缺省值,必须由用户提供。注意这些参数的顺序,最常用的先定义
                                                                                                  • 将必须使用名称的才能使用的参数,定义为keyword-only参数,要求必须使用关键字传参
                                                                                                  • 如果函数有很多参数,无法逐一定义,可使用可变参数。如果需要知道这些参数的意义,则使用可变关键字参数收集

                                                                                                  # 参数解构

                                                                                                  参数解构:

                                                                                                  • 在给函数提供实参的时候,可以在可迭代对象前使用 * 或者 ** 来进行结构的解构,提取出其中所有元素作为函数的实参
                                                                                                  • 使用 * 解构成位置传参
                                                                                                  • 使用 ** 解构成关键字传参
                                                                                                  • 提取出来的元素数目要和参数的要求匹配
                                                                                                  edit icon编辑此页open in new window
                                                                                                  上次编辑于: 2021/6/23 03:40:27
                                                                                                  贡献者: clay-wangzhi
                                                                                                  上一页
                                                                                                  4.1 函数的定义 & 调用 & 返回值
                                                                                                  下一页
                                                                                                  4.3 作用域
                                                                                                  备案号:冀ICP备2021007336号
                                                                                                  Copyright © 2022 Clay