python函数 | 函数详解 - Powered by Discuz! Archiver

饱饱發表於 2019-9-10 22:42:00

python函数 | 函数详解

<h2>一、函数初识</h2>
函数的产生：函数就是封装一个功能的代码片段。
<div class="cnblogs_code">
<pre>li = ['spring', 'summer', 'autumn', 'winter']
def function():
count = 0
for j in li:
 count += 1
print(count)
function()　　　　　　　　# 4</pre>
</div>
<ul>
<li>def 关键字,定义一个函数</li>
<li>function 函数名的书写规则与变量一样。</li>
<li>括号是用来传参的。</li>
<li>函数体,就是函数里面的逻辑代码</li>
</ul>
代码从上至下执行，执行到def function() 时, 将function这个变量名加载到临时内存中，但它不执行。
函数的执行：函数名 + () 
 
使用__name__方法获取函数名，使用__doc___方法获取函数的解释  
<div class="cnblogs_code">
<pre>def func1():
"""
此函数是完成登陆的功能，参数分别是...作用。
return: 返回值是登陆成功与否（True，False）
"""
print(666)

func1()
print(func1.__name__) #获取函数名
print(func1.__doc__) #获取函数名注释说明 </pre>
</div>
<pre>执行输出：
666
func1
此函数是完成登陆的功能，参数分别是...作用。
return: 返回值是登陆成功与否（True，False）</pre>
这个有什么用呢？比如日志功能，需要打印出谁在什么时间，调用了什么函数，函数是干啥的，花费了多次时间，这个时候，就需要获取函数的有用信息了
 
<h3>1. 函数返回值</h3>
写函数，不要在函数中写print(),  函数是以功能为导向的，除非测试的时候，才可以写print()
<ul>
<li>在函数中，遇到return结束函数</li>
</ul>
<div class="cnblogs_code">
<pre>def fun():
print(111)
return
print(444)
fun() </pre>
</div>
<pre>执行输出：111</pre>
<ul>
<li>将值返回给函数的调用者</li>
</ul>
<div class="cnblogs_code">
<pre>def fun():
a = 134
return a
print(fun()) </pre>
</div>
<pre>执行输出：123</pre>
1）无 return
<div class="cnblogs_code">
<pre>def fun():
pass
print(fun()) </pre>
</div>
<pre>执行输出：None</pre>
2）return 1个值。该值是什么，就直接返回给函数的调用者，函数名()
<div class="cnblogs_code">
<pre>def fun():
return
print(fun()) </pre>
</div>
<pre>执行输出：</pre>
3）return 多个值 将多个值放到一个元组里，返回给函数的调用者。
<div class="cnblogs_code">
<pre>def fun():
return 1,2,,'abc'
print(fun()) </pre>
</div>
<pre>执行输出：
(1, 2, , 'abc')</pre>
<h3>2. 函数的传参</h3>
（1）实参：在函数执行者里面的参数叫实参
①位置参数：按顺序，一一对应
<div class="cnblogs_code">
<pre>def func(a,b,c):
print(a)
print(b)
print(c)

func('fdsafdas',3,4) </pre>
</div>
<pre>执行输出：
fdsafdas
3
4</pre>
如果少一个参数呢?
<div class="cnblogs_code">
<pre>def func(a,b,c):
print(a)
print(b)
print(c)

func(3,4) </pre>
</div>
<pre>执行报错：TypeError: func() missing 1 required positional argument: 'c'</pre>
必须是一一对应的。
<div class="cnblogs_code">
<pre>def compare(x,y):
ret = x if x > y else y #三元运算，针对简单的if else才能使用
return ret

print(compare(123,122334)) # 122334</pre>
</div>
②关键字参数：可以不按顺序，但是必须一一对应
<div class="cnblogs_code">
<pre>def compare(x,y):
ret = x if x > y else y
return ret
print(compare(y=13,x=1))</pre>
</div>
<pre>执行结果：13</pre>
③混合参数：关键字参数一定要在位置参数后面
<div class="cnblogs_code">
<pre>def func1(a,b,c,d,e):
print(a)
print(b)
print(c)
print(d)
print(e)

func1(1,4,d=2,c=3,e=5) </pre>
</div>
<pre>执行输出：
1
4
3
2
5</pre>
（2） 形参：
①位置参数：按顺序和实参一一对应，位置参数必须传值
<div class="cnblogs_code">
<pre>def func(a,b,c):
print(a)
print(b)
print(c)

func('fdsafdas',3,4) </pre>
</div>
<pre>执行输出：
fdsafdas
3
4</pre>
②默认参数：传参则覆盖，不传则默认，默认参数永远在位置参数后面
例1.
<div class="cnblogs_code">
<pre>def func(a,b=666):
print(a,b)
func(1,2) </pre>
</div>
<pre>执行输出：1 2</pre>
例2.
<div class="cnblogs_code">
<pre>def func(a,b=666):
print(a,b)
func(1)

执行输出：1 666</pre>
</div>
举一个场景：班主任录入员工信息表，有2个问题：第一，男生居多；第二，完成函数功能 *****
<div class="cnblogs_code">
<pre>defInfor(username,sex='男'):
with open('name_list',encoding='utf-8',mode='a') as f1:
 f1.write('{}\t{}\n'.format(username,sex))

while True:
username = input('请输入姓名(男生以1开头)：').strip()
if '1' in username:
 username = username #去除1
 Infor(username)
else:
 Infor(username,'女') </pre>
</div>
③动态参数：当函数的形参数量不一定时，可以使用动态参数。用*args和**kwargs接收，args是元组类型，接收除键值对以外的参数（接收位置参数），kwargs是字典类型，接收键值对(关键字参数)，并保存在字典中。
<div class="cnblogs_code">
<pre>def func(*args,**kwargs):
print(args,type(args))
print(kwargs,type(kwargs))

func(1,2,3,4,'alex',name = 'alex')</pre>
</div>
<pre>输出结果是：
(1, 2, 3, 4, 'alex') <class 'tuple'>
{'name': 'alex'} <class 'dict'></pre>
“ * "的魔性作用
（1）在函数定义时：*位置参数和**关键字参数代表聚合
将所有实参的位置参数聚合到一个元组中，并将这个元组赋值给args。在关键参数前加“ ** ”代表将实参的关键字参数聚合到一个字典中，并将这个字典赋值给kwargs。
将2个列表的所有元素赋值给args
<div class="cnblogs_code">
<pre>def func(*args):
print(args)

l1 =
l2 =
func(*l1)
func(*l1,*l2) </pre>
</div>
<pre>执行输出：
(1, 2, 30)
(1, 2, 30, 1, 2, 33, 21, 45, 66)</pre>
传两个字典给**kwargs
<div class="cnblogs_code">
<pre>def func(**kwargs):
print(kwargs)

dic1 = {'name':'jack','age':22}
dic2 = {'name1':'rose','age1':21}
func(**dic1,**dic2) </pre>
</div>
<pre>执行输出：
{'name': 'jack', 'age': 22, 'name1': 'rose', 'age1': 21}</pre>
<div class="cnblogs_code">
<pre>def func(*args,**kwargs):
print(args)
print(kwargs)

func(*, *, **{'name':'alex'}, **{'age':18})　　#相当于func(, {'name':'alex','age':18})</pre>
<pre></pre>
</div>
（2）在函数的调用执行时，打散
 　　*可迭代对象，代表打散(list,tuple,str,dict(键))将元素一一添加到args。
　　 **字典，代表打散，将所有键值对放到一个kwargs字典里。
<div class="cnblogs_code">
<pre>def func(*args,**kwargs):
print(args,kwargs)

dic1 = {'name':'jack','age':22}
dic2 = {'name1':'rose','age1':21}

func(*,*'asdk',**dic1,**dic2) </pre>
</div>
<pre>执行输出：(1, 2, 3, 4, 'a', 's', 'd', 'k') {'age1': 21, 'name': 'jack', 'age': 22, 'name1': 'rose'}</pre>
形参的顺序：位置参数 ----> *args ----->关键字参数-------->默认参数 ------->**kwargs
*args参数，可以不传，默认为空()，**kwargs 动态传参，他将所有的关键字参数(未定义的)放到一个字典中
<div class="cnblogs_code">
<pre>def func(a,b,c,d,*args,e='男',**kwargs):
print(a,b,c,d,args,e,kwargs)

func(1,2,3,4,5,6,7,v=3,m=7,h=9,e='女') </pre>
</div>
<pre>执行输出：1 2 3 4 (5, 6, 7) 女 {'v': 3, 'h': 9, 'm': 7}</pre>
<div class="cnblogs_code">
<pre>def func(a,b,c,**kwargs):
print(kwargs)
func(1,2,r=4,b1=5,c1=6,c=7)

执行输出：{'r': 4, 'c1': 6, 'b1': 5}</pre>
</div>
执行没有报错，是因为函数接收参数后，它会从左边到右找，最后找到了c，c=7参数，在a,b,c里面已经定义好了，所以在输出的字典中，并未出现。因为kwargs返回的是未定义的关键字参数。
如果函数含有多个未知参数，一般使用如下格式：
<div class="cnblogs_code">
<pre>def func1(*args,**kwargs):
pass
func1() </pre>
</div>
<h2>二、命名空间和作用域</h2>
　　当执行函数的时候，他会在内存中开辟一个临时名称空间，存放函数体内的所有变量与值的关系，随着函数的执行完毕，临时空间自动关闭。
 
函数里面的变量，在函数外面能直接引用么？不能
<div class="cnblogs_code">
<pre>def func1():
m = 1
print(m)

print(m) # NameError: name 'm' is not defined</pre>
</div>
上面为什么会报错呢？现在我们来分析一下python内部的原理是怎么样：
我们首先回忆一下Python代码运行的时候遇到函数是怎么做的，从Python解释器开始执行之后，就在内存中开辟里一个空间，每当遇到一个变量的时候，就把变量名和值之间对应的关系记录下来，但是当遇到函数定义的时候，解释器只是象征性的将函数名读入内存，表示知道这个函数存在了，至于函数内部的变量和逻辑，解释器根本不关心。等执行到函数调用的时候，Python解释器会再开辟一块内存来储存这个函数里面的内容，这个时候，才关注函数里面有哪些变量，而函数中的变量会储存在新开辟出来的内存中，函数中的变量只能在函数内部使用，并且会随着函数执行完毕，这块内存中的所有内容也会被清空。
<h3>1. 命名空间和作用域</h3>
命名空间：存放”名字与值关系的空间“
①全局命名空间：代码在运行时，创建的存储”变量名与值的关系“的内存空间
②局部命名空间：在函数调用时临时开辟出来的空间，会随着函数的执行完毕而被清空
③内置命名空间：存放了python解释器为我们提供的名字：input,print,str,list,tuple...它们都是我们熟悉的，拿过来就可以用的方法。
 
作用域：就是作用范围
①全局作用域：全局命名空间、内置命名空间。在整个文件的任意位置都能被引用、全局有效
②局部作用域：局部命名空间，只能在局部范围内生效
 
加载顺序：
内置命名空间（程序运行前加载）----->   全局命名空间（程序运行中从上至下加载） -----> 局部命名空间（程序运行中：调用时才加载)
 
取值顺序：
　　在局部调用：局部命名空间->全局命名空间->内置命名空间
　　在全局调用：全局命名空间->内置命名空间
 
综上所述，在找寻变量时，从小范围，一层一层到大范围去找寻。取值顺序：就近原则
 
局部变量举例
<div class="cnblogs_code">
<pre>name = 'summer'
def func1():
name = 'spring'
print(name)
func1()</pre>
</div>
<pre>执行输出：spring 取值是从内到外 </pre>
<div class="cnblogs_code">
<pre>name = 'summer'
def func1():
print(name)
func1() </pre>
</div>
 执行输出：summer
代码从上至下依次执行，调用函数：函数里面从上至下依次执行。
<div class="cnblogs_code">
<pre>print(111)
def func1():
print(333)
func2()
print(666)
def func2():
print(444)
def func3():
print(555)
func2()

func1()
print(222) </pre>
</div>
<pre>执行输出：
111
333
444
666
222</pre>
<div class="cnblogs_code">
<pre>def f1():
def f2():
 def f3():
 print("in f3")
 print("in f2")
 f3()
print("in f1")
f2()
f1() </pre>
</div>
<pre>执行输出：
in f1
in f2
in f3</pre>
<h3>2. globals和locals方法</h3>
<div class="cnblogs_code">
<pre>print(globals())　　　　 #全局名称空间所有变量，字典
print(locals())　　　　　　#局部名称空间所有变量，字典（当前）</pre>
</div>
globals()和locals()一般很少用，在函数逻辑比较复杂的情况下，可能会用到。
<div class="cnblogs_code">
<pre>li = ['spring', 'summer', 'autumn', 'winter']

def func():
a = 1
b = 2
print('func', globals())
print('func', locals())

def func1():
 c = 3
 d = 4
 print('func1', globals())
 print('func1', locals())

func1()

func()</pre>
</div>
输出结果
<div class="cnblogs_code">
<pre>func {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x011CC410>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/Administrator/houseinfo/test.py', '__cached__': None, 'li': ['spring', 'summer', 'autumn', 'winter'], 'func': <function func at 0x03542E40>}
func {'b': 2, 'a': 1}
func1 {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x011CC410>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/Administrator/houseinfo/test.py', '__cached__': None, 'li': ['spring', 'summer', 'autumn', 'winter'], 'func': <function func at 0x03542E40>}
func1 {'d': 4, 'c': 3}</pre>
</div>
 （1）global：
①在局部命名空间声明全局变量
<div class="cnblogs_code">
<pre>def func2():
global name
name = 'summer'

func2()
print(name)</pre>
</div>
<pre>执行结果：summer</pre>
②在局部命名空间对全局变量进行修改(限于字符串，数字)。
<div class="cnblogs_code">
<pre>count = 1
def func1():
global count
count = count + 1
print(count)
func1()
print(count)</pre>
</div>
<pre>执行结果： 2 2</pre>
因为全局变量count被函数体的global count 覆盖了
（2）nonlocal
①子函数对父函数的变量进行修改，此变量不能是全局变量
<div class="cnblogs_code">
<pre>a = 4
def func1():
nonlocal a
a = 5 #修改全局变量
#print(name)
func1()
print(a) </pre>
</div>
<pre>执行输出：SyntaxError: no binding for nonlocal 'a' found</pre>
②在局部作用域中，对父级作用域的变量进行引用和修改，并且引用的哪层，从那层及以下此变量全部发生改变。
例1
<div class="cnblogs_code">
<pre>def func1():
b = 6
def func2():
 b = 666
 print(b)
func2()
print(b) #父级不受影响
func1() </pre>
</div>
<pre>执行输出：
666
6</pre>
例2
<div class="cnblogs_code">
<pre>def func1():
b = 6
def func2():
 nonlocal b #表示可以影响父级，也就是func1()
 b = 666 #重新赋值
 print(b)
func2()
　　 print(b) #这个时候，影响了b的值，输出666
func1() </pre>
</div>
<pre>执行输出：
666
666</pre>
例3******
<div class="cnblogs_code">
<pre>def aa(): #不受ccl影响
b = 42
def bb():
 b = 10 #影响子级函数，b都是10
 print(b)
 def cc():
 nonlocal b #只能影响父级，也就是bb()
 b = b + 20 #b=10+20 也就是30
 print(b)
 cc()
 print(b)
bb()
print(b)
aa()</pre>
</div>
<pre>执行输出：
10
30
30
42</pre>
注意
<div class="cnblogs_code">
<pre>a = 5
def func1():
a += 1
print(a)
func1() </pre>
</div>
执行报错。这里函数对全局变量做了改变，是不允许操作的。函数内部可以引用全局变量，不能修改。如果要修改，必须要global一下
<div class="cnblogs_code">
<pre>a = 5
def func1():
global a
a += 1
print(a)

func1() #输出6</pre>
</div>
<h2> </h2> 
来源：https://www.cnblogs.com/Summer-skr--blog/p/11498293.html

頁: [1]

琼殿技术论坛's Archiver

python函数 | 函数详解