zoukankan      html  css  js  c++  java
  • 数据池,集合及深浅拷贝

    1. 小数据池(python中一种提高效率的方式,固定数据类型使用同一个内存地址)

      • 支持str,int,bool

      • id 查看空间的内存地址 获取开辟空间的一种地址 print(id(a))

      • 代码块: 一个文件,一个模块,一个函数,一个类,终端中每一行都是一个代码块

        在python中是用字典的方式存储

      • is # 判断两个内存地址是否相同 # 必须记住
        == # 判断等号两边的值是否相同 # 必须记住

      • 字符串:1.字符串在做乘法的时候总长度不能超过20,进行驻留 # 记住
        2.自己定义的字符串 长度不限制 字符串必须(字母,数字.下划线)组成,进行驻留
        3.特殊字符(中文除外)定义1个时候,进行驻留
        4.字符串*1 其实就是赋值

      • 如果is判断相同 == 一定相同
        如果==判断相同 is 不一定相同

        a = 1000
        b = 1000
        print(a == b)
        
        a = "alexdsb" * 2
        b = "alexdsb" * 2
        print(a is b)
        
        a ="12345678912345678qwertyuioqwertUIOWERTYUIOQghjksdfghjk____asdgadsfasdfgasdgasdgfsdaf"
        b ="12345678912345678qwertyuioqwertUIOWERTYUIOQghjksdfghjk____asdgadsfasdfgasdgasdgfsdaf"
        print(a is b)
        
        a = "你"
        b = "你"
        print(a is b)   # pycharm中是True 因为执行了代码块,终端中是False
        
        a = "@"
        b = "@"
        print(a is b)
        
        a = "你好"
        b = a * 1
        print(a is b)          先执行代码块,不符合代码块才会执行小数据
        
        
      • 代码块的规则:
        数字: 全部驻留
        字符串:
        1.字符做乘法的时候总长度不能超过20
        2.自定定义的都驻留
        3.乘数为1的时候 就是赋值
        4.python3.7 乘法的时候总长度不能超过4096

      • 总结:
        小数池 -- 支持: str,int,bool
        小数据池数字: -5 ~ 256
        小数据池字符串: 乘法时长度不能超过20

      • 怎么能自己驻留?

        需要使用python的内置模块
        from sys import intern
        a = intern("@@@@@@"*20)
        b = intern("@@@@@@"*20)
        print(a is b)        # 自己进行驻留
        
      • 小数据在哪用?
        1.面试的时候偶尔会用到
        2.解决自己的疑惑

    2. 集合( 集合就是一个没有值的字典,遵循:唯一,无序,元素要求可哈希(不可变)------------------------set {1,2,3}

      • s = {1,2,3,"123",False,(1,2,3,4)}

      • 集合是无序的

      • 集合是可变的

      • 集合的增删改

        增:

        s.update("3456")  # 迭代添加
        print(s)
        
        s.add("怼怼")
        print(s)
        

        删:

        s = {1,2,3,"123",False,(1,2,3,4)}
        print(s)
        s.pop()   #随机删除
        s.remove(3) # 通过元素删除
        s.clear()    # 清空
        del s        #删除整个集合
        print(s)
        

        改:删了再加

        查:

        for
        

        天然去重 -- 唯一

        其他操作:

        s1 = {1,2,3,4,5,6,7}
        s2 = {3,4,5,6
        
        print(s1 - s2)  #差集
        print(s1 | s2)  #并集   (合集)
        print(s1 & s2)  #交集
        print(s1 ^ s2)  #对称差集  -- 反交集
        print(s1 > s2)  # 超集   -- 父集
        print(s1 < s2)  # 子集
        

        冻结集合(可变 转换成 不可变) -- 更不常用:

        f_s = frozenset({1,2,3,4,5})
        dic = {f_s:"1"}
        print(dic)
        

        集合在哪里用

        1. 去重
          li = [1,2,3,4,5,2,2,2,33,3,3,2,2,1,]
          print(list(set(li)))]

        2. 面试题:
          li = [1,2,3,4,2,1,3] #一行代码去重
          print(list(set(li)))

      1. 深浅拷贝(拷贝 -- copy 复制了一份)

        l1 = [1,2,3,4,[5,6,7,]]
        l2 = l1  # 赋值    赋值不是拷贝
        l1.append(8)
        print(l1)
        print(l2)
        
        • 浅拷贝
        l1 = [1,2,3,4,[4,5,6]]
        l2 = l1[:]   # 浅拷贝
        l2 = l1.copy() # 浅拷贝  -- 只拷贝第一层
        print(id(l1[0]))
        print(id(l2[0]))
        浅拷贝会创建一个新的列表(容器),
        新创建的列表中的元素和原列表的元素用的是同一个内存空间
        l1 = [1,2,3,4]
        l2 = l1.copy()
        print(l1)
        print(id(l1))
        print(id(l2))
        print(id(l1[0]))
        print(id(l2[0]))
        
        li = [1,2,32,[3,4,5]]
        l2 = li.copy()
        li.append(8)
        print(l2)
        print(li)
        
        li[-1].append(8)
        print(l2)
        
        l1 = [1,2,3,(1,2,3)]
        l2 = l1.copy()
        l2[-1] = 6
        print(l1)  # 不变
        print(l2)  # 不变
        
        l1 = [1,2,3,4,[5,6,7,]]
        l2 = l1.copy()
        l1[-1].append(8)
        print(l2)  #[1,2,3,4,[5,6,7,8]]
        
        li = [1,2,3,4,]
        l2 = li  # 赋值   两个变量指向了一个列表内存地址
        li.append(9)
        print(l2)
        
        l1 = [1,2,3,4,5,]
        l2 = l1.copy()
        l1.append(8)
        print(l2)
        print(l1)
        
        l1 = [1,2,3,[4,5,6]]
        l2 = l1.copy()
        l2[-1] = 77
        print(l1)
        print(l2)
        

        深拷贝:import copy

        深拷贝:import copy
        li = [1,2,3,4,5,[6,7,8]]
        l2 = copy.deepcopy(li)
        print(li)
        print(id(li))
        print(id(li[-1]))
        print(l2)
        print(id(l2))
        print(id(l2[-1]))
        
        深拷贝 --
        不可变的数据类型和原列表指向同一个空间
        可变数据会创建一个新的空间
        
        import copy
        li = [1,2,3,4,5,[6,7,8]]
        l2 = copy.deepcopy(li)
        li[-1].append(678)
        print(l2)
        
        import copy
        li = [3,4,5,[1,2,3,4],6,7,8,{"k":'v'}]
        l2 = copy.deepcopy(li)
        li[-1]['k'] = "a"
        print(li)
        print(l2)
        

        怎么用,在哪用:

        dic = {}   # "v":4
        li = []    #[{"v":0},{"v":1},{"v":2},{"v":3},{"v":4}]
        for i in range(0,5):
        dic["v"] = i
        li.append(dic)
        print(li)
        
        • 1.面试
          2.不让修改原数据的时候,使用
  • 相关阅读:
    ant 软件包不存在报错
    在 Internet Explorer 中使用 Windows 窗体控件
    智能客户端
    Back to the Future with Smart Clients
    "Automation 服务器不能创建对象" 的解决方案
    Top 10 Reasons for Developers to Create Smart Clients
    Updater Application Block for .NET
    Smart Client Application Model and the .NET Framework 1.1
    Security and Versioning Models in the Windows Forms Engine Help You Create and Deploy Smart Clients
    智能客户端技术总结(二)
  • 原文地址:https://www.cnblogs.com/-777/p/11005589.html
Copyright © 2011-2022 走看看