精华内容
下载资源
问答
  • 列表和元组

    2020-12-22 01:26:36
    元组形式及元素特点3.列表与元组的区别六、编程实践1.创建一个列表2.删除列表中的重复元素3.对列表进行数据排序4.获取列表中索引为偶数的元素5.获取列表中索引为奇数的元素 一、序列 1.序列的概述  (1)序列是Python...
  • 本文实例讲述了Python列表和元组的定义与使用操作。分享给大家供大家参考,具体如下:#coding=utf8print '''''可以将列表和...列表和元组区别:--------------------------------------------------------------...

    本文实例讲述了Python列表和元组的定义与使用操作。分享给大家供大家参考,具体如下:

    #coding=utf8

    print '''''

    可以将列表和元组当成普通的“数组”,它能保存任意数量任意类型的Python对象。

    列表和元组通过数字索引来访问元素(从0开始)。

    列表和元组的区别:

    ------------------------------------------------------------------------------------

    元组 \ 列表

    ------------------------------------------------------------------------------------

    列表元素用中括号[] \ 元组元素用小括号()

    元素的个数及元素的值可以改变 \ 元素的个数及元素的值不可改变

    ------------------------------------------------------------------------------------

    元组可以看出只读的列表。

    列表和元组可以通过使用索引运算符([])和切片运算符([:])可以得到子集

    '''

    NumberList=[1,2,3,4,5,6,7,8.9,0101,017,0xab]

    StringList=['hello',"hello world",'''''goddness''']

    MixList=[12,13.2,01,'abc','hello']

    NumberTouple=(1,2,3,4,5,6,7,8.9,0101,017,0xab)

    StringTouple=('hello',"hello world",'''''goddness''')

    MixTouple=(12,13.2,01,'abc','hello')

    print "output the element of the NumberList by index--------->",NumberList[0],NumberList[1],NumberList[2],NumberList[-1]

    print "output the element of the StringList by index--------->",StringList[0],StringList[1],StringList[2],StringList[-1]

    print "output the element of the MixList by index--------->",MixList[0],MixList[1],MixList[2],MixList[-1]

    print "output the element of the NumberTouple by index--------->",NumberTouple[0],NumberTouple[1],NumberTouple[2],NumberTouple[-1]

    print "output the element of the StringTouple by index--------->",StringTouple[0],StringTouple[1],StringTouple[2],StringTouple[-1]

    print "output the element of the MixTouple by index--------->",MixTouple[0],MixTouple[1],MixTouple[2],MixTouple[-1]

    print "output the element of the NumberList by slice--------->",NumberList[0:2],NumberList[1:3],NumberList[0:],NumberList[:-1]

    print "output the element of the StringList by slice--------->",StringList[0:1],StringList[2:3],StringList[0:],StringList[:-1]

    print "output the element of the MixList by slice--------->",MixList[0:],MixList[:1],MixList[0:2],MixList[2:-1]

    print "output the element of the NumberTouple by slice--------->",NumberTouple[0:2],NumberTouple[1:3],NumberTouple[2:],NumberTouple[:-1]

    print "output the element of the StringTouple by slice--------->",StringTouple[0:2],StringTouple[1:3],StringTouple[2],StringTouple[-1]

    print "output the element of the MixTouple by slice--------->",MixTouple[0:],MixTouple[1:3],MixTouple[2],MixTouple[:-1]

    NumberList[0]=59

    #NumberTouple[0]=56

    print "Change the value of NumberList[0] to 59------------",NumberList[0]

    #print "Can not change the value of NumberTouple[0] to 56------------",NumberTouple[0]

    运行结果:

    201772690815462.jpg?201762691012

    希望本文所述对大家Python程序设计有所帮助。

    展开全文
  • 1. 列表(list)以[]括起来,各元素之间用","进行分隔,可以存放各种数据类型,1.1 索引切片字符串一样,列表也是可迭代对象,所以也有索引,可以进行切片索引也是从0开始数,切片的写法为list[开始位置:结束位置:步长],...

    1. 列表(list)

    以[]括起来,各元素之间用","进行分隔,可以存放各种数据类型,

    1.1 索引和切片

    和字符串一样,列表也是可迭代对象,所以也有索引,可以进行切片

    索引也是从0开始数,切片的写法为list[开始位置:结束位置:步长],在数学是左闭右开,即:包含开始位置,不包含结束位置.当步长为负数的时候,意为从后往前数,开始位置会比结束位置大.

    1.2 增删改查

    1.2.1 增加

    append(a):向列表最后添加一个新元素a

    insert(a, b):向索引为a的位置插入新元素b,原来的元素顺次后移

    extend(a):当a为单个对象时,把a添加到列表的最后;当a为列表或者元组等对象时,把其中所有元素依次添加到列表的最后

    1.2.2 删除

    pop(a):当a为空的时候,默认删除最后一个,当a为索引时,删除对应索引的元素. 需要注意的是,pop为弹出的意思,该函数的返回值为被"弹出"的元素

    remove(a):当知道要删除的元素具体是什么的时候,用该方法,返回值为None,当a在列表中不存在时,会报错

    clear()清空列表

    关键字 del: 可以删除列表的切片形式

    1.2.3 修改

    使用索引和切片直接修改

    1.2.4 查询

    直接使用索引,遍历可以用for循环

    1.3 其他操作

    count(a) :统计列表中a出现的次数

    sort():对元素进行排序,默认升序,参数reverse=True时降序.

    reverse():将列表翻转

    2.元组(tuple)

    俗称不可变的列表.被成为只读列表,元组也是python的基本数据类型之一,()括号括起来,里面可以放任何数据类型的数据,查询可以.循环也可以.切片也可以.但就是不能改.

    元组的不可变的意思是⼦元素不可变. 而子元素内部的子元素是可 以变, 这取决于子元素是否是可变对象.

    注意:如果只有一个元素,需要加一个逗号,否则不是元组

    方法:也有count(),index(),len()等方法

    展开全文
  • 列表和元组区别3. 列表和元组的创建/访问/修改3.1 创建3.2 访问3.3 修改4. 列表和元组的相关接口4.1 list(列表)运算符4.2 list (列表)函数&方法4.3 tuple(元组)运算符4.4 tuple(元组)内置函数5. 列表和元组...

    重学Python: 01列表和元组

    1. 什么是列表和元组

    列表和元组,都是一个可以放置任意数据类型的有序集合

    l = [1, 2, 3, 'a', 'abc', 'hhhe']
    l
    [1, 2, 3, 'a', 'abc', 'hhhe']
    
    tup = (111, 'hello', 'WORLD')
    tup
    (111, 'hello', 'WORLD')
    

    2. 列表和元组的区别

    列表是动态的,长度大小不固定,可以随意地增加、删减或者改变元素(mutable)
    元组是静态的,长度大小固定,无法增加删减或者改变(immutable)

    l = [1, 2, 3, 'a','abc', "hhhe" ]
    l.append('CSUST')
    l
    [1, 2, 3, 'a', 'abc', 'hhhe', 'CSUST']
    l[2] = 888
    l
    [1, 2, 888, 'a', 'abc', 'hhhe', 'CSUST']
    
    tup = (111, 'hello', 'WORLD')
    tup[-1] 
    'WORLD'
    
    tup[0] = 1
    tup
    ---------------------------------------------------------------------------
    TypeError                                 Traceback (most recent call last)
    <ipython-input-11-31dca4ff425f> in <module>()
          1 tup = (111, 'hello', 'WORLD')
    ----> 2 tup[0] = 1
          3 tup
    
    TypeError: 'tuple' object does not support item assignment
    
    • 对于列表进行元素修改可以操作,因为列表是动态的、可变的
    • 对于元组不可以进行修改操作, tuple 一旦初始化就不能修改。 也就是说元组(tuple)是不可变的。
      元组(tuple) 不可变是指当你创建了 tuple 时候,它就不能改变了,也就是说它也没有 append(),insert() 这样的方法,但它也有获取某个索引值的方法,但是不能赋值。
    • 那么为什么要有 tuple 呢?
      那是因为 tuple 是不可变的,所以代码更安全。
      所以建议能用 tuple 代替 list 就尽量用 tuple

    3. 列表和元组的创建/访问/修改

    3.1 创建

    列表的创建: list = [1 , 2, 3, ‘222’, ‘2233’]

    其实列表就是用中括号 [] 括起来的数据,里面的每一个数据就叫做元素。每个元素之间使用逗号分隔。

    而且列表的数据元素不一定是相同的数据类型。

    元组的创建: tup = (1,2,‘222’)

    元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。

    tuple1=('两点水','twowter','liangdianshui',123,456)
    tuple2='两点水','twowter','liangdianshui',123,456
    

    创建空元组

    tuple3=()
    

    元组中只包含一个元素时,需要在元素后面添加逗号

    tuple4=(123,)
    

    如果不加逗号,创建出来的就不是 元组(tuple),而是指 123 这个数了。

    这是因为括号 () 既可以表示元组(tuple),又可以表示数学公式中的小括号,这就产生了歧义。

    所以如果只有一个元素时,你不加逗号,计算机就根本没法识别你是要进行整数或者小数运算还是表示元组。

    因此,Python 规定,这种情况下,按小括号进行计算,计算结果自然是 123 ,而如果你要表示元组的时候,就需要加个逗号。

    tuple4=(123,)
    tuple5=(123)
    print(tuple4)
    print(tuple5)
    
    #输出:
    (123,)
    123
    

    3.2 访问

    列表和元组中元素都可以通过索引和切片进行访问

    name = ['一点水', '两点水', '三点水', '四点水', '五点水']
    # 通过索引来访问列表
    print(name[2])
    # 通过方括号的形式来截取列表中的数据
    print(name[0:2])
    
    name = ()'一点水', '两点水', '三点水', '四点水', '五点水')
    # 通过索引来访问列表
    print(name[2])
    # 通过方括号的形式来截取列表中的数据
    print(name[0:2])
    

    切片访问时,元素区间是左闭右开区间的。

    所以 name[0:2] 的意思就是从第 0 个开始取,取到第 2 个,但是不包含第 2 个。

    3.3 修改

    列表的修改

    name = ['一点水', '两点水', '三点水', '四点水', '五点水']
    
    # 通过索引对列表的数据项进行修改或更新
    name[1]='2点水'
    print(name)
    
    # 使用 append() 方法来添加列表项
    name.append('六点水')
    print(name)
    
    ['一点水', '2点水', '三点水', '四点水', '五点水']
    ['一点水', '2点水', '三点水', '四点水', '五点水', '六点水']
    

    删除 List(列表) 里面的元素

    使用 del 语句来删除列表的的元素

    name = ['一点水', '两点水', '三点水', '四点水', '五点水']
    print(name)
    
    # 使用 del 语句来删除列表的的元素
    del name[3]
    print(name)
    
    ['一点水', '两点水', '三点水', '四点水', '五点水']
    ['一点水', '两点水', '三点水', '五点水']
    

    修改元组 (tuple)

    可能看到这个小标题有人会疑问,上面不是说 tuple 是不可变的吗?

    这里怎么又来修改 tuple (元组) 了。

    那是因为元组中的元素值是不允许修改的,但我们可以对元组进行连接组合,还有通过修改其他列表的值从而影响 tuple 的值。

    具体看下面的这个例子:

    #-*-coding:utf-8-*-
    list1=[123,456]
    tuple1=('两点水','twowater','liangdianshui',list1)
    print(tuple1)
    list1[0]=789
    list1[1]=100
    print(tuple1)
    list1.append(90)
    print(tuple1)
    

    输出的结果:

    ('两点水', 'twowater', 'liangdianshui', [123, 456])
    ('两点水', 'twowater', 'liangdianshui', [789, 100])
    ('两点水', 'twowater', 'liangdianshui', [789, 100, 90])
    

    可以看到,两次输出的 tuple 值是变了的。

    可以看到,tuple1 有四个元素,最后一个元素是一个 List ,List 列表里有两个元素。

    当我们把 List 列表中的两个元素 124456 修改为 789100 的时候,从输出来的 tuple1 的值来看,好像确实是改变了。

    但其实变的不是 tuple 的元素,而是 list 的元素。

    tuple 一开始指向的 list 并没有改成别的 list,所以,tuple 所谓的“不变”是说,tuple 的每个元素,指向永远不变。注意是 tupe1 中的第四个元素还是指向原来的 list ,是没有变的,我们修改的只是列表 List 里面的元素。

    这个就相当C语言中的char * const p; //指针指向不可改变但是指针里面的内容却是可以改变的。

    const char*p; //指针指向的内容不可改变

    const char* const p; //指针内容和指针指向均不可以改变

    删除元组 (tuple)

    tuple 元组中的元素值是不允许删除的,但我们可以使用 del 语句来删除整个元组

    #-*-coding:utf-8-*-
    
    tuple1=('两点水','twowter','liangdianshui',[123,456])
    print(tuple1)
    del tuple1
    

    4. 列表和元组的相关接口

    4.1 list(列表)运算符

    列表对 +* 的操作符与字符串相似。+ 号用于组合列表,* 号用于重复列表。

    Python 表达式结果描述
    len([1, 2, 3])3计算元素个数
    [1, 2, 3] + [4, 5, 6][1, 2, 3, 4, 5, 6]组合
    [‘Hi!’] * 4[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]复制
    3 in [1, 2, 3]True元素是否存在于列表中
    for x in [1, 2, 3]: print x,1 2 3迭代

    4.2 list (列表)函数&方法

    函数&方法描述
    len(list)列表元素个数
    max(list)返回列表元素最大值
    min(list)返回列表元素最小值
    list(seq)将元组转换为列表
    list.append(obj)在列表末尾添加新的对象
    list.count(obj)统计某个元素在列表中出现的次数
    list.extend(seq)在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
    list.index(obj)从列表中找出某个值第一个匹配项的索引位置
    list.insert(index, obj)将对象插入列表
    list.pop(obj=list[-1])移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
    list.remove(obj)移除列表中的一个元素(参数是列表中元素),并且不返回任何值
    list.reverse()反向列表中元素
    list.sort([func])对原列表进行排序

    4.3 tuple(元组)运算符

    与字符串一样,元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制,运算后会生成一个新的元组。

    Python 表达式结果描述
    len((1, 2, 3))3计算元素个数
    (1, 2, 3) + (4, 5, 6)(1, 2, 3, 4, 5, 6)连接
    (‘Hi!’,) * 4(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)复制
    3 in (1, 2, 3)True元素是否存在
    for x in (1, 2, 3): print(x)1 2 3迭代

    4.4 tuple(元组)内置函数

    方法描述
    len(tuple)计算元组元素个数
    max(tuple)返回元组中元素最大值
    min(tuple)返回元组中元素最小值
    tuple(seq)将列表转换为元组

    注意:

    • list.reverse() 和 list.sort() 分别表示原地倒转列表和排序(注意,元组没有内置的这两个
      函数, 元组是不可变化的)
    • reversed() 和 sorted() 同样表示对列表 / 元组进行倒转和排序,但是会返回一个倒转后
      或者排好序的新的列表 / 元组

    5. 列表和元组存储方式的差异

    根据前面的叙述,我们知道列表和元组最重要的区别就是,列表是动态的、可变的,而元组是静态的、不可
    变的。这样的差异,势必会影响两者存储方式。我们可以来看下面的例子 :

    内置函数 __sizeof__() : 打印系统分配空间的大小

    l = [1, 2, 3]
    len1 = l.__sizeof__()
    tup = (1,2,3)
    len2 =tup.__sizeof__()
    print(len1)
    print(len2)
    
    64
    48
    

    对比发现,对列表和元组,我们放置了相同的元素,但是元组的存储空间,却比列表要少
    16 字节 。

    事实上,由于列表是动态的,所以它需要存储指针,来指向对应的元素(上述例子中,对于
    int 型,8 字节)。另外,由于列表可变,所以需要额外存储已经分配的长度大小(8 字
    节),这样才可以实时追踪列表空间的使用情况,当空间不足时,及时分配额外空间

    l = []
    len1 = l.__sizeof__()
    print(len1)
    l.append(1)
    len1 = l.__sizeof__()
    print(len1)
    
    l.append(2)
    len1 = l.__sizeof__()
    print(len1)
    
    l.append(3)
    len1 = l.__sizeof__()
    print(len1)
    
    l.append(4)
    len1 = l.__sizeof__()
    print(len1)
    
    l.append(5)
    len1 = l.__sizeof__()
    print(len1)
    
    #输出
    40
    72
    72
    72
    72
    104
    

    上面的例子,大概描述了列表空间分配的过程。我们可以看到,为了减小每次增加 / 删减
    操作时空间分配的开销,Python 每次分配空间时都会额外多分配一些,这样的机制
    (over-allocating)保证了其操作的高效性[Redis中也存在预分配内存的用法]:增加 / 删除的时间复杂度均为 O(1)
    但是对于元组,情况就不同了。元组长度大小固定,元素不可变,所以存储空间固定

    6. 列表和元组的性能

    通过学习列表和元组存储方式的差异,我们可以得出结论:元组要比列表更加轻量级一些,
    所以总体上来说,元组的性能速度要略优于列表.

    另外,Python 会在后台,对静态数据做一些资源缓存(resource caching)。通常来说,因为垃圾回收机制的存在,如果一些变量不被使用了,Python 就会回收它们所占用的内存,返还给操作系统,以便其他变量或其他应用使用。

    但是对于一些静态变量,比如元组,如果它不被使用并且占用空间不大时,Python 会暂时缓存这部分内存。这样,下次我们再创建同样大小的元组时,Python 就可以不用再向操作系统发出请求,去寻找内存,而是可以直接分配之前缓存的内存空间,这样就能大大加快程序的运行速度

    下面的例子,是计算初始化一个相同元素的列表和元组分别所需的时间。我们可以看到,元组的初始化速度,要比列表快 5

    import timeit
     
    print(timeit.timeit(stmt="tup = (1,2,3,4,5,6)", number=1000000))
    print(timeit.timeit(stmt="l = [1,2,3,4,5,6]", number=1000000))
    
    ##输出
    0.015461600000000075
    0.06565259999999995
    

    但如果是索引操作的话,两者的速度差别不大,在同一个数量级上, 几乎可以忽略不计

    import timeit
    code1 = """
    tup = (1,2,3,4,5,6)
    y = tup[2] 
    """
    
    code2 = """
    l = [1,2,3,4,5,6]
    y = l[4] 
    """
    print(timeit.timeit(stmt=code1, number=10000000))
    print(timeit.timeit(stmt=code2, number=10000000))
    
    ##输出
    0.3606373000000076
    0.8088017999999977
    

    如果测试增加、删减或者改变元素,那么列表显然更优。
    因为对于元组,必须得通过新建一个元组来完成 。

    7. 列表和元组的使用场景

    1. 如果存储的数据和数量不变,比如你有一个函数,需要返回的是一个地点的经纬度,然
      后直接传给前端渲染,那么肯定选用元组更合适
    2. 如果存储的数据或数量是可变的,比如微博头条日志功能,需要统计一个用户在
      一周之内看了哪些用户的帖子,那么则用列表更合适 。
    展开全文
  • 主要介绍了Python列表和元组的定义与使用操作,结合实例形式分析了Python中列表和元组的功能、区别、定义及使用方法,需要的朋友可以参考下
  • python列表和元组

    2020-03-20 09:28:48
    python列表和元组 一、序列 1.序列的概述 Python 内置的四种常用数据结构:列表(list)、元组(tuple)、字典(dict)以及集合(set)。 这四种数据结构一但都可用于保存多个数据项,这对于编程而言是非常重要的,...

    python列表和元组

    一、序列

    1.序列的概述

    Python 内置的四种常用数据结构:列表(list)、元组(tuple)、字典(dict)以及集合(set)。

    这四种数据结构一但都可用于保存多个数据项,这对于编程而言是非常重要的,因为程序不仅需要使用单个变量来保存数据,还需要使用多种数据结构来保存大量数据,而列表、元组、字典和集合就可满足保存大量数据的需求。

    列表(list)和元组(tuple)比较相似,它们都按顺序保存元素,每个元素都有自己的索引,因此列表和元组都可通过索引访问元素。二者的区别在于元组是不可修改的,但列表是可修改的。

    字典(dict)和集合(set)类似,它们存储的数据都是无序的,其中字典是用 key-value 的形式保存数据

    2.索引和元素

    • 索引:从0开始,最后是-1,数据类型为整型(int).

    • 元素:列表和元组的元素可以是不同的数据类型,可重复。

    3.通用序列操作

    • 所有的序列都可以进行某些特定的操作。这些操作包括:
      • 索引(indexing)
      • 分片(sliceing)
      • 加(adding)
      • 乘(multiplying)
      • 检查某个元素是否属于这序列(index)
      • 计算序列长度(len)
      • 找出最大元素和最小元素(min/max)

    二、列表

    1.列表元素的特点

    可修改、可重复、可嵌套和支持多种数据类型

    2.基本列表操作

    创建函数list()

    使用方法:name=list()[1,2][1,[1,2]]

    元素的增加

    • append()方法:用于在列表末尾添加新的对象。

    使用方法:list.append(obj).

    参数obj为添加到列表末尾的对象。

    • extend()函数:用于在列表末尾一次性追加另一个序列中的多个值,即用新的列表来扩充原来的列表。

    使用方法:list.extend(seq).

    参数seq为元素列表。

    • insert()函数:用于将指定对象插入到列表的指定位置。

    使用方法:list.insert(index,obj)

    参数index为对象obj需要插入的索引位置;

    参数obj为要插入列表中的对象。

    元素的删除

    • del:用于删除指定索引的元素或者删除整个列表。

    使用方法:del name[0]del name

    • clear()函数表示清空原有地址内容,但是地址不发生改变。

    使用方法:list.clear()

    • pop()函数:用于移除列表中的一个元素(默认最后一个元素),并返回该元素的值。

    使用方法:list.pop([index=-1])

    参数index为可选参数,要移除列表元素的索引值,不能超过列表总长度,默认为index=-1即最后一个列表值。

    • remove()函数:用于移除列表中某个值的第一个匹配项。

    使用方法:list.remove(obj)

    参数obj为列表中要移除的对象。

    元素的修改

    修改方法举例:name[1]=2

    元素的查找

    • count()方法:用于统计某个元素在列表中出现的次数,会返回元素在列表中出现的次数。

    使用方法:list.count(obj).

    参数obj为列表中统计的对象。

    • index()函数:用于从列表中找出某个值第一个匹配项的索引位置。

    用法:list.index(obj)

    参数obj为查找的对象。

    • 内置函数min(),max(),len(),in,not in

    分别表示获取列表中的最大值,最小值,列表长度,判断元素在列表中,判断元素不在列表中。

    列表的反转

    reverse()函数:用于反向列表中的元素。

    使用方法:list.reverse(),无参数

    列表的排序

    sort()函数:用于对原列表进行排序,可指定参数(Python3中数据类型必须相同)。

    使用方法:list.sort(cmp=None, key=None, reverse=False)

    参数cmp为可选参数,如果指定了该参数会使用该参数的方法进行排序。

    key主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代的对象中,指定可迭代对象中的一个元素来进行排序。

    reverse是排序规则,值为Ture表示降序,值为False表示升序(默认值)。

    三、元组

    1.元组概述

    • 元组与列表类似,不同之处在于元组的元素不能修改。

    • 元组使用小括号,列表使用方括号。

    • 元组的创建很简单,只需要在小括号中添加元素,并使用逗号分隔即可。

    2.元组的特点

    元组的特点有:可重复,不可修改,可嵌套,支持多种数据类型。

    四、总结

    1.列表的形式及元素特点

    形式:列表在方括号内,元素以逗号分隔。

    元素特点:可重复,可修改,可嵌套,支持多种数据类型。

    2.元组的形式及元素特点

    形式:元组在小括号内,使用逗号分隔。

    元素特点:可重复,不可修改,可嵌套,支持多种数据类型。

    3.列表与元组的区别

    列表与元组的最大区别就是元素是否可以修改。

    五、代码实现

    1.创建一个列表

    代码如下

    name = [1,2,3,4,5,6,7,8,9,8,7,6,5,4,3,2,1]
    print(name)
    

    2.删除列表中的重复元素

    name=set(name)
    name=list(name)
    print(name)
    

    3.对列表进行数据排序

    name.sort(reverse=True)
    print(name)
    

    这里选择降序排序

    4.获取列表中索引为偶数的元素

    print("索引为偶数的列表:",name[0::2])
    

    5.获取列表中索引为奇数的元素

    print("索引为奇数的列表:",name[1::2])
    
    展开全文
  • 本次学习笔记的内容主要是Python列表和元组。什么是列表(list),简单的可以理解为数组,但是比数组的范围要大,Python的列表就是一个大染缸,什么乱七八糟的元素都能往里面装。好了,废话不多说,直接动手...
  • 列表和元组是按顺序存放元素,每个元素有自己的索引,可通过索引访问元素,两者的区别在于,元组是不可修改的,列表可以修改。字典以 key-value(键值对)形式保存数据。这三种数据结构是编程中必不可少的内容。一、...
  • 二、列表和元组

    2021-05-22 18:54:19
    2.1copy() clear() 方法实例 2.2列表推导式(列表解析) 2.3方法列表 二、元组 1.元组的性质 2.元组的内置函数 三、其他 1.list、tuple、str之间的相互转化 2.python的负数索引 一、列表 1.列表的常用...
  • python笔记 列表和元组

    2018-12-25 16:17:55
    列表和元组的主要区别是列表可以修改,而元组 不能。 python中还有一种名为容器的数据结构。容器基本是包含其他对象的任意对象。序列(例如列表和元组)和映射(例如字典)是两类主要的容器。 通用序列操作 ...
  • 列表和元组的主要区别:列表是可以修改的,元组不可以修改。列表用[]表示,元组用()表示一、列表、元组的通用用法1.通过索引使用元素也可以直接使用索引,不需要赋值给变量如果函数返回一个序列,可对返回结果进行...
  • 主要介绍了Python数据类型之列表和元组的相关知识,列表是一组有序项目的集合 ,可变的数据类型可 进行增删改查,本文通过实例文字相结合的形式给大家介绍的非常详细 ,需要的朋友可以参考下
  • 列表元组和字典

    2020-12-12 13:42:23
    列表元组和字典 1. 通用序列操作 Pyhton中有六种内置序列:列表元组、字符串、Unicode字符串、buffer对象xrange对象,其中列表元组和字符串这三种序列是最常见的。 Python中的大部分序列都可以进行通用操作...
  • (3)python 列表和元组

    2019-10-06 18:43:03
    列表和元组的主要区别:列表是可以修改的,元组不可以修改。列表用[]表示,元组用()表示 一、列表、元组的通用用法 1.通过索引使用元素 也可以直接使用索引,不需要赋值给变量 如果函数返回一个序列,可对...
  • 实现效果如下: zip:将对象中对应的元素打包成一个个元组
  • Python列表和元组介绍Python中列表和元组是比较常用的数据结构,尤其列表几乎是最常用的数据结构,就像java中的ArrayList. list列表是存储一组有序元素的数据结构。元素类型可以是任意数据类型.tuple元组和列表十分...
  • Python-列表和元组

    2020-04-01 16:28:06
    序列类型: 字符串、列表元组 映射类型: 字典 集合: set() 在 Python中列表元组、字典、集合都称为容器。 ###2. 序列类型数据结构共有的特点: 序列类型中的元素都有对应的位置,这个位置叫偏移量或者索引...
  • 列表和元组 对于一门编程语言来说,数据结构都是其根基。 python提供的数据结构有列表(list)、元组(tuple)、字典(dict)、集合(set), 而这篇文章就记录一下列表和元组的特性和用法,以备不时之需。 ...
  • Python学习:列表和元组用哪一个?

    千次阅读 2020-08-31 16:01:19
    实际列表和元组,都是一个可以放置任意数据类型的有序集合。 在绝大多数编程语言中,集合的数据类型必须一致。不过,对于 Python 的列表和元组来说,并无此要求:(我认为这是Python相对厉害的地方) l = [1, 2,...
  • 字符串和元组属于不可变数据,即创建后不可修改。列表、字典、集合属于可变数据,即创建后可以修改元素。2.创建有元素的对象3.创建没有元素的对象列表使用eval()或list()或中括号[]进行创建,元素之间使用逗号分隔。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 108,195
精华内容 43,278
关键字:

列表和元组形式上的区别