精华内容
下载资源
问答
  • Posted by 撒得一地 on 2016年4月2日 in ...例如,在一个字符串列表中替换索引包含“abc”的字符串。实现的方法有很多,比如可以用下面这种方法:>>> list = ['abc','abcde','ff','abc']>>> for s...

    Posted by 撒得一地 on 2016年4月2日 in python教程

    国外稳定加速器推荐

    vypr |

    Nord

    有些时候想要迭代序列中的对象,同时还要获取当前对象的索引。例如,在一个字符串列表中替换索引包含“abc”的字符串。实现的方法有很多,比如可以用下面这种方法:

    >>> list = ['abc','abcde','ff','abc']

    >>> for string in list:

    ...     if 'abc' in string:

    ...             index = list.index(string)

    ...             list[index] = 'ccc'

    ...

    >>> list

    ['ccc', 'ccc', 'ff', 'ccc']

    上面的例子中,不好的地方在于在替换字符串前还要搜索给定的字符串。还有另一种比较好的方法,如:

    >>> list = ['abc','abcde','ff','abc']

    >>> index = 0

    >>> for string in list:

    ...     if "abc" in string:

    ...             list[index] = "ccc"

    ...     index += 1

    ...

    >>> list

    ['ccc', 'ccc', 'ff', 'ccc']

    另一种方法是使用内建的enumerate函数:

    >>> list = ['abc','abcde','ff','abc']

    >>> for (index,string) in enumerate(list):

    ...     if "abc" in string:

    ...             list[index] = "ccc"

    ...

    >>> list

    ['ccc', 'ccc', 'ff', 'ccc']

    enumerate函数可以在提供索引的地方迭代索引-值(键值)对。

    ... other posts by psz1992

    展开全文
  • python列表索引总结

    万次阅读 多人点赞 2019-06-03 19:17:25
    Python包含6种内建序列: 列表 元组 字符串 Unicode字符串 buffer对象 ...序列中的每个元素都有编号,即其位置或索引,其中第一个元素的索引为0,第二个元素的索引为1,依此类推。在有些编程语...

    Python包含6种内建序列:

    • 列表
    • 元组
    • 字符串
    • Unicode字符串
    • buffer对象
    • xrange对象

    1.数据结构

    数据结构是以某种方式(如通过编号)组合起来的数据元素(如数、字符乃至其他数据结构)集合。在Python中,最基本的数据结构为序列(sequence)。序列中的每个元素都有编号,即其位置或索引,其中第一个元素的索引为0,第二个元素的索引为1,依此类推。在有些编程语言中,从1开始给序列中的元素编号,但从0开始指出相对于序列开头的偏移量。这显得更自然,同时可回绕到序列末尾,用负索引表示序列末尾元素的位置。

    2.序列

    元组是一种特殊的序列,类似于列表,列表和元组的主要不同在于,列表是可以修改的,而元组不可以。这意味着列表适用于需要中途添加元素的情形,而元组适用于出于某种考虑需要禁止修改序列的情形。禁止修改序列通常出于技术方面的考虑,与Python的内部工作原理相关,这也是有些内置函数返回元组的原因所在。在你自己编写程序时,几乎在所有情况下都可使用列表来代替元组。一种例外情况是将元组用作字典键。在需要处理一系列值时,序列很有用。在数据库中,你可能使用序列来表示人,其中第一个元素为姓名,而第二个元素为年龄。如果使用列表来表示(所有元素都放在方括号内,并用逗号隔开),将类似于下面这样:

    >>> edward = ['Edward Gumby', 42]

    序列还可包含其他序列,因此可创建一个由数据库中所有人员组成的列表:

    >>> edward = ['Edward Gumby', 42]
    
    >>> john = ['John Smith', 50]
    >>> database = [edward, john]
    >>> database
    [['Edward Gumby', 42], ['John Smith', 50]]

    有几种操作适用于所有序列,包括索引、切片、相加、相乘和成员资格检查。另外,Python还提供了一些内置函数,可用于确定序列的长度以及找出序列中最大和最小的元素。

    3. 索引

    序列中的所有元素都有编号——从0开始递增。你可像下面这样使用编号来访问各个元素:

    >>> greeting = 'Hello'
    >>> greeting[0]
    'H'

    字符串就是由字符组成的序列。索引0指向第一个元素,这里为字母H。不同于其他一些语言,Python没有专门用于表示字符的类型,因此一个字符就是只包含一个元素的字符串。

    这称为索引(indexing)。你可使用索引来获取元素。这种索引方式适用于所有序列。当你使用负数索引时,Python将从右(即从最后一个元素)开始往左数,因此-1是最后一个元素的位置。

    >>> greeting[-1]
    'o'

    对于字符串字面量(以及其他的序列字面量),可直接对其执行索引操作,无需先将其赋给变量。这与先赋给变量再对变量执行索引操作的效果是一样的。

    >>> 'Hello'[1]
    'e

    如果函数调用返回一个序列,可直接对其执行索引操作。例如,如果你只想获取用户输入的年份的第4位,可像下面这样做:

    >>> fourth = input('Year: ')[3]
    Year: 2005
    >>> fourth
    '5'

    负数索引与正数索引之间存在一个规律:当正数索引+负数索引的绝对值=元素的个数,它们所指的是同一个元素。

    # Hello World!:总共有12个元素,含空格和标点符号
    print('Hello World!'[8]) # r
    print('Hello World!'[-4])# r

    4. 切片

     除使用索引来访问单个元素外,还可使用切片(slicing)来访问特定范围内的元素。为此,可使用两个索引,并用冒号分隔:

    >>> tag = '<ahref="http://www.python.org">Python web site</a>'
    >>> tag[9:30]
    'http://www.python.org'
    >>> tag[32:-4]
    'Python web site'

    如你所见,切片适用于提取序列的一部分,其中的编号非常重要:第一个索引是包含的第一个元素的编号,但第二个索引是切片后余下的第一个元素的编号。请看下面的示例:

    >>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    >>> numbers[3:6] [4, 5, 6]
    >>> numbers[0:1] [1]

    简而言之,你提供两个索引来指定切片的边界,其中第一个索引指定的元素包含在切片内,但第二个索引指定的元素不包含在切片内。

    4.1 绝妙的简写

    分片用于截取某个范围内的元素,通过:来指定起始区间(左闭右开区间包含左侧索引值对应的元素,但不包含右测索引值对应的元素)。假设你要访问前述数字列表中的最后三个元素,显然可以明确地指定这一点。

    >>> numbers[7:10]
    [8, 9, 10]

    在这里,索引10指的是第11个元素:它并不存在,但确实是到达最后一个元素后再前进一步所处的位置。明白了吗?如果要从列表末尾开始数,可使用负数索引。

    >>> numbers[-3:-1]
    [8, 9]

    然而,这样好像无法包含最后一个元素。如果使用索引0,即到达列表末尾后再前进一步所处的位置,结果将如何呢?结果并不是你想要的。事实上,执行切片操作时,如果第一个索引指定的元素位于第二个索引指定的元素后面(在这里,倒数第3个元素位于第1个元素后面),结果就为空序列。好在你能使用一种简写:如果切片结束于序列末尾,可省略第二个索引。

    >>> numbers[-3:]
    [8, 9, 10]

    同样,如果切片始于序列开头,可省略第一个索引。

    >>> numbers[:3]
    [1, 2, 3]

    实际上,要复制整个序列,可将两个索引都省略。

    >>> numbers[:]
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    4.2 更大的步长

    执行切片操作时,你显式或隐式地指定起点和终点,但通常省略另一个参数,即步长。在普通切片中,步长为1。这意味着从一个元素移到下一个元素,因此切片包含起点和终点之间的所有元素。

    >>> numbers[0:10:1]
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    在这个示例中,指定了另一个数。你可能猜到了,这显式地指定了步长。如果指定的步长大于1,将跳过一些元素。例如,步长为2时,将从起点和终点之间每隔一个元素提取一个元素。

    >>> numbers[0:10:2]
    [1, 3, 5, 7, 9]
    numbers[3:6:3]
    [4]

    显式地指定步长时,也可使用前述简写。例如,要从序列中每隔3个元素提取1个,只需提供步长4即可。

    >>> numbers[::4]
    [1, 5, 9]

    当然,步长不能为0,否则无法向前移动,但可以为负数,即从右向左提取元素。

    >>> numbers[8:3:-1]
    [9, 8, 7, 6, 5]
    >>> numbers[10:0:-2]
    [10, 8, 6, 4, 2]

    步长为负数时,第一个索引必须比第二个索引大。否则无法取值

    >>> numbers[0:10:-2]         
    []
    >>> numbers[::-2]
    [10, 8, 6, 4, 2]
    
    >>> numbers[5::-2]
    [6, 4, 2]
    >>> numbers[:5:-2]
    [10, 8]

    在这种情况下,要正确地提取颇费思量。如你所见,第一个索引依然包含在内,而第二个索引不包含在内。步长为负数时,第一个索引必须比第二个索引大。当你省略起始和结束索引时:步长为正数时,它从起点移到终点,而步长为负数时,它从终点移到起点。

    注意:数据的一些细微区别

    num = [1,2,3,4,5,6,7,8,9,10]
    num1 = num[-1] # 输出:10  type:int
    num2 = num[-1:]# 输出:[10] type:list

    ‘+’运算

    表示两个序列的相连,但是仅对相同类型的序列进行连接操作。举例:

    #列表
    >>> [1,2,3] + [3,2,1]
    [1, 2, 3, 3, 2, 1]
    #字符串
    >>> 'Hi' + ',' + 'Baby'
    'Hi,Baby'
    #元组(tuple)
    >>> ('This','is','a') + ('test','case')
    ('This', 'is', 'a', 'test', 'case')
    #如果序列类型不一致,则会报错
    >>> 'Hi' + [1,2]
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: cannot concatenate 'str' and 'list' objects


    ‘*’运算(乘)

    ‘*’运算表示生成一个元素重复多次的序列,乘法表示将指定序列重复N次以生成一个新的序列,None可以用来初始化序列。

    >>>print('hi '*5)
    'hi hi hi hi hi '
    >>> print("hello" * 3)
    'hellohellohello'
    >>> (1,2,3) * 4 # tuple类型
    (1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3)
    >>> [1,2,3] * 4 # list类型
    [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
    >>> [None]*5 # none
    [None, None, None, None, None]
    >>> 4 * [1,2,3] # 支持交换律
    [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]

     

    参考:

    https://blog.csdn.net/jamfiy/article/details/87910881

    https://blog.csdn.net/qq_30622831/article/details/81704168

    https://blog.csdn.net/wang_weina/article/details/53613099

    展开全文
  • R:列表索引

    千次阅读 2014-10-27 09:10:08
    总共有三种方法访问列表lst中的组件c,返回值是c的数据类型: ...注:列表分量常常会被编号,我们总是可以用这种编号来访问分量。 后面两种方法还有另外两种: ●lst[”c”] ●lst[i] #i是c在lst中的数字编号  


     

        总共有三种方法访问列表lst中的组件c,返回值是c的数据类型:

    ●lst$c

    ●lst[[”c”]]   #是双重中括号,中括号之间不能打空格

    ●lst[[i]]       #i是c在lst中的数字编号

    注:列表分量常常会被编号,我们总是可以用这种编号来访问分量。

        后面两种方法还有另外两种:

    ●lst[”c”]

    ●lst[i]         #i是c在lst中的数字编号

        使用单括号和双括号都可以提取到表的元素。但是与普通(原子型)向量索引相比,两者存在很大不同。使用单中括号[]返回的是一个新的列表,它是原列表的子列表。

    > l <- list( name="Joe", salary=55000, union=T )

    > j <- l[[ 2 ]]

    > j

    [1] 55000

    > class( j )

    [1] "numeric"

    > str( j )

    num 55000

     

    > j <- l[ 2 ]

    > j$salary[1] 55000> class( j )

    [1] "list"

    > str( j )

    List of 1 $ salary: num 55000


        对原列表的取子集操作返回一个新的列表,新的列表由原列表的前两个元素组成。这里说“返回”是因为中括号也是一个函数。就类似于“+”这种操作符,看起来不像函数,但实际上是函数。

        而双重中括号“[[]]”一次只能提取列表的一个组件,返回值是组件本身的类型,而不是列表。

    > j <- l[[ 1:2 ]]

    Error in l[[1:2]] : subscript out of bounds

     

     


    展开全文
  • 列表list定义L1 =[]L2= [1,2,'abc']L3=list()L4= list(range(5))L5= [1,'abc',True,None,[4,5,'abc'],str]isinstance(L5,list)True列表索引访问L6 = list(range(5,10))L6[5, 6, 7, 8, 9]正索引:从下边界至上边界,...

    列表list定义

    L1 =[]

    L2= [1,2,'abc']

    L3=list()

    L4= list(range(5))

    L5= [1,'abc',True,None,[4,5,'abc'],str]

    isinstance(L5,list)

    True

    列表索引访问

    L6 = list(range(5,10))

    L6

    [5, 6, 7, 8, 9]

    正索引:从下边界至上边界,从0开始,为列表中每一个元素编号  #为便于理解,认为列表左为下边界,右为上边界

    负索引:从上边界至下边界,从-1开始

    列表通过索引访问:list[index]  #index为索引

    L6[3],L6[-3]

    (8, 7)

    正负索引不可以超出边界,否则报异常IndeError

    L6[9]---------------------------------------------------------------------------IndexError Traceback (most recent call last) in

    ----> 1 L6[9]

    IndexError: list index out of range

    列表元素查询

    index(value,[start,[stop]]) 通过值value,从指定区间查找列表内的元素是否匹配;时间复杂度为O(n)

    从下边界开始,匹配第一个就立即返回索引

    匹配不到报异常ValueError

    L6.index(5)

    0

    L6.index(5,2,4)2L6.index(9)---------------------------------------------------------------------------ValueError Traceback (most recent call last) in

    ----> 1 L6.index(9)

    ValueError:9 is not in list

    count(value) 返回列表中匹配value次数;时间复杂度为O(n)

    L6.count(5)2

    len() 统计列表长度;时间复杂度为O(1)

    len(L6)5

    时间复杂度

    O(1) 执行步骤为常数,效率较高

    O(n) 随着列表数据规模的增大,执行步骤增大,效率低

    修改,增加,插入元素

    list[index]=value 列表元素修改;时间复杂度为O(1)

    L6[-3] = 5L6

    [5, 6, 5, 8, 9]

    L6[-1] = L6[-3] + 5L6

    [5, 6, 5, 8, 10]

    append(object) 尾部追加,返回值为None,修改自身;时间复杂度为O(1)

    L7 = list(range(5,10))

    L7

    [5, 6, 7, 8, 9]

    L7.append(12)

    L7

    [5, 6, 7, 8, 9, 12]

    insert(index,object) 指定index处插入object,返回值为None,修改自身;时间复杂度为O(n)

    L7.insert(1,12)

    L7

    [5, 12, 6, 7, 8, 9, 12]

    extend(iteratable) 追加可迭代对象的元素,返回值为None,修改自身;时间复杂度为O(1)

    L8 = list(range(1,4))

    L8

    [1, 2, 3]

    L7.extend(L8)

    L7

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

    L7.extend(range(15,19))

    L7

    [5, 12, 6, 7, 8, 9, 12, 1, 2, 3, 15, 16, 17, 18]

    + 连接操作,将两个列表连接,返回list,产生新列表,原列表不变

    L7,L8

    ([5, 12, 6, 7, 8, 9, 12, 1, 2, 3, 15, 16, 17, 18], [1, 2, 3])

    L7+L8

    [5, 12, 6, 7, 8, 9, 12, 1, 2, 3, 15, 16, 17, 18, 1, 2, 3]

    L7,L8

    ([5, 12, 6, 7, 8, 9, 12, 1, 2, 3, 15, 16, 17, 18], [1, 2, 3])

    * 重复操作,将本列表元素重复n次,返回list,产生新列表,原列表不变

    L8 * 3[1, 2, 3, 1, 2, 3, 1, 2, 3]

    L8

    [1, 2, 3]

    展开全文
  • 我们知道,如果只是想将值分组到一个结构中,并且通过编号对其引用,那么列表就完全能够做到。但如果想通过名字来引用具体的值,像函数映射,那就要用到字典了,字典是python中唯一内建的映射类型,字典的值并没有...
  • 列表与元组——索引

    2017-02-09 15:36:06
    序列中所有的元素都是有编号的——从0开始递增 greeting = 'Hello' greeting[0] Out[7]: 'H' 这就是索引,可以通过索引获取元素,所有序列都可以通过这种方式进行索引。使用负数索引,python会从右边,也就是...
  • 索引

    2020-08-14 17:01:25
    索引:从左至右,从0开始,为列表中每一个元素编号 如果列表有元素,索引范围[0, 长度-1] 负索引:从右至左,从-1开始 如果列表有元素,索引范围[-长度, -1] 正、负索引不可以超界,否则引发异常IndexError 为了...
  • for i, elem in enumerate(foo):#i will equal the index#elem will be the element in foo at that index#etc...enumerate内置需要一些序列(如列表或生成器),并产生一个元组,其中第一个元素包含迭代编号,第二个元素...
  • 在程序猿的世界,数字是从0开始的,这个同样适用于python语言中的列表索引,我们建立了列表之后,如果要查询或者读取其中的第n个元素,这个元素的索引值并不是n,而是n-1,因为第一1个元素的索引编号是0,也就是有1...
  • 倒排索引列表 倒排索引创建索引的流程 搜索的过程 文档列表 ES先对原始doc文件进行编号 倒排索引列表 对文档中数据进行分词,得到词条。对词条进行编号,以词条创建索引。 然后记录下包含该词条的所有...
  • 一、简要概述whatislist? 1、用[和]括起来,用逗号间隔每...4、数据项对应的位置为索引编号(index)。默认第一个是0 5、有序的数据集合 whatisstring? 1、用单引号、双引号、三引号引起来。 2、字符串是一个常量不可...
  • 三、 搜索引擎索引[重点关注]3.1 索引基础3.1.1 单词-文档矩阵3.1.2 倒排索引...3.3 倒排列表在实际的搜索引擎系统中,并不存储倒排索引项中的文档编号,而是文档编号的差值(一种很常见的压缩技巧)。3.4 建立索引3...
  • 访问字符串、列表、元组中的元素需要通过“索引”,也可以称为下标,即给字符编号,方便我们“点名”。 可以从左往右编号,即正序,起始序号是“0”,如:0、1、2、3…… 也可以从右往左编号,即逆序,起始序号是“-...
  • 1. 索引编号超过对象的实际长度 1.1 Python 列表索引 Python 2.7.12 (default, Nov 12 2018, 14:36:49) [GCC 5.4.0 20160609] on linux2 Type "help", "copyright", "credits" or "license" for more information. ...
  • searcher.IndexDocument(0, types.DocumentIndexData{Content: "此次百度收购将成中国...// 将文档加入索引 // // 输入参数: // docId 标识文档编号,必须唯一 // data 见DocumentIndexData注释 // // 注...
  • 索引倒排

    2015-01-19 21:58:00
    正向索引:左边是文档编号,右边是关键词 正向索引的结构像下面这样子的: 文档编号1 此文档中出现的关键词列表(单词1,出现位置,出现次数;单词2,出现位置,出现次数………..) 文档编号2 此文档中出现的...
  • 列表

    2019-03-17 17:00:57
    1. 列表 列表的定义 ...索引 就是数据在 列表 中的位置编号索引 又可以被称为 下标 注意:从列表中取值时,如果 超出索引范围,程序会报错 name_list = [&quot;zhangsan&quot;, &quot;...
  • 倒排索引

    2016-06-12 17:00:00
    1、倒排索引相关概念: 文档、文档集合、文档编号(DocId)、单词编号 倒排索引、单词词典、倒排列表、倒排文件 ...在实际的搜索引擎中,并不保存倒排索引项中的实际文档编号,而是代之以文档编号差值(D-...
  • Python——索引

    2019-10-27 20:17:44
    序列是 一块用于存放多个值的连续内存空间,并且按一定顺序排列,每...序列中的每个元素都有一个编号,也称为索引,这个索引是从0开始的,即下标为0的是第一个元素,下标为1的是第二个元素,以此类推,如下图: 在...
  • 列表list

    2020-07-17 13:12:39
    Python列表一、列表定义二、列表索引访问三、列表查询四、列表的增加、插入元素五、列表的反转、排序六、列表删除元素七、列表的复制 一、列表定义 一个队列,一个排列整齐的队伍 列表内的个体称作元素,由若干元素...
  • inode(index node)表中包含文件系统所有文件列表一个节点 (索引节点)是在一个表项,包含有关文件的信息( 元数据 ),包括:文件类型,权限,UID,GID链接数(指向这个文件名路径名称个数)该文件的大小和不同的时间戳...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 904
精华内容 361
关键字:

列表索引编号