python 列表展开，适用于N层嵌套的列表

       前一段去云英面试，技术官很”不厚道“了问了一个非常简单的问题：如何将多维列表转化了一维的？当时虽然想到了使用迭代或者列表生成式可以做到，但是可以没能可行的代码，回来后一顿后悔。

     对于规范的且嵌套维度较低的多维列表，python中有很多方法可以实现：

     

    
    

      
      

       
       

      
      
      
      

       
       

        
        a=[[
        
        1,
        
        2],[
        
        3,
        
        4],[
        
        5,
        
        6]]
       
       
      
      

      
      

       
       

      
      
      
      

       
       

        
        print [j 
        
        for i 
        
        in li 
        
        for j 
        
        in i]
       
       
      
      

      
      

       
       

      
      
      
      

       
       

        
        #or
       
       
      
      

      
      

       
       

      
      
      
      

       
       

        
        from itertools 
        
        import chain
       
       
      
      

      
      

       
       

      
      
      
      

       
       

        
        print list(chain(*a))
       
       
      
      

      
      

       
       

      
      
      
      

       
       

        
        #or
       
       
      
      

      
      

       
       

      
      
      
      

       
       

        
        import itertools
       
       
      
      

      
      

       
       

      
      
      
      

       
       

        
        a = [[
        
        1,
        
        2,
        
        3],[
        
        4,
        
        5,
        
        6], [
        
        7], [
        
        8,
        
        9]]
       
       
      
      

      
      

       
       

      
      
      
      

       
       

        
        out = list(itertools.chain.from_iterable(a))
       
       
      
      

      
      

       
       

      
      
      
      

       
       

        
        #or
       
       
      
      

      
      

       
       

      
      
      
      

       
       

        
        a=[[
        
        1,
        
        2],[
        
        3,
        
        4],[
        
        5,
        
        6]]
       
       
      
      

      
      

       
       

      
      
      
      

       
       

        
        t=[]
       
       
      
      

      
      

       
       

      
      
      
      

       
       

        
        [t.extend(i) 
        
        for i 
        
        in a]
       
       
      
      

      
      

       
       

      
      
      
      

       
       

        
        print t
       
       
      
      

      
      

       
       

      
      
      
      

       
       

        
        #or
       
       
      
      

      
      

       
       

      
      
      
      

       
       

        
        a=[[
        
        1,
        
        2],[
        
        3,
        
        4],[
        
        5,
        
        6]]
       
       
      
      

      
      

       
       

      
      
      
      

       
       

        
        print sum(a,[])
       
       
      
      

      
      

       
       

      
      
      
      

       
       

        
        #or
       
       
      
      

      
      

       
       

      
      
      
      

       
       

        
        reduce(
        
        lambda x, y: x+ y, a)
       
       
      
      
    
    

      对于复杂的多维嵌套列表就需要使用一些复杂的方法：

     
     

       
       

        
        

       
       
       
       

        
        

         
         #递归的方法比较容易理解
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
         def expand_list(nested_list):
        
        
       
       

       
       

        
        

       
       
       
       

        
        
    
         
         for item 
         
         in nested_list:
        
        
       
       

       
       

        
        

       
       
       
       

        
        
        
         
         if isinstance(item, (list, tuple)):
        
        
       
       

       
       

        
        

       
       
       
       

        
        
            
         
         for sub_item 
         
         in expand_list(item):
        
        
       
       

       
       

        
        

       
       
       
       

        
        
                
         
         yield sub_item
        
        
       
       

       
       

        
        

       
       
       
       

        
        
        
         
         else:
        
        
       
       

       
       

        
        

       
       
       
       

        
        
            
         
         yield item
        
        
       
       

       
       

        
        

       
       
       
       

        
        
            
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
         #在stackoverflow看到大牛的列表生成式版本
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
         func = 
         
         lambda x: [y 
         
         for l 
         
         in x 
         
         for y 
         
         in func(l)] 
         
         if type(x) 
         
         is list 
         
         else [x]
        
        
       
       

       
       

        
        

       
       
       
       

        
        

         
         #生成式的方法还有很多，可以自行摸索
        
        
       
       
     
     

      
      
补充(非递归的方法)适用于python3
def flatten(input_list):
    output_list = []
    while True:
        if input_list == []:
            break
        for index, i in enumerate(input_list):

            if type(i)== list:
                input_list = i + input_list[index+1:]
                break
            else:
                output_list.append(i)
                input_list.pop(index)
                break

    print(output_list)
 b = [1, [2, [3], [4, 5] ], [6, 7]]
 flatten(b)
 代码的原理比较简单，伪代码是：

遍历原始列表
对于列表中的当前元素
2.1 如果它是非列表元素，存入输出列表。
2.2 如果它是列表元素：进入该列表，执行2.1
一句话说清楚就是“遍历原始列表，对于列表内的元素，如果非列表就存入输出列表中，如果是列表元素，则进入改列表元素并查看列表内元素类型”

转载链接：https://www.jianshu.com/p/8215f455e4e5

     
     

    对于使用python2.X的童鞋，还可以使用flatten函数来做：

      
      

        
        

         
         

        
        
        
        

         
         

          
          >>> d=[
          
          1,
          
          2,
          
          3,[
          
          4,
          
          5],[
          
          6,
          
          7,[
          
          8,
          
          9]]]
         
         
        
        

        
        

         
         

        
        
        
        

         
         

          
          >>>
          
          from compiler.ast 
          
          import flatten
         
         
        
        

        
        

         
         

        
        
        
        

         
         

          
          >>>flatten(a)
         
         
        
        

        
        

         
         

        
        
        
        

         
         

          
          [
          
          1, 
          
          2, 
          
          3, 
          
          4, 
          
          5, 
          
          6,
          
          7,
          
          8,
          
          9]
         
         
        
        
      
      

   其实上边列举的方法仅仅是冰山一角，大海下的冰山就等这童鞋们自行去寻找挖掘了。

    

转载：https://blog.csdn.net/ACMer_Ding/article/details/73195260