04 python之函数详解

  • 2019 年 10 月 3 日
  • 笔记

一、函数初识

函数的产生:函数就是封装一个功能的代码片段。

li = ['spring', 'summer', 'autumn', 'winter']  def function():      count = 0      for j in li:          count += 1      print(count)  function()        # 4

  • def 关键字,定义一个函数
  • function 函数名的书写规则与变量一样。
  • 括号是用来传参的。
  • 函数体,就是函数里面的逻辑代码

代码从上至下执行,执行到def function() 时, 将function这个变量名加载到临时内存中,但它不执行

函数的执行:函数名 + () 

 

使用__name__方法获取函数名 ,使用__doc___方法获取函数的解释  

def func1():      """      此函数是完成登陆的功能,参数分别是...作用。      return: 返回值是登陆成功与否(True,False)      """      print(666)    func1()  print(func1.__name__)         #获取函数名  print(func1.__doc__)         #获取函数名注释说明 

执行输出:  666  func1  此函数是完成登陆的功能,参数分别是...作用。  return: 返回值是登陆成功与否(True,False)

这个有什么用呢?比如日志功能,需要打印出谁在什么时间,调用了什么函数,函数是干啥的,花费了多次时间,这个时候,就需要获取函数的有用信息了

 

1. 函数返回值

写函数,不要在函数中写print(),  函数是以功能为导向的,除非测试的时候,才可以写print()

  • 在函数中,遇到return结束函数
def fun():      print(111)      return      print(444)  fun() 

执行输出:111
  • 将值返回给函数的调用者
def fun():      a = 134      return a  print(fun()) 

执行输出:123

1)无 return

def fun():      pass  print(fun()) 

执行输出:None

2)return 1个值该值是什么,就直接返回给函数的调用者,函数名()

def fun():      return [1,2,3]  print(fun()) 

执行输出:[1, 2, 3]

3)return 多个值 将多个值放到一个元组,返回给函数的调用者。

def fun():      return 1,2,[33,44],'abc'  print(fun()) 

执行输出:  (1, 2, [33, 44], 'abc')

2. 函数的传参

(1)实参:在函数执行者里面的参数叫实参

位置参数:按顺序一一对应

def func(a,b,c):      print(a)      print(b)      print(c)    func('fdsafdas',3,4) 

执行输出:  fdsafdas  3  4

如果少一个参数呢?

def func(a,b,c):      print(a)      print(b)      print(c)    func(3,4) 

执行报错:TypeError: func() missing 1 required positional argument: 'c'

必须是一一对应的。

def compare(x,y):      ret = x if x > y else y   #三元运算,针对简单的if else才能使用      return ret    print(compare(123,122334))        # 122334

关键字参数:可以不按顺序,但是必须一一对应

def compare(x,y):      ret = x if x > y else y      return ret  print(compare(y=13,x=1))

执行结果:13

混合参数:关键字参数一定要在位置参数后面

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) 

执行输出:  1  4  3  2  5

(2) 形参:

位置参数:按顺序和实参一一对应,位置参数必须传值

def func(a,b,c):      print(a)      print(b)  print(c)    func('fdsafdas',3,4) 

执行输出:  fdsafdas  3  4

默认参数:传参则覆盖,不传则默认,默认参数永远在位置参数后面

1.

def func(a,b=666):      print(a,b)  func(1,2) 

执行输出:1 2

2.

def func(a,b=666):      print(a,b)  func(1)    执行输出:1 666

举一个场景:班主任录入员工信息表,有2个问题:第一,男生居多;第二,完成函数功能 *****

def  Infor(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:]        #去除1          Infor(username)      else:          Infor(username,'') 

③动态参数当函数的形参数量不一定时,可以使用动态参数。用*args和**kwargs接收,args是元组类型,接收除键值对以外的参数(接收位置参数),kwargs是字典类型,接收键值对(关键字参数)并保存在字典中。

def func(*args,**kwargs):      print(args,type(args))      print(kwargs,type(kwargs))    func(1,2,3,4,'alex',name = 'alex')

输出结果是:  (1, 2, 3, 4, 'alex') <class 'tuple'>  {'name': 'alex'} <class 'dict'>

“ * “的魔性作用

(1)在函数定义时:*位置参数和**关键字参数代表聚合

将所有实参的位置参数聚合到一个元组中,并将这个元组赋值给args。在关键参数前加“ ** ”代表将实参的关键字参数聚合到一个字典中,并将这个字典赋值给kwargs。

将2个列表的所有元素赋值给args

def func(*args):      print(args)    l1 = [1,2,30]  l2 = [1,2,33,21,45,66]  func(*l1)  func(*l1,*l2) 

执行输出:  (1, 2, 30)  (1, 2, 30, 1, 2, 33, 21, 45, 66)

传两个字典给**kwargs

def func(**kwargs):      print(kwargs)    dic1 = {'name':'jack','age':22}  dic2 = {'name1':'rose','age1':21}  func(**dic1,**dic2) 

执行输出:  {'name': 'jack', 'age': 22, 'name1': 'rose', 'age1': 21}
def func(*args,**kwargs):      print(args)      print(kwargs)    func(*[1,2,3], *[4,5,6], **{'name':'alex'}, **{'age':18})    #相当于func([1,2,3,4,5,6], {'name':'alex','age':18})

(2)在函数的调用执行时,打散

   *可迭代对象,代表打散(list,tuple,str,dict(键))将元素一一添加到args。

   **字典,代表打散,将所有键值对放到一个kwargs字典里。

def func(*args,**kwargs):      print(args,kwargs)    dic1 = {'name':'jack','age':22}  dic2 = {'name1':'rose','age1':21}    func(*[1,2,3,4],*'asdk',**dic1,**dic2) 

执行输出:(1, 2, 3, 4, 'a', 's', 'd', 'k') {'age1': 21, 'name': 'jack', 'age': 22, 'name1': 'rose'}

形参的顺序:位置参数 —-> *args —–>关键字参数——–>默认参数 ——->**kwargs

*args参数,可以不传,默认为空(),**kwargs 动态传参,他将所有的关键字参数(未定义的)放到一个字典中

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='') 

执行输出:1 2 3 4 (5, 6, 7) 女 {'v': 3, 'h': 9, 'm': 7}
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}

执行没有报错,是因为函数接收参数后,它会从左边到右找,最后找到了c,c=7参数,在a,b,c里面已经定义好了,所以在输出的字典中,并未出现。因为kwargs返回的是未定义的关键字参数。

如果函数含有多个未知参数,一般使用如下格式:

def func1(*args,**kwargs):      pass  func1() 

二、命名空间和作用域

  当执行函数的时候,他会在内存中开辟一个临时名称空间,存放函数体内的所有变量与值的关系,随着函数的执行完毕,临时空间自动关闭。

 

函数里面的变量,在函数外面能直接引用么?不能

def func1():      m = 1      print(m)    print(m)                          # NameError: name 'm' is not defined

上面为什么会报错呢?现在我们来分析一下python内部的原理是怎么样:

我们首先回忆一下Python代码运行的时候遇到函数是怎么做的,从Python解释器开始执行之后,就在内存中开辟里一个空间,每当遇到一个变量的时候,就把变量名和值之间对应的关系记录下来,但是当遇到函数定义的时候,解释器只是象征性的将函数名读入内存,表示知道这个函数存在了,至于函数内部的变量和逻辑,解释器根本不关心。等执行到函数调用的时候,Python解释器会再开辟一块内存来储存这个函数里面的内容,这个时候,才关注函数里面有哪些变量,而函数中的变量会储存在新开辟出来的内存中,函数中的变量只能在函数内部使用,并且会随着函数执行完毕,这块内存中的所有内容也会被清空。

1. 命名空间和作用域

命名空间:存放”名字与值关系的空间“

①全局命名空间:代码在运行时,创建的存储”变量名与值的关系“的内存空间

②局部命名空间:在函数调用时临时开辟出来的空间,会随着函数的执行完毕而被清空

③内置命名空间:存放了python解释器为我们提供的名字:input,print,str,list,tuple…它们都是我们熟悉 的,拿过来就可以用的方法。

 

作用域:就是作用范围

①全局作用域:全局命名空间、内置命名空间。在整个文件的任意位置都能被引用、全局有效

②局部作用域:局部命名空间,只能在局部范围内生效

 

加载顺序:

内置命名空间(程序运行前加载)—–>   全局命名空间(程序运行中从上至下加载) —–> 局部命名空间(程序运行中:调用时才加载)

 

取值顺序:

  在局部调用:局部命名空间->全局命名空间->内置命名空间

  在全局调用:全局命名空间->内置命名空间

 

综上所述,在找寻变量时,从小范围,一层一层到大范围去找寻。取值顺序:就近原则

 

局部变量举例

name = 'summer'  def func1():      name = 'spring'      print(name)  func1()

执行输出:spring
取值是从内到外
name = 'summer'  def func1():      print(name)  func1() 

 执行输出:summer

代码从上至下依次执行, 调用函数:函数里面从上至下依次执行。

print(111)  def func1():      print(333)      func2()      print(666)  def func2():      print(444)  def func3():      print(555)      func2()    func1()  print(222) 

执行输出:  111  333  444  666  222
def f1():      def f2():          def f3():              print("in f3")          print("in f2")          f3()      print("in f1")      f2()  f1() 

执行输出:  in f1  in f2  in f3

2. globals和locals方法

print(globals())         #全局名称空间所有变量,字典  print(locals())        #局部名称空间所有变量,字典 (当前)

globals()和locals()一般很少用,在函数逻辑比较复杂的情况下,可能会用到。

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()

输出结果

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}

 (1)global:

①在局部命名空间声明全局变量

def func2():      global name      name = 'summer'    func2()  print(name)

执行结果:summer

②在局部命名空间对全局变量进行修改(限于字符串,数字)。

count = 1  def func1():      global count      count = count + 1      print(count)  func1()  print(count)

执行结果:
2
2

因为全局变量count被函数体的global count 覆盖了

(2)nonlocal

子函数对父函数的变量进行修改,此变量不能是全局变量

a = 4  def func1():      nonlocal a      a = 5             #修改全局变量      #print(name)  func1()  print(a) 

执行输出:SyntaxError: no binding for nonlocal 'a' found

在局部作用域中,对父级作用域的变量进行引用和修改,并且引用的哪层,从那层及以下此变量全部发生改变。

1

def func1():      b = 6      def func2():          b = 666          print(b)      func2()      print(b)                 #父级不受影响  func1() 

执行输出:  666  6

例2

def func1():      b = 6      def func2():          nonlocal b          #表示可以影响父级,也就是func1()          b = 666             #重新赋值          print(b)      func2()     print(b)                 #这个时候,影响了b的值,输出666  func1() 

执行输出:  666  666

3******

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()

执行输出:  10  30  30  42

注意

a = 5  def func1():      a += 1      print(a)  func1() 

执行报错。这里函数对全局变量做了改变,是不允许操作的。函数内部可以引用全局变量,不能修改。如果要修改,必须要global一下

a = 5  def func1():      global a      a += 1      print(a)    func1()     #输出6