• Python基础学习笔记(06)代码块、集合、深浅copy


    Python基础学习(06)

    一、今日内容大纲

    • id 内存地址
    • 代码块及其缓存机制
    • set 集合(了解)
    • 深浅copy
    • enumerate 枚举

    二、id 内存地址

    id()可以返回目标变量的地址,而is可以用来判断两者的id是否相同,若相同则返回True。

    i1 = 100
    j1 = 100
    i2 = '100'
    j2 = '100'
    i3 = [100]
    i4 = [100]
    print(i1 is j1)
    print(i2 is j2)
    print(i3 is j3)			#==仅仅是判断两者的值是否相同,同is的使用略有不同,这里==会返回True
    

    程序运行结果为:

    True
    True
    False
    

    三、代码块

    这篇博客写的比较清楚:https://www.cnblogs.com/zx125/p/11745864.html

    1. 什么是代码块

      我们所有的代码都需要依赖代码块执行,一个函数、一个文件就是一个代码块,在交互式命令下,每一行都是一个代码块。同一个代码块下,有一个缓存机制;不同的代码块下,遵循不同的缓存机制。

    2. 同一代码块的缓存机制

      • 机制内容:Python在执行统一代码块的初始化对象的命令时,会检查是否其值已经存在,如果存在,会将其重用。换句话说:执行同一个代码块时,遇到初始化对象的命令时,它会将初始化的这个变量与值存储在一个字典中,在遇到新的变量时,会先在字典中查询记录,如果有同样的记录那么它会重复使用这个字典中之前的这个值。

      • 适用对象:int(float)、str、bool

      • 具体细则:所有的数字、布尔值及几乎所有的字符串

      • 优点:提升性能、节省内存

    3. 不同代码块的缓存机制(小数据池)

      • 机制内容:Python自动将-5~256的整数进行了缓存,当你将这些证书赋值给变量时,并不会重新创建对象,而是使用已经创建好的缓存对象。Python会将一定规则的字符串在字符串驻留池中创建一份,当你将这些字符串赋值给变量时,并不会重新创建对象,而是使用在字符串驻留池中创建好的对象。
      • 适用对象:-5~256整数、str、一定规则的字符串

    四、set 集合(了解)

    1. 集合

      容器型的数据类型,它要求它里面的元素是不可变(可hash)的数据(int、bool、str),但是它本身是可变的数据类型,集合是无序的,相同元素只允许存在一个,用大括号括起表示。

    2. 集合的作用

      • 列表的去重
      • 关系测试:交集、并集、差集等
    3. 集合的基本操作

      • 集合的创建

        set1 = set({1,3,'barry',False})
        set1 = {1,3,'barry',False}        # 一般使用这种方式
        
      • 空集合的表示

        print({},type({}))
        set1 = set()
        print(set1,type(set1))
        
        # result:
        # {} <class 'dict'>
        # set() <class 'set'>
        
      • 集合的有效性

        set1 = {[1,2,3],3,{'name':'alex'}}
        print(set1)
        
        # result: TypeError: unhashable type: 'list'
        
      • add 函数:添加元素

        set1 = {1,2,3,'Raigor'}
        set1.add('xx')
        print(set1)
        
        # result: {1, 2, 3, 'Raigor', 'xx'}
        
      • update 函数:迭代添加

        set1 = {1,2,3,'Raigor'}
        set1.update('sad')
        print(set1)
        
        # result: {1, 2, 3, 's', 'Raigor', 'a', 'd'}
        
      • remove函数:按照元素删除

        set1 = {1,2,3,'Raigor'}
        set1.remove('Raigor')
        print(set1)
        
        # result: {1, 2, 3}
        
      • pop函数:随即删除

        set1 = {1,2,3,'Raigor'}
        set1.pop()
        print(set1)
        
        # result: {1,2,3}
        
      • 修改操作:先删除在增加

        set1 = {1,2,3,'Raigor'}
        set1.remove('Raigor')
        set1.add(4)
        print(set1)
        
        # result: {1, 2, 3, 4}
        
      • 查找操作:常在列表中使用的in函数也可用于集合的查找操作

    4. 集合的操作

      有以下两个集合:

      set1 = {1,2,3,4,5}
      set2 = {4,5,6,7,8}
      
    • 交集

      print(set1 & set2)
        
      # result: {4, 5}
      
    • 并集:| 或者 union

      print(set1 | set2)
      
      # result: {1, 2, 3, 4, 5, 6, 7, 8}
      
    • 差集:- 或者 difference

      print(set1 - set2)
         
      # result: {1, 2, 3}
      
    • 反交集:^ 或者 symmetric_difference

      print(set1 ^ set2)
      
      # result: {1, 2, 3, 6, 7, 8}
      
    • 子集:< 或者 issubset

      print(set1 < set2)
      
      # result: False
      
    • 超集:> 或者 issuperset

      print(set1 > set2)
      
      # result: False
      
    1. 应用:列表的去重

      l1 = [1,1,2,2,3,3,4,5,6]		# 利用集合去重不会保持原先顺序
      set1 = set(l1)
      l1 = list(set1)
      print(l1)
      
      # result: [1, 2, 3, 4, 5, 6]
      

    五、深浅copy

    1. 赋值运算

      l1 = [1, 2, 3, [22, 33]]
      l2 = l1
      l1[1] = 999
      l1.append(666)			# 对于列表等容器型数据类型而言,容器内部其他数据的改变不影响容器本身的地址
      print(l1)		
      print(l2)
      
      # result:
      # [1, 999, 3, [22, 33]]
      # [1, 999, 3, [22, 33]]
      
    2. 浅拷贝 copy(切片属于浅copy)

      l1 = [1, 2, 3, [22, 33]]
      l2 = l1.copy()          # l1,l2此时的id已经不是一个地址了
      l1.append(666)
      print(l1)
      print(l2)
      
      # result:
      # [1, 2, 3, [22, 33], 666]
      # [1, 2, 3, [22, 33]]
      

      另一种情况:

      l1 = [1, 2, 3, [22, 33]]
      l2 = l1.copy()
      l1[-1].append(666)          # l1[-1],l2[-1]的id仍然相同
      print(l1)
      print(l2)
      
      # result:
      # [1, 2, 3, [22, 33, 666]]
      # [1, 2, 3, [22, 33, 666]]
      
    3. 深拷贝 deepcopy

      python对深copy进行了优化,将可变的重新创建了一份,不可变的数据类型沿用之前的,节省了空间。

      import copy
      l1 = [1 ,2 ,3 , [22, 33]]
      l2 = copy.deepcopy(l1)
      l1[-1].append(666)
      print(l1)
      print(l2)
      
      # result:
      # [1, 2, 3, [22, 33, 666]]
      # [1, 2, 3, [22, 33]]
      

    六、enumerate 枚举

    是一种可迭代对象遍历方法,会返回多组一个数字和对象值的元组类型,使用方法如下:

    l1 = ['a', 'b', 'c']
    for i in enumerate(l1):
        print(i)
    for i in enumerate(l1,start = 100):		# 可以设置开始数字
        print(i)
    

    程序运行结果为:

    (0, 'a')
    (1, 'b')
    (2, 'c')
    (100, 'a')
    (101, 'b')
    (102, 'c')
    
  • 相关阅读:
    10.28
    10.29
    11.05周四
    数据库增删改查
    11.03Tuesday
    11.10
    连接数据库
    10.30
    11.04周三
    10.27
  • 原文地址:https://www.cnblogs.com/raygor/p/13236914.html
Copyright © 2020-2023  润新知