精华内容
下载资源
问答
  • 主要介绍了Python列表和元组的定义与使用操作,结合实例形式分析了Python中列表和元组的功能、区别、定义及使用方法,需要的朋友可以参考下
  • 列表和元组的区别

    千次阅读 2020-07-30 16:07:23
    列表和元组的区别 列表(list) 列表一旦创建了我们就可以根据自己的需要随意改变他的内容; >>> list=[1,2,3,4,5,6] >>> list[0]=8 >>> list[6]=0 >>> list [8, 2, 3,...

    列表和元组的区别

    1. 列表(list)

      列表一旦创建了我们就可以根据自己的需要随意改变他的内容;

      >>> list=[1,2,3,4,5,6]
      >>> list[0]=8
      >>> list[6]=0
      >>> list
      [8, 2, 3, 4, 5, 6]
      

      可以为列表添加新的数据:

      >>> len(list) #查看这个列表中有多少数据
      6
      >>> list.append(7) #在列表尾插入
      >>> list
      [8, 2, 3, 4, 5, 6, 7]
      >>> len(list)
      7
      >>> list.insert(3,10)  #在列表任意位置插入数据,第一个参数表示索引,第二个参数表示插入的数据
      >>> list
      [8, 2, 3, 10, 4, 5, 6, 7]
      >>> 
      

    ​ 这是因为list支持resize操作,当有新的数据添加进入列表时,如果大于当前的容量,就会开辟新的list,将原有的元素复制到新的list中,然后将原有的list删除。

    注意 利用切片取得的数据类型还会是list

    >>> type(list[:2])
    <class 'list'>
    
    1. 元组(Tuple)

      元组是固定不可变的。这意味着一但元组被声明,他的内容无法被修改,大小也无法改变。

      >>> tuple=(1,2,3,4)
      >>> tuple
      (1, 2, 3, 4)
      >>> tuple[2]
      3
      >>> tuple[2]=8
      Traceback (most recent call last):
        File "<pyshell#13>", line 1, in <module>
          tuple[2]=8
      TypeError: 'tuple' object does not support item assignment
      

      虽然tuple不支持改变大小,但是我们可以将两个tuple合并起来。

      >>> t=(5,6,8,6)
      >>> t+tuple
      (5, 6, 8, 6, 1, 2, 3, 4)
      

      与list.append比较list添加元素的时间复杂读为O(1),而tuple这种方式的时间复杂度为O(n)

    2. 总结

      1. 列表是动态数组,它们不可变且可以重设长度(改变其内部元素的个数)。
      2. 元组是静态数组,它们不可变,且其内部数据一旦创建便无法改变。
      3. 元组缓存于Python运行时环境,这意味着我们每次使用元组时无须访问内核去分配内存。

     

     

    列表元组字典的一些区别

    1、列表list:有序,可变。

    2、元组tuple:有序,不可变。

    3、字典dict:无序,字典的key是不可变的,值是可变的;在python中字符串,数字,元组都是不可变的对象。

    4、序列:列表,元组和字符串都序列;即成员有序排列,可以通过下标访问,可以进行切片操作。字符串(普通字符串和unicode字符串)

    5、集合:没有顺序的简单对象的聚集。可以检查成员是否存在,是否是另一个集合的子集,得到两个集合的交集等等

    6、复制一个列表或者类似的序列或者其他复杂对象,那么必须使用切片操作符来去的拷贝。当你创建一个对象并将它赋值给一个变量的时候,这个变量仅仅引用那个对象,而不是表示这个对象本身!也就是说,变量名指向你计算机中存储那个对象的内存。这被称作名称到对象的绑定。

    展开全文
  • 本文实例讲述了Python 字符串、列表元组的截取与切片操作。分享给大家供大家参考,具体如下: demo.py(字符串、列表元组的截取): # 切片(截取) [开始索引:结束索引:步长] 步长默认为1 结束索引默认截取到...
  • 重学Python: 01列表和元组 文章目录重学Python: 01列表和元组1. 什么是列表和元组2. 列表和元组的区别3. 列表和元组的创建/访问/修改3.1 创建3.2 访问3.3 修改4. 列表和元组的相关接口4.1 list(列表)运算符4.2 list ...
  • python列表和元组

    2020-12-20 22:23:10
    :sort()对列表进行临时排序:sorted()倒着打印列表:reverse()确定列表的长度:len()遍历整个列表创建数值列表使用range()函数创建数字列表对数字列表的运算列表解析切片创建切片遍历切片复制列表元组 建立 在Python...
  • 列表和元组

    2020-12-22 01:26:36
    索引元素二、通用序列操作三、列表1.列表元素的特点2.基本列表操作(1)创建函数list()(2)元素的增加(3)元素的删除(4)元素的修改(5)元素的查找(6)列表的反转(7)列表的排序四、元组1.元组的概述2.元组的特点五、总结...
  • 主要介绍了Python中列表和元组的使用方法区别详解的相关资料,需要的朋友可以参考下
  • 主要介绍了python数据结构之列表和元组的详解的相关资料,希望通过本文能帮助到大家,让大家彻底理解掌握这部分内容,需要的朋友可以参考下
  • 列表和元组的内容,可以是各种值,也可以是各种数据结构。如以下代码片段所示: >>> list1 = ['a', 1, (5,6,7), [3,5]] >>> list1 ['a', 1, (5, 6, 7), [3, 5]] 问题元组和列表都是表示一些元素的序列,好像作用是...
  • 主要介绍了Python中对元组和列表按条件进行排序的方法示例,需要的朋友可以参考下
  • 序列 什么是序列 列表(List)是什么 列表对象的常用方法列表对象的四种创建列表元素的增加删除列表元素的访问计数列表对象的切片操作列表元素的排序逆序列表相关的内置函数 多维列表(List的延伸) 二维列表 元组...
  • 列表(list)和元组(tuple)的一些基础 listtuple都是一个可以放置任意数据类型的有序集合,都是既可以存放数字、字符串、对象等 listtuple都支持负索引 In [8]: nums[-2] Out[8]: ‘ad’ In [9]: tp[-2] Out[9]:...
  • 主要介绍了python中的列表元组的使用,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 如果有了解过python中的列表和元组,你可能会知道相对于列表元组是不可变的,也就是说元组中的数据不能随意更改。除了列表是用中括号表示而元组是用小括号表示之外,这两种数据类型好像并没有什么不同,都是用来...

    如果有了解过python中的列表和元组,你可能会知道相对于列表,元组是不可变的,也就是说元组中的数据不能随意更改。除了列表是用中括号表示而元组是用小括号表示之外,这两种数据类型好像并没有什么不同,都是用来存放一系列的数据,事实真是如此吗?

    a = [1, 3, 5, 7, "a"]

    b = (1, 3, 5, 7, "b")

    # 现在改变b中的值

    b[2] = 4

    TypeError Traceback (most recent call last)

    in ()

    4

    5 # 现在改变b中数据的值

    ----> 6 b[2] = 4

    TypeError: "tuple" object does not support item assignment

    看起来除了元组不可变之外,列表完全可以取代元组,为什么要多此一举创造出元组这种类型?其实这背后有更深层的含义,列表是用来表示一组相同类型(相同价值)的数据,而元组用来存放不同类型(不同价值)的数据,简单来说,列表是同质的,而元组是异构的。

    比如说,现在有一本书,书里面有一些批注。我们用元组来表示书中第几页第几行的内容,像这样:position = (page, line),然后把它放到字典里作为批注的键,表示第几页第几行有批注。同时,我们用列表来表示这些位置,如果有新的位置,可以加入列表。这符合列表可以更改数据的特点。但是如果更改元组里面的数据就没有意义了,因为这些坐标本来就是存在的。

    在python的模块中,我们可以找到很多例子:

    range(10)

    range(0, 10)

    比如range方法用来生成一列有序地数据,这些数据是等价的,并没有不同的功能,所以用列表来表示最合适。而像下面的例子:

    from datetime import datetime

    datetime.now()

    datetime.datetime(2017, 12, 17, 20, 23, 13, 578752)

    当前时间适合用元组来表式,因为元组中每个数据有不同的功能,或者说有不同的价值,像第一个数据表示年份。

    说到这,想起了我们之前说过的具名元组nametuple,它用来快速的生成一个类,可以看成是类的轻量级替代方法,也很符合我们上面说的元组的功能。

    展开全文
  • Python 列表和元组的区别是什么?

    千次阅读 2018-10-24 14:48:46
    列表 VS 元组 一个 Python 初学者的普遍疑问:列表元组的区别是什么? 答案是:它们之间有两点不同,并且二者之间有着复杂的相互作用。它们分别是”技术上”的差异“文化上”的差异。 首先,有一点是相同的:...

    列表 VS 元组

    一个 Python 初学者的普遍疑问:列表与元组的区别是什么?

    答案是:它们之间有两点不同,并且二者之间有着复杂的相互作用。它们分别是”技术上”的差异和“文化上”的差异。

    首先,有一点是相同的:列表与元组都是容器,是一系列的对象。

    Python

     

    1

    2

    3

    4

    5

    6

    >>> my_list = [1, 2, 3]

    >>> type(my_list)

    <class 'list'>

    >>> my_tuple = (1, 2, 3)

    >>> type(my_tuple)

    <class 'tuple'>

    二者都可以包含任意类型的元素甚至可以是一个序列,还可以包含元素的顺序(不像集合和字典)。

    Python

     

    1

    2

    3

    4

    5

    6

    7

    >>> my_list[1] = "two"

    >>> my_list

    [1, 'two', 3]

    >>> my_tuple[1] = "two"

    Traceback (most recent call last):

      File "<stdin>", line 1, in <module>

    TypeError: 'tuple' object does not support item assignment

    现在来讲讲区别。列表和元组的“技术差异”是,列表是可变的,而元组是不可变的。这是在 Python 语言中二者唯一的差别。

    尽管有好几种表现方式,但这是列表和元组唯一的“技术差异”。比如:列表有一个 append() 的方法来添加更多的元素,而元组却没有这个方法

    Python

     

    1

    2

    3

    4

    5

    6

    7

    >>> my_list.append("four")

    >>> my_list

    [1, 'two', 3, 'four']

    >>> my_tuple.append("four")

    Traceback (most recent call last):

      File "<stdin>", line 1, in <module>

    AttributeError: 'tuple' object has no attribute 'append'

    元组并不需要一个 append() 方法,因为元组不能修改。

    “文化差异“是指二者在实际使用中的差异:在你有一些不确定长度的相同类型队列的时候使用列表;在你提前知道元素数量的情况下使用元组,因为元素的位置很重要。

    举个例子,假设你有一个函数是用来在目录中查找结尾为 *.py 的文件。函数返回的应该是一个列表,因为你并不知道你会找到多少个文件,而这些文件都有相同的含义:它们仅仅是你找到的另一个文件。

    Python

     

    1

    2

    >>> find_files("*.py")

    ["control.py", "config.py", "cmdline.py", "backward.py"]

    另一方面,让我们假设你需要存储五个值来代表气象观测站的位置:id ,城市,国家,纬度,经度。元组就比列表更适用于这种情况:

    Python

     

    1

    2

    3

    >>> denver = (44, "Denver", "CO", 40, 105)

    >>> denver[1]

    'Denver'

    (让我们暂时不要讨论使用类来表示的这种情况)。第一个元素是 id ,第二个元素是城市,等等。位置决定了它的意义。

    把这种“文化差异”放到 C 语言来讲,列表像是数组,元组则像是 structs 结构体。

    Python 采用了命名元组的方法来使含义更加明确:

    Python

     

    1

    2

    3

    4

    5

    6

    7

    8

    9

    >>> from collections import namedtuple

    >>> Station = namedtuple("Station", "id, city, state, lat, long")

    >>> denver = Station(44, "Denver", "CO", 40, 105)

    >>> denver

    Station(id=44, city='Denver', state='CO', lat=40, long=105)

    >>> denver.city

    'Denver'

    >>> denver[1]

    'Denver'

    对元组和列表之间“文化差异”的一个总结是:元组是不需要名字的命名元组。

    “技术差异”和“文化差异”这种区分也并不准确,因为有时候他们并不稳定。为什么同种元素的序列可变,而不同元素的序列不可变呢?举个例子,我不能修改我的气象站,因为命名元组是不可变的元组。

    Python

     

    1

    2

    3

    4

    >>> denver.lat = 39.7392

    Traceback (most recent call last):

      File "<stdin>", line 1, in <module>

    AttributeError: can't set attribute

    有时技术考量要比文化考量重要。比如你不能把列表当做字典的关键字,因为只有不可变的值才能进行哈希运算,因此只有不可变的值才能作为关键字。要使用列表做关键字,你需要把它转化为元组:

    Python

     

    1

    2

    3

    4

    5

    6

    7

    8

    9

    >>> d = {}

    >>> nums = [1, 2, 3]

    >>> d[nums] = "hello"

    Traceback (most recent call last):

      File "<stdin>", line 1, in <module>

    TypeError: unhashable type: 'list'

    >>> d[tuple(nums)] = "hello"

    >>> d

    {(1, 2, 3): 'hello'}

    技术和文化的另一个冲突是:在 Python 中元组使用的地方,列表也起着重要作用。当你定义一个带参函数,元组作为参数传入,即使这个值的位置并不显著,至少 Python 知道这是一个元组。你可能会说这是个元组因为你不能改变被传进来的值,但这只是重视了技术上的差异而非文化上的差异。

    我知道:在参数数组中,位置很重要,因为他们是位置参数。但是在函数中,它会接收参数数组并传入另一个函数,它仅仅是一组参数,与其他参数并无不同。其中一些会在调用中变化。

    Python 之所以在这里使用元组是因为元组比列表更节省空间列表被重复分配使得在添加元素上更快。这体现了 Python 的实用性:相比于在参数数组上,列表/元组的语义差别,在这种情况下,使用这种数据结构更好。

    大部分情况下,你应该根据文化差异来选择使用列表还是元组。思考下你数据的含义。如果实际上根据你的程序来计算,你的数据长度并不固定,那么可能用列表更好。如果在写代码时你知道第三个元素的含义,那么用元组更好。

    另一方面,函数式编程强调使用不可变的数据结构来避免产生使代码变得更难解读的副作用。如果你喜欢使用函数式编程,那么你可能因为元组的不可变而更喜欢它们。

    展开全文
  • 3、列表和元组的区别:列表可以进行修改,但是元组不行 4、tuple常作为字典的键 5、序列都可以进行以下操作:  索引(indexing)、分片(sliceing)、加(adding)、乘(multiplying)、以及检查元素是否属于序列(in)、...
  • python——列表和元组性能对比

    千次阅读 2019-06-10 15:51:26
    创建列表方式 # 创建空列表 # option A empty_list = list() # option B empty_list = [] 区别主要在于 list() 是一个 function call,Python 的 function call 会创建 stack,并且进行一系列...列表和元组存储...

    创建列表方式

    # 创建空列表
    # option A
    empty_list = list()
    
    # option B
    empty_list = []
    

    区别主要在于 list() 是一个 function call,Python 的 function call 会创建 stack,并且进行一系列参数检查的操作,开销较大,反观 [] 是一个内置的 C 函数,可以直接被调用,因此效率高。

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

    列表和元组最重要的区别就是,列表是动态的、可变的,而元组是静态的、不可变的。这样的差异势必会影响两者存储方式:

    list1 = [1, 2, 3]
    list1.__sizeof__() # 分配的空间
    
    64
    
    tup1 = (1, 2, 3)
    tup1.__sizeof__()
    
    48
    

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

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

    l = []
    l.__sizeof__() # 空列表的存储空间为 40 字节
    
    40
    
    l.append(1)
    l.__sizeof__() # 加入了元素 1 之后,列表为其分配了可以存储 4 个元素的空间(72 - 40)/ 8 = 4
    
    72
    
    l.append(2)
    l.__sizeof__() # 由于之前分配了空间,所以加入元素 2,列表空间不变
    
    72
    
    l.append([3, 4])
    l.__sizeof__()
    
    72
    
    l.append(5)
    l.__sizeof__() # 加入元素 5 之后,列表的空间不足,所以又额外分配了可以存储 4 个元素的存储空间
    
    104
    

    为了减小每次增加/删减操作时空间分配的开销, Python每次分配空间时都会额外多分配一些,这样的机制( over- allocating)保证了其操作的高效性:增加/删除的时间复杂度均为 O(1)。

    但是对于元组,情况就不同了。元组长度大小固定,元素不可变,所以存储空间固定。

    列表和元组的性能

    元组要比列表更加轻量级一些,所以总体上来说,元组的性能速度要略优于列表。

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

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

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

    import timeit
    t1 = timeit.Timer('x=[1, 2, 3, 4, 5, 6]')
    t1.timeit()
    
    0.07322828826904981
    
    t2 = timeit.Timer('x=(1, 2, 3, 4, 5, 6)')
    t2.timeit()
    
    0.01978216423486856
    

    如果是索引操作的话,两者的速度差别非常小,几乎可以忽略不计。

    t11 = timeit.Timer('y=x[3]', 'x=[1, 2, 3, 4, 5, 6]')
    t11.timeit()
    
    0.03726485971640159
    
    t22 = timeit.Timer('y=x[3]', 'x=(1, 2, 3, 4, 5, 6)')
    t22.timeit()
    
    0.03577006133559735
    

    列表和元组的使用场景

    1. 如果存储的数据和数量不变,比如你有一个函数,需要返回的是一个地点的经纬度,然后直接传给前端渲染,那么肯定选用元组更合适。
    def get_location():
        ......
        return (longitude, latitude)
    
    1. 如果存储的数据或数量是可变的,比如社交平台上的一个日志功能,是统计一个用户在一周之内看了哪些用户的帖子,那么则用列表更合适。
    viewer_owner_id_list = [] # 里面的每个元素记录了这个 viewer 一周内看过的所有 owner 的 id
    records = queryDB(viewer_id) # 索引数据库,拿到某个 viewer 一周内的日志
    for record in records:
        viewer_owner_id_list.append(record.id)
    
    1. 元素不需要改变时:
      两三个元素,使用 tuple,元素多一点使用 namedtuple。

    2. 元素需要改变时:
      需要高效随机读取,使用 list。需要关键字高效查找,采用 dict。去重,使用 set。大型数据节省空间,使用标准库 array。大型数据高效操作,使用 numpy.array。

    总结

    列表和元组都是有序的(可通过下标检索),可以存储任意数据类型的集合,主要有以下区别:

    • 列表是动态的,长度可变,可以随意地增删改元素。列表的存储空间略大于元组,性能略逊于元组。
    • 元组是静态的,长度大小固定,不可以对元组元素进行增删改操作。元组对于列表更加轻量级,性能稍优。
    展开全文
  • 第5章 列表元组和字典.pptx
  • 主要介绍了Python字符串、列表元组、字典、集合,结合实例形式详细分析了Python字符串、列表元组、字典、集合常见函数使用方法及相关操作注意事项,需要的朋友可以参考下
  • 列表和元组 内容描述:序列常用方法、列表元组列表的常用方法以及元组的常用方法。 一、序列概述 1、概念:(1)索引:从0开始,最后是-1,数据类型为整型(int) (2)元素:列表和元组的元素可以是不同数据...
  • 如果有了解过python中的列表和元组,你可能会知道相对于列表元组是不可变的,也就是说元组中的数据不能随意更改。除了列表是用中括号表示而元组是用小括号表示之外,这两种数据类型好像并没有什么不同,都是用来...
  • 作业:列表元组

    2020-12-22 00:23:49
    2)Python中,常见序列有列表元组、字符串。 3)序列可以进行的操作,有索引,切片,加,乘,检查成员。 此外, Python已经内置确定序列的长度以及确定最大最小的元素的方法。 列表是最常用的Python数据类型,它可以...
  • 浅谈列表和元组的区别

    千次阅读 2020-09-27 14:28:49
    列表(list)和元组(tuple)的区别使用场景 一、相同点 列表和元组都是序列化类型的容器对象,可以存放任何类型的数据,支持切片迭代 二、不同点 列表用方括号表示,元组用圆括号表示 元组是不可变类型,大小...
  • 列表和元组,都是一个可以放置任意数据类型的有序集合。在绝大多数编程语言中,集合的数据类型必须一致。不过,对于 Python 的列表和元组来说,并无此要求。 列表: l = [1, 2, 'hello', 'world'] l [1, 2, 'hello...
  • python中的列表和元组

    2020-10-01 23:34:17
    python中的列表元组一、序列二、列表元组 一、序列 成员有序排列的,且可以通过下标偏移量访问到它的一个或者几个成员,这类类型统称为序列。 序列数据类型包括:字符串,列表,元组类型。 特点: 都支持下面的特性 ...
  • 一、列表和元组的区别 列表是动态数组,它们不可变且可以重设长度(改变其内部元素的个数)。 元组是静态数组,它们不可变,且其内部数据一旦创建便无法改变。 元组缓存于Python运行时环境,这意味着我们每次使用...
  • 列表和元组的主要区别在于,列表可以修改,元组则不能。一般情况下,在几乎所有的情况下列表都可以代替元组 例如:使用序列可以表示数据库中一个人的信息(姓名,年龄) 复制代码 代码如下: >>> edward=[‘Edward ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 214,972
精华内容 85,988
关键字:

关于列表和元组