创建变量并分配值
要在 Python 中创建变量，你需要做的就是指定变量名称，然后为其赋值。
<variable name> = <value>
Python 使用 = 为变量赋值。不需要提前声明变量（或为其分配数据类型），为变量本身赋值并声明并使用该值初始化变量。如果没有为变量赋值，则无法声明变量。
# Integer
a = 2
print(a)
# Output: 2
# Integer
b = 9223372036854775807
print(b)
# Output: 9223372036854775807
# Floating point
pi = 3.14
print(pi)
# Output: 3.14
# String
c = 'A'
print(c)
# Output: A
# String
name = 'John Doe'
print(name)
# Output: John Doe
# Boolean
q = True
print(q)
# Output: True
# Empty value or null data type
x = None
print(x)
# Output: None
变量赋值从左到右。因此，以下内容将为你提供语法错误。
0 = x
=> Output: SyntaxError: can't assign to literal
你不能将 python 的关键字用作有效的变量名。你可以通过以下方式查看关键字列表：
import keyword
print(keyword.kwlist)
变量命名规则：
- 变量名称必须以字母或下划线开头。
x = True # valid
_y = True # valid
9x = False # starts with numeral
=> SyntaxError: invalid syntax
$y = False # starts with symbol
=> SyntaxError: invalid syntax
- 变量名的其余部分可能包含字母，数字和下划线。
has_0_in_it = "Still Valid"
- 名称区分大小写。
x = 9
y = X*5
=>NameError: name 'X' is not defined
尽管在 Python 中声明变量时不需要指定数据类型，但在内存中为变量分配必要的区域时，Python 解释器会自动为其选择最合适的内置类型 ：
a = 2
print(type(a))
# Output: <type 'int'>
b = 9223372036854775807
print(type(b))
# Output: <type 'int'>
pi = 3.14
print(type(pi))
# Output: <type 'float'>
c = 'A'
print(type(c))
# Output: <type 'str'>
name = 'John Doe'
print(type(name))
# Output: <type 'str'>
q = True
print(type(q))
# Output: <type 'bool'>
x = None
print(type(x))
# Output: <type 'NoneType'>
现在你已经了解了赋值的基础知识，让我们在 python 中获得关于赋值的精妙之处。
当你使用 = 做一个赋值操作，你对 = 的左边是一个名称的对象在右边。最后，= 的作用是将右侧对象的引用分配给左侧的名称。
那是：
a_name = an_object # "a_name" is now a name for the reference to the object "an_object"
因此，从上述许多分配的例子，如果我们选择 pi = 3.14，然后 pi 是一个名称（不是的名字，因为一个对象可以有多个名字）为对象 3.14。如果你对下面的内容不了解，请回到这一点并再次阅读！ 此外，你可以查看此内容以便更好地理解。
你可以在一行中为多个变量分配多个值。请注意，= 运算符的右侧和左侧必须有相同数量的参数：
a, b, c = 1, 2, 3
print(a, b, c)
# Output: 1 2 3
a, b, c = 1, 2
=> Traceback (most recent call last):
=> File "name.py", line N, in <module>
=> a, b, c = 1, 2
=> ValueError: need more than 2 values to unpack
a, b = 1, 2, 3
=> Traceback (most recent call last):
=> File "name.py", line N, in <module>
=> a, b = 1, 2, 3
=> ValueError: too many values to unpack
通过将剩余值分配给相等数量的任意变量，可以避免最后一个示例中的错误。这个虚拟变量可以有任何名称，但通常使用下划线（_）来分配不需要的值：
a, b, _ = 1, 2, 3
print(a, b)
# Output: 1, 2
请注意，_的数量和剩余值的数量必须相等。否则，如上所述抛出解压错误的值太多：
a, b, _ = 1,2,3,4
=>Traceback (most recent call last):
=>File "name.py", line N, in <module>
=>a, b, _ = 1,2,3,4
=>ValueError: too many values to unpack (expected 3)
你还可以同时为多个变量分配单个值。
a = b = c = 1
print(a, b, c)
# Output: 1 1 1
当使用这种级联赋值时，重要的是要注意所有三个变量 a，b 和 c 引用内存中的同一个对象，一个值为 1 的 int 对象。换句话说，a，b 和 c 是三个不同的名称给同一个 int 对象。之后为其中一个分配不同的对象不会改变其他对象，就像预期的那样：
a = b = c = 1 # all three names a, b and c refer to same int object with value 1
print(a, b, c)
# Output: 1 1 1
b = 2 # b now refers to another int object, one with a value of 2
print(a, b, c)
# Output: 1 2 1 # so output is as expected.
以上对于可变类型（如 list，dict 等）也是如此，就像对于不可变类型（如 int，string，tuple 等）一样：
x = y = [7, 8, 9] # x and y refer to the same list object just created, [7, 8, 9]
x = [13, 8, 9] # x now refers to a different list object just created, [13, 8, 9]
print(y) # y still refers to the list it was first assigned
# Output: [7, 8, 9]
到现在为止还挺好。当级联赋值用于可变类型时，在修改对象时（与将名称分配给不同的对象，我们在上面做过） 相比，情况有所不同。看看下面，你会看到它的第一手：
x = y = [7, 8, 9] # x and y are two different names for the same list object just created, [7, 8, 9]
x[0] = 13 # we are updating the value of the list [7, 8, 9] through one of its names, x in this case
print(y) # printing the value of the list using its other name
# Output: [13, 8, 9] # hence, naturally the change is reflected
嵌套列表在 python 中也有效。这意味着列表可以包含另一个列表作为元素。
x = [1, 2, [3, 4, 5], 6, 7] # this is nested list
print x[2]
# Output: [3, 4, 5]
print x[2][1]
# Output: 4
最后，Python 中的变量不必保持与它们首次定义的类型相同 - 你可以简单地使用 = 为变量赋值，即使该值属于不同类型。
a = 2
print(a)
# Output: 2
a = "New value"
print(a)
# Output: New value
如果这困扰你，请考虑一下 = 左侧的内容只是一个对象的名称。首先用 a 调用 int 对象，然后改变主意并决定将 a 这个名称赋予 string 对象，其值为 New value。简单吧？