精华内容
下载资源
问答
  • 给出列表切片的格式: [开头元素::步长] # 输出直到最后一个元素,(最后一个冒号和步长可以省略,下同) [开头元素:结尾元素(不含):步长] # 其中,-1表示list最后一个元素 首先来看最简单的单一列表: a = [1,2,3,4]...
  • 在本篇文章里小编给大家分享了关于Python列表切片的知识点实例,需要的朋友们可以参考下。
  • 本文实例讲述了Python列表切片操作。分享给大家供大家参考,具体如下: 切片指的是列表的一部分。 1 基本用法 指定第一个元素和最后一个元素的索引,即可创建切片Python 会在到达指定的第二个索引之前元素后停止 ...
  • Python列表切片详解

    2020-10-16 19:53:40
    Python切片是list的一项基本的功能,类似的代码 a = list[::10] — 《Python核心编程中文版(第二版)》 解释一下[::n]的意思 >>> s = 'abcdefgh' >>>s[::-1] # 可以视为翻转操作 output: '...

    Python列表切片详解[] [:] [::]

    简介

    Python切片是list的一项基本的功能,类似的代码

    a = list[::10]

    — 《Python核心编程中文版(第二版)》

    解释一下[::n]的意思

    >>> s = 'abcdefgh'
    >>> s[::-1] # 可以视为翻转操作
    output: 'hgfedcba'
    >>>  s[::2]
    output: 'aceg'

    序列

    • 每一个元素通过指定一个偏移量的方式得到

    • 下标偏移量是从0开始到总元素数-1结束

    序列类型操作符

    序列操作符作用
    seq[ind]获取下标为ind的元素
    seq[ind1:ind2]获取下标从ind1到ind2间的元素集合
    seq * expr序列重复expr次
    seq1 + seq2连接序列seq1和seq2
    obj in seq判断obje元素是否包含在seq中
    obj not in seq判断obj元素是否不包含在seq中

    切片操作符([], [:], [::]

    • 序列类型即包含一些顺序排列的对象的一个结构

    • 访问一个数据元素的语法如下

      sequence[index]

       

    • index是想要访问的元素对应的偏移量,

      • 可以为正:​

      • 可以为负:​,

    • 正索引以序列的开始为起点

    • 负索引以序列的结束为终点

    • 切片:一次性得到多个元素

       sequence[starting_index:ending_index]
      • 通过这种方式可以得到从起始索引到结束索引之间的一“片”元素(不包含结束索引对应的元素)

      • 具体方式

        • 整个切片:[:]

        • 部分切片:[0:3]

    • 用步长索引来进行扩展的切片操作

      • 多出来的第三个索引值被用做步长参数

      • 可以和range()中的步长参数,或者C/C++中的for语句中的步长参数类比

         >>> s = 'abcdefgh'
         >>> s[::-1] # 可以视作“翻转”操作
         'hgfedcba'
         >>> s[::2] # 隔一个取一个的操作
         'aceg'

         

    更多内容

    • 切片索引的语法要比简单的单一元素索引灵活的多

    • 开始和结束索引值可以超过字符串的长度,

      • 即起始索引可以小于0,而对于结束索引,索引值为100的元素不存在并不会报错,即用100来作为一个长度不到100的序列的结束索引不会有什么问题

         >>> s = 'abcde'
         >>> i = -1
         >>> for i in range(-1, -len(s), -1)
                 print(s[:i])
             abcd
             abc
             ab
             a

         

      • 问题是:如何在第一次迭代的时候显示整个字符串呢?是否一种方法不用在整个循环之前加入一个额外的print方法?如何定义一个索引,代表整个的序列?

        • 方案:使用另外一个小技巧:用None作为索引值,比如,在想用要给变量作为索引来从第一个到遍历最后一个元素的时候:

           >>> s = 'abcde'
           >>> for i in [None] + range(-1, -len(s), -1):
                   print(s[:i])
           output:
               abcde
               abcd
               abc
               ab
               a

           

        • 现在这个程序符合要求了。

        • 另外一种方法:先创建一个只包含None的列表,然后用extend()函数把range()的输出添加到这个列表,或者先建立range()输出组成的列表然后再把`None插入到这个列表的最前面,然后对这个列表进行遍历

          • 然而,可变对象的内建函数extend()根本就没有返回值,此方法不通

             >>> for i in [None].extend(range(-1, -len(s), -1)):
                     print(s[:i])
             output:
                 error
             >>> for i in range(-1, -len(s), -1).extend([None]):
                     print(s[:i])
             正常输出
          • 错误发生的原因在于:[None].extend(…)

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • Python列表切片及方法

    千次阅读 多人点赞 2020-07-15 13:33:27
    ///网上总结,若有错误欢迎纠正/// 序列 ...切片的方法可取出一个列表中的一部分并且生成一个新的列表 通过:变量名[索引值 : 索引值 : 步长] ———— 进行切片 a = [1,2,3,4,5,6,7,8,9] 取出部

    本文章除特殊例子外,所有例子以此列表为准:

    a = [1,2,3,4,5,6,7,8,9]
    
    1. 序列
      顺序存放值的对象

    1. 列表
      用 [ ] 来创建一个列表
      a = [ ]

    1. 索引值
      列表的第一个索引值为0,每个元素之间相隔一个索引值,越往后索引值越大,索引值可以为负数,最后一个索引值为-1,以上方法以此类推。
      通过:变量名[索引值] ———— 来取出相对应的值

    1. 切片
      切片的方法可取出一个列表中的一部分并且生成一个新的列表
      通过:变量名[索引值 : 索引值 : 步长] ———— 进行切片
      (步长不能为0)

    取部分元素
    a [ 0 : 3 ] ———— 取出列表中 0 - 2 的元素 组成一个新列表
    a = [ 1 , 2 , 3 ] (左闭右开原则)
    a [ 2 : ] ———— 取列表索引值为2及以后的元素 组成一个新列表
    a = [ 4 , 5 , 6 , 7 , 8 , 9 ]
    a [ : 3 ] ———— 取列表从开始到索引值为3之前的元素 组成一个新列表
    a = [ 1 , 2 , 3 ]


    间隔取元素
    a [ 0 : 3 : 2 ] ———— 在范围里每隔一个取一个元素 组成一个新列表
    a = [ 1 , 3 ]


    反取元素
    a [ 3 : 0 : -1 ] ———— 逆序取元素 组成一个新列表
    a= [ 4, 3 , 2 ] (当反取元素时 应范围反取 且不步长为负数 否则将生成一个空列表) (左闭右开原则)


    选取整个列表
    a [ : ] ———— 取出所有元素
    a = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ]


    1. 修改列表
      (其方法可以理解为:删除选中的索引值 并重新添加元素)

    按索引值修改单个元素
    a [ 1 ] = 1
    此时列表为 : a = [ 1 , 1 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ]

    当这样操作时:
    a [ 0 ] = 1 , 2 , 3 , 4
    此时列表为 a = [ (1 , 2 , 3 , 4) , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ]
    (修改添加的元素可为任意对象 ,添加的值只占一个元素)


    按索引值修改部分连续元素
    a [ 0 : 3 ] = 1
    此时列表为:a = [ 1 , 4 , 5 , 6 , 7 , 8 , 9 ]

    当这样操作时:
    a [ 0 : 3 ] = 5 , 6 , 7, 8 , 9
    此时列表为 a = [ 5 , 6 , 7, 8 , 9 , 4 , 5 , 6 , 7 , 8 , 9 ]
    (当选中的元素为多个时,添加的元素,会分开存放,添加元素的个数不限)


    按索引值修改部分间隔元素
    a [ 0 : 3 : 2 ] = 2 , 2
    此时列表为 a = [ 2 , 2 , 2 , 4 , 5 , 6 , 7 , 8 , 9 ]
    (当间隔取元素修改时,添加元素个数应和选取元素个数相等)


    在指定位置插入元素
    (插入的元素 必须是可迭代的)
    a [ 1 : 1 ] = 1 , 2
    此时列表为 a = [ 1 , 1 , 2 ,2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ]


    1. 修改列表的方法

    .append(元素) ———— 整个元素当一个元素添加在尾部
    a.append ( [ 1 , 2 , 3 ] ) 执行后:
    a = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , [ 1 , 2 , 3 ] ]


    .insert(位置,元素) ———— 整个元素当一个元素插入到指定位置
    a.insert ( 1 , [ 1 , 2 ] ) 执行后:
    a = [ 1 , [ 1 , 2 ] , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ]


    .extend (元素) ———— 将元素扩展到当前列表(必须是可迭代的)
    a.extend ( [ 1 , 2 , 3 ] ) 执行后:
    a = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 1 , 2 , 3 ]


    .clear( ) ———— 清空当前列表
    a.clear ( ) 执行后:
    a = [ ]


    .pop (索引值) ———— 根据索引值删除兵返回元素
    a.pop ( ) 执行后:
    a = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 ]
    (当没有指定索引值,默认删除最后一个)
    a.pop ( 1 ) 执行后:
    a = [ 1 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ]


    .remove ( 元素 )———— 删除指定元素
    a.remove ( 1 ) 执行后:
    a = [ 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ]


    .reverse ( ) ———— 反转列表
    a.reverse ( ) 执行后:
    a = [ 9 , 8 , 7 , 6 , 5 , 4 , 3 , 2 , 1 ]


    .sort ( ) ———— 对列表进行排序 默认从小到大
    例如列表为:

    a = [ 9 , 3 , 5 , 7, 2 ]
    

    a. sort ( ) 执行后 :
    a = [ 2 , 3 , 5 , 7 ,9 ] (从小到大)
    (列表元素大小排序参考ASCII码
    a.sort ( reverse = True ) 执行后:
    a = [ 9 ,7 ,5, 3, 2 ] (从大到小)


    1. range( )函数
      语法:range ( 开始,结束,步长 ) (左闭右开原则)
      开始 默认是从0开始 例如 range(5) 等价于 range(0, 5) 0可以省略
      结束 不包括结束 例如 range(0, 5) 是多少? [0, 1, 2, 3, 4]
      步长 默认为1 可以省略 例如 range(5) 等价于range(0, 5) 等价于 range( 0 , 5 , 1)
      (开始,结束,步长 都只能为整数)

    可以用range函数创建有序列表:
    a = list( range ( 0 , 10 ) ) ———— 创建一个0到9的有序列表
    a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]


    1. for函数
      语法:for 变量① in 变量② :
      (每次从变量②中顺序取一个元素存放到变量① 简称:迭代

    例如计算1到10的和:

    sum = 0
    for i in range(1,11):
    	sum += i
    

    1. 通用操作

    + 可以将两个列表拼接成一个列表
    * 可以将列表重复指定的次数

    例如 + :

    a = [1,2,3]
    b = [4,5,6]
    c = a + b
    

    结果为:c =[1,2,3,4,5,6]

    例如 * :

    a = [1,2,3,4]
    b = a * 3
    

    结果为:b = [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]


    in用来检测指定预算是否在列表中
    not in 用来检测指定元素是否不在列表中

    a = ["hello","world"]
    b = "hello" in a
    c = "world" not in a
    

    此时 b的值为:True   ,  c的值为:Flase


    .index( )函数
    语法:变量名.index( 元素,开始位置,结束位置 )(左闭右开原则)
    作用:可以获取变量中某个范围内某个元素的第一个位置 默认为整个变量

    a = "hello wrold"
    b = a.index("o",5,8)
    

    此时b的值为:7
    (当没有找到时,会自动报错 ValueError: substring not found )


    .count( )函数
    语法:变量名.count( 元素 )
    作用:计算变量中指定元素的个数

    a = [1,2,3,5,2,4,1,3,6]
    b = a.count(1)
    

    此时b的值为:2


    更多操作请访问python官网~

    展开全文
  • python 列表切片

    万次阅读 2018-05-18 14:52:46
    这篇内容我们通过简单的示例来学习如何处理列表的一部分,这在python中称之为切片。 下面我们通过获取一个成员列表中指定元素的实例来说明如何使用。 #group members groups = ["张三",&...

    这篇内容我们通过简单的示例来学习如何处理列表的一部分,这在python中称之为切片。

    下面我们通过获取一个成员列表中指定元素的实例来说明如何使用。

    #group members
    groups = ["张三","李四","王五","赵六","老七"];
    
    #print the members range of 0-2
    print(groups[0:3]);

    在上述代码中,我们特别注意的是groups[0:3] 的写法,其中0:3分别代表的是从列表第一个元素开始,到第三个元素终止。这样的写法在前面大家也见过,如果没有印象的话,可以回想一下range函数的使用。

    上述代码打印的也是一个列表,不过是group列表的子集,输出大家可以参考以下:

    ['张三', '李四', '王五']
    

    当然了,大家可以指定任意范围的元素索引来提取我们想要的信息。

    如果,我们没有指定第一个索引位置,会发生什么情况呢?

    print(groups[:3]);

    这样的python代码会输出什么内容呢?

    ['张三', '李四', '王五']
    

    这是我想让大家注意的一点,如果没有指定第一个索引,python会默认从0开始处理列表,那么大家看到这里可能会想到,如果没有指定终止索引呢?

    答案和你们想的一样,如果没有指定最后一个索引,python会从列表末尾终止。

    print(groups[0:]);

    输出:

    ['张三', '李四', '王五', '赵六', '老七']
    

    那假如我们指定的列表索引超出了界限,python会如何处理呢?

    假如有如下代码:

    print(groups[0:10]);

    会和我们预想的一样python给我们提示列表越界吗?

    ['张三', '李四', '王五', '赵六', '老七']
    

    没有,python还是正常的打印了整个列表并没有提示有任何的错误。

    前面学习过range函数,想必大家对下面的代码应该不陌生吧。

    #print the members range of 0-2
    print(groups[-3:]);

    这行代码是从group列表的末尾第三个元素开始至列表末尾结束。这点大家想必很容易理解。大家只要记住:负数索引返回的的是距离列表末尾相应距离的元素。

    输出:

    ['王五', '赵六', '老七']
    

    至于如何遍历切片结果,这点参考前面学习过的for循环的使用,下面给一个简单的列子:

    #group members
    groups = ["张三","李四","王五","赵六","老七"];
    
    #print the members range of 0-2
    for member in groups[0:3]:
        print("current member is:" + member);

    输出:

    current member is:张三
    current member is:李四
    current member is:王五
    

    在很多情况下,在我们的程序中需要对列表进行复制然后创建一个全新的列表。
    大家可能第一想到的是下面这种写法:

    #group members
    groups = ["张三","李四","王五","赵六","老七"];
    
    new_groups = groups;
    
    print("groups:");
    print(groups);
    
    print("new groups:");
    print(new_groups);

    输出和大家预想的一样,两者的输出是相同的:

    groups:
    ['张三', '李四', '王五', '赵六', '老七']
    new groups:
    ['张三', '李四', '王五', '赵六', '老七']
    

    那么,我们突然对new groups列表新增一个成员,两者的输出还会一致吗?

    new_groups.append("老八");

    好了,老八加入了这个成员俱乐部,那么原来的列表应该没有老八这个人吧,我们在打印一下这两个列表:

    groups:
    ['张三', '李四', '王五', '赵六', '老七', '老八']
    new groups:
    ['张三', '李四', '王五', '赵六', '老七', '老八']
    

    咦,怎么两个列表都有老八呢?明明只会对新的列表增加了一个人,为什么会对原来的列表产生影响呢?

    在python中这种赋值语法其实是将变量groups和new_groups 关联在了一起,两者都是指向了同一个列表。

    那么该何如避免这个问题呢?

    切片,上面提到了切片这个概念,通过切片产生了一个新的列表,这就相当于又重新创建了一个列表,这样通过使用切片进行赋值的列表就没有了关联关系,自然不会产生影响。

    #group members
    groups = ["张三","李四","王五","赵六","老七"];
    
    new_groups = groups[:];
    new_groups.append("老八");
    
    print("groups:");
    print(groups);
    
    print("new groups:");
    print(new_groups);

    输出:

    groups:
    ['张三', '李四', '王五', '赵六', '老七']
    new groups:
    ['张三', '李四', '王五', '赵六', '老七', '老八']
    展开全文
  • 这篇文章主要介绍了Python列表切片常用操作实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 最近在爬一个网站的文档的时候,老师要求把一段文字切割...
  • 本文实例讲述了Python列表切片用法。分享给大家供大家参考,具体如下: Python中符合序列的有序序列都支持切片(slice),例如列表,字符串,元组。  格式:【start:end:step】  start:起始索引,从0开始,-1表示...
  • Python 列表切片的四大常用操作

    千次阅读 2019-10-14 06:55:00
    原创小白系列第7篇小白:小码哥,你能帮我解决几个问题吗?我想提取列表的某一段或者全部偶数位置的元素?这些信息在数据分析中经常遇到。小白:另外,通过前两篇文章小码哥:今...

    640?wx_fmt=png

    原创小白系列第  7  篇
    小白: 小码哥,你能帮我解决几个问题吗?我想提取列表的某一段或者全部偶数位置的元素?这些信息在数据分析中经常遇到。

    小白:另外, 通过前两篇文章

    小码哥: 今天我们一起聊一下列表的切片。它是非常好用的一个点,肯定可以帮你解决问题。


    01
    什么是切片?


    列表切片是处理列表的部分元素,也就是把整个列表切开。

    它是整个列表中的重点内容,在以后的Python项目中经常使用到。

    语法:

         [start:end:step]

         start:起始索引,从0开始

         end:结束索引,但是end-1为实际的索引值

         step:步长,步长为正时,从左向右取值。步长为负时,反向取值

        注意切片的结果不包含结束索引,即不包含最后的一位,-1代表列表的最后一个位置索引

    640

    02
    切片的四大常见操作

    《扶摇》是去年很火的一个电视剧。咱们今天使用列表存储里面的角色,然后用切片把它分开。具体如下?

    name_fuyao = ['扶摇','周叔','国公','无级太子','医圣','非烟殿主','穹苍']

    接下来,咱们使用上面的列表信息,盘点一下列表切片的常见用法:

    1. 利用切片,根据位置信息提取列表中的元素

    # 指定开始和结束位置,注意不包括最后的位置元素

    print('扶摇电视列表中第三个到第五个人物的名字:',name_fuyao[2:5])

    # 不指定开始的位置,则默认从头开始

    print('扶摇电视列表中前5个人物名字:',name_fuyao[:5])

    # 不指定结束的位置,则从开始位置到结束

    print('扶摇电视列表从6个人物的名字:',name_fuyao[5:])

    # 开始和结束位置都不指定

    print('扶摇电视列表中的名字:',name_fuyao[:])

    # 负数索引表示返回距离列表末位相应距离的元素,也就是取列表中后半部分的元素

    print('扶摇电视列表中最后三个人物的名字:',name_fuyao[-3:])

    # 取偶数位置的元素

    print('扶摇电视列表中偶数位置的人物是:',name_fuyao[::2])

    # 取奇数位置的元素

    print('扶摇电视列表中奇数位置的人物是:',name_fuyao[1::2])

    以上代码输出结果是:

    扶摇电视列表中第三个到第五个人物的名字: ['国公', '无级太子', '医圣']

    扶摇电视列表中前5个人物名字: ['扶摇', '周叔', '国公', '无级太子', '医圣']

    扶摇电视列表从6个人物的名字: ['非烟殿主', '穹苍']

    扶摇电视列表中的名字: ['扶摇', '周叔', '国公', '无级太子', '医圣', '非烟殿主', '穹苍']

    扶摇电视列表中最后三个人物的名字: ['医圣', '非烟殿主', '穹苍']

    扶摇电视列表中偶数位置的人物是: ['扶摇', '国公', '医圣', '穹苍']

    扶摇电视列表中奇数位置的人物是: ['周叔', '无级太子', '非烟殿主']

    640

    2. 利用切片逆序列表

    # 逆序列表,相当于reversed(list)

    print('扶摇电视列表中人物颠倒顺序:',name_fuyao[::-1])

    以上代码输出结果是:

    扶摇电视列表中人物颠倒顺序: ['穹苍', '非烟殿主', '医圣', '无级太子', '国公', '周叔', '扶摇']

    3. 利用切片插入多个元素

    # 在某个位置插入多个元素

    # 也可以用同样的方法插入或者删除多个元素

    name_fuyao[3:3]=['玄机','太渊','天煞']

    print('扶摇电视列表中人物变为:',name_fuyao)

    以上代码输出结果是:

    扶摇电视列表中人物变为: ['扶摇', '周叔', '国公', '玄机', '太渊', '天煞', '无级太子', '医圣', '非烟殿主', '穹苍']

    640

    4. 利用切片复制列表

    # 复制列表,相当于copy(),复制以后的新的列表是一个新的,可以对其操作

    # 注意如果new_name_fuyao = name_fuyao是变量赋值,也就是同一个值给了两个变量,一个改变了值 ,另外的两个值跟着修改了。

    new_name_fuyao = name_fuyao[:]

    print('新的列表元素:{}'.format(new_name_fuyao))

    以上代码输出结果是:

    新的列表元素:['扶摇', '周叔', '国公', '玄机', '太渊', '天煞', '无级太子', '医圣', '非烟殿主', '穹苍']

    以上内容摘自《零基础轻松学 Python》

    640?wx_fmt=png

    展开全文
  • 在学习深度学习的过程中,由于神经网络算法要用到向量化的方法来加速计算,因此时常用到Python中的列表数据结构,切片列表的常用操作,最近发现初学的时候对切片如何截取列表常常遗忘和混淆,这里用一篇手记简单...
  • python列表切片总结

    千次阅读 2019-10-22 10:19:38
    列表切片形式: list_name[start_index : end_index : step_length] 规则 1: 左闭右开 2:下标取值: (1):大于0——即从左往右索引,下标范围[0, len(list_name)-1] (2):小于0——即从右往左索引,下标范围[-...
  • range()函数配合循环一块使用很方便,今天来整理一下这个函数...#list函数是将range的值列表化,这时候的输出为 1,2,3,4 (没有5!即不包括最后一个end的值) print(list(range(1,5,2))) #输出结果是 [1, 3] ,步长为2,而
  • 列表切片–获取列表中指定位置的元素 name = ["aa","bb","cc","dd","ee"] print(name[0:3]) print(name[1:]) print(name[::-1]) # 反向排序输出 print(name[::2]) # 从开始输出,每间隔两个输出 提供Python自动化...
  • Python列表切片练习题

    千次阅读 2019-01-12 20:01:07
    利用切片操作,实现一个trim()函数,去除字符串首尾的空格,注意不要调用str的strip()方法: def trim(s): while s[:1] == ’ ': s = s[1:] while s[-1:] == ’ ': s = s[:-1] return s ...
  • s = 'abcdefg'# 返回从起始位置到索引位置 2 处的字符串切片print(s[:3]) # 输出 'abc' # 返回从第三个索引位置到结尾的字符串切片print(s[3:]) # 输出 'defg' # 字符串逆序输出print(s[::-1]) # 输出 'gfedcba' # ...
  • 今天小编就为大家分享一篇Python 利用切片列表中取出一部分使用的方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Python列表切片详解([][:][::])

    千次阅读 2018-03-22 12:05:00
    Python切片是list的一项基本的功能,最近看到了一个程序,里面有这样一句类似的代码: a = list[::10] 1 不太明白两个冒号的意思就上网百度,发现大多数人写的博客中都没有提到这一个用法,因此自己翻阅...
  • Python列表切片和统计

    千次阅读 多人点赞 2019-05-10 23:38:12
    from collections import Counter a = [1, 2, 2, 3, 4, 5, 5, 5, ...#切片。 s = slice(0, 4, 1) print(s.start) print(s.step) print(s.stop) print(a[s]) print(a[:4]) #统计出现次数最多的整数TOP2 my_count...
  • Python列表切片操作的一些问题 列表操作用到切片的场景 1、通过切片获取列表元素(会生成新的容器) list01=['a','b','c','d','e'] #不使用切片,意即list02和list01引用同一个列表 list02=list01 #通过切片获取...
  • 今天小编就为大家分享一篇Python高级特性——详解多维数组切片(Slice),具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • python列表切片和嵌套列表取值操作

    万次阅读 2018-04-06 16:00:37
    给出列表切片的格式:[开头元素::步长] # 输出直到最后一个元素,(最后一个冒号和步长可以省略,下同) [开头元素:结尾元素(不含):步长] # 其中,-1表示list最后一个元素首先来看最简单的单一列表:a = [1,2,3,4] a[:]...
  • Python中的列表切片非常灵活,要根据表象来分析它的内在机理,这样用起来才能溜。 下标可以为负数有利有弊,好处是使用起来更简便,坏处是当我下表越界了我也不知道反倒发生奇奇怪怪的错误。 print str[0:3] #截取...
  • Python学习笔记之列表切片(六)

    万次阅读 多人点赞 2018-08-20 10:11:25
    什么是切片:在Python中处理列表的部分元素,称之为切片。创建切片,可指定要使用的第一个元素和最后一个元素的索引,示例代码如下: ​#列表切片 lists = ['张学友','刘德华','黎明','郭富城']; print(lists[0:3]...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 112,364
精华内容 44,945
关键字:

python列表切片

python 订阅