python 函数基础
函数基础
函数定义
先定义后调用
定义函数发生的事情
1、申请内存空间保存函数体代码
2、将上述内存地址绑定函数名
3、定义函数不会执行函数体代码，但是会检测函数体语法
调用函数发生的事情
1、通过函数名找到函数的内存地址
2、然后加括号就是在触发函数体代码的执行
print(func)
func()
1.定义的语法
def 函数名(参数1,参数2,...):
"""文档描述"""
函数体
return 值
形式一：无参函数
def func():
# x 定义函数不会执行函数体代码，但是会检测函数体语法
# print(
print('哈哈哈')
无参函数的应用场景
def interactive():
name=input('username>>: ')
age=input('age>>: ')
gender=input('gender>>: ')
msg='名字：{} 年龄：{} 性别'.format(name,age,gender)
print(msg)
interactive()
interactive()
interactive()
interactive()
形式二：有参函数
def func(x,y): # x=1 y=2
print(x,y)
func(1,2)
有参函数的应用场景：可以输入参数灵活性更高
def add(x,y): # 参数-》原材料
# x=20
# y=30
res=x + y
# print(res)
return res # 返回值-》产品
res=add(20,30)
print(res)
形式三：空函数,函数体代码为pass
def func(x, y):
pass
空函数的应用场景：程序结构的构思
函数调用
直接调用
interactive()
add(1,2)
用于表达式
def add(x,y): # 参数-》原材料
res=x + y
return res # 返回值-》产品
#赋值表达式
res=add(1,2)
print(res)
#数学表达式
res=add(1,2)*10
print(res)
用于参数
res=add(add(1,2),10)
print(res)
函数返回值
return是函数结束的标志，即函数体代码一旦运行到return会立刻
终止函数的运行，并且会将return后的值当做本次运行的结果返回：
1,返回None：函数体内没有return
return
return None
2、返回一个值：return 值
def func():
return 10
res=func()
print(res)
3、返回多个值：用逗号分隔开多个值，会被return返回成元组
def func():
return 10, 'aa', [1, 2]
res = func()
print(res, type(res))
函数参数
形参实参介绍
函数的参数分为形式参数和实际参数，简称形参和实参：
形参即在定义函数时，括号内声明的参数。形参本质就是一个变量名，用来接收外部传来的值。
实参即在调用函数时，括号内传入的值，值可以是常量、变量、表达式或三者的组合:
形参实参使用
按照从左到右的顺序依次定义的参数称之为位置参数
位置参数
-
位置形参：在函数定义阶段，按照从左到右的顺序直接定义的"变量名"，必须被传值，多一个不行少一个也不行
-
位置实参：在函数调用阶段， 按照从左到有的顺序依次传入的值，按照顺序与形参一一对应
关键字参数
关键字实参：在函数调用阶段，按照key=value的形式传入的值,指名道姓给某个形参传值，可以完全不参照顺序
def func(x,y):
print(x,y)
func(y=2,x=1)
func(1,2)
混合使用
1、位置实参必须放在关键字实参前
func(1,y=2)
2、不能能为同一个形参重复传值
默认参数
在定义函数时，就已经为形参赋值，这类形参称之为默认参数，当函数有多个参数时，需要将值经常改变的参数定义成位置参数，
而将值改变较少的参数定义成默认参数。
def register(name,age,sex='male'): #默认sex的值为male
print('Name:%s Age:%s Sex:%s' %(name,age,sex))
定义时就已经为参数sex赋值，意味着调用时可以不对sex赋值，这降低了函数调用的复杂度,也可以修改。
register('tom',17) #大多数情况,无需为sex传值,默认为male
Name:tom Age:17 Sex:male
register('Lili',18,'female') #少数情况,可以为sex传值female
Name:Lili Age:18 Sex:female
需要注意：
1、默认参数必须在位置参数之后
2、默认参数的值仅在函数定义阶段被赋值一次，准确的说是内存地址。（可变类型与不可变类型的区别）
示范1：不可变类型
m=2
def func(x,y=m): # y=>2的内存地址
print(x,y)
m=3333333333333333333
func(1)
示范2：可变类型
m = [111111, ]
def func(x, y=m): # y=>[111111, ]的内存地址
print(x, y)
m.append(3333333)
func(1)
3、虽然默认值可以被指定为任意数据类型，但是不推荐使用可变类型
函数最理想的状态：函数的调用只跟函数本身有关系，不外界代码的影响.
如果一定用可变类型的话，推荐在内部再定义：
def func(x,y,z,l=None):
if l is None:
l=[]
l.append(x)
l.append(y)
l.append(z)
print(l)
长度可变参数
参数的长度可变指的是在调用函数时，实参的个数可以不固定，而在调用函数时，实参的定义无非是按位置或者按关键字两种形式，
这就要求形参提供两种解决方案来分别处理两种形式的可变长度的参数
- 1.如果在最后一个形参名前加*号,那么在调用函数时，溢出的位置实参，
都会被接收，以元组的形式保存下来赋值给该形参。args是一个元组
def foo(x,y,z=1,*args): #在最后一个形参名args前加*号
print(x)
print(y)
print(z)
print(args)
foo(1,2,3,4,5,6,7) #实参1、2、3按位置为形参x、y、z赋值，
#多余的位置实参4、5、6、7都被*接收，以元组的形式保存下来，赋值给args，即args=(4, 5, 6,7)
1.1 *可以用在实参中，实参中带※，其后的值打散（打伞）成位置实参
def func(x,y,z):
print(x,y,z)
# func(*[11,22,33]) # func(11，22，33)
# func(*[11,22]) # func(11，22)只能多不能少
l=[11,22,33]
1.2 形参与实参中都带*,一步步来先打伞后接收。
def func(x,y,*args): # args=(3,4,5,6)
print(x,y,args)
func(1,2,[3,4,5,6])
func(1,2,*[3,4,5,6]) # func(1,2,3,4,5,6)
func(*'hello') # func('h','e','l','l','o')
- 2.如果在最后一个形参名前加号,那么在调用函数时，溢出的关键字实参，
都会被接收，以字典**的形式保存下来赋值给该形参。约定俗成应该是kwargs
def foo(x,**kwargs): #在最后一个参数kwargs前加**
print(x)
print(kwargs)
foo(y=2,x=1,z=3) #溢出的关键字实参y=2，z=3都被**接收，以字典的形式保存下来，**kwargs是一个字典**
1
{'z': 3, 'y': 2}
2.1 实参中有**，还是先打伞，
def func(x,y,z):
print(x,y,z)
func(*{'x':1,'y':2,'z':3}) # func('x','y','z')字典被一星打伞的结果
func(**{'x':1,'y':2,'z':3}) # func(x=1,y=2,z=3)字典被两星打伞的结果
#错误用法
func(**{'x':1,'y':2,}) # func(x=1,y=2)#少了
func(**{'x':1,'a':2,'z':3}) # func(x=1,a=2,z=3)对不上
2.2 形参与实参中都带**，还是先打伞，后接收。
def func(x,y,**kwargs):
print(x,y,kwargs)
func(y=222,x=111,a=333,b=444)
func(**{'y':222,'x':111,'a':333,'b':4444})
终极boss：一星两星，形参实参混用：一星args必须在两星kwargs之前（Markdown语法自动转译*，有点烦）
def func(x,*args,**kwargs):
print(args)
print(kwargs)
func(1,2,3,4,5,6,7,8,x=1,y=2,z=3)
配合使用：
def index(x,y,z):
print('index=>>> ',x,y,z)
def wrapper(*args,**kwargs): #args=(1,) kwargs={'z':3,'y':2}
index(*args,**kwargs)
# index(*(1,),**{'z':3,'y':2})
# index(1,z=3,y=2)
wrapper(1,z=3,y=2) # 为wrapper传递的参数是给index用的
# 原格式---》汇总-----》打回原形
命名关键字参数
命名关键字参数：在定义函数时，*后定义的参数，如下所示，称之为命名关键字参数
特点：
1、命名关键字实参必须按照key=value的形式为其传值
def func(x,y,*,a,b): # 其中，a和b称之为命名关键字参数
print(x,y)
print(a,b)
func(1,2,b=222,a=111)
- 组合使用
形参混用的顺序：位置新参，默认形参,*args,命名关键字形参，**kwargs
def func(x,y=111,*args,z,**kwargs):
print(x)
print(y)
print(args)
print(z)
print(kwargs)
函数名称空间
名称空间即存放名字与 对象映射/绑定关系的地方，是对栈区相互独立的划分，先开辟空间再放名称。
内置名称空间
用来存放一些内置的名字
伴随python解释器的启动而产生，关闭而回收，因而是第一个被加载的名称空间
全局名称空间
用来存放非内置的、非函数内定义的名字
伴随python文件的开始执行而产生，执行完毕而回收，是第二个被加载的名称空间，文件执行过程中产生的名字都会存放于该名称空间中
局部名称空间
用来存放函数的形参、函数内定义的名字
伴随函数的调用而临时产生，结束时回收，每调用一次函数就开辟一个局部名称空间（包括同一个函数的重复调用）
名称空间的一些顺序
加载顺序：内置名称空间->全局名称空间->局部名称空间
回收顺序：内置名称空间-<全局名称空间-<局部名称空间
查找顺序：局部名称空间->全局名称空间->内置名称空间，查找起始位置为当前位置
input=444
def func():
input=333
print(input)
func()#此时位置局部，查找顺序为
input=333,input=444,<built-in function input>依次查找
print(input)#此时位置全局，查找顺序为
从input=444，<built-in function input> 依次查找
示范1:什么是函数定义阶段，
input=1
def func():
input=1
print(input)
input=1
func()
input=1
示范2：局部名称空间是以函数定义阶段为准，与调用位置无关
x=1
def func():
print(x)
def foo():
x=222
func()
foo()
示范3：函数嵌套，依次向外找
input=111
def f1():
def f2():
# input=333
print(input)
input=222
f2()
def f3():
input=555
f1()
f3()
f2()#函数没定义
示范4:在定义阶段已经确定了名称所属的空间和空间关系了，但是不检测语法
input=1
def func():
print(input)
input=1
func()
名称空间作用域
全局作用域:位于全局名称空间、内建名称空间中的名字属于全局范围，该范围内的名字全局存活（除非被删除，否则在整个文件执行过程中存活）、全局有效（在任意位置都可以使用）
局部作用域:位于局部名称空间中的名字属于局部范围。该范围内的名字临时存活（即在函数调用时临时生成，函数调用结束后就释放）局部有效（只能在函数内使用）。
L —— Local(function)；函数内的名字空间
E —— Enclosing function locals；外部嵌套函数的名字空间(例如closure)
G —— Global(module)；函数定义所在模块（文件）的名字空间
B —— Builtin(Python)；Python内置模块的名字空间
global与nonlocal
global（声明这是全局的名字不是本地的）用于局部想要修改全局的名字
nonlocal （声明这不是本地的名字）会依次向外层函数寻找该名字，由于在定义阶段已经确定了空间关系了，找不到该名字会报错。
两者只用于不可变类型的数据修改
