共计 4126 个字符，预计需要花费 11 分钟才能阅读完成。
如前所说，写程序如同给算法写壳，而算法就是流程，所以流程是程序的配角（但这个流程不肯定要你来设计）。在程序中，为了配合流程（算法）的实现，除了程序、分支与循环语句的应用，还要借助“变量”这个角色。变量是重要的角色，男二号。
变量示意可变动的值，但这个值是有范畴的，并不是所有值都能够搁置到同一个变量中，值的范畴，由变量的类型决定。
变量的类型，决定两个事件，一是用多大的空间来存储这个变量值，二是这个变量值的范畴是多少。好了，这个不重要，先不要管这个细节，先把变量用起来，并把握一些基础知识即可。
变量有哪些类型呢？
（1）数字类型、bool 与字符串
这三个是常见的内置类型。
留神，值，决定了变量的类型，你给变量赋什么值，它就是什么类型。比方：
a = 10 # int 整数类型
a = 9.9 # float 浮点类型。变量名还是 a，然而值的变动，让它变成了一个新的变量
a = 987654321L # long 长整数类型，值以 ’L’ 完结
a = 3+4j # complex 复数类型
以上几个变量类型，别离是 int、float、long 跟 complex 类型，这几个类型能够归为数字类型。
除了数字类型，python 中的值还有 bool 类型跟 str 字符串类型，比方：
a = False # bool 类型，值要么为 False，要么为 True
a = “hellotype” # str 字符串类型
如果想晓得以后变量是什么类型，那能够应用内置函数（python 提供的一组函数）type()来确认，比方能够这样，注意 type()的输入：
所以，基本上，python 的变量类型，包含数字类型（int/float/long/complex）、bool 跟 str。
其中，str，即字符串，对它的操作会常常遇到，比方：
a = “hellotype”
a[1:] # 第 1 个字符到最初（留神索引是从 0 开始的）
a[2:]
a = “123456”
a[1:5] # 第 1 个字符到第 5 个字符的内容，但不包含第 5 个字符，也就是左闭右开的区间
a[-1] # - 1 示意最初一个字符，- 2 就是倒数第二个，如此类推
执行成果：
（2）常见的数据结构
除了以上常见的内置变量类型，pyton 还提供了一些罕用的数据结构，这些数据结构也是变量类型。
数据结构服务于算法，但因为某些数据结构切实太罕用了，以至于很多算法都有它们的身影，于是，把这些罕用的数据结构抽离进去，做为一个独立的结识点来讲，也是很正当的，但显著不是本文的事件。
数据结构，就是数据的组织构造，各个数据结构肯定会有本人的组织特点。python 中有几个常见的内置的数据结构，因为常常应用，甚至曾经被当作变量类型，跟数字类型、bool 与 str 一样的存在。
这几个常见的数据结构，别离是：列表、元组、汇合、字典。
同样，值决定类型（或数据结构）。
list 即列表，也是由值定义进去（以 [] 来定义），比方：
a = [1,2,3,4] # list
type(a)
list 的操作，跟字符串的相似，比方：
tuple 即元组，是只读列表（以 () 来定义），也就是元组的内容不容许批改，比方：
a = (‘hellotuple’, 123, True)
a[0]
a[1] = 100 # 试图批改元组的内容，会报错
a * 2 # 跟 list 的操作统一，内容反复 2 次，并产生新的元组
b = (1,2)
a + b # 元组相加是能够的，因为产生了新的元组，并没有批改原来的元组
执行的成果如下：
list 跟 tuple 的特点，是能够寄存任意类型的元素，内容有序、可反复。
另一种常见的数据结构是 set，特点是，能够寄存任意类型的元素，内容是无序的，而且不能反复，这个就是汇合的特点。
set 即汇合的局部应用如下（以 {} 来定义）：
a = {2, True, ‘helloset’}
a[2] # 汇合 set 是无序，所以没有索引可言，试图应用索引会导致报错
b = set(‘helloset’) # 应用构造函数来创立一个 set，留神汇合中的元素会去重（这里元素是字符）
b = {‘a’, ‘a’, 1} # 元素会被去重
执行的成果如下：
最初一种数据结构是 dict，也就是字典。
dict 也是一个汇合，是键值对（key-value）的汇合，同样 以{}来定义，但包含 key 跟 value，比方：
d = {‘k1’:1, ‘k2’:2}
dict 跟 set 相似，内容无序，而且 key 不能反复。set 只保留了 key（无序且不反复），而去掉了 value。
dict 的局部应用如下：
d = {}
d[‘k1’] = “hellodict”
d[2] = “this is int”
d[True] = “bool true”
a = {‘a’:’first one’, ‘d’:’hellodict’, 3:’three’, ‘e’:34.45}
执行成果如下：
以上四种内置类型之间的转换，有可能在理论场景中利用到，操作上很简略，只须要用类型名去解决须要转换的值即可，比方：
a = list(set1) # type_name(xxx)
以上是 list、tuple、set 与 dict 的简略介绍，你能够依据理论场景去应用它们。
另外，我并没有介绍这四种数据结构的操作函数，实事上，被抽离封装的数据结构都有一系列操作函数，也就是对象的行为（对象不是指女朋友），比方以上几种数据结构，有对应的 append()、pop()、remove()等一系列的操作，这个在实践中再去了解与使用了。
（3）变量类型应用示例
不论是简略的变量类型（数字类型等）还是常见的数据结构（list 等），你都能够把它们归为变量类型。这些变量类型常常被应用，因为变量是程序的重要主角。
我在这里举几个示例，都是以 list 作为栈来解决问题的例子，心愿让你对变量类型有一个应用上的感知，而后在理论场景中灵便应用。
（a）判断左右符号是否配对
左符号：([{
右符号：)]}
配对的状况如：'([]){()}’，不配对的状况如：'[{]}]’。
用栈来了解就是：遍历所有字符。遇左符号则入栈；遇右符号则出栈（如果为空则间接返回 False），出栈返回的字符如果与右符号不配对则返回 False，如果配对则持续下一个字符。所有字符遍历完后，栈非空则返回 False，否则返回 True。
def sybol_match(str):
L=['(','{','['];
R=[')','}',']'];
s=[]
for c in str:
if c in L:
s.append(c)
else:
if not s:
return False
a=s.pop()
lp = L.index(a)
rp = R.index(c)
if lp!=rp:
return False
return not s（b）计算后缀表达式
计算一个表达式时，表达式能够以中断或后缀的形式录入，而后缀表达式因为不须要应用括号而简化了解决，所以是一个广泛的抉择。
比方：
中断：12(2/2) 后缀：12 2 2 /
中断：10-(23) 后缀：10 2 3 –
中断：(3-2)(9/3)+5 后缀：3 2 – 9 3 / 5 +
你能够画出树状图，再来了解（比方后缀遍历失去后缀表达式）。
用栈来了解就是：遍历所有宰割项（以空格切分）。遇到数字则入栈；遇到操作符出栈两次（这里简化为都是二元操作，第一次出栈的为参数 2，第二次为参数 1），并进行运算，再把后果入栈。遍历完所有宰割项后，返回栈中内容（只有一个值）。
operators = {
'+' : lambda p1, p2: p1+p2,
'-' : lambda p1, p2: p1-p2,
'*' : lambda p1, p2: p1*p2,
'/' : lambda p1, p2: p1/p2,
}
def calc_postfix(str):
expr = str.split()
s = []
for e in expr:
if e.isdigit():
s.append(int(e))
else:
f = operators[e]
p2 = s.pop()
p1 = s.pop()
s.append(f(p1, p2))
return s.pop()（c）背包问题
有若干个物品，每一个物品都有分量。背包有最大容量限度，求刚好装满背包最大容量的所有解。
比方：
物品名称 分量
物品 0 1kg
物品 1 8kg
物品 2 4kg
物品 3 3kg
物品 4 5kg
物品 5 2kg
背包最大能够装 10kg，那可能的解是：[0,2,3,5]、[1,5]等。
用栈来了解就是：纵情地装（按物品程序，只有能装得下就装），如果残余容量刚好为 0 或者之后的各个物品都装不下了，则出栈，即拿掉最初的一个物品 k，再持续从 k + 1 个物品开始装。在栈为空而且填装的物品的索引曾经超出范围，则完结循环。因为，总会始终出栈到一个物品都没有，再从下一个物品开始填装，所以肯定会呈现栈为空且没有物品可装的状况。
def knapsack(w, ws):
"""
w -- 背包容量
ws -- 物品分量列表 [1, 3, ..]
"""
ret = []
s = []
i = 0
cnt = len(ws)
rest = w
while s or i < cnt: # 栈不为空或者还有得装
while i < cnt and rest > 0: # 还有得装且还有容量
if rest >= ws[i]: # 装得下就装
s.append(i)
rest -= ws[i]
i += 1 # 不论以后的是否装得下，都要尝试下一个
if rest == 0:
ret.append(s[:]) # one solution
i = s.pop()
rest += ws[i]
i += 1
return ret
if __name__ == '__main__':
# print(sybol_match('[{()}]{}[()]()'))
# print(sybol_match('[({}])'))
# print(calc_postfix('12 2 2 / *'))
# print(calc_postfix('3 2 - 9 3 / * 5 +'))
ret = knapsack(10, [1, 8, 4, 3, 5, 2])
print(ret)以上是几个示例，你可不用关怀算法的设计，因为这是另外的话题，重点关怀代码中变量类型的应用，比方 list、dict 的应用等。
好了，本文介绍了 python 的变量类型跟常见的数据结构，你能够把内置的数据结构也当作变量类型。变量类型包含 int、float、long、complex、bool、list、tuple、set、dict。文章最初还就 list 举了几个应用例子，心愿能够帮忙你了解变量类型的应用。有缘再见，see you。