DEFAULT CURRENT_TIMESTAMP默认值无效

---

以下内容最好都在pycharm内运行,变量污染问题很头疼,还影响实验结果!!!

---

作用域

• 函数作用域指一个标识符的可见范围，也就是标识符的作用域，我们也常说变量的作用域

def foo():
    x = 200

print(x)

• 上例中 x 是访问不到的，并且抛出（NameError:name ‘x’ is not defined），问题在于函数是一个封装体，他会开辟一个作用域，x变量被限制在作用域内，所以在函数外x变量不可见
• 每个函数都会开辟一个作用域

作用域分类

• 全局作用域

• 在整个程序运行环境可见
• 全局作用域中的变量称为全局变量

• 局部作用域

• 在函数、类等内部可见
• 局部作用域中的变量称为局部变量，适用范围不可超过其所在局部作用域

# a局部变量
def fn1():
    x = 1   #局部作用域,x为局部变量,使用范围在fn1内

def fn2():
    print(x) #x能打印么??

print(x)     #x可以打印么??

• 这里函数fn2中是无法打印的,函数内没有定义x并且函数外没有全局变量x
• 函数外的x也是无法打印的,因为,函数内变量对其不可见

# 全局变量
x = 10 
def foo():      #全局变量,定义在函数外
    print(x)    #可见么??

foo()

• 一般来说外部作用域变量在函数内部可见,可以使用
• 反之,函数内部局部变量,不能再函数外看到

---

函数嵌套

• 在一个函数中定义另外一个函数

def outer():
    def inner():
        print("inner")
    print("outer")
    inner()
outer()                 # 这样可以吗??
inner()                 #这样呢??

• 运行后会发现函数inner不能在函数外直接使用,会抛出NameError异常,因为它在函数外部不可见
• inner只是一个标识符,就是函数outer内部定义的变量(注意这里inner,就是inner不是inner函数,别看错啦)

---

接下来我们看如下代码:

def outer1():
    x = 65
    def inner():
        print("inner {}".format(x))
        print(chr(x))

    inner()
    print("outer1 {}".format(x))

outer1()

def outer2():
    x = 65 
    def inner():
        x = 97
        print("inner {}".format(x))
        print(chr(x))
    
    inner()
    print("outer2 {}".format(x))

outer2()

• 运行后发现外层变量在内部作用域可见
• 函数outer2,在内存作用域inner中重新定义了x值,相当于在当前函数inner作用域内重新定义了一个新变量x,但这个内部x值并不能覆盖掉外部作用域outer2中的x值,不过对于函数inner来说其只能可见自己作用域中定义的变量x

---

接下来我们看这两段代码 :

# 函数 1
x = 5
def foo():
    print(x)

foo()
# 可以正常执行

# 函数 2
x = 5 
def foo():
    y = x + 1
    # x += 1        #打开这一句会报错吗?要是换成x = 1呢?
    print(x)

foo()

• 对于函数 2 :

• 这里发现函数2可以正常运行,打开x+=1会UnboundLocalError
• 打开x=1也会报UnboundLocalError

原因分析:

• x += 1 其实是 x = x + 1
• 相当于在foo内部定义一个局部变量x,那么foo内部所有x都是这个局部变量x
• x = x + 1相当于使用了局部变量x,但是这个x还没有完成赋值就被右边拿来做加一操作

如何解决这个问题呢?看下面…

global语句

x = 10 
def foo():
    global x    # 函数内定义全局变量
    x += 1
    print(x)

foo()

• 使用global关键字的变量,将foo内的x生命为使用外部全局作用域中的x
• 全局作用域中必须存在x的定义

要是全局作用域中没有x的定义又会如何呢?

def foo():
    global x
    x += 10
    primt(x)

foo()
# 虽然声明了全局变量x,不过x没有定义,所以肯定会报错的

def foo():
    global x
    x = 10
    x += 1
    print(x)

foo()
print(x)
# 这样做可以吗 >.<

分析 :

• 上面函数不会报错
• 使用global关键字定义的变量在函数foo中声明,但是这也告诉函数foo作用域,这个x变量将变成全局变量
• 虽然函数foo中写了x=10,也不会在函数foo局部作用域中定义局部变量x
• 使用了global声明变量,函数内的变量将变成全局变量

---

总结

• x += 1这种特殊形式产生错误的原因?先引用后赋值,而python动态语言是赋值才算定义,才可以引用.解决办法,在引用语句前加x=0之类的赋值语句或者使用global告诉内部作用域去全局查找变量定义
• 内部作用域使用x=10之类的赋值语句会重新定义局部变量,但是,一旦这个作用域global x ,那么x再出现赋值定义情况就相当于修改全局变量

global使用原则

• 外部作用域变量在内部作用域可见,单页不要在内部局部作用域直接使用,函数目的就是为了封装,尽量与外界隔离
• 如果函数需要使用外部的全局变量,请尽量使用形参定义并调用实参解决
• 最好不要使用global,这里为了更好理解引入global

---

闭包

• 闭包:闭包是一个概念,出现在嵌套函数中,指的是内层函数引用到了外层函数的自由变量,就形成了闭包.
• 自由变量:未在本地作用域定义的变量,定义在内层函数外的外层函数的作用域的变量

def counter():
    c = [0]
    def inc():
        c[0] += 1       #会报错嘛??
        return c[0]
    return inc

foo = counter()
print('1',foo(),foo())      #打印什么呢??
c = 100
print('2',foo())            #打印什么呢??

运行发现 :

• 首先明确不会报错
• 第一次打印,函数foo两个返回值分别是1, 2
• 第二次打印函数foo返回值是3

代码分析 :

• foo = counter()这里执行函数counter并返回inc对应的函数对象,这个函数对象并不释放,因为foo记住了它
• c[0] += 1这里不会报错,因为c在函数counter内定义过,而且inc中的使用方式是为c的元素修改值,而不是重新定义c变量
• 函数外的c = 100 和函数counter内的c不一样,函数inc引用的自由变量正是函数counter中的变量c

这是python2中实现闭包的方式,python3可以使用nonlocal关键字

---

def counter():
    global count
    count = 0
    def inc():
        global count
        count += 1
        return count
    return inc

foo = counter()
print(foo(),foo())

• 这里举一个不恰当的栗子,上面代码虽然实现了利用global解决了内层函数拿到了外层函数的变量,不过不再是闭包了

下面我们可以看下python3中是如何巧妙解决这个问题的…

nonlocal语句

nonlocal :将变量标记为不在本地作用域定义,而是在上级的某一级局部作用域中定义,但不能在全局作用域中定义

def counter():
    count = 0 
    def inc():
        nonlocal count
        count += 1
        return count
    return inc

foo = counter
print(foo(),foo())

• count 是外层函数的局部变量,被内层函数引用
• 内层函数使用nonlocal关键字声明count变量在上级作用域而非本地作用域中定义
• 代码中内层函数引用外层函数局部作用域中的自由变量,形成闭包

错误示范 :

a = 100
def counter():
    nonlocal a
    a += 1
    print(a)
    count = 0 
    def inc():
        nonlocal count
        count += 1
        return count
    return inc

foo = counter
foo()
foo()

• 外层函数声明变量a不在当前作用域,但是往外就是全局作用域了,所以错误

---

默认值作用域

def foo(xyz=1):
    print(xyz)

foo()           #打印什么呢??
foo()           #打印什么呢??
print(xyz)      #打印什么呢??

• 这里第一次调用函数打印 1,第二次调用打印 1
• 到了print(xyz)时报NameError

往下对比着看 :

def foo(xyz=[]):
    xyz.append(1)
    print(xyz)


foo()           #打印什么呢??
foo()           #打印什么呢??
print(xyz)      #打印什么呢??

• 这里第一次调用函数打印 [1],第二次调用打印 [1, 1]
• 到了print(xyz)时报NameError

为什么这里第二次调用函数foo打印的是[1, 1]呢?

• 函数也是对象,每个函数被定义执行过后就生成一个函数对象和函数名这个标识符关联
• python把函数默认值放在函数对象的属性中,这个属性伴随着这个函数对象的整个生命周期

---

查看foo.__defaults__属性,它是个元组…

def foo(xyz=[],m = 123, n = 'abc'):
    xyz.append(1)
    print(xyz)

print(id(foo),foo.__defaults__)
foo()
print(id(foo),foo.__defaults__)
foo()
print(id(foo),foo.__defaults__)

运行结果如下 :

• 可见函数地址没有发生变化,就是说函数foo对象没变,调用它,他的属性__defaults__中使用了元组保存默认值,xyz默认值是引用类型,引用类型元素变动,并不是元组的变化

---

再看下面这段代码 :

#非引用类型缺省值
def foo(xyz,m = 123, n = 'abc'):
    m = 456
    n = 'def'
    print(xyz)

print(foo.__defaults__)
foo('test')
print(foo.__defaults__)

运行结果如下 :

• 属性__defaults__中使用元组保存所有位置默认值,它不会在函数体内改变了局部变量(形参)的值而发生改变

---

# keyword-only参数的缺省值
def foo(xyz,m = 123, *,n = 'abc',t = [1, 2]):
    m = 456
    n = 'def'
    print(xyz)

print(foo.__defaults__,foo.__kwdefaults__)
foo('test')
print(foo.__defaults__,foo.__kwdefaults__)

运行结果如下 :

• 属性__faults__中使用了元组保存了所有位置参数默认值
• 属性__kwfaults__中使用字典保存了所有keyword-only参数默认值

---

这里提一下列表的 + 和 +=

def x(a = []):
    a += [5]

print(x.__defaults__)
x()
x()
print(x.__defaults__)

运行结果如下 :

---

def y(a = []):
    a = a + [5]

print(y.__defaults__)
y()
y()
print(y.__defaults__)

运行结果如下 :

两者却别 :

• + 表示两个列表合并并返回一个全新的列表
• += 表示就地修改一个列表,在其后追加返回一个列表,就是extend方法

---

变量名解析原则 LEGB

• Local,本地作用域、局部作用域的local命名空间.函数调用时创建,调用结束消亡
• Enclosing,python2.2时引入嵌套函数,实现了闭包,这个就是嵌套函数的外部函数的命名空间
• Global,作用域即一个模块的命名空间.模块被import时创建,解释器退出时消亡
• Build-in,内置模块的命名空间,生命周期从python解释器启动时创建到解释器退出时消亡,例如print(open), print和open都是内置的变量

所以一个名词的查找顺序就是LEGB

函数的销毁

• 定义一个函数就是生成一个函数对象,函数名指向就是函数对象
• 可以使用del语句删除函数,使其引用计数减一
• 可以使用同名标识符覆盖原有定义,本质上也是使其引用计数减一
• python程序结束时,所有对象销毁
• 函数也是对象,不例外,是否销毁,还是看引用计数是否减为零

未完…有时间再继续补充…