精华内容
下载资源
问答
  • 一、什么是列表 列表是容器型数据,用[]表示 ...负下标从最后一个开始,是负就是倒数第个。 print(list[1]) #2 print(list[-2]) #a 2、查询多个元素(切片) 列表[开始下标:结束下标:步长] 步长可以

    一、什么是列表

    • 列表是容器型数据,用[]表示

    • 列表元素可以是任何数据类型,元素之间用逗号隔开

    • 列表是有序的、可变的。

      list1 = [1,2,3,4,'a','张三']
      

    二、列表的增删改查

    一、查

    1、查询单个元素
    1. 使用下标查询,下标有正负两种之分,下标不可越界。正下标从0开始到n-1;负下标从最后一个开始,是负几就是倒数第几个。

      print(list[1])		#2
      print(list[-2])		#a
      
    2、查询多个元素(切片)
    1. 列表[开始下标:结束下标:步长]
    2. 步长可以省略,省略步长那么步长前面的冒号一起省略,默认步长为1。列表[开始下标:结束下标]
    3. 若省略开始下标,那么取结束下标前的所有数据,冒号不省略。列表[:结束下标:步长]
    4. 若省略结束下标,那么从开始下标开始取剩余所有数据(包含开始下标),冒号不省略。列表[开始下标::步长]
    5. 从开始下标开始取值,但是取不到结束下标的值,只能取到结束下标的前一个,切片下标值可以越界。
    6. 若步长为正,那么从前往后遍历元素;若步长为负,则从后往前遍历元素。
    list1[1:4:2]		#[2, 4]
    list1[1:4]		#[2, 3, 4]
    list1[:4:2]		#[1, 3]
    list1[:4]			#[1, 2, 3, 4]
    list1[1::2]		#[2, 4, '张三']
    list1[1:]			#[2, 3, 4, 'a', '张三']
    list1[-7:-1:-1]	#[]
    list1[1:8:2]		#[2, 4, '张三']
    list1 [::2]		#[1, 3, 'a']
    

    二、改

    • 列表[index] = 值 - 修改某个特定下标的值
    • 列表[下标1:下标2] = [列表]- 修改某个范围的值,等号左右两边的值的个数可以不同
    list1[2]=30					#[1, 2, 30, 4, 'a', '张三']
    list1[1:3]=[10,20,30]		#[1, 10, 20, 30, 4, 'a', '张三']
    

    三、增

    • append(元素) - 添加在列表的末尾
    • insert(下标,元素) - 在给定下标的前面添加元素
    • extend(序列) - 将序列中的元素添加到列表中(不会产生新的列表)
    list1.append(60)			#[1, 10, 20, 30, 4, 'a', '张三', 60]
    list1.insert(3,50)			#[1, 10, 20, 50, 30, 4, 'a', '张三', 60]
    list1.extend([70,80,90])	#[1, 10, 20, 50, 30, 4, 'a', '张三', 60, 70, 80, 90]
    

    四、删

    • list.pop(下标) - 取出元素,默认取最后一个,取出后原列表中该元素将不存在
    • del 列表[下标] - 删除列表中指定下标对应的元素(下标不能越界)
    • list.remove(元素) - 若元素不存在,程序会报错;如果指定的元素存在多个,只删最前面的那个
    list1.pop(-1)		#90
    del list1[2]		#[1, 10, 50, 30, 4, 'a', '张三', 60, 70, 80]
    list1.remove(80)	#[1, 10, 50, 30, 4, 'a', '张三', 60, 70]
    

    三、列表相关的函数操作

    • 列表1 + 列表2 将列表1和列表2中的元素合并并产生一个新的列表

    • 列表*N 或 N*列表 N是正整数,将列表中的元素重复n次产生一个新的列表

     list1 = [1,2,3]
     list2 = ['a','b','c']
     list1 + list2			#[1, 2, 3, 'a', 'b', 'c']
     list1 * 2				#[1, 2, 3, 1, 2, 3]
    
    • == 和 !=

      补充:is 的用法
      is 和 == 的区别:

      • == 判断的是存储的值是否相等;
      • is 判断的是数据存储的地址是否相等。

      注意:给不同的变量赋相等的数字或者字符串,赋值之前系统会检查这个数字或字符串是否存在,
      如果存在直接返回数据的地址给变量,不存在才开辟新的内存。

    num1 = 10
    num2 = 10
    print(num1 == num2)     #True
    print(num1 is num2)     #True
    
    list3 = [1,2,3]
    list1 == list3		#True
    list4 = [2,1,3]
    list1 == list4		#False  	注意列表是有序的,除了值相等以外,元素所在的位置也要相同
    list1 is list3		#False
    
    • max(列表)
    • min(列表)

    注意:此处列表中的元素类型必须一致,并且支持比较运算。

    • sorted(列表)- 将列表中的元素从小到大进行排序,产生一个新的列表,不会改变原列表。
    • sorted(列表,reverse = True) - 将列表中的元素从大到小进行排序,产生一个新的列表。

    注意:此处列表中的元素类型必须一致,并且支持比较运算。

    • sum(列表) - 返回列表中所有元素的和

    注意 :列表中的元素必须全部是数字

    • list(数据) - 将数据转换成列表
      • a. 所有的容器型数据类型的数据都可以转换成列表

      • b. 将容器中的元素全部转换成列表中的元素

    四、列表的相关方法

    • 列表.clear - 清空列表

    • 列表.copy() - 复制列表中所有元素产生一个新的列表

    • 列表.copy() == 列表[:] == 列表+[] == 列表*1 - 浅拷贝

    • 列表.count(元素) - 统计指定元素在列表中出现的次数

    • 列表.extend(序列)- 将序列中的元素添加到列表中(不会产生新的列表)

    • 列表.index(元素) - 获取指定元素在列表中的下标值(正下标值)

      a. 如果元素不存在会报错
      b.如果元素有多个,只返回最前面那一个的下标值

    • 列表.index(元素,开始下标,结束下标)- 获取元素在列表中的下标,查找范围在开始下标到结束下标选中范围内(结束下标对应的值取不到)

    • 列表.reverse() 将列表中的元素倒序(不会产生新的列表)

    • 列表.sort()

    • 列表.sort(reverse=True)

    五、列表推导式

    1. [表达式 for 变量 in 序列] (可以按照下面的方式理解)
       for 变量 in 序列:
         表达式
    
       让变量去序列中取值,每取一个值就创建列表中的一个元素,元素的值就是表达式的值
    
    list2 = [x for x in range(4)]
    print(list2)        #[0, 1, 2, 3]
    
    1. [表达式 for 变量 in 序列 if 条件语句]

        for 变量 in 序列:
          if 条件语句:
            产生元素
      
      让变量去序列中取值,每取一个值就判断条件语句是否为True,如果为TRUE就创建一个列表元素,元素的值就是表达式的值.
      
    list7 = [x**2 for x in range(6) if x % 2 ]
    print(list7)        #1,3,5的平方 [1, 9, 25]
    
    1. [表达式 for 变量1 in 序列1 for 变量2 in 序列 2]

      for 变量1 in 序列 1:
      for 变量2 in 序列2:
      产生一个列表元素(值还是表达式结果)

    list8 = [x*y for x in range(4) for y in range(3)]
    print(list8)		#[0, 0, 0, 0, 1, 2, 0, 2, 4, 0, 3, 6]
    
    1. [表达式 for 变量1 in 序列1 for 变量2 in 序列 2 if 条件语句]
    list9 = [x+y for x in range(3) if x%2 for y in range(3)]
    print(list9)		#[1,2,3]
    
    展开全文
  • python 列表list操作

    2019-01-02 23:26:09
    list :用方括号将数据包起来,数据间用逗号隔开,数据类型可以不... 下标从0开始 形如: print(list[2]) , 结果为:12 (2)访问列表个数据 左闭右开,第一个冒号左边的表示数据开始的位置,第一个冒号...

    list :用方括号将数据包起来,数据间用逗号隔开,数据类型可以不一样

    形如:

    list=['a','b',12,45,['a','panda']]

    1、访问列表中的值

    (1)访问一个数据,用一个下标

               下标从0开始

    形如:

    print(list[2])

    ,

    结果为:12

    (2)访问列表中几个数据

    左闭右开,第一个冒号左边的表示数据开始的位置,第一个冒号右边的表示数据结束的位置,若省略则表示到最后一个数据,下标若为负,则表示从末尾开始,-1表示最后一个数据的下标;第二个冒号右边的表示步长,正表示从前往后,负表示从后往前

    形如:

    print(list[1:4])
    print(list[1:4:2])
    print(list[1:])
    print(list[1:-1])
    print(list[-1::-1])

    结果为:

    ['b', 12, 45]
    ['b', 45]
    ['b', 12, 45, ['a', 'panda']]
    ['b', 12, 45]
    [['a', 'panda'], 45, 12, 'b', 'a']

    2、list操作

    (1)添加元素

    list.append(x) 将x添加到列表尾部
    list.insert(i,x) 在下标为i的位置添加元素x

    (2)修改元素

    list[num]='s' 将下标为num的元素改为's'
    list[n:m]=['s','w'....] 将列表中下标从n到m的元素修改为's','w'....

    (3)删除元素

    list.remove(x) 将list中的x元素删除,没有返回值
    list.pop(num) 将下标为num的元素删除,返回删除的元素
    del list[num] 将list中的x元素删除

    (4)其他操作

    list.count(x) 统计列表中元素x出现的次数
    list.extend(x) 在列表末尾一次性追加x列表中的多个值
    list.index(x) 获取x元素在列表中第一次出现的下标
    list.reverse() 将list反序
    list.sort() 默认升序排序
    list.clear() 清空列表
    list.copy() 返回list列表的复制
    len(list) 返回列表的长度
    max(list) 返回列表中的最大值
    min(list) 返回列表中的最小值
    list(sqe) 将sqe转为list类型

     

    展开全文
  • python 切片 使用格式 python切片使用范围包括...只是因为python、c和其它语言一样下标0开始。 好处: 可以快速看出切片和区间有个元素,如range(3)和my_list[:3]都返回3个元素。 可以快速看出切片区间和长度...

    python 切片

    使用格式

    python切片使用范围包括:列表,元组,字符串

    为什么切片和 区间会忽视最后一个元素

    例如:

    L=[1,2,3,4,5,6]
    L[:2]#在下标为2的地方分割
    [1, 2]

    只是因为python、c和其它语言一样下标都从0开始。
    好处:

    • 可以快速看出切片和区间有几个元素,如range(3)和my_list[:3]都返回3个元素。
    • 可以快速看出切片区间和长度
    • 可以用任意一个下标,获得不重复的片段,如
    >>>L=[20,30,40,50,60,70]
    >>>L[:2]
    [20,30]
    >>>L[2:]
    [40,50,60,70]
    

    对对象进行切片

    我们可以用s[a:b;c]对s对象进行在a和b的区间以间隔为c的间隔取值,且c可以为负数,负数代表反过来取值

    >>>L=[20,30,40,50,60,70,80]
    >>>L[::-1]
    [80,70,60,50,40,30,20]
    >>>L[2::2]
    [40,60,80]
    

    多维切片和省略

    []运算符可以使用逗号分开多个索引或者切片,numpy的库就用到这个特性。

    X=[[1,2,3,4],[5,6,7,8],[9,0,11,12]]
    '列表调用多维值'
    X[2][2]
    '输出'
    11
    '列表转换为数组'
    X=np.array(X)
    '数组调用多维值'
    X[2][2]
    '输出'
    11
    '还可以是这样的'
    X[2,2]
    '输出'
    11
    

    给切片赋值

    把切片放在赋值语句左边,或者做为del操作对象 时,我们可以对序列进行嫁接,切除,修改操作。
    注意:如果赋值的对象是切片,那么右侧的赋值语句必须是可迭代的对象。如:

    L=[20,30,40,50,60,70,80]
    L[2:3]=100
    '会出现下文的错误’
    TypeError                                 Traceback (most recent call last)
    <ipython-input-19-ce8f28f73e75> in <module>
          1 L=[20,30,40,50,60,70,80]
    ----> 2 L[2:3]=100
          3 
          4 
    
    TypeError: can only assign an iterable
    '正确的使用方法是'
    L[2:3]=[100]
    >>>[20, 30, 100, 50, 60, 70, 80]
    
    
    展开全文
  • 列表是最常用的数据类型之一,本文整理了 StackOverflow 上关于列表操作被访问最多的10个...enumerate还可以指定元素的第一个元素从几开始,默认是0,也可以指定从1开始: 2、append 与 extend 方法有什么区别 ...

    列表是最常用的数据类型之一,本文整理了 StackOverflow 上关于列表操作被访问最多的10个问答,如果你在开发过程中遇到这些问题,不妨先思考一下如何解决。

    1、迭代列表时如何访问列表下标索引

    普通版:

     

    优雅版:

     

    enumerate 还可以指定元素的第一个元素从几开始,默认是0,也可以指定从1开始:

     

    2、append 与 extend 方法有什么区别

    append表示把某个数据当做新元素追加到列表的最后面,它的参数可以是任意对象

     

    extend 的参数必须是一个可迭代对象,表示把该对象里面的所有元素逐个地追加到列表的后面

     

    3、检查列表是否为空

    普通版:

     

    优雅版:

     

    4、如何理解切片

    切片用于获取列表中指定范的子集,语法非常简单

    items[start:end:step]

    从 start 到 end-1 位置之间的元素。step 表示步长,默认为1,表示连续获取,如果 step 为 2 就表示每隔一个元素获取。

     

    5、如何拷贝一个列表对象

    第一种方法:

    new_list = old_list[:]

    第二种方法:

    new_list = list(old_list)

    第三种方法:

     


    6、如何获取列表中的最后一个元素

    索引列表中的元素不仅支持正数还支持负数,正数表示从列表的左边开始索引,负数表示从列表的右边开始索引,获取最后一个元素有两种方法。

     

    7、如何对列表进行排序

    列表排序有两种方式,一种是列表自带的方式sort,一种是内建函数sorted。复杂的数据类型可通过指定key参数进行排序。由字典构成的列表,根据字典元素中的age字段进行排序:

     

    列表有 sort方法,用于对原列表进行重新排序,指定 key 参数,key 是匿名函数,item 是列表中的字典元素,我们根据字典中的age进行排序,默认是按升序排列,指定 reverse=True 按降序排列

     

    如果不希望改变原列表,而是生成一个新的有序列表对象,那么可以内置函数 sorted ,该函数返回新列表

     

    8、如何移除列表中的元素

    删除列表中的元素有三种方式

    remove 移除某个元素,而且只能移除第一次出现的元素

     

    del 根据指定的位置移除某元素

     

    pop 与del 类似,但是 pop 方法可以返回移除的元素

     

    9、如何连接两个列表

     

    列表实现了 + 的运算符重载,使得 + 不仅支持数值相加,还支持两个列表相加,只要你实现了 对象的 __add__操作,任何对象都可以实现 + 操作,例如:

     

    10、如何随机获取列表中的某个元素

     

    展开全文
  • python之list列表

    千次阅读 2013-12-10 17:29:08
    >>>print(“今天就简单的写写python中的列表,打发...python的list可以和数组一样有下标的操作,并且下标从0开始列表中存储的数据类型可以是混合的不同数据类型。 2.list内置操作函数 list可以有一下个内置函数
  • python-列表,元组

    2016-11-14 22:18:00
    下标取值,下标0开始的 切片: 顾头不顾...是1,写上步长的话,写就隔个元素取一次 步长为负数的时候,从列表的末尾开始取值,是正数的话,就从列表的开头开始取值。 切片下标的操作同样适用于字符串 "...
  • 列表的使用:列表名 = [元素1,元素2,…] 中括号隔开,元素数据类型可同可不同,获取元素值方法:下标访问(下标从0开始,可为负值表示倒数第个元素) list1 = [23,'Apple',True] print(list1[1]) print(list1[-1...
  • 列表与元组 列表是最常用的数据类型之一,通过列表可以对数据实现最方便的存储、修改等操作 ... 1 #通过下标访问列表中的元素,下标从0开始计数 2 >>> #查 3 >>> names[0] ...
  • 1 切片操作切片是截取list/tuple/str中元素的简便操作。这是一种采用下标操作的方式,所以自然不适合于dict和set这种无序存储对象。...注意两点:1、list的下标是从0开始的,我只见过matlab下标从1开
  • python的list怎么取后个元素

    千次阅读 2021-01-09 11:29:42
    截取以冒号的形式分隔,切片顾头不顾尾,会包含你写的开头下标不会包含你写的结尾下标,比如【0:2】意思是从下标0开始截取到下 标为2的前一个值也就是下标为1的值。 >>> arr = [1,3,5,7,12,'a','v','b']...
  • python切片

    2020-07-19 21:21:35
    # 从下标为1开始包括本身到最后 下标从开始 a[1:] ----> [2, 3, 4, 5, 6, 7, 8] # 取个值,从前往后取值的个数,-1为最后一个 a[:4] -----> [1,2,3,4] a[:-1] ----> [1,2,3,4,5,6,7,8] # 切片截取 从...
  • 该一系列python学习笔记都是根据《Python基础教程(第3版)》内容所记录整理的 1.通用的序列操作  有种操作适用于... 序列中的所有元素都有编号——0开始递增,通常我们称这些编号为下标,即为索引(indexin...
  • python---list列表、元组

    2018-06-06 20:34:00
    2.如果第一个范围不写的话,第一个元素开始取,默认的是0 3.如果切片的的范围不写的话代表去到结尾 4.开头和结尾的下标都不写的话,代表去整个list 5.-1代表最后一个元素 6.切片同样应用于字符串 2.列表分...
  • 序列 序列是指它的成员都是有序排列,并且可以通过下标偏移量访问到它的一个...print(chinese_zodiac[0]) # 下标从0开始 # 鼠 print(chinese_zodiac[-1]) # 反向访问 # 猪 字符串常用操作 对象 [not] in 序列 print...
  • 方法1:先判断是否是闰年,然后再利用... # 分别创建平年,闰年的月份天数列表(注意列表下标从0开始,而月份是从1月开始,所以1月份对应的下标是0) leap_year = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] ...
  • 如果想取出部分字符,可以通过下标的方法取得(python下标从0开始)。   字符串支持切片(切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作)操作。操作语法如下: 变量名[起始:...
  • python 序列

    2020-04-05 14:59:02
    在数学里,序列也叫数列,是指按照一定顺序排列的一列数,而在程序设计中,序列是一...这个索引是0开始递增的,即下标为0表示第一个元素,下标为1表示第2个元素,依此类推。如图所示。 Python比较神奇,它的索引...
  • 字符串、 列表、元组、字典字符串下标*python下标从0开始切片 字符串常用操作findrfindindex跟find 一样,只是检测不到报错rindex跟index一样,不过是从右向左检测,检测不到报错count检测查找的东西出现的次数...
  • python 入门学习 Day 3

    2021-02-22 19:19:18
    按照从左到右的顺序定义字符集合,下标从0开始顺序访问,所以有序 下标索引 可以进行切片操作;切得时候管前不管后 不可变,它不能像列表一样修改某个元素,所有元素必须是一改俱改 字符串常用操作 center(self,...
  • list下标为正数时0开始计数(左往右)(0到正无穷),下标为为负数时-1开始右往左)(-1到负无穷)。 list的个方法:  x.append(xxx) 给x这个list末尾增加新元素xxx  x.insert(i, xxx) 给x这个list的...
  • Python Day03

    2020-05-01 12:01:36
    序列 定义:按照顺序排列的值 类型:字符串,列表,元组 优点:支持索引和切片的操作 特征:第一个正索引为0,指向的是...步长指隔下标取一个字符,步长默认为一 三个部分都可省略其中任意两个 0开始 一旦改变...
  • 查找的基本概念 查找:在数据集合中寻找满足某种条件的数据元素的过程称为查找。 查找常见的种方法:顺序查找、二分查找...要确定列表中是否存在需要查找的数据项,首先从列表的第一项开始,按照下标增加的顺序,逐个
  • Python个数据类型 : List 列表,Tuple 元组,Set 集合,Dictionary 字典 ...和字符串一样,列表也可以被索引和截取,列表截取的语法格式是:变量[ 头下标 : 尾下标 ] 索引值以0为开始值,-1为末尾开始
  • Python数据类型——字符串详解(1)

    千次阅读 多人点赞 2020-05-20 23:57:29
    这一篇开始我们将开始学习一种新的Python数据类型,它们的成员是有序排列的,并且可以通过下标偏移量访问到它的一个或者个成员,这类 Python 类型统称为序列。包括下面这些:字符串,列表,和元组类型。这一篇...
  • python-list基本操作

    2019-10-07 05:54:54
    list基本操作 1)list列表,数组 ...查找名字叫“小龙女”的元素在第位,下标从0开始计算  print(stus[1]) 空list  stus=list[] 2)添加 append在list末尾增加一个元素  st...
  • python之字符串处理

    2019-07-17 21:17:12
    下标:字符编号,开始。 切片:对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。 切片的语法:[起始:结束:步长] 算头不算尾,步长为个为一组 字符串的切片 通过下标开始。符号:...
  • 下标取值,下标0开始的 切片: 顾头不顾尾 切片冒号前面的值,省略不写的话,代表取前面所有的值 切片冒号后面的值,省略不写的话,代表取后面所有的值 只写一个冒号的话,取整个列表,它可以用来复制一个新...
  • 元组与字符串,list数组等类似,可以用下标取值,下标从0开始 元组中也可以用【】截取某个元素的值 Tuple不支持元素的删除和修改 元组中的元素值是不允许修改的,但我们可以对元组进行连接组合 元组中的值是不...
  • python实现插入排序

    2020-06-07 13:23:50
    每次将后面无序的第0(整个列表从1开始)个比较, 判断是否需要交换位置,以此类推 ''' l = len(li) for j in range(1, l): #重复while循环对整个列表排序 i = j while i>0: #while循环排序一次

空空如也

空空如也

1 2 3
收藏数 44
精华内容 17
关键字:

python列表下标从几开始

python 订阅