函数的定义解构及销毁过程

Posted 2020-10-11

函数主要作用为了复用

函数中的return定义

函数中，所有的语句都是有retrun操作，如果函数没有自定义的return，则默认retrun None值

形参和实参 

参数中，是一种形式的表示，一种符号的表达简称形参；而调用时所传达的参数列表为实实在在传入的值，简称为实参

def fn(xx):        #形参

    return xx

print(fn(‘hello‘))    #实参数

callable

使用callbale可以看其是否是可被调用对象

例:

def add(x,y):

    return 1

print(callable(add))

True

函数参数

测定函数需要匹配定义个数相匹配（可变参数例外）

位置参数

调用使用：按照要求是按照顺序去定义传入实参

In [1]: def f(x,y):

   ...:     print(x,y)

   ...:

In [2]: f(‘a‘,‘ccc‘)

a ccc

关键字参数

调用使用对应的形参明确指定要传入的参数

使用形式参数名字传入实参的方式，顺序是可以和定义的顺序不一样，因为是通过名称去定义

In [3]: f(y=‘python‘, x=‘hello‘)

hello python

关键字传参

In [5]: def f(x,y,z):

   ...:     print(x,y,z)

调用

In [7]: f(z=None,y=10,x=[1])

返回值：

[1] 10 None

In [8]: f((1,),z=6,y=4.1)

返回值：

(1,) 4.1 6

位置参数必须在关键字参数之前传入，否则会被误认

In [13]: f((1,),z=6,1)

  File "<ipython-input-13-452adbde2693>", line 1

    f((1,),z=6,1)

              ^

SyntaxError: positional argument follows keyword argument

def add(x,y):

    result = x + y

    print(result)

add(6,7)

13

#将关键字参数先传进会提示报错

add(x=6,7)

    add(x=6,7)

           ^

SyntaxError: positional argument follows keyword argument

总结：简单来讲，有默认值的参数，需要在后面进行调用

一般流程来讲，用户必须要填写的参数，直接定义为位置参数

例：

def add(x,y=9):

    result = x + y

    print(result)

add(6)                #这样x就被定义为必须定义的对象

定义一个login函数，参数命名为host，port，username，password

def login(host=‘127.0.0.1‘,port=‘8080‘,username=‘chaoye‘,password=‘q1w2e3‘):

    print(‘{}:{}:{}/{}‘.format(host,port,username,password))

login()

127.0.0.1:8080:chaoye/q1w2e3

login(‘192.168.0.1‘,9909,username=‘haha‘)

192.168.0.1:9909:haha/q1w2e3

login(‘192.168.0.1‘,9909,password=‘this‘)

192.168.0.1:9909:chaoye/thi

*name 可变参数

传递参数，可以匹配任意个（0个到n个）参数

def fn(*args):

    print(type(args))

    print(args)

fn(1,2,3,4,88)

<class ‘tuple‘>

(1, 2, 3, 4, 88)

fn()

<class ‘tuple‘>        # 可变参数在封装过程中，将其以元组的方式进行传递

()

def fn(*nums):

    sum = 0

    for x in nums:

        sum+=x

    print(sum)

fn(10)

10

add(1,2,3,4,88) 这里定义表示可以接收多个参数，这里形参可以接受0个到多个实参

在传递的过程中，可变参数在封装过程中，将其以元组的方式进行传递，因为传递的同时已知其需要传递的个数，因为内部是不允许改变nums

*传递是一个不可变的类型（元组)

验证return

In [5]: def add(*nums):

   ...:     sum = 0

   ...:     for x in nums:

   ...:         sum += x

   ...:     print(sum)

   ...:     #retrun sum

   ...:     

In [6]: val = add(3,5,7)

15

In [8]: print(val)

None

这里没有定义return，则解释器直接调用隐含的return None进行返回

自定义return

In [12]: def add(*nums):

    ...:     sum = 0

    ...:     for x in nums:

    ...:         sum += x

    ...:     return(sum)

In [14]: add(0)

0

Out[14]: 0

**kwargs 可变关键字参数

**kwargs 将传递进来的值封装为字典类型，格式如下：

def showconfig(**name):

    print(name)

showconfig(a=5,b=32,hj=90)

调用：

调用的时候需要对关键字进行指定值的赋予

{‘a‘: 5, ‘b‘: 32, ‘hj‘: 90}

例：

def showconfig(**kwagrs):

    for k,v in kwagrs.items():

        print(k,v)

showconfig(hostname=‘127.0.0.1‘,port=‘8080‘,username=‘chaoye‘,passwd=‘134qwe‘)

hostname 127.0.0.1

username chaoye

port 8080

passwd 134qwe

以上，传递的信息是未知的，可能是n个，所以需要使用可变类型去接收

我们需要确定这个值传递给那些kv，所以需要key=value 这样进行赋值

传递之后会形成一个字典，我们只需要对字典进行操作即可

混合使用

将关键字参数提取，比如username,passwd ，因为有些参数为用户必填，所以将其单独分离出来，其他全部给予默认值

有时我们会忘记关键字参数，那么可以只写敏感部分，比如监控端口，用户密码等

def showconfig(username,password,**kwagrs):

    print(username)

    print(password)

    for k,v in kwagrs.items():

        print(‘{} = {}‘.format(k,v))

showconfig(‘wangchao‘,‘1234‘,host=‘127.0.0.1‘)

wangchao

1234

host = 127.0.0.1

改进：

def showconfig(username,*args,**kwargs):

    print(username)

    print(args)

    for k,v in kwargs.items():

        print(k,v)

showconfig(‘chaoye‘)

定义时，第一个是必须需要定义的，其他都是可变类型，可变类型支持0到n个

定义位置的先后顺序

*args 一般需要定义在**kwargs 之前的位置，以复杂度进行排放

def showconfig(username,**kwargs,*args):

    print(username)

    print(args)

    for k,v in kwargs.items():

        print(k,v)

如果定义的顺序不当，则会直接告警

  File "E:\python_project\a.py", line 3

    def showconfig(username,**kwargs,*args):

                                    ^

SyntaxError: invalid syntax

[Finished in 0.1s with exit code 1]

总结：

·有位置可变的参数和关键可变的参数，*args和**kwargs

·位置可变参数和关键字可变参数（*args和**kwargs都可以收集若干个实例，位置可变参数(*args)收集实参封装为一个元组，关键字可变参数(**kwargs)则封装为一个字典

·混合使用参数的过程，可变参数要放到参数的列表最后，普通参数需要放到参数列表前，位置参数*args需放置**kwargs关键字参数前

  即： 位置参数 --> 关键字参数 -->*args --> **kwargs

例：

以下语法没有问题

def fn(*args,x,y,**kwargs):

    print(x)

    print(y)

    print(args)

    print(kwargs)

首先对位置参数进行赋值

fn(1,2,3)

提示：

TypeError: fn() missing 2 required keyword-only arguments: ‘x‘ and ‘y‘

只对关键字参数进行赋值，但是没有对位置参数进行传递，所以此类语法无法识别

fn(3,5,a=1,b=‘py‘)

以下语句通过，首先对args进行了传递，x和y分别以关键字形式进行传递，b以kw的方式传递

fn(3,5,y=1,x=2,b=‘python‘)

2

1

(3, 5)

{‘b‘: ‘python‘}

关键字的传参方式依然是将x，y进行对应，原则上没有更变，只是区别当前的传参的方式

keyword-only 关键字参数形参（强制参数）

keyword-only 在python3种加入，如在一个星号形参后，或一个位置可变参数后，则是kw-only参数类型

def fn(*args,x):

    print(x)

    print(args)

fn(3,5,1,x=9)

args可以手机所有的位置参数，x不能使用关键字参数就不可能拿到实参

如果kw放在后面是kw-only参数，kw为可变kw，x也同样，所以区分不出来，本身kw就跟顺序无关，其本意都是收集到一个字典

*号特殊意义   后期详细看

加上*号之后，*号将后面所有参数都强行转为keyword-only参数

def fn(*,x,y):

    print(x,y)

fn(x=1,y=2)

这样的定义在py3种的函数库大量存在

例：

def fn(z,*,x,y):

    print(z)

    print(x,y)

fn(9,x=1,y=3)

单星号之后的参数都是kw-only参数，需要指定绝对的缺省值

一般都会给一个默认值，但是必须提醒其存在

def fn(*args,x=1):

    print(x)

    print(args)

可变的本身就是0个，唯一需要确定的是在args星号后，不是普通参数，而是变身为kw-only类型，如果需要传参的话，至少传3个

def connect(host=‘localhost‘,port=3306,user=‘admin‘,**kwargs):

    print(host,port)

    print(user)

    print(kwargs)

connect(db=‘cmdb‘)

localhost 3306

admin

{‘db‘: ‘cmdb‘}

connect(host=‘123‘,db=‘cmdb‘)

123 3306

admin

{‘db‘: ‘cmdb‘}

函数解构

例：

def add(x,y):

    print(x+y)

    return x+y

add((1,2)[0],(3,4)[1])

使用*号对数据结构进行解析

def add(x,y):

    print(x+y)

    return x+y

t = (3,4)

add(*t)

当前变量t为记忆参数，对应的是元组，但是需要将元组拆解

def add(x,y):

    print(x,y)

t = [1,2]

add(*t)

1 2

这里必须将其对应参数位置，否则会报错，也就是说形参和实参数必须对应一致

t = [1,2,3,4]

add(*t)

    add(*t)

TypeError: add() takes 2 positional arguments but 4 were given

使用可迭代对象

add(*range(1,3))

1 2

解构字典

如解构字典类型必须使用**kwargs的形参即可

def fn(**kwargs):

    for k,v in kwargs.items():

        print(k,v)

d = {‘a‘:1,‘b‘:2}

fn(**d)

在解构的过程，必须对应函数的位置参数

使用字典方法进行传参：这样就并非是字符串传参，而是直接将其付给形参

可以对其进行遍历或者取key或value进行解构

可变的类型：

def add(*iterable):

    result = 0

    for x in iterable:

        result += x

    return result

print(add(1,2,3))

print(add(*[1,2,3]))

add(*range(10))

函数返回值

return和print

return的作用是直接出栈，写在return之后会被认为是废语句

print 会作为隐含类型进行转换并输出

隐式调用

return = return None

def showlist():

    return [1,2,3]

print(type(showlist()))

showlist返回的为一个值，这里为一个列表，但是列表中是存在元素的

def showlist():

    return 1,2,3

print(type(showlist()))

当没有定义返回的数据类型，则默认将其封装为元组并进行返回

所以，在return的时候都是返回一个值，最后一个以元组方式进行封装并返回

函数嵌套

内部函数不能被外部直接使用，会直接抛NameError异常

如下

def outer():

    def inner():

        print(‘inner‘)

    print(‘outer‘)

outer()

inner()

    inner()

NameError: name ‘inner‘ is not defined

函数外是不可看到函数内部，也就是说在函数外是找不到内部定义的

作用域

函数作为一个标识符的可见范围，被称为作用域，一般来讲指的是变量

例：

def fn():

    out = 123        #这个变量也算为一个标识符

    print(‘outer‘)

fn()

在函数内定义的变量，在函数外是不可被调用，因为不可以超越函数

目前我们在全局定义变量，在函数内是可以的

x = 50

def show():

    print(x)

show()

在函数中将变量进行更改

x = 50

def show():

    x += 1

    print(x)

show()

    x += 1

UnboundLocalError: local variable ‘x‘ referenced before assignment

在函数本地变量中，不允许对全局变量进行操作

作用域

全局作用域

    在整个程序中运行环境都可见

局部作用域

    在函数内定义的变量，被称为本地变量，只限局部使用范围，其他范围不可以被调用

函数嵌套结构

def outer1():

    o = 65

    def inner():

        print(‘inner‘,o)

    print(‘outer‘,o)

    inner()

outer1()

outer 65

inner 65

def outer2():

    o = 65

    def inner():

        o = 97              #当进入嵌套函数中，o已经被重新定义为一个新的变量

        print(‘inner‘,o)    #其打印的变量为上行重新定义的值

    print(‘outer‘,o)

    inner()

outer2()

outer 65

inner 97

原因在于赋值的定义，在外部的变量o与inner函数中的变量o没有任何关系

外部对内部是可见的，但是内部对外部则为不可见，在动态语言中，赋值既定义 所以都是在局部作用域中生效

x = 5

def foo():

    y = x + 1

    x += 1

    print(x)

foo()

    y = x + 1

UnboundLocalError: local variable ‘x‘ referenced before assignment

在函数本地变量中，不允许对其进行操作，看似是y赋值时错误，但实际为x+=1的时候出现错误

以上信息为没有绑定变量本地错误

至于x += 1为何报错的解释如下：

因为在本地语句块定义的x，在等式中先进行右运算，右边有x存在，那么被认为

x没有被赋值的空标识符，所以都被认为是局部变量

全局变量global

通过global对其进行全局变量声明

z = 1

def xx():

    global z

    z += 21

    print(z)

xx()

22

工作流程是先调用内部，再调用外部；在函数体内通过golbal 关键字声明变量；

将xx内的z使用外部的全局作用域中进行定义

赋值既定义的理念

回到之前的例子中，

x = 5

def foo():

    y = x + 1

    x += 1

    print(x)

foo()

    y = x + 1

UnboundLocalError: local variable ‘x‘ referenced before assignment

当x = 10，在x内部作用域作为一个外部作用域的变量赋值，所以在x+=1 的时候不会报错，这里的x作用域还是全局的x+=1，先引用后赋值

而python中，赋值才算真正的定义，才能被引用

解决办法：在语句前重新增加赋值语句，或者使用global告知内部作用域去全局作用域中定义这个变量

内部作用域中x = 1 之类的赋值语句会重新定义局部作用域使用的变量x，但是一旦声明全局global，声明x为全局的，那么x=1相当于在全局作用域的变量x赋值

例：

z = 1

def xx():

    global z

    z += 21

    print(‘xx_z:‘,z)

xx()

print(‘global_z:‘,z)

xx_z: 22

global_z: 22

闭包

闭包在装饰器中使用比较广泛

闭包的概念

自由变量：

没有在本地作用域中定义变量，在内层函数外的定义函数的自由变量

并且在因曾函数引用到了外层函数的自由变量

def counter():

    c = [0]

    def inc():

        c[0] += 1         #仅仅是对元素在赋值，与赋值变量是两码事

        return c[0]

    return inc            # 是返回一个标识符（函数的引用），可调用的对象，inc本身就是可调用对象

foo = counter()

print([foo() for _ in range(10)])

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

查看函数的类型

def counter():

    c = [0]

    def inner():

        c[0] += 1

        return c[0]

    return inner

foo = counter()

print(type(foo))

<class ‘function‘>

按照常理c会被赋值，但是现在为内部调用，所以在foo = counter()的时候，获取了引用变量，引用变量+1，inner不会被销毁，在return的时候直接return到inner()函数中进行了调用

c = 200

def counter():

    c = [0]

    def inner():

        c[0] += 1

        return c[0]

    return inner

c = 200

foo = counter()

print(type(foo))

c = 200

print(foo())

print(foo())

<class ‘function‘>

1

2

内部函数使用了外部自由变量则产生了一个闭包

如果对外部的自由变量进行改变的话，在2版本中只能使用元素修改的方式

如下所示：

c = 200

def counter():

    c = [0]

    def inner():

        c[0] += 1

        print(c)

        return c[0]

    print(c[0])

    return inner

foo = counter()

foo()

foo()

[0]

#以下为闭包所产生的值

1

2

3 

总结：

闭包的概念：内部函数使用了“外部自由变量”的时候产生了一个所谓比高

nonlocal

python3使用了nonlocal方式进行闭包

将变量标记在上级的局部作用域中定义，但是不能在全局作用域中定义

python2 中和 python3种的闭包对比：

python3

def outer():

    count = 0

    def inner():

        nonlocal count

        count += 1

        print(count)

        return count

    return inner

foo = outer()

foo()

foo()

1

2

在3中，使用nonlocal只能对其可以直接对上级变量进行操作，但是不能在全局中进行操作

python2中，仅能对自由变量进行操作

def outer():

    c = [0]

    def inner():

        c[0] += 1

        print(c)

        return c

    return inner

foo = outer()

foo()

foo()

默认值作用域 foo.__defaults__ 

涉及函数形参默认值

def foo(a=[]):

    a.append(100)

    print(a)

foo()

[100]

虽然是形式参数，但其也是局部变量

这个函数是一个对象，这个对象并非被销毁，说明对象存在，那么将其默认值a=[]存放在一个特殊属性上，也就是foo.__defaults__

In [2]: foo.__defaults__

Out[2]: ([],)

In [3]: foo()

[1]

In [4]: foo()

[1, 1]

在此查看默认值

In [10]: foo.__defaults__

Out[10]: ([1, 1],)

在函数外部调用并查看

In [11]: print(foo(),id(foo))

[1, 1, 1]

None 139733908903048

In [12]: print(foo.__defaults__)

([1, 1, 1],)

In [13]: print(foo(),id(foo))

[1, 1, 1, 1]

None 139733908903048

In [14]: print(foo.__defaults__)

([1, 1, 1, 1],)

In [15]: print(foo(),id(foo))

[1, 1, 1, 1, 1]

None 139733908903048

当传递进来lst之后，则是将引用对象传递，他们之间都是调用同一个id的，所以值是更改的

将更改的值return

def foo(a=None):

    if a is None:

        a = []

    a.append(1)

    return a

print(foo([1]))

print(foo())

[1, 1]

[1]

赋予函数None缺省值是一种惯例，一般形参上定义None说明接下来会传递某些参数进行一些处理性的操作

一般如果后期有定义或者传递的需求，建议将默认值写为None

总结：

1.使用浅拷贝创建一个新的对象，永远不能改变传入的参数

2.通过值判断，灵活的选择串讲或者修改传入的对象

  方法很龙火，在很多场景下，函数定义都可以看到使用None，这个不可变的值作为默认值进行传参，

函数的销毁

1.del funcname

2.覆盖，查看地址是否一致

3.待到程序结束时

本文出自 “心情依旧” 博客，请务必保留此出处http://yijiu.blog.51cto.com/433846/1973113