函数二

Posted cjluchen

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了函数二相关的知识,希望对你有一定的参考价值。

关于默认参数的陷阱问题:

见如下代码:

def func(m=[]):#默认参数的值是可变类型
    m.append(1)
    print(m)
func()
func()
func()

#控制台输出如下:

[1]
[1, 1]
[1, 1, 1]

即如果默认参数的值是一个可变数据类型,那么每一次调用函数的时候,如果不传值就共用这个数据类型的资源。

 

 

函数的命名空间

1:内置命名空间

就是python解释器一启动就可以使用的名字,存储在内置命名空间中

内置的名字在启动解释器的时候被加载进内存里

 

2:全局命名空间

是在程序从上到下被执行的过程中依次加载进内存的,放置了我们设置的所有变量名和函数名

 

3:局部命名空间

就是函数内部定义的名字

当调用函数的时候才会产生这个名称空间,随着函数执行的结束,这个命名空间就又消失了。

 

在局部:可以使用全局,内置命名空间中的名字

在全局:可以使用内置命名空间中的名字,不能使用局部命名空间中的名字

在内置:不能使用全局,局部命名空间中的名字

多个函数应该拥有多个独立的命名空间,不互相共享

 

作用域:

全局作用域----作用在全局----内置和全局命名空间中的名字都属于全局作用域

局部作用域----作用在局部----函数(局部命名空间中的名字属于局部作用域)

 

对于不可变数据类型,在局部可以查看全局作用域中变量,但是不能直接修改,如果想要修改,需要在局部的一开始添加global声明,如果在一个局部(函数)内声明了一个global变量,那么这个变量在局部的所有操作将对全局的变量有效。

 例如如下代码:

 

a=1#声明了一个全局变量a,值为1
def func():
    a=2#在局部(函数)改变a的值
func()#调用这个函数
print(a)#由输出结果可知局部的改变并没有影响到全局变量

#控制台输出
1

 

再看下面代码

a=1
def func():
    global a#在上面代码的基础上,添加global声明
    a=2
func()
print(a)#由输出结果可知,在局部声明了global后,局部的变化影响到了全局变量


#控制台输出
2

 

函数的嵌套定义:

内部函数可以使用外部函数的变量(不可变类型),但也不能直接修改,想要修改,需要在内部函数的变量前添加nonlocal声明

def outer():#定义一个外部函数
    a=1#在外部函数定义变量a
    def inner():#定义一个内部函数
        b=2
        print(a)
        print(inner)
        def inner2():#定义一个内部函数
            print(a,b)#可以查看a,b的值,但是不能直接修改
            print(inner2)
        inner2()
    inner()

outer()

#控制台输出
1
inner
1 2
inner2

如果企图在内部函数修改变量a

def outer():
    a=1
    def inner():
        b=2
        print(a)
        print(inner)
        def inner2():
            a+=1#企图在内部函数修改a
            print(a,b)
            print(inner2)
        inner2()
    inner()

outer()

#控制台输出:(报错)

UnboundLocalError: local variable ‘a‘ referenced before assignment

在内部函数为变量a添加nonlocal声明后:

def outer():
    a=1
    def inner():
        b=2
        print(a)
        print(inner)
        def inner2():
            nonlocal a#添加nonlocal声明,nonlocal只能用于局部变量,只会找上层中离当前函数最近一层的局部变量,如果最外层函数也没有这个变量,就会报错,不会去全局命名空间找,声明了nonlocal的内部函数的变量修改会影响到离当前函数最近一层的局部变量
            a+=1
            print(a,b)
            print(inner2)
        inner2()
    inner()

outer()

输出为:

1
inner
2 2#可见a的值变化
inner2

 

函数名的本质:

函数名本质上就是函数的内存地址。

1.可以被引用(可以赋值)

def func():
    print(123)
func2=func#函数名可以赋值
func2()
#控制台输出:123

2.可以被当作容器类型的元素(容器类型即列表,元组,集合这些)

def func():
    print(123)
func2=func
l=[func,func2]#函数名可以作为容器类型的元素
print(l)
for i in l:
    i()

#控制台输出
[<function func at 0x000001B98ED85950>, <function func at 0x000001B98ED85950>]
123
123

3.函数名可以作为函数的参数和返回值

#函数名作为函数的参数
def func():
    print(123)

def wahaha(f):
    f()

wahaha(func)#函数名可以作为函数的参数

#控制台输出
123
#函数名作为函数的返回值
def func():
    print(123)

def wahaha(f):
    f()
    return f#函数名可以作为函数的返回值

qqxing=wahaha(func)
qqxing()

#控制台输出
123
123

所以函数是第一类对象,什么是第一类对象?

第一类对象(first-class object)指
1.可在运行期创建
2.可用作函数参数或返回值

3.可存入变量的实体。

 

不明白?那就记住一句话,就当普通变量使用

 

闭包:

内部函数包含对外部作用域而非全局作用域的名字的引用,该内部函数成为闭包函数。

def outer():
    a=1
    def inner():#这个函数就是一个闭包函数
        print(a)#如果没有这句,这个函数就不是一个闭包函数,因为内部函数没有引用外部函数的变量
outer()

想要知道一个内部函数是不是闭包函数,需要使用__closure__方法。

def outer():
    a=1
    def inner():
        print(a)
    print(inner.__closure__)#注意没有__closure__括号
outer()

#控制台输出
(<cell at 0x000001D98A4EC078: int object at 0x00000000584F22D0>,)
有cell 什么什么的,就说明是一个闭包函数

 

我们都知道如果想要在函数外部使用函数内部的变量,只需返回这个变量,同理,如果我们想在函数外部使用函数内部嵌套的函数,只需将内部函数返回即可,这就是闭包最常用的方法

def outer():
    a=1
    def inner():
        print(a)
    return inner#返回inner()函数的地址
inn=outer()#执行outer()函数,返回inner()函数的地址赋给inn变量
inn()#加上括号表示执行这个函数,inn变量里面是inner函数的地址

#控制台输出
1

闭包的好处:

若不使用闭包,则内部函数想要在外部调用必须如下操作:

def outer():
    a=1
    def inner():
        print(a)
    inner()#必须写上这句
outer()#然后再外部执行外部函数

这样每次调用outer()函数都会在内存创建a变量,结束调用后又删除a变量,浪费了很多时间,若使用闭包,当执行inn=outer()时,内部函数的地址就被inn变量保存,当结束调用后python解释器会认为变量a还有用,所以不会删除,这样以后每次要使用内部函数时,只要写inn()就可以,节省了时间。

 




以上是关于函数二的主要内容,如果未能解决你的问题,请参考以下文章

为什么二代测序的原始数据中会出现Read重复现象?

二代身份证号码编码规则

染色体基因芯片分析和第二代测序应用的区别

开工第二天

C零基础视频-26-身份证号校验程序

二代下机文件在Integrative Genomics Viewer中实现reads可视化的流程