什么是函数
具备某一功能的工具
对于工具的使用，我们应该先准备好工具，然后再使用。即我们对函数应该先定义后引用。和变量一样。
为什么用函数
1、程序的组织结构不清晰，可读性差
2、如果要用到重复的功能，只能拷贝功能的实现代码=》代码冗余
3、可扩展性差
如何使用函数
函数使用原则：先定义后引用
# 定义函数：
def 函数名(参数1,参数2,参数3,...):
"""文档注释"""
代码1
代码2
代码3
...
return 返回值
# 调用函数：
函数名(值1，值2，值3,...)
函数的基本使用
# 1、定义函数：申请内存空间把函数体代码保存下来，然后把内存地址绑定给函数名-》函数名=函数的内存地址
def sayhi():
print('*'*10)
print('hello')
print('*'*10)
print(sayhi) # 函数名本质是一串内存地址，注意下方开头是function，表明是一个函数。
---------------------
<function hello at 0x7fdc6a5ba1f0>
# 2、调用函数: 函数名()=> 函数的内存地址()，会触发函数体代码的运行
sayhi()
定义函数的三种格式
# 2.1: 无参函数,即函数本身不需要参数传入
def login():
inp_name=input("your name: ").strip()
inp_pwd=input("your pwd: ").strip()
if inp_name == "yang" and inp_pwd == "123":
print('login successful')
else:
print('login error')
login()
# 2.2: 有参函数，函数内需要外部参数传入
def max2(x,y):
if x > y:
print(x)
else:
print(y)
max2(10,20)
max2(11,22)
'''2.3: 空函数,空函数在项目初期，有些功能还没做完时，可以先用空函数顶替，防止程序无法运行'''
def func():
pass
函数的返回值
利用return 可以将函数内处理之后的结果返回
# 函数内可以有多个return，但只要执行一次函数就立刻结束，并会把return后的值当作本次调用的结果返回
'''
函数可以有三种形式的返回值
1、return 值：返回的就是该值本身
2、return 值1,值2,值3：返回一个元组
3、没有return：默认返回None
'''
def max2(x, y):
if x > y:
return x
else:
return y
res = max2(1, 2)
print(res)
--------------------
2
函数调用的三种格式
# 语句形式：单纯地调用一下函数就完了
def hello(s,n):
print(s*n)
print('hello')
print(s*n)
hello('*',30)
# 表达式形式：
def max2(x,y):
if x > y:
return x
else:
return y
res=max2(11,22) * 12
print(res)
#可以把函数的调用当作值传给另外一个函数
print(max(33,max2(11,22)))
总结
'''
函数的使用一定要分两个阶段去看：
1、定义阶段：只检测语法，不执行代码
2、调用阶段：执行函数体代码
'''
# 如果发生的语法错误，定义阶段就会立马检测出来
def func():
print("hello" # 直接报错
# 如果发生的不是语法错误，而是逻辑错误，只能在调用阶段检测到
def func():
xxx
func() # 报错
三、函数参数
函数的参数分为两大类：形参与实参
# 1、形参：在定义函数时，括号内定义的变量名，称之为形式参数，简称形参=》变量名
def func(x,y): # x,y就是形参
x=1
y=2
print(x)
print(y)
# 2、实参：在调用函数时，括号内传入的值，称之为实际参数，简称实参=》变量值
func(1,2)
在python中参数的种类
'''
1、位置参数：
（1）位置形参：在函数定义阶段按照从左到右的顺序依次定义形参（变量名），称之为位置形参
特点：必须被传值
'''
def func(x,y):
print(x,y)
func(1,2)
func(1) # 少一个不行
func(1,2,3) # 多一个也不行
'''
（2）位置实参：在函数调用阶段按照从左到右的顺序依次定义实参（传入的变量值），称之为位置实参
特点：按照位置传值，一一对应
'''
def func(x1,x2,x3,x4,x5,x6):
print(x1,x2,x3,x4,x5,x6)
func(1,2,3,4,5,6)
'''
2、关键字实参：在函数调用阶段按照key=value的形式为指定的形参名传值，该形式称之为关键字实参
特点：在传值时可以完全打乱顺序，但是仍然能够指名道姓地为指定的形参传值
'''
def func(name, age):
print(name, age)
func("yang",18)
func(18,"yang")
func(age=18,name="yang")
-----------------------
yang 18
18 yang
yang 18
'''
注意:可以混用位置实参与关键字实参,但是
1 位置实参必须放在关键字实参的前面
2 不能为同一个形参重复赋值
'''
def func(name, age, salary):
print(name,age,salary)
func('yang',salary=3.1,age=18)
# func('yang',salary=3.1,18) # 错误
func('yang', 18, salary=3.1)
# func('yang',18,age=19,salary=3.3) # 错误
-------------------------------
yang 18 3.1
yang 18 3.1
'''
3、默认形参：在函数定义阶段就已经为某个形参赋值,该形参称之为有默认值的形参,简称默认形参
特点: 定义阶段就已经被赋值意味着在函数调用阶段可以不用为其赋值
'''
def func(x,y=2):
print(x,y)
func(1) # 不会报错，因为有默然形参，如果没有传值，那么y默认为2
func(1,33333)
'''
注意:
1 默认形参应该放在位置形参的后面
'''
def func(y=2,x): # 错误
pass
'''
2 默认形参的值通常应该是不可变类型,因为若值是可变类型，我们获取到的是一个id地址，传入值的时候也是通过id，就会导致传的每个值都通过这个id存值，使得所有值都放在了一起
'''
def func(name,hobby,hobbies=[]):
hobbies.append(hobby)
print("%s 的爱好是:%s" %(name,hobbies))
func("yang",'play')
func('yang','music')
func("egon",'read')
---------------------------------------
yang 的爱好是:['play']
yang 的爱好是:['play', 'music']
egon 的爱好是:['play', 'music', 'read']
'''
要实现以上单独存的功能，应该把hobbies放到函数里面定义
'''
def func(name,hobby,hobbies=None):
if hobbies is None:
hobbies=[]
hobbies.append(hobby)
print("%s 的爱好是:%s" %(name,hobbies))
func("yang",'play')
func('yang','music')
func("egon",'read')
------------------------------------
yang 的爱好是:['play']
yang 的爱好是:['music']
egon 的爱好是:['read']
'''
3 默认形参的值只在函数定义阶段被赋值一次,函数定义之后的改变对默认形参没有影响
'''
m=333
def func(x,y=m): # y=333
print(x,y)
m=444
func(1)
-------------------
1 333
def register(name,age,gender='male'):
print(name)
print(age)
print(gender)
register('yang',18,)
register('jack',20,)
register('mary',18,'female')
四：可变长参数
可变长指的是参数的个数不固定
站在实参的角度，实参是用来为形参赋值的，如果实参的个数不固定，那么必须要有对应的形参能够接收溢出实参
*与**在形参与实参中的应用
在形参中用*与**
在形参名前加 *
* 会把溢出的位置实参存成元组，然后赋值其后的形参名
def func(x,*y): # y=(2,3,4)
print(x)
print(y)
func(1,2,3,4)
func(1)
----------------
1
(2, 3, 4)
1
()
# func() # 位置形参x必须被传值
在形参名前加**
**会把溢出的关键字实参存成字典，然后赋值其后的形参名
def func(x, **y): # y=(2,3,4)
print(x)
print(y)
func(1,a=111,b=222,c=333)
func(a=111, b=222, x=1, c=333)
----------------------------------
1
{'a': 111, 'b': 222, 'c': 333}
1
{'a': 111, 'b': 222, 'c': 333}
在实参前加*
*会把其后的值打散成位置实参
def func(x,y,z):
print(x,y,z)
nums = [1, 2, 3]
func(*nums) # func(1,2,3)
# 若只有一个形参，则多余出来的值没处放，会出错
-------------------
1 2 3
在实参前加 **
**会把其后的值打散关键字实参
def func(x,y,z):
print(x, y, z)
dic = {'y': 111, 'z': 222, 'x': 333}
func(**dic) # func(y=111,z=222,x=333)
------------------------
333 111 222
*args与**kwargs一起使用
'''
同时使用*与**的作用是可以把外部传的值原封不动的传给另一个函数，这在闭包函数，装饰器中有很大作用
'''
def index(x,y,z,a,b,c):
print("index===>",x,y,z,a,b,c)
def wrapper(*args, **kwargs):
# args=(1, 2, 3,) kwargs={"a":111,"b":222,"c":333}
index(*args, **kwargs)
# index(*(1, 2, 3,),**{"a":111,"b":222,"c":333})
# index(1,2,3,c=333,b=222,a=111)
wrapper(1, 2, 3, a=111, b=222, c=333)
---------------------------------
index===> 1 2 3 111 222 333
五、函数对象
函数对象指的是函数可以被当成变量去使用
def foo(): # foo = 函数的内存地址
print('from foo')
可以被赋值
f = foo
print(f is foo)
f()
可以当作参数传给一个函数
def bar(func):
print(func)
func()
bar(foo)
可以当成一个函数的返回值
def bar(func):
return func
res=bar(foo)
print(res)
可以当成容器类型的元素
在之前学习if判断时候，我们举过这个例子，当有大量if判断的分支且结果是执行函数时，可以用字典。
l = [foo]
print(l)
l[0]()
示例:当我们的主函数是由多个其他函数组成，即我们需要使用许多的if来判断用户输入且调用对应的函数时候，可以使用这种容器的方法，使得代码量减少,同时，在面试时，若被问到如何减少if操作时，可使用字典替换
def login():
print('登录功能......')
def withdraw():
print('提现功能......')
def transfer():
print('转账功能......')
def recharge():
print('充值功能')
func_dic={
"1": [login,"登录"],
"2": [withdraw,"提现"],
"3": [transfer,"转账"],
"4": [recharge,"充值"]
}
while True:
print("0 退出")
for k in func_dic:
print("%s %s" %(k,func_dic[k][1]))
choice = input("请输入你的指令编号: ").strip()
if choice == "0":
break
if choice in func_dic:
func_dic[choice][0]()
else:
print('输入的指令不存在')
六、函数嵌套
函数的嵌套调用
def bar():
print('from bar')
def foo():
print('from foo')
bar()
foo()
---------------------
from foo
from bar
def max2(x,y):
if x > y:
return x
else:
return y
def max4(a,b,c,d):
res1 = max2(a,b)
res2 = max2(res1,c)
res3 = max2(res2,d)
print(res3)
max4(1,2,3,4)
-----------------
4
函数的嵌套定义
def f1():
print('from f1')
def f2():
print("from f2")
f1() # 此时不会触发f2运行
-----------------
from f1
定义在函数内的函数特点是: 正常情况只能在函数体内调用
from math import pi
def circle(radius,mode=0):
def perimiter(radius):
return 2 * pi * radius
def area(radius):
return pi * (radius ** 2)
if mode == 0:
return perimiter(radius)
elif mode == 1:
return area(radius)
res1=circle(3,0)
res2=circle(3,1)
print(res1)
print(res2)
-------------------------
18.84955592153876
28.274333882308138
def func():
x = 10
print(x)
def f2():
print('from f2')
f2()
func()
print(x)
---------------------------------
10
from f2
NameError: name 'x' is not defined
七、名称空间与作用域
名称空间
名称空间在python中有非常重要的地位，在python之禅中专门提到了名称空间,在python解释器中输入 impoet this 可以看到python之禅.
Namespaces are one honking great idea -- let's do more of those!
名称空间就是存放名字的地方
名(函数名、变量名等)：存放在内存里
值(变量值等）：存放在内存里
通过划分出各个名字空间，允许在不同的空间内，可以有相同的名字
内置名称空间
存放内置的名字（python解释器启动时便定义好的）如 print、input、len
生命周期：解释器启动则产生，解释器关闭则销毁 （python解释器在pyhton程序执行时运行，执行结束时结束）
全局名称空间
存放的是顶级的名字
生命周期：python程序运行时则产生，python程序结束则销毁
局部名称空间
即函数内的名字
只有调用函数时，局部名字才产生,定义函数时并不会产生，因为代码并未执行，python解释器只会扫描是否有语法错误。
生命周期：调用函数时产生，函数调用结束则销毁
名字的查找优先级
从当前位置往外查找,如果当前是在局部:局部名称空间->全局名称空间->内置名称空间
从当前位置往外查找,如果当前是在全局:全局名称空间->内置名称空间
内置名称空间
存放的是内置的名字,如print，input，len等等
生命周期: 解释器启动则产生,解释器关闭则销毁
全局名称空间
存放的是顶级的名字
生命周期: python程序运行时则产生,python程序结束则销毁
一般来说，没有缩进的名字都是顶级名字，但是如果这个名字在if分支里，他也属于顶级名字
x = 10
def func():
x = 111
print(x)
if 1:
y = 6666 # y也是顶级名字
局部名称空间
函数内的名字
生命周期: 调用函数时则产生,函数调用结束则销毁
名字的查找优先级:
从当前位置往外查找,如果当前是在局部:局部名称空间->全局名称空间->内置名称空间
从当前位置往外查找,如果当前是在全局:全局名称空间->内置名称空间
def func():
len = 222
# print(len)
# len = 111
func()
print(len)
# 名称空间可以理解为一层套一层的关系,问题是嵌套关系是在函数定义阶段生成的,还是在函数调用阶段生成的?
x = 111
def foo():
print(x)
def bar(f):
x=222
f()
bar(foo)
------------
111
一个非常重要的结论
名称空间的嵌套关系是函数定义阶段(即扫描语法时)就固定死的,与函数的调用位置无关
x = 111
def func():
print(x)
x=2222
func()
'''
以上这个例子会报错，因为python解释器在扫描语法时发现需要打印x，但是x定义在print后面，
本来如果func中不写x=2222,那么func会到外面去找111，但是在函数中写了，那么会优先用
自己的，但是又因为还未定义，所以会报错
'''
# 练习
x=0
def f1():
x=1
def f2():
x=2
print(x)
f2()
f1()
---------
2
全局范围/全局作用域对应内置名称空间+全局名称空间
特点:全局存活,全局有效
局部范围/局部作用域对应局部名称空间
特点:临时存活,局部有效
案例1
x = 10
def func(x):
x = 20
func(x)
print(x)
--------------
10
案例2
x = [11,22,33]
def func(x):
x[0] = 66
func(x)
print(x)
--------------
[66,22,33]
案例3
x = [11,22,33]
def func():
x[0] = 66
func()
print(x)
-------------
[66,22,33]
案例4
x = 10
def func():
global x
x=22
func()
print(x)
----------
22
案例5:nonlocal生命名字是来自于外层函数的(了解)
x = 10
def f1():
x = 111
def f2():
nonlocal x
x = 222
f2()
print(x)
f1()
print(x)
-------------
222
10