定义一个递归函数就行了，下面是一个例子：
def get(d):
l=[]
for k,v in d.items():
if isinstance(v,dict):
l.append(get(v))
else:
l.append(v)
return l
d={"1":"2","a":{"b":{"c":"1"}},"b":"c"}
l=get(d)
print(l)
这是运行截图：
设为星标，第一时间获取更多干货在python中，数据类型主要由以下几类组成：
列表(list): [a, b]
元组(tuple)：(a, b, )
集合(set)： {a, b}
字典(Dictonary): {a: ‘aaa’, b: ‘bbb’}
1. 列表
列表(List)
列表是Python中使用最频繁的数据类型，专门用于存储一串信息
列表是一种有序和可更改的集合。允许重复的元素
列表使用[]定义，元素之间使用，分隔。例：[1,2, ...]
列表的索引从位置0开始
索引就是元素在列表中的位置编号，索引又可以被称为下标
注意：从列表中取值时，如果超过索引范围，程序会报错
虽然列表可以存储不同类型元素，但是曰常中一般存储相同类型的元素
如何使用列表
列表[索引]: 从列表中取值，获取指定索引的元素
列表[开始索引:结束索引:步长]:
返回从开始索引到结束索引-1的列表，如果设置步长，按步长跳过元素
len(列表): 获取列表的长度
元素 in 列表: 判断元素是否在列表中
列表.count(元素): 返回指定元素在列表中的个数
列表.index(元素): 返回指定元素在列表中第一次出现的索引，查找失败时报错
列表.sort(): 从小到大排序，括号内增加reverse=True ,则是从大到小排序
列表_reverse(): 逆序(反转)列表
列表.clear(): 清空列表
Eg:
# 0 init listL = [1, 2, 3, 4, 5, 7, 6]# 1 index valueL[1]# -->2# 2 stepL[2: 5: 2] # -->[3, 5]# 3 lengthlen(L) # -->6# 4 in6 in L # --->True8 in L # --->False# 5 countL.count(1) # --->1# 6 indexL.index(2) # --->1# 7 sortL.sort() # --->[1, 2, 3, 4, 5, 6, 7] 注意：会改变自己 返回None # 8 reverseL.reverse() # 由于第7步改变了自己， 这里变成[7, 6, 5, 4, 3, 2, 1] 会改变自己 返回None # 9. clearL.clear() # --->[]
列表特有的一些使用方法
L = [1, 2, 3, 4, 5]
列表[索引]=元素：修改指定索引的元素，索引不存在会报错
L[2] = 7 L# --->[1, 2, 7, 4, 5]
列表 . append(元素)：在列表的末尾追加元素
L.append(6)L # --->[1, 2, 7, 4, 5, 6]
列表 . insert(索引，元素)：在指定索引位置插入元素，索引不存在时在末尾追加
L.insert(3, 9)L # --->[1, 2, 7, 4, 9, 5, 6]
列表.pop(索引)：
删除并返回指定索引的元素，未指定索引时删除最后一项，索引不存在时报错
L.pop(3) # 4, L 变成[1, 2, 7, 9, 5, 6]L.pop() # 6, L 变成[1, 2, 7, 9, 5]
列表 . remove(元素)：删除列表中第一个出现的指定元素，查找失败时报错
L.remove(2) # L 变成[1, 7, 9, 5]
del 列表[索引]: 删除指定索引位置的元素，索引不存在时报错
del L[3] # L 变成[1, 7, 9]
列表l.extend(列表2): 将列表2拼接在列表1后
L.extend([8, 9, 10]) L # L 变成[1, 7, 9, 8, 9, 10], 等价于 L = L + [8, 9, 10]
2. 元组
元组(Tuple)
元组是一种有序且不可更改的集合, 允许重复的成员
元组与列表的类似，不同之处在于元组元素不可修改
元组使用()定义，元素之间使用,分隔。例：(a, b, …)
元组中只包含一个元素时，可以省略()，只需要在元素后加逗号
init_tuple = 100,type(init_tuple) # --->tuple# ---- 另外写法init_tuple = (100, ) # 逗号一定要加
注意：如果一个非元组类型的数据突然变成元组，检查是不是误加了逗号
集合与元组的通用方法
元组[索引]:从元组中取值，获取指定索弓丨的元素
元组[开始索引:结束索引:步长]:
返回从开始索引到结束索引-1的元组，如果设置步长，按步长跳过元素
len(元组)：获取元组的长度
元素in元组：判断元素是否在元组中
元组.count(元素)：返回指定元素在元组中的个数
元组.index(元素)：返回指定元素在元组中第一次出现的索引，查找失败会报错
元组和列表之间的转换
list(元组)：将元组转换成列表
tuple(列表): 将列表转换成元组
3. 集合
集合(Set)
集合是一种无序和无索引的序列。没有重复的元素
集合会自动删除重复的元素，一般应用于去重、交并差运算场景
集合使用{}定义，元素之间使用，分隔。例：{a, b, …}
集合与列表的通用方法
len(集合)：获取集合的长度
元素in集合：判断元素是否在集合中
集合.clear(): 清空集合
集合特有的使用方法
s = {1, 2, 3}
集合.add(元素)：将元素添加到集合中
s.add(5) # --->{1, 2, 3, 5}
集合1.update(集合2): 添加新的元素或集合到当前集合中
s.add{4, 5, 6} # --->{1, 2, 3, 5, 4, 6}
集合.remove(元素): 删除指定的元素，元素不存在时报错
s.remove(4) # ---->{1, 2, 3, 5, 6}
集合1&集合2 : 交集，获得由集合1和集合2中都存在的元素组成的新集合
s &{3, 4, 5} # --->{3, 5}
集合1|集合2: 并集，获得集合1和集合2中所有元素的新集合
s | {8, 9, 10} # --->{1, 2, 3, 5, 6, 8, 9, 10}
集合1 - 集合2 : 差集，获得在集合1中存在但是在集合2中不存在的元素集合
s - {9, 10} # --->{1, 2, 3, 5, 6, 8}
集合和列表之间的转换(也可以和元组进行转换，方式类似)
list(集合)：将集合转换成列表
set(列表)：将列表转换成集合
单纯从数据结构上来讲的话，字典的数据结构是散列，也就是哈希表，它是无序的，而列表的数据结构是链表，是有序的，所以想把字典转换成列表并且保持顺序不变，是不可行的。题主可以使用OrderedDict（Python 2.7+）有序字典，OrderedDict是dict的子类，它记住了内容添加的顺序。
另外如果想把字典的key转换成列表，使用dict.keys()就可以了。
