小数据池 深浅拷贝 集合

标签：浅拷贝   rem   pre   copy   循环   布尔值   upd   建议   机制   

小数据池

小数据池 ———— 缓存机制(驻留机制)

1. == 判断两边的内容是否相等

2. a = 10
   b = 10
   print(a == b)
   # True

   is 判断两边的值内存地址是否相等

   a = 10
   b = 10
   print(a is b)
   # True
   print(id(a))
   print(id(b))
   #True
   4329728336
   
   地址是一样的

小数据池的数据范围: -5 ~ 256

a = -5
b = -5
c = -5
print(id(a))
print(id(b))
print(id(c))

代码块

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

? 支持: 数字 字符串 布尔值

• 数字: 在同一代码块下,只要内容相同就采用相同的内存地址
• 数字在做乘法的范围-5~256
• 数字在做乘法的时候不能使用浮点数

字符串

• 在同一代码块下,只要内容相同就要采用相同的内存地址
• 乘法的时候总长度不能超过 20
• 乘法的时候中文,特殊符号乘以 1 或 0

布尔值

在同一代码块下,只要内容相同就采用相同的内存地址

小数据池

数字

• ? -5 ~256

布尔值

• 在同一代码块下,只要内容相同就采用相同的内存地址

• 乘法的时候中文符号乘以 0 (没有 1)

• 乘法的总长度不能超过 20

补充:小数据池的验证方法,必须先脱离代码块才能进行验证,先执行代码块的规则,再执行小数据的规则 (驻留机制)

深浅拷贝

浅拷贝定义 : 复制一份

lst = [1,2,3,[5,6,7]]
lst1 = lst
lst[-1].append(8)
print(lst1)
print(lst)


#
[1, 2, 3, [5, 6, 7, 8]]
[1, 2, 3, [5, 6, 7, 8]]

lst = [1,2,3,[5,6,7]]
lst1 = lst.copy()    #新开辟了一个空间
print(lst1)
print(lst)
print(id(lst1))
print(id(lst))


#
[1, 2, 3, [5, 6, 7]]
[1, 2, 3, [5, 6, 7]]
4450516552
4450515208     #即使表面上都是一样的,但是地址不一样

lst = [1,2,3,[5,6,7]]
lst1 = lst.copy()
lst1[-1].append(8)   #浅拷贝的时候,只会开辟一个新的容器,其他元素使用的都是源列表中的元素
print(lst)
print(lst1)
#
[1, 2, 3, [5, 6, 7, 8]]
[1, 2, 3, [5, 6, 7, 8]]   ##第二层里的数据变化就变了

lst = [1,2,3,[5,6,7]]
lst1 = lst.copy()
lst[0]=11
print(lst)
print(lst1)


#
[11, 2, 3, [5, 6, 7]]
[1, 2, 3, [5, 6, 7]]    #第一层的数据变化  后面就不变 

lst = [1,2,3,[5,6,7]]
lst1 = lst.copy()
lst[3][0] = 567
print(lst)
print(lst1)


#
[1, 2, 3, [567, 6, 7]]
[1, 2, 3, [567, 6, 7]]

浅拷贝:浅拷贝的时候,只拷贝第一层元素.浅拷贝在修改第一层元素的时候(不可变数据类型),拷贝出来的新列表不进行改变

浅拷贝在修改第一层元素(可变数据类型)的时候,拷贝出来的新列表进行改变

浅拷贝在修改第一层元素中的元素的时候,拷贝出来的新列表进行改变

深拷贝

深拷贝开辟一个容器空间,不可变数据共用,可变数据类型(再次开辟一个新的空间),空间里的值不可变的数据进行共用,可变的数据类型再次开辟空间

import copy
lst = [1,2,3,[5,6,7]]
lst1 = copy.deepcopy(lst)
lst[-1].append(8)
print(lst)
print(lst1)

#
[1, 2, 3, [5, 6, 7, 8]]
[1, 2, 3, [5, 6, 7]]

集合------set

性质: 1. 没有值的字典,无序不支持索引 2. 最大的作用就是天然去重 (字典中键唯一)

定义集合

s = {1,"alex",False,(1,2,3)}    不支持列表

面试题

给你一个列表,让你去重,首先去重转化为集合,然后转化为列表

lst = [1,2,1,2,4,2,45,3,2,45,2345]
print(list(set(lst)))

增

1. s.add( )

   s = {1,2,3,4}
   s.add("89")   #只能添加一个
   print(s)
   #{1, 2, 3, 4, '89'}

2. s.update( )

s = {1,2,3,4}
s.update("今天")
print(s)

#{1, 2, 3, 4, '今', '天'}

删

1. s.pop( )

   s = {1,2,3,4}
   s.pop()
   print(s)
   #{2, 3, 4}    #随机删除,集合是无序的

2. s.remove()

s = {1,2,3,4}
s.remove(3)   #指定元素删除
print(s)
#{1, 2, 4}

1. s.clear( )

s = {1,2,3,4}
s.clear()
print(s)
#set()   #直接清空了,一般不建议使用

改

先删再加

查

for i in {1,2,3}:
    print(i)
#
1
2
3

其他操作

s1 = {1,2,3,4,5,6,7}
s2 = {5,6,7,31,1,2314}
print(s1&s2)           #交集
print(s1 | s2)         #并集
print(s1 - s2)         #差集
print(s1 ^ s2)         #反交集
print(s1 > s2)         #父集(超集)   父亲里都包含儿子里的就是父集
print(s1 < s2)         #子集    同样 你没有人家多  你当然当儿子
#
{1, 5, 6, 7}
{1, 2, 3, 4, 5, 6, 7, 2314, 31}
{2, 3, 4}
{2, 3, 4, 2314, 31}
False
False

今日总结

1.小数据池

? 1.1 代码块:一个文件,一个函数, 一个类,一个模块 终端有一行

? 1.1.1 数字 : -5~256

? 1.1.2 字符串:乘法时总长度不超过 20

? 1.1.3 布尔值 : 内容相同,内存地址也相同

1.2 小数据池

? 1.2.1:数字:-5~256

? 1.2.1: 字符串:乘法时总长度不超过 20

? 1.2.3:内容相同内存地址也相同

? 1.3 先执行代码块,再执行小数据池

? 1.4 == is

? 1.4.1:== 判断等号两边的值是否相等

? 1.4.2:==判断两边的内存地址是否相等

2.深浅拷贝

2.1 : 赋值

? 多个变量名指向同一个内存地址

? 一个变量对其进行操作,其他变量查看时都变动

2.2 : 浅拷贝

? 浅拷贝只拷贝第一层元素

? 修改第一层元素时,新开辟的不进行改变

? lst [: ]

2.3 : 深拷贝

? 不可变的数据类型共用,可变的数据类型重新开辟一个空间

? 对源数据进行修改,深拷贝的内容不进行改变

3.集合

? 3.1:集合是没有值的字典

? 3.2:集合是无序,可变

? 3.3 集合天然去重

? 3.4 增: add. update

? 删: pop. remove clear

? 改: 先删再加

? 查: for 循环

? 3.5 其他操作

? & 交集 | 并集 - 差集 ^反交集 >超集 < 子集

? 3.6:面试题

? List(set(要去重的数据))

小数据池 深浅拷贝 集合

标签：浅拷贝   rem   pre   copy   循环   布尔值   upd   建议   机制   

原文地址：https://www.cnblogs.com/hualibokeyuan/p/11171908.html