python内置数据结构之list

列表简单总结

  • 类和实例之间的理解

            人类,哺乳类
            实例是某一类中的真实个体
  • 时间复杂度
            O(1)
            O(n)
            O(n**2)
    
            随着处理的数据逐渐增加,程序返回结果的时间变化的描述.
                O(1)表示无论程序处理的数据如何增加,返回结果的时间是常数
                O(n)随着处理数据的数量n的增加,返回结果的时间线性增长n
                O(n)随着处理数据的数量n的增加,返回结果的时间指数级增长n**2
  • list,链表,queue,stack
            list: 有序的、紧密的可变序列
            链表: 手拉手的有序序列
            queue: 有序队列,常用于先进先出模型
            stack: 常用于后进先出的有序队列
  • 列表O(1)操作:
            append()
            extend()
            pop()
            insert() 
                插入方法插入时的时间是O(1),但导致其他元素的后移,所使用的时间更久.慎用.
  • 列表O(n)操作:
            count()
            index()
            remove()
            pop(index)
  • 列表复制:
            ==,内容,值比较
            is,内存地址比较,是否是同一对象
            = , 赋值,此赋值仅复制了对象的引用
            list.copy, 列表的第一次简单元素深复制,嵌套结构仅复制引用
            copy.deepcopy, 深复制,递归复制所有对象本身
    
            浅复制
                l1=l2
                l1=l2.copy()
            深复制
                l1=copy.deepcopy()
    
            示例;
                >>> l1=[1,2,3,[1]]
                >>> l1
                [1, 2, 3, [1]]
                >>> l2=l1             # 直接复制
                >>> l3=l1.copy()      # 使用列表方法复制
                >>> l1 
                [1, 2, 3, [1]]
                >>> l2
                [1, 2, 3, [1]]
                >>> l3
                [1, 2, 3, [1]]
                >>> l1[0]=100         # 修改第一层列表中元素
                >>> l1
                [100, 2, 3, [1]]
                >>> l2
                [100, 2, 3, [1]]
                >>> l3                # copy()复制的元素不变
                [1, 2, 3, [1]]
                >>> l1[-1][0]=100     # 修改嵌套在里面的列表中元素
                >>> l1
                [100, 2, 3, [100]]
                >>> l2
                [100, 2, 3, [100]]
                >>> l3                # l2,l3都被修改
                [1, 2, 3, [100]]
  • ==和is示例;
                >>> l1
                [1, 2, 3]
                >>> l2=l1
                >>> l3=l1.copy()
                >>> id(l1)
                140604879543624
                >>> id(l2)
                140604879543624
                >>> id(l3)              
                140604745250184
                >>> l1 == l2
                True
                >>> l1 == l3
                True
                >>> l1 is l2
                True
                >>> l1 is l3
                False
  • append()和extend()区别
            L.append(object) -> None
            L.extend(iterable) -> None
    
            append() 将对象附加至列表尾部
            extend() 将可迭代对象的元素附加至列表尾部
    
            >>> l1
            [1, 2, 3]
            >>> l2
            [‘a‘, ‘b‘, ‘c‘]
            >>> l1.append(l2)           # 将l2列表作为一个对象附加至列表l1
            >>> l1
            [1, 2, 3, [‘a‘, ‘b‘, ‘c‘]]
            >>> l1.extend(l2)           # 将l2中的元素逐个附加至列表l2
            >>> l1
            [1, 2, 3, [‘a‘, ‘b‘, ‘c‘], ‘a‘, ‘b‘, ‘c‘]
  • [[0],[0],[0]] 和 0*n 区别
            >>> l1 = [[0],[0],[0]]    # 创建三个不同的对象
            >>> l1
            [[0], [0], [0]]
            >>> id(l1[0][0])          # 不同的内存地址
            8948000
            >>> id(l1[1][0])
            8947968
            >>> id(l2[0][0])         # 同一内存地址,也就是同一对象
            8948000
            >>> id(l2[1][0])
            8948000
            >>> l2 = [[0]]*3          # 创建三个同一对象
            >>> l2
            [[0], [0], [0]]
            >>> l1[0][0]=1
            >>> l1
            [[1], [0], [0]]
            >>> l2[0][0]=1
            >>> l2
            [[1], [1], [1]]
时间: 2024-11-08 23:20:33

python内置数据结构之list的相关文章

Python内置数据结构——列表list,元组tuple

内置数据结构分类: 数值型 int , float , complex , bool 序列对象 字符串 str 列表 list tuple(元组) 键值对 集合 set 字典 dict 数字型 int ,float , complex , bool都是class, 1,5.0 , 2+3j都是对象的实例 int : python3的int就是长整型,没有大小限制,受限于内存大小 float:有整数部分和小数部分组成,支持十进制和科学计数法表示,只有双精度型 complex:有实数和虚部组成,实部

Python内置数据结构

内置数据结构 可变 list 列表 byterray dict 字典 set 集合 不可变 tuple 元组 bytes 常量(int,str,bool 等) list 列表 (推荐使用索引)列表相当于一个排列整齐的队列,可以理解为在内存中是一片排列整齐的连续的空间,它是可索引,可变的,有序的,线性结构,可迭代.优点:通过索引(index)查找.替换元素 效率高 时间复杂度O(1).尾部追加(append)与 尾部移除(pop)元素快 效率高 时间复杂度O(1).缺点:从中间增加或移除元素会使列

Python内置数据结构操作VS sqlite3操作

1.摘要 在同一数据库中查询某值,内置数据结构的查询速度快还是数据库sqlite3的查询速度快?针对这一问题,通过构建一个包含2500个随机数的列表,并将其插入sqlite3数据库中,利用timeit模块,分别对内置数据结构list和sqlite3查询某一值在不在数据组中进行对比. 2.代码 >>> import numpy as np >>> import sqlite3 >>> test=np.random.randn(2500) >>

【Python】07、python内置数据结构之字符串及bytes

一.字符串 1.定义和初始化 In [4]: s = "hello python" In [4]: s = "hello python" In [5]: s Out[5]: 'hello python' In [6]: s = 'hello python' In [7]: s Out[7]: 'hello python' In [8]: s = '''hello python''' In [9]: s Out[9]: 'hello python' In [10]: 

Python内置数据结构3

解构 In [8]: lst = [1,2] In [9]: lst Out[9]: [1, 2] In [10]: first,second = lst  #解构 In [11]: print(first,second) 1 2 按照元素顺序,把线性结构的元素赋值给变量 解构的变化 In [21]: lst = list(range(10)) In [22]: lst Out[22]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] In [23]: head,*mid,tail

python内置数据结构 - list

目录: 分类 数字的处理函数 类型判断 list 练习题 一. 分类 1). 数值型:int(整型), float(浮点型), complex(复数), bool (布尔型) 2). 序列对象:str (字符串), tuple(元组) 3). 键值对:set(集合), dict(字典) 二. 数字的处理函数 round(), 对浮点数取近似值 In [1]: round(2.675, 2) Out[1]: 2.67 In [2]: round(2.676, 2) Out[2]: 2.68 在机器

chapter . 2.2、Python内置数据结构:字符串、字节和字节数组

字符串 有序的序列,是字符的集合 使用单引号,双引号,三引号引注的字符序列 字符串是不可变对象,我们看到的合并字符串,其实是返回一个由原来两个值复制后返回的值,会占用新的空间. 从python3起,字符串是Unicode类型 s1 = 'string' s2 = '''this's a "string''' s3 = r"hello \n aasdasd"    :r和R表示忽略转义 s4 = R'windows \net' sql = """s

【Python】11、python内置数据结构之字典

一.字典 1.字典的初始化 字典是一种key-value结构 In [160]: d = {} In [161]: type(d) Out[161]: dict In [166]: d = {'a':1, 'b':2} In [167]: d Out[167]: {'a': 1, 'b': 2} In [180]: d = dict({"a":0, "b":1}) In [181]: d Out[181]: {'a': 0, 'b': 1} In [164]: d 

【Python】06、python内置数据结构1

一.数据结构与获取帮助信息 1.数据结构 通过某种方式(例如对元素进行编号)组织在一起的数据元素的集合,这些数据元素可以是数字或者字符,甚至可以是其它的数据结构. python的最基本数据结构是序列 序列中的每个元素被分配一个序号(即元素的位置),也称为索引:索引从0开始编号 2.python中如何获取命令帮助 获取对象支持使用的属性和方法:dir(), 某方法的具体使用帮助:help() 获取可调用对象的文档字串:print(obj.__doc__) In [15]: dir(list) Ou