Pyhton知识点6——列表

本文作者:林箖霖😉
本文原创,未经允许,禁止转载!

6. Python中的列表

  1. Python中的列表和数组很相似,但是列表存储的对象的类型可以不一样,而数组存储的对象类型一样

  2. 列表的特点: 1)列表元素按顺序有序排序 2)索引映射唯一数据 3)列表可以存储重复数据 4)任意数据类型混存 5)根据需要动态分配和回收内存 6)列表是一个可变序列

  3. 列表在内存中的存储方式

6.1 列表的创建

  1. 使用中括号 [ ]

    # 用中括号创建列表
    List = ['hello', 1, 90, 'world']
    print(List)  # ['hello', 1, 90, 'wordl']
    print(List[2])  # 90   顺序索引: 'hello'的索引值0,1的索引值为1,以此类推
    print(List[-1])  # world  逆序索引:'world'的索引值为-1,90的索引值为-2,以此类推
    
  2. 使用内置函数list()

    # 用list()函数
    
    # 该方法和使用中括号的效果一样
    List = list(['hello', 1, 90, 'world'])
    print(List)  # ['hello', 1, 90, 'world']
    
    # 如果list()里面放的是字符串,那么list()函数会将字符串分割为一个字符分别存储到列表中
    List2 = list('hello world')
    print(List2)  # ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
    List3 = list('123456')
    print(List3)  # ['1', '2', '3', '4', '5', '6']
    
    # list()函数也可以搭配range()函数创建
    List4 = list(range(1, 10, 2))
    print(List4)  # [1, 3, 5, 7, 9]
    
  3. 使用列表生成式

    # 列表生成式
    List = [i for i in range(1, 10, 1)]
    print(List)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]
    

6.2 列表的查询

  1. 查询元素索引(使用 index()方法)

    #List.index(对象值)
    List = list(['hello', 1, 90, 'world', 'hello'])
    print(List.index('hello'))  # 0  ;若列表中存在重复值,则只输出查找到的第一个索引值(顺序索引)
    print(List.index(1))  # 1
    
  2. 获取单个元素(通过元素索引查询)

    • 元素索引分为顺序和逆序,顺序的索引从0开始,到N-1结束;逆序的索引从 -1 开始

      # 用中括号创建列表
      List = ['hello', 1, 90, 'world']
      print(List)  # ['hello', 1, 90, 'world']
      print(List[2])  # 90   顺序索引: ' hello '的索引值0,1的索引值为1,以此类推
      print(List[-1])  # world  逆序索引:' world '的索引值为-1,90的索引值为-2,以此类推
      
  3. 获取多个元素

    • 在获取多个元素所使用到的切片操作时,其会在源列表的基础上产生一个新的列表

      # 切片语法结构
      # 列表名[start : stop :step]
      # 切片所使用的索引号为顺序索引号,从0开始,N+1结束
      List = [10, 20, 30, 40, 50, 60]
      
      # 步长为正数
      list1 = List[1:5:]  # 不标明step,步长默认为1,从索引号1开始,一直到索引号4结束,顺序切割
      print(list1)  # [20, 30, 40, 50]
      list2 = List[:5:2]  # 不标明start,则默认从索引号为0的开始,步长为2
      print(list2)  # [10, 30, 50]
      list3 = List[1::1]  # 不标名stop,则默认到最后一个索引结束
      print(list3)  # [20, 30, 40, 50, 60]
      
      # 步长为负数
      # 由于不标明的step默认值为1,所以在逆序切片的时候一定要标明step值
      list4 = List[5::-1]  # 不标明stop,从索引号为5的元素开始往左切片(逆序切片),切到最后一个索引
      print(list4)  # [60, 50, 40, 30, 20, 10]
      list5 = List[:1:-2]  # 不标明start,默认从最后一个元素开始切片(步长为负数,逆序切片)
      print(list5)  # [60, 40]
      list6 = List[5:0:]  # 不标明step,默认步长为1,由于start为5大于stop0,故切出来的是空列表
      print(list6)  # []
      
  4. 查询该元素是否在列表中(in / not in)

       # 使用 in/not in 判断
       List2 = [10, 20, 'hello', 'world']
       print(10 in List2)  # True
       print(100 not in List2)  # True
       print("Hello" in List2)  # False
       print("hello" in List2)  # True
    

6.3 列表的增删改

  1. 增加元素

    • 使用 append()方法

       # append()方法 在原列表的末尾添加一个元素
       list1 = [10, 20, 'Hello']
       list1.append(100)
       print(list1)  # [10, 20, 'Hello', 100]
       list1.append("world")
       print(list1)  # [10, 20, 'Hello', 100, 'world']
       lis = [10, 20]
       list1.append(lis)  # 将lis当作一个元素添加到列表尾部
       print(list1)  # [10, 20, 'Hello', 100, 'world', [10, 20]]
      
    • 使用 extend()方法

       # extend()方法 在列表的末尾添加至少一个元素
       list2 = [10, 20, 'Hello']
       lis = ['world', 100]
       list2.extend(lis)
       print(list2)  # [10, 20, 'Hello', 'world', 100]
      
    • 使用 insert()方法

       # insert()方法 在列表的任意位置添加一个元素
       list3 = [10, 20, 'Hello']
       list3.insert(1, 'world')  # 在索引为1的位置上添加'world'
       print(list3)  # [10, 'world', 20, 'Hello']
      
    • 切片

       # 切片在列表任意位置添加至少一个元素
       list4 = [10, 20, 'Hello', "world1", 99]
       lis = [1, "world2", 100]
       
       # 顺序切片(步长为1)添加多少个元素都行
       # list4[1:3]=lis #从索引号1开始,将索引号为1,2的元素删掉,并将lis中的元素放进去
       # 输出为 [10, 1, 'world2', 100, 'world1', 99]
       # list4[1::1]=lis  #从索引号1开始,将后面的所有元素切掉,并且将切掉的元素更改为lis列表中的元素
       # 输出为[10, 1, 'world2', 100]
       
       # 间隔切片(步长不为1)的时候;逆序切片(步长为负数)时,切掉多少个元素,只能放多少个元素进去(不能多,不能少)
       # 顺序切片只能顺序放入元素
       # 逆序切片只能逆序放入元素
       
       # list4[0:3:2]=lis
       # 报错,因为lis列表里有三个元素,而切片只切掉了索引号为0,2的元素,位置不够
       
       # list4[0::2]=lis  #从索引号0开始,因为只把索引号为0,2,4的元素切掉,所以只能插入三个元素
       # 输出为[1, 20, 'world2', 'world1', 100]
       
       # list4[4::-2]=lis  #从索引号4开始,逆序切片,把索引号为4,2,0的元素切掉
       # 输出为[100, 20, 'world2', 'world1', 1],注意,逆序放入的!
       
       # list4[:0:-1]=lis  #从最后一个索引号开始,将索引号为5,4,3,2,1的元素切掉,但是由于是逆序,所以前面只能放四个元素
       # 报错,因为lis列表里面只有三个元素,而切片切掉了四个元素
       
       print(list4)
      
  2. 删除元素

    • 使用 remove()方法

      1. 重复元素只删除第一个

      2. 元素不存在则抛出ValueError

         # remove()方法
         # 一次只移除一个元素
         
         List1 = [10, 20, 30, 40, 50, 60, 30]
         List1.remove(30)
         print(List1)  # [10, 20, 40, 50, 60, 30]  只移除了20后面的30
         # 如果需要移除的元素不在列表里面,则会报错
         List1.remove(100)  # ValueError: list.remove(x): x not in list
        
    • 使用 pop()方法

      1. 通过指定索引删除指定元素

      2. 若索引不存在,则抛出IndexError

      3. 若不指定索引,则默认删除最后一个元素

         # pop()方法
         # 删除指定元素
         
         List2 = [10, 20, 30, 40, 30]
         List2.pop(1)  # [10, 30, 40, 30]  20的索引为1,移除了20
         print(List2)
         # 指定索引不存在
         List2.pop(5)  # IndexError: pop index out of range
         List2.pop()  # [10, 30, 40]  移除了最后一个30
         print(List2)
        
    • 使用 clear()方法

      1. 清楚列表所有元素

         # clear()方法
         # 清空列表所有元素
         List4 = [1, 2, 3]
         List4.clear()
         print(List4)  # []
        
    • 使用 del语句

      1. 将列表对象删除

         # def()语句
         # 删除列表对象
         List5 = [1, 2, 3, 4]
         del List5
         print(List5)  # NameError: name 'List5' is not defined
        
    • 切片

      1. 一次删除多个元素

      2. 只能删除连续索引号的元素,不能间隔删除元素

      3. 并不是真正的删除,只是把需要删除的元素用空列表替代

      4. step只能为1(默认值)

         # 切片
         # 删除至少一个元素
         List3 = [10, 20, 30, 40, 60, 20]
         # 连续删除元素
         List3[1:3:1] = []  # 将需要删除的元素用空列表代替
         print(List3)  # [10, 40, 60, 20],将索引号为1和2的元素删除
         # 间隔删除元素(不可行)
         # 删除不了,会报错 ValueError: attempt to assign sequence of size 0 to extended slice of size 2
         # List3[1:5:2] = []  
        
  3. 修改元素

    • 通过索引

      1. 一次修改一个元素

         # 通过索引
        List1 = [1, 2, 3, 50]
        List1[2] = 30  # 将索引号为2的元素替换为30
        print(List1)  # [1, 2, 30, 50]
        
    • 切片

      1. 一次修改多个元素

         # 切片
         List2 = [1, 30, 1, 50]
         # 顺序切除(步长为1)
         List2[1:3] = [100, 200, 300, 440]  # 将切除的位置放入新元素
         print(List2)  # [1, 100, 200, 300, 440, 50]
        

6.4 列表的排序

  1. 使用sort()方法

    • 在原列表上进行操作,不产生新的列表对象

      # sort()方法,默认升序排序
      list1 = [1, 3, 8, 10, 14]
      list1.sort()
      print(list1)  # [1, 3, 8, 10, 14]
      # 当reverse为True时,进行降序排序,若不指定reverse,则默认值为False
      list1.sort(reverse=True)  # 降序排序
      print(list1)  # [14, 10, 8, 3, 1]
      
  2. 使用内置函数:sorted()

    • 排序会产生新的列表对象

       # 调用内置函数sorted(),默认升序排序
       list2 = [10, 11, 1, 0, 2, 4, 20]
       new_list = sorted(list2)
       print(list2)  # [10, 11, 1, 0, 2, 4, 20]
       print(new_list)  # [0, 1, 2, 4, 10, 11, 20]
       # 当reverse为True时,进行降序排序,若不指定reverse,则默认值为False
       new_list = sorted(list2, reverse=True)
       print(new_list)  # [20, 11, 10, 4, 2, 1, 0]
      
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值