python-函数(def)参数 及参数解构 变量 知识整理
函数
python 函数
由若干语句组成的语句块、函数名称、参数列表构成,他是组织代码的最小单元
完成一定的功能
函数的作用:
结构化编程对代码的最基本的封装,一般按照功能组织一段代码
封装的目的是为了复用,减少冗余代码
代码更加简洁美观、可读易懂
函数的分类:
内建函数:如max(),reversed()等
库函数:如math.ceil()
函数 及 变量
#形参:
特点:1、不占内存空间,只有调用函数的时候传入一个值给它,它才占用内存空间。
2、而且函数运行完后形参就会被释放掉。
return 返回多个的时候,会变成一个元组
位置参数:要求函数按照顺序 一 一 对应,
关键字参数:z=1,x=2,y=3 特点:不用再考虑位置了
位置参数和关键字参数混合时原则:位置参数必须在关键字参数的左边。
默认参数:在定义的时候先配置好。
为什么要使用函数:
1.减少重复代码
2.保持一致性,易维护
3.可扩展性
![](https://img2018.cnblogs.com/blog/1541545/201905/1541545-20190520110323694-1712980583.png)
- 函数名就是标识符,命名要求一样
- 语句块必须缩进,约定4个空格
- python 的函数没有return语句,隐式会返回一个None值
- 定义中的参数列表成为形式参数,只是一种符号表达,简称形参
- 调用:
- 函数定义,只是声明了一个函数,它不会被执行,需要调用
- 调用的方式,就是函数名加上小括号,括号内写上参数
- 调用时写的参数是实际参数,是实实在在传入的值,简称实参
函数参数:
参数调用时传入的参数要和定义的个数匹配(可变参数例外)
位置参数:
def ff(x,y,z) 调用时使用 ff(1,3,5)
按照参数定义顺序传入实参
关键字参数:
def f(x,y,z) 调用使用f(x=1,z=5,y=3)
使用形参的名字来传入实参的方式,如果使用了形参的名字,那么传参顺序就可和定义顺序不同
要求:位置参数必须在关键字参数之前传入。位置参数是按位置对应的。
函数参数默认值
参数默认值:
定义时,在形参后跟上一个值,叫做默认值(缺省值)
作用:
参数的默认值 可以在未传入足够的实参的时候,对没有给定的参数赋值为默认值。
参数非常多的时候,并不需要用户每次都输入所有的参数,简化函数调用。
可变参数:
一个形参可以匹配任意个参数
1、 位置参数的可变参数:
在形参前使用* 表示该形参是可变参数,可以接收多个实参
收集多个实参为一个tuple。
注:位置可变参数不能传入keyword实参。不支持。
![](https://img2018.cnblogs.com/blog/1541545/201906/1541545-20190612154024475-1776253619.png)
2、关键字参数的可变参数:
形参前使用 ** 符号,表示可以接受 多个关键字参数
收集的实参名称和值 组成一个字典
3、keyword-only 参数 关键字参数
如果一个星号参数后,或者一个位置可变参数后, 出现的普通参数,实际上已经不是普通的参数了,而是keyword-only参数
下图报错: 可以理解为kwargs 会截获所有的关键字参数,就算你写了x=5,x也永远得不到这个值,所以语法错误。
特殊写法:
def fn(*,x,y): # * 什么意义都没有,只是让x,y 都必须为keyword-only参数。
print(x,y)
往往可变参数都会跟着默认值。
1、创建函数
def 函数名称(形式参数):
函数体
2、返回值 return
return "111"
2.1 return 什么就返回什么,没有跟数,就返回None
2.2 一旦遇到return 函数内部的 return以下代码就不再执行。
3、 执行函数
函数名(实际参数)
2.1 注:形参有即可要加几个实参,默认是按照顺序一一对应的,数量要一致
4、指定参数
在指定参数时,传入实参,可以不按照顺序,需要指定等于谁,如下图
函数可以有默认参数(有默认值得参数一定要放在参数的尾部)
callable(add)
True # 如果是True 说明add 是可调用的函数
5、动态参数一: def aa(*a) 所有的参数为一个元组,传参数的时候只能按照顺序来传
def aa(*name):
print(name,type(name))
aa(11,22,33,444)
# (11, 22, 33, 444) <class 'tuple'> # 元组,传的参数变成元组的元素了
动态参数二: def bb(**a)所有参数必须为a=xxx, b=xxx,
def bb(**name):
print(name,type(name))
bb(k1=11,k2=22,k3=33,k4=444)
# {'k2': 22, 'k1': 11, 'k3': 33, 'k4': 444} <class 'dict'> #字典 ,传的参数变成字典的元素了
动态参数三: *a 和**a的结合
如果传的是f1(11,22,33,44) 会自动识别为*a这个参数
如果传的是f1(k1=123,k2=456) 会自动识别为**a 这个参数
一般定义为:一个*就写成 *args
两个*就写成**kwargs
6、动态参数传入 列表、字典、元组
def f1(*args):
def f1(**kwargs):
## 一个星的时候
def f1(*args):
# 元组 ([11, 22, 33, 44], 123)
print(args,type(args))
li = [11,22,33,44]
tu = (22,33,44,55,66)
f1(li,123) # 不加*的将整个列表都加到参数里
# ([11, 22, 33, 44], 123) <class 'tuple'>
f1(*li,123) # 加上*后,将列表的每一个元素都放到参数里
# (11, 22, 33, 44, 123) <class 'tuple'>
f1(tu) # ((22, 33, 44, 55, 66),) <class 'tuple'>
f1(*tu) # (22, 33, 44, 55, 66) <class 'tuple'>
## 两个星的时候
def f1(**kwargs):
print(kwargs,type(kwargs))
dic = {"k1":123,"k2":456}
f1(kk=dic) # {'kk': {'k2': 456, 'k1': 123}} <class 'dict'>
f1(**dic) # {'k2': 456, 'k1': 123} <class 'dict'>
可变参数总结:
- 有 位置可变参数(*args) 和 关键字可变参数(**kwargs)
- 位置可变参数在形参前使用一个星号*
- 关键字可变参数在形参前使用两个星号**
- 位置可变参数和关键字可变参数都可以收集若干个实参,普通参数需要放到参数列表前面,位置可变参数需要在关键字可变参数之前
----------------- 参数解构 --------------------------
参数解构:
给函数提供实参的时候,可以在集合类型前使用 * 或者 ** ,把集合类型的结构解开,提取出所有元素作为函数的实参。
非字典类型使用 * 结构成位置参数
字典类型使用 ** 结构成关键字参数
提取出来的元素数目要和参数的要求匹配,也要和参数的类型匹配
参数解构和可变参数:
给函数提供实参的时候,可以在集合类型前使用 * 或者 ** ,把集合类型的结构解开,提取出所有元素作为函数的实参。
## 全局变量和局部变量
7.1 全局变量:
一般命名规则:大写
修改:global
所有人都可以使用,但是不能修改。如果要修改,请加上关键字global
7.2 局部变量:
在函数中定义的变量,只能在函数中使用
一般命名规则:小写
注:如果如果想要在局部变量修改全局变量要使用关键字:
全局变量 :global
上一级变量 :nonlocal
global使用原则;
1、外部作用域变量会在内部作用域可见,但是一般在内部作用域中直接使用,因为函数的
目的就是为了封装,尽量与外界隔离。
2、如果函数需要使用外部全局变量,请使用函数的形参传参解决
3、一句话:不要轻易使用global,这样会破坏分装。
闭包:
自由变量: 未在本地作用域中定义的变量。例如定义在内存函数外的外层函数的作用域中的变量
闭包:就是一个概念,出现在嵌套函数中,指的是内层函数引用到了外层函数的自由变量,就形成了闭包。
函数参数传递引用:
举例一:
def f2(arg):
if len(arg) > 2:
del arg[2:]
li = [11,22,33,44,55]
f2(li)
print(li)
# [11, 22]
举例二:
说明:一旦变量遇到变量遇到等号
如:name = xxx
如果xxx 是一个真实的值,那么就会在内存中去创建这个值,name 就会等于这个值。
如果xxx 是一个变量,变量就指向另一个值,
def f3(arg):
arg = 123
li = [1,2,3,4]
f3(li)
print(li)
# [1, 2, 3, 4]
前向引用: