Python 通过变量引用内存中的值，变量的值占用多少空间是由变量类型决定。声明变量不需要显示指定变量的类型，解释器会自动根据值来判断。变量的名称必须符合标识符的定义。
标识符
标识符是由字母、数字和下划线构成。
标识符不能以数字开头。
标识符是区分大小写的。
下划线开头的标识符有特殊的意义，例如 _foo 代表不能直接访问的类属性。双下划线 __foo 代表类的私有成员。双下划线开头和结尾的例如 __foo__ 代表类里的特殊方法。
标识符不能是保留字。
保留字
保留字在 Python 程序中有特殊意义。不能用于定义变量名。这些保留字是：
and,exec,not,assert,finally or,break,for,pass,class,from,print,continue,global,raise,def,if,return,del,import,try,elif,in,while,else,is,with,except,lambda,yield
下面的例子声明了不同类型的变量，你可以任意赋值并打印他们
x = 3 # 数字类型
f = 3.1415926 # 浮点数类型 floating point number
name = 'alex' # 字符串类型 string
a = 1, 2, 3, 4, 5 # 元组
b = ['hello', 'world', '!'] # 列表
d = dict(name='alex', age=18) # 字典
Python有5个标准的数据类型。
数字类型 Numbers字符串类型 String列表 Lists元组 Tuple字典 Dictionary当你声明一个变量的时候，是不需要指定变量类型的，可以直接给变量赋与任何类型的值。
数字类型 Numbers
Python 支持很多数字类型
整数 Numeric浮点数 Float复数 Complex>>> a = 1 # 整数
>>> print(a)
1
>>> b = 3.14 # 浮点数
>>> print(b)
3.14
>>> c = 2 + 3j # 复数
>>> print(c)
(2+3j)
>>> complex(2, 3) # 复数
(2+3j)
a+bj 和 complex(a, b) 等效。
字符串
字符串类型是一个不可变的字符序列，由 str 对象表示。
字符串字面量有几种不同的定义形式
单引号：'foo'双引号："foo"三个引号： '''foo''' 或者 """foo"""三个引号的形式可以定义多行，换行符也算字符串的字符。
>>> a = """
... aaa
... bbb
... """
>>> a
'\\naaa\\nbbb\\n'
>>> print(a)
aaa
bbb
>>>
字符串相当于表达式，可以使用空格连续写多个字符串，相当于定义一个。例如 ('foo ' 'bar') 相当于 'foo bar'。
如果字符串里包含双引号，单引号，需要使用 \\ 转义。
>>> a = 'hello \\"world\\"'
>>> print(a)
hello "world"
>>> a = 'hello \\'world\\''
>>> print(a)
hello 'world'
可以转义单引号，双引号。以上输出并没有 \\。 若你想输出 \\，需要写两个连续的 \\。例如：
a = '\\\\'
print(a) # 输出 "\\"
或者加前缀 r，取消转义。
>>> a = r'hello \\'world\\''
>>> print(a)
hello \\'world\\'
字符串可以使用 + ，连接多个字符串，返回一个新的字符串。
>>> a = 'hello'
>>> b = ' world'
>>> a+b
'hello world'
列表
列表是可修改的序列类型。所以列表不可以作为字典的键。
>>> a = [1]
>>> hash(a)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
/<module>/<stdin>
如果调用 hash() 函数抛出异常 TypeError。
列表的操作：
赋值操作: s[i] = x赋值操作: s[i:j] = t删除操作：del s[i:j] 相当于 s[i:j] = []赋值操作：s[i:j:k] = t删除操作：del s[i:j:k]添加元素到末尾：举例：
>>> s
[1, 3]
>>> s.extend([4])
>>> s
[1, 3, 4]
>>> s += [6,7]
>>> s
[1, 3, 4, 6, 7]
>>> s *= 2
>>> s
[1, 3, 4, 6, 7, 1, 3, 4, 6, 7]
>>> s.insert(3, 10)
>>> s
[1, 3, 4, 10, 6, 7, 1, 3, 4, 6, 7]
>>> s.pop()
7
>>> s
[1, 3, 4, 10, 6, 7, 1, 3, 4, 6]
>>> s.pop(3)
10
>>> s
[1, 3, 4, 6, 7, 1, 3, 4, 6]
>>> s.remove(1)
>>> s
[3, 4, 6, 7, 1, 3, 4, 6]
>>> s.reverse()
>>> s
[6, 4, 3, 1, 7, 6, 4, 3]
>>> s.remove(100)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
/<module>/<stdin>
s.remove(e) 只会删除一个元素。
元组
元组是不可变的序列类型。由于它的不可变，可作为字典的键。
>>> t = 1,
>>> hash(t)
3430019387558
列表调用 hash() 函数会抛出 TypeError 异常，元组没有问题，返回的是一个整数。
元组的构造方式
使用一对小括号生成一个空的元组 ()逗号加在一个字符末尾，声明一个元素的元组 2, 或者 (2,)逗号分隔的元素 1,2,3 或者 (1,2,3)利用 tuple() 函数，tuple() 或者 tuple(iterable)>>> t = tuple()
>>> print(t)
()
>>> t = 1,
>>> print(t)
(1,)
>>> t[0]
1
>>> t[1]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: tuple index out of range
>>> t2 = (1,2,3)
>>> print(t2)
(1, 2, 3)
>>> t3 = tuple([1,2,3,4])
>>> print(t3)
(1, 2, 3, 4)
>>> t4 = tuple(range(10))
>>> print(t4)
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
>>> print(t4[3])
3
>>> print(t4[3:8])
(3, 4, 5, 6, 7)
/<module>/<stdin>
列表和元组访问如果下标越界，会抛出 IndexError 异常，例如元组越界会抛出 IndexError: tuple index out of range。
字典
Python中的字典是一个可映射的对象，映射是指一个可哈希化（hashable）的键值对应一个对象。字典是一个可变对象。
例如 {'name': 'alex', 'age': 18} ，声明了一个字典，对应两个映射对象，键姓名 name 对应一个字符串值alex，键年龄 age 对应一个整数
>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> a
{'one': 1, 'two': 2, 'three': 3}
>>> b
{'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1,2,3]))
>>> c
{'one': 1, 'two': 2, 'three': 3}
>>> d = dict([('one', 1), ('two', 2), ('three', 3)])
>>> d
{'one': 1, 'two': 2, 'three': 3}
字典的操作：
返回字典长度 len(d)返回键值 d[key]，如果键不存在，抛出 KeyError设置或更新键值 d[key] = value从字典中删除键 del d[key]，如果键不存在，抛出 KeyErrorkey in d 判断一个键是否存在iter(d) 返回一个包含字典中所有键的迭代器d.clear() 清空字典classmethod fromkeys(seq, [value])>>> d = {}
>>> d['one'] = 1
>>> d['two'] = 2
>>> d
{'one': 1, 'two': 2}
>>> del d['not_exists']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'not_exists'
>>> del d['one']
>>> d
{'two': 2}
>>> d.clear()
>>> d
{}
>>> len(d)
0
>>> d = dict.fromkeys('abc', 2)
>>> d
{'a': 2, 'c': 2, 'b': 2}
>>> d.get('a', 100)
2
>>> d.get('f', 100)
100
>>> d
{'a': 2, 'c': 2, 'b': 2}
>>> for i in d.items(): print(i)
...
('a', 2)
('c', 2)
('b', 2)
>>> for i in d.keys(): print(i)
...
a
c
b
>>> d['c'] = 5
>>> for i in d.values(): print(i)
...
2
5
2
>>> d.pop('f')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'f'
>>> d.pop('f', 99)
99
>>> d
{'a': 2, 'c': 5, 'b': 2}
>>> d.popitem()
('a', 2)
>>> d
{'c': 5, 'b': 2}
>>> d.setdefault('c', 99)
5
>>> d
{'c': 5, 'b': 2}
>>> d.setdefault('e', 99)
99
>>> d
{'e': 99, 'c': 5, 'b': 2}
>>> d.update({'d': 8})
>>> d
{'e': 99, 'c': 5, 'b': 2, 'd': 8}
/<module>/<stdin>/<module>/<stdin>