python之列表(list)

列表(list)和元组(tuple)都是有序序列(sequence)，一个列表（或者元组）可以包含0个或多个元素，与字符串序列不同的是：他们包含的元素的类型可以互不相同。事实上，他们的每一个元素都可以是python中的任何一种类型。

列表是可以更改的。你可以随意往列表里插入或者删除列表元素。

1.创建列表

     li=[ ]             #创建一个空列表

    

     或

     li=list( )        # list()是一个builtin函数，他将合适的参数转化为列表，参数为空时，返回空列表

     a=list("ABC")    ---> a==[A,B,C]

     a=list( (1,2,3) )   --> a==[1,2,3]

     numbers=[1,2,3,4,5]

    colors=["red","black","blue"]

    

     mix=[ 1 , "red" , "hello" , 6.11 , [1,2] ,1 ]    #前面提到过：列表的元素类型可以互不相同。列表的元素类型是任意的，所以可以嵌套,混合

2.使用索引获取列表的元素（随机读取）

   列表元素支持用索引访问，正向索引从0开始

            

   colors=["red","blue","green"]

            colors[0] =="red"

            colors[1]=="blue"

           

   同时，也可以使用负向索引(python中有序序列都支持负向索引)

            colors[-1]=="green"

          

      

3.列表的切片操作

  切片操作不是列表特有的，python中的有序序列都支持切片，如字符串，元组。

  切片的返回结果类型和切片对象类型一致，返回的是切片对象的子序列，如：对一个列表切片返回一个列表，字符串切片返回字符串。

 

  li=["A","B","C","D"]

 

  格式：  li[start : end : step]   

 start是切片起点索引，end是切片终点索引，但切片结果不包括终点索引的值。step是步长默认是1。

      

 

      t=li[0:3]      t-->["A","B","C"]                  #起点的0索引可以省略，t=li[:3]

     t=li[2: ]        t->>["C","D"]                       #省略end，则切到末尾

      t=li[1:3]      t-->["B","C"]

     

      t=li[0:4:2]    t-->["A","C"]                     #从li[0]到li[3],设定步长为2。

                   

      

 

 如何确定start和end，他们是什么关系？

        在step的符号一定的情况下，start和end可以混合使用正向和反向索引，无论怎样，你都要保证

      start和end之间有和step方向一致元素 间隔，否则会切出空列表

            t=li[0:2]

            t=li[0:-2]

            t=li[-4:-2]

            t=li[-4:2]

            

            上面的结果都是一样的；t为["A","B"]

     

     

         t=li[-1:-3:-1]

         t=li[-1:1:-1]

         t=li[3:1:-1]

         t=li[3:-3:-1]

         上面的结果都是一样的；t为["D","C"]

     

 

      

          

         t=li[-1:-3]

         t=li[-1:1]

         t=li[3:1]

         t=li[3:-3]

         都切出空列表

          

            

   

      同时，step的正负决定了切片结果的元素采集的先后

              

      省略start  和 end表示以原列表全部为目标

      t=li[::-1]     t--->["C","B","A"]          #反向切，切出全部

                  

      t=li[:]        t--->["A","B","C","D"]   #正向切全部

                    

     

4.列表的操作接口（列表是基于栈实现的）

  

       a=[“jobs”,”tom”]

 

 

 

         a.append(“mary”)       #追加一个元素到列表尾部

 

 

         a.extend([6,7,8])        #扩张列表

             

             a+=[6,7,8]             #也可以

 

         

         

 

         a.insert(0,”bob”)     #把bob插入为索引为0的位置

                                           #如果索引值超过了列表索引的最大值，不会有问题

                                             #只是把这个元素插入尾部而已，此时就像append

 

 

 

         a.remove(“tom”)       #删除列表中的值为tom的元素

 

 

         

         a.pop( )               #删除列表最后一个元素

         a.pop(1)               #删除索引为1的元素

 

 

         

 

         a.index(“tom”)     #返回元素tom的索引

 

         a.count(“tom”)     #返回元素tom出现的次数

 

        

         a.sort( )                              #排序(默认升序)

         a.sort(reverse=True)      #改为降序 

                          

                                                    注意：sort使用时，列表类要有排序意义

                                                    如：数字和字符串混合的列表，是无排序意义的。

                                                    就不能用sort( )

 

 

         del    a           解除a对列表对象的引用，就好象销毁了列表

        

         del    a[1]        从列表中删除a[1]这个元素

                                 注意：del的实际作用是解除引用，并非删除一个

                                内存对象。

                                当内存对象没有任何变量引用它时，他才会被垃圾

                                 回收机制回收。

 

    

 

 

 

         成员存在运算  in

             

         “tom”  in  a       -->True（a中有"tom"）   or    Flase(a无"tom")