首先申明下，本文为笔者学习《Python学习手册》的笔记，并加入笔者自己的理解和归纳总结。

1. 变量

1.1 变量命名规则

  • 变量名必须以下划线或字母开头，而后面接任意数目的字母、数字或下划线。
  • 区分大小写，"Hello"与"hello"是不同的。
  • 禁止使用保留字。

1.2 保留字

False       class       finally     is          return
None        continue    for         lambda      try
True        def         from        nonlocal    while
and         del         global      not         with
as          elif        if          or          yield
assert      else        import      pass
break       except      in          raise

1.3 变量赋值

基本形式
一个对象赋值给一个变量。

>>> val = 12                       # 整型
>>> val = 1.23                     # 浮点型
>>> val = "Hello World"            # 字符串

序列赋值
右侧可以是任何类型的序列，但左侧的变量数量必须与右侧一致。

>>> a, b = "Hello", "World"        # 元组赋值
>>> a, b
('Hello', 'World')

>>> a, b, c = ["aa", "bb", "cc"]   # 列表赋值
>>> a, b, c
('aa', 'bb', 'cc')

>>> [a, b, c] = (1, 2, 3)          # 元组赋值给列表
>>> a, b, c
(1, 2, 3)

>>> a, b, c = "abc"                # 字符串赋值
>>> a, b, c
('a', 'b', 'c')

>>> ((a, b), c) = ["ab", "hello"]  # 嵌套序列
>>> a, b, c
('a', 'b', 'hello')

多目标赋值

>>> a = b = "Hello World"          # 多目标赋值，等于b = "Hello World"，a = b
>>> a, b
('Hello World', 'Hello World')

>>> a = b = [1, 2]
>>> a.append(3)                    # 修改a的引用内容
>>> a, b                           # b的内容也被修改
([1, 2, 3], [1, 2, 3])

自赋值语句

X += Y    X -= Y    X /= Y    X *= Y
X %= Y    X &= Y    X |= Y    X ^= Y
X <<= Y   X >>= Y   X **= Y   X //= Y

X += Y等同于X = X + Y

>>> val = 1
>>> val += 10                      # 自加赋值
>>> val
11

>>> a = b = [1, 2]
>>> a += [3, 4]                    # 自加赋值，等同于extend方法
>>> a, b                           # a，b同时被修改
([1, 2, 3, 4], [1, 2, 3, 4])

1.4 变量是动态类型

变量的类型是动态的，只有当变量被赋值后，才能确定被定义成什么类型。

>>> val = 12                       # val是整型
>>> type(val)
<type 'int'>

>>> val = "Hello World"            # val是字符串
>>> type(val)
<type 'str'>

1.5 共享引用

共享引用是多个变量名引用了同一个对象。

>>> valA = 123
>>> valB = valA                    # 变量valA与valB指向同一个对象
>>> valA, valB
(123, 123)

>>> valB = "Hello World!"          # 对变量valB重新赋值，不会影响变量valA
>>> valA, valB
(123, 'Hello World!')

在对象原处修改，会影响所有的引用

>>> valA = [1, 2, 3, 4]            # 变量valA引用了一个列表 
>>> valB = valA                    # 变量valA与valB指向同一个对象
>>> valA, valB
([1, 2, 3, 4], [1, 2, 3, 4])

>>> valB[1] = 34                   # 变量valB在原处修改
>>> valA, valB                     # 变量valA也被修改
([1, 34, 3, 4], [1, 34, 3, 4])

1.6 共享引用和相等

对共享引用来说，相等并且是同一个对象。

>>> valA = [1, 2, 3]
>>> valB = valA
>>> valA == valB                   # 变量valA和valB的值是否相同
True

>>> valA is valB                   # 变量valA和valB是否是同一对象
True

对变量B重新赋值，相等但并不是同一个对象。

>>> valA = [1, 2, 3]
>>> valB = [1, 2, 3]
>>> valA == valB                   # 变量valA和valB的值相同
True

>>> valA is valB                   # 变量valA和valB不是同一对象
False

对整型或字符串来说，赋同一个值，相等并且是同一个对象，系统对值进行了缓存。

>>> int1 = 12; int2 = 12
>>> int1 == int2
True

>>> int1 is int2                   # 系统对整型进行了缓存
True

>>> str1 = "HelloWorld!"; str2 = "HelloWorld!"
>>> str1 == str2
True

>>> str1 is str2                   # 系统对字符串进行了缓存
True

2. 变量作用域

2.1 作用域基本规则

  • 变量名引用查找，首先是本地，其次是函数内，然后是全局，最后是内置。
  • 所有def函数内赋值的变量名，默认均是本地变量，除非在之前声明为全局变量。
  • 在def函数之外给一个变量名赋值时，本地作用域与全局作用域是相同的。
>>> (a, b, c) = (1, 2, 3)     # 定义全局变量a, b, c
>>> def fun1():
    a = 11                    # a变量在方法fun1内定义，默认是本地变量
    def fun2():
        b = 21                # b变量在方法fun2内定义，默认是本地变量
        print a, b, c         # a和b是本地变量，c是全局变量
    fun2()

>>> fun1()
11 21 3

>>> a, b, c                   # a和b没有被修改
(1, 2, 3)

2.2 全局变量

跨文件访问
在文件mymod.py中

valA = "Hello World"
valB = 13

访问mymod模块。

>>> import mymod              # import导入mymod
>>> print mymod.valA          # 访问mymod模块的变量valA
Hello World

>>> mymod.valB += 3           # 修改mymod模块的变量valB
>>> print mymod.valB
16

文件内函数访问
在函数中访问全局变量。

>>> x = "Hello World!"
>>> def fun():
    print x                   # 直接访问变量x
>>> fun()
Hello World!

函数内修改全局变量
在函数内对任何一个变量的赋值，都会在本地变量上修改。除非调用global，声明该变量为全局变量。

>>> x = "Hello World!"
>>> def fun():
    global x                  # 声明x是全局变量
    x = "welcome"             # 重新对x赋值
>>> fun()
>>> x
'welcome'

global声明变量可以在全局没有声明过

>>> def fun():
    global b                  # 变量b没有在全局被定义过
    b = 17

>>> b                         # b没有被定义
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    b
NameError: name 'b' is not defined

>>> fun()                     # 调用方法fun，b被定义为全局变量
>>> b
17

2.3 循环中访问变量

嵌套函数在调用时才会使用变量，这时候参数都是同一个值。

>>> L = [1, 2, 3, 4, 5]
>>> actions = []
>>> for x in L:
    def fun():                # 定义方法fun
        print x ** 2,         # 使用循环中的变量x
	actions.append(fun)
>>> for ac in actions:
	ac()
25 25 25 25 25

在方法中添加参数记录值。

>>> actions = []
>>> for x in L:
    def fun(i = x):           # 定义方法fun，设置参数i
        print i ** 2,
    actions.append(fun)
>>> for ac in actions:
	ac()
1 4 9 16 25

2.4 访问函数内的本地变量

>>> def fun1():
    param = 12                # param是一个本地变量
    def fun2():
        print param           # 可以访问变量param
        param = 13            # 修改param的值，会引发异常
	fun2()

>>> fun1()
Traceback (most recent call last):
  File "<pyshell#132>", line 1, in <module>
    fun1()
  File "<pyshell#131>", line 6, in fun1
    fun2()
  File "<pyshell#131>", line 4, in fun2
    print param
UnboundLocalError: local variable 'param' referenced before assignment