精华内容
下载资源
问答
  • 数组,集合列表的区别 数组和列表也是集合,但是有序。[]在python中我们可以把数组 列表看出一回事 数组只是里面只能写一种元素,列表里面各种元素可以混着写 python中的数组可以理解为字符串的表达形式,这就...

    数组,集合,列表的区别

    数组和列表也是集合,但是有序。[]在python中我们可以把数组和
    列表看出一回事
    数组只是里面只能写一种元素,列表里面各种元素可以混着写
    python中的数组可以理解为字符串的表达形式,这就通透了
    我们一般说的集合是无序的。python中用{}

    # a=['范冰冰','李冰冰','杨幂']
    # # 我喜欢的明星还有,我还得加
    # a.append('刘诗诗')
    # # 我觉得在我眼中舒畅最美
    # a.insert(0,'舒畅')
    # print(a)
    #
    # # 范冰冰有点年纪big了,不是我这个年纪喜欢的了
    # a.pop(1)
    # print(a)
    # # 我想把李冰冰改成蒋欣
    # a[1]='蒋欣'
    # print(a)
    
    shuzu='nihaoshijie'
    for i in range(len(shuzu)):
        print(shuzu[i],end='')
    print()
    
    list=['张三','lisi','ermazi']
    for i in list:
        print(i,end='')
    print()
    
    jihe={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32}   #集合遍历出来肯定是随机的顺序,因为是无序的
    a=set((1,2,3,4,5,6,7,8,9))
    # a = set(("Google", "Runoob", "Taobao"))
    while True:
        for i in a:
            print(i,end='  ')
    
        print()
    
    
    
    
    
    
    
    
    
    
    展开全文
  • 一、列表和元组的区别 列表是动态数组,它们不可变且可以重设长度(改变其内部元素的个数)。 元组是静态数组,它们不可变,且其内部数据一旦创建便无法改变。 元组缓存于Python运行时环境,这意味着我们每次使用...

    转载自品略图书馆 http://www.pinlue.com/article/2020/05/2001/1810565237426.html

     

    一、列表和元组的区别

    列表是动态数组,它们不可变且可以重设长度(改变其内部元素的个数)。

    元组是静态数组,它们不可变,且其内部数据一旦创建便无法改变。

    元组缓存于Python运行时环境,这意味着我们每次使用元组时无须访问内核去分配内存。

    这些区别结实率两者在设计哲学上的不同:

    列表可被用于保存多个互相独立对象的数据集合

    元组用于描述一个不会改不安的事务的多个属性

    二、列表(List)

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

    >>> l = [1, 2, 3, 4, 5, 6]>>> l[0] = l[2] * l[3]>>> l[12, 2, 3, 4, 5, 6]

    另外我们可以给列边添加新的数据来增加其大小:

    >>> len(l)6>>> l.append(7)>>> l[12, 2, 3, 4, 5, 6, 7]>>> len(l)7

    这是因为动态数组支持resize操作,可以增加数组的容量。当一个大小为N的列表第一次需要添加数据时,Python会创建一个新的列表,足够放原来的N个元素以及额外添加的元素。不过,实际分配的并不是N+1个元素,而是M个元素,M > N, 这是为了给未来的添加预留空间。然后旧列表的数据被复制到新列表中,旧列表则会被销毁。从设计理念上来说,第一次添加可能是后续多次添加的开始,通过预留空间的做法,我们就可以减少这一分配空间的操作次数以及内存复制的次数。这点非常重要,因为内存复制可能非常的昂贵,特别是当列表大小开始增长以后。

    三、元组(Tuple)

    元组是固定且不可改变的。这意味着一旦元组被创建,和列表不同,它的内容无法被修改或它的大小也无法被改变。

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

    虽然它们不支持改变大小,但是我们可以将两个元组合并成一个新元组。这一操作类似列表的resize操作,但我们不需要为新生的元组分配任何额外的空间:

    >>> t1 = (1, 2, 3, 4)>>> t2 = (5, 6, 7, 8)>>> t1 + t2(1, 2, 3, 4, 5, 6, 7, 8)

    如果我们将其与列表的append操作比较,我们会看到它的复杂度是O(n)而不是列表的O(1)。这是因为对元组每添加一个新元素都会有分配和复制操作,而不是像列表那样仅在额外的空间耗尽时发生。所以元组并没有提供一个类似append的自增操作,任意两个元组相加始终返回一个新分配的元组。

    该网站为Python Tutor,一个能够对python运行内存可视化的网站,非常适合初学者研究,在运行过程中内存发生了什么。

    元组的静态特性的另一个好处体现在一些会在Python后台发生的事情:资源缓存。

    Python是一门垃圾收集语言,这意味着当一个变量不再被使用时,Python会将该变量使用的内存释放回操作系统,以供其他程序(变量)使用。然而,对于长度为1~20的元组,即使它们不在被使用,它们的空间也不会立刻还给系统,而是留待未来使用。这意味着当未来需要一个同样大小的新的元组时,我们不再需要向操作系统申请一块内存来存放数据,因为我们已经有了预留的空间。

    这看上去可能是个细微的好处,但是实际上是元组一个很神奇的地方:它们可以被轻松快速地创建,因为它们可以避免跟操作系统频繁的打交道,而后者会花很长的时间。

    下面举个例子会非常直观的说明问题

    In [1]: %timeit l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]93.7 ns ± 3.33 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)In [2]: %timeit t = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)18.5 ns ± 1.19 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

    上面的示例中显示了初始化一个列表比初始化一个元组慢了5.1倍——如果这是在一个循环中,这点差别会很快的累加起来。

    展开全文
  • 列表(list)元组(tuple)一些基础 listtuple都是一个可以放置任意数据类型有序集合,都是既可以存放数字、字符串、对象等 listtuple都支持负索引 In [8]: nums[-2] Out[8]: ‘ad’ In [9]: tp[-2] Out[9]:...
  • 特点:元素可重复,类型可以不同(这也是数据最本质的区别),可修改 li1 = [123,123,234,'happy'] li[1] = 456(使用索引标记来为某个特定的、位置明确的元素赋值,但是不能为一个位置不存在的元素进行赋值) ...

    1、列表

    list = ['word',123]       

    特点:元素可重复,类型可以不同(这也是和数据最本质的区别),可修改

    li1 = [123,123,234,'happy']

    li[1] = 456(使用索引标记来为某个特定的、位置明确的元素赋值,但是不能为一个位置不存在的元素进行赋值)

    关于列表的几个函数:

    list:       将string拆成列表      eg:   name = list['perl']     name = ['p','e','r','l']

    append:用于在列表末尾追加新的对象  

    count:统计某个元素在列表中出现的次数

    extend : 可以在列表的末尾追加另一个序列的多个值

    index:找出列表中某个值的第一个匹配项的索引位置

    insert:将对象插入到列表中 li.insert(3,‘lalala’)

    pop:移除列表中的一个元素,并且返回该元素,默认是最后一个,所以可以用pop实现一个栈数据结构,栈是先进后出的,队列是先进先出的

    可以用append方法来进行入栈的操作,python没有入栈的方法

    remove:用于移除列表中的某个值的第一个匹配项,它修改了列表,但是没有返回值

    reverse:将列表中的元素反向存放

    sort:在原位置对列表进行排序,默认是升序

    sort方法有两个可选的参数,key 和 reverse ,key是排序标准的关键词  x.sort(key=len),reverse是简单的布尔值,就是表示要不要反向排序

    关于列表的操作有很多,就不一一列举

    2、元组

    t = (1,2,3)   元组和列表一样,也是一种序列,函数也基本相同,唯一不同的是元组不能修改,
    a = touple([1,2,3])   a = (1,2,3)     touple 和list函数一样,可以用来修改数据类型
    元组因为不能修改,所以基本操作比较简单,就是创建元组和访问元组,其中元组的切片还是元组 
    展开全文
  • Python列表、元组、集合、字典的区别和相互转换

    万次阅读 多人点赞 2017-04-28 11:40:09
    列表、元组、集合、字典的区别 列表 元组 集合 字典 英文 list tuple set dict 可否读写 读写 只读 读写 读写 可否重复 是 是 否 是 存储方式 值 值 值 键值对 是否有序 有序 有序 ...

    ##列表、元组、集合、字典的区别

    列表 元组 集合 字典
    英文 list tuple set dict
    可否读写 读写 只读 读写 读写
    可否重复
    存储方式 键(不能重复) 键值对(键不能重复)
    是否有序 有序 有序 无序 无序,自动正序
    初始化 [1,'a'] ('a', 1) set([1,2]){1,2} {'a':1,'b':2}
    添加 append 只读 add d['key'] = 'value'
    读元素 l[2:] t[0] d['a']

    ##列表、元组、集合、字典相互转换

    ###列表元组转其他

    
    # 列表转集合(去重)
    list1 = [6, 7, 7, 8, 8, 9]
    set(list1)
    # {6, 7, 8, 9}
    
    #两个列表转字典
    list1 = ['key1','key2','key3']
    list2 = ['1','2','3']
    dict(zip(list1,list2))
    # {'key1': '1', 'key2': '2', 'key3': '3'}
    
    #嵌套列表转字典
    list3 = [['key1','value1'],['key2','value2'],['key3','value3']]
    dict(list3)
    # {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
    
    # 列表、元组转字符串
    list2 = ['a', 'a', 'b']
    ''.join(list2)
    # 'aab'
    
    tup1 = ('a', 'a', 'b')
    ''.join(tup1)
    # 'aab'
    
    

    ###字典转其他

    # 字典转换为字符串
    dic1 = {'a':1,'b':2}
    str(dic1)
    # "{'a': 1, 'b': 2}"
    
    # 字典key和value互转
    dic2 = {'a': 1, 'b': 2, 'c': 3}
    {value:key for key, value in a_dict.items()}
    # {1: 'a', 2: 'b', 3: 'c'}
    

    ###字符串转其他

    # 字符串转列表
    s = 'aabbcc'
    list(s)
    # ['a', 'a', 'b', 'b', 'c', 'c']
    
    # 字符串转元组
    tuple(s)
    # ('a', 'a', 'b', 'b', 'c', 'c')
    
    # 字符串转集合
    set(s)
    # {'a', 'b', 'c'}
    
    # 字符串转字典
    dic2 = eval("{'name':'ljq', 'age':24}")
    
    # 切分字符串
    a = 'a b c'
    a.split(' ')
    # ['a', 'b', 'c']
    

    参考地址:
    https://docs.python.org/2/library/index.html

    展开全文
  • 如果把python列表 做为一种有序对象集合类型话,那python字典 就是无序的集合类型,python 列表主要是根据偏移来取得存取,而python字典主要是根据键来存取。 字典格式以{key:value}格式来定义 比如 ...
  • 列表(list) 可变 可重复 有序 [] 元组(tuple) 不可变 可重复 有序 () 字典(dictionary) 可变 可重复 无序 {key:value} 集合(set) 可变 不可重复 无序 {} 或([]) ...
  • 一、列表 1.任意对象有序集合 列表是一组任意类型值,按照一定顺序组合而成 ...列表可以当成普通数组,每当用到引用时,Python总是会将这个引用指向一个对象,所以程序只需处理对象操作。当
  • 字典(dict)和集合(set)在 Python 被广泛使用,并且性能进行了高度优化,其重要性不言而喻。 字典和集合基础 字典是一系列由键(key)和值(value)配对组成元素集合。python3.7之后,字典底层是2个数组,一...
  • 列表是任意对象序列,列表用[ ]表示。 将一组值打包到一个对象中,称为元组,元组用()表示。 ...与列表和元组不同,集合是无序,也不能通过索引进行访问。此外,集合元素不能重复。 ...
  • 列表:就像动态大小的数组一样,用其他语言声明(C ++中的vectorJava中的...Python的集合类表示集合的数学概念。 字典: 在Python中是数据值的无序集合,用于存储数据值(如地图),与其他仅将单个值作为元素的数
  • #python列表appendextend的区别 list.append(obj):在列表末尾添加新的对象,新对象作为列表的一个元素,新对象可以是任何类型(字符串、数字、列表、元组、字典、集合) list.extend(seq):在列表末尾一次性追加...
  • 在初步学习python时,面对列表,元组,字典,集合时,由于它们较为相似,新手常常会被弄晕头转向。 列表 元组 字典 集合 名称 list tuple dict set 能否更改 能 不能 能 能 能否重复 能 能 能 不能 ...
  • 列表(list) 可变 可以重复 有序 [ ] 元组(tuple) 不可变 可以重复 有序 ( ) 字典(dictionary) 可变 可重复 无序 {key:value} 集合 可变 不可重复...
  • 时间复杂度为列表的长度,即从第一个元素遍历到最后一个元素为止,O(len(list)) 集合数据无序,不可重复,查找某个元素方式为哈希。即某个元素通过哈希计算,他位置永远固定(顺序却不按输入元素顺序,解释了为...
  • 区别参见表:
  • 元组:元组是任意对象有序集合,(这一点和列表相同)元组是不可变(不可以增删改查),但可以对元组进行合并 列表 列表:列表元素是任意类型包括列表的类型可以进行合并,删除,索引,切片等 集合 集合:...
  • 序列是一个基类类型,元组、列表是序列类型一种扩展,继承序列类型全部通用操作。 (1)集合set 集合就是我们数学学的集合集合最好应用是去重——集合类型所有元素无重复。可以利用{}或set()建立集合。 ...
  • python列表和字典区别

    2021-05-26 20:41:05
    列表 1.任意对象有序集合 列表是一组任意类型值,按照一定顺序组合而成 2.通过偏移读取 ...列表可以当成普通数组,每当用到引用时,Python总是会将这个引用指向一个对象,所以程序只需处
  • 列表是处理一组有序数据结构,可以读写,添加删除,或者搜索列表元素。因为可以添加删除,所以称为可变数据类型,即这种类型是可以被改变,并且列表可以嵌套。 res = [1,2,'yihang'] #增加元素:...
  • ...列表、元组、集合、字典的区别 列表 元组 集合 字典 英文 list tuple set dict 可否读写 读写 只读 读写 读写 可否重复 是 是 否 ...

空空如也

空空如也

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

python列表和集合的区别

python 订阅