python之深浅拷贝(基础四）

第六章python之深浅拷贝(基础四）

6.1 小数据池

小数据池就是Python中一种提高效率的方式,固定数据类型使用同一个内存地址

小数池 -- 支持: str,int,bool

a = 1
b = 1
id 查看空间的内存地址 获取开辟空间的一种地址

print(id(a))
print(id(b))

小数据池数字支持范围: -5 ~ 256 *记住

a = 300
b = 300
print(id(a))
print(id(b))

代码块: 一个文件,一个模块,一个函数,一个类,终端中每一行都一个代码块
在python中是用字典的方式存储

a = 1000
b = 1000
print(id(a))
print(id(b))

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 = "12345678912345678qwertyuioqwertyuioQWERTYUIOWERTYUIOQWERTYUIOasdfghjksdfghjk____asdgadsfasdfgasdgasdgfsdaf"
    b = "12345678912345678qwertyuioqwertyuioQWERTYUIOWERTYUIOQWERTYUIOasdfghjksdfghjk____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

6.2 set 集合

集合介绍

set集合是python的?一个基本数据类型. ：无序，可变。

一般不是很常?用. set中的元素是不重复的.无序的.面的元素必须是可hash的(int, str, tuple,bool), 我们可以这样来记. set就是dict类型的数据但 是不保存value, 只保存key. set也?用{}表?示

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

set 集合增加

s.update 迭代添加

s = {1,2,3,"123",False,(1,2,3,4)}
s.update("3456")  # 迭代添加，且无序
print(s)
{False, 1, 2, 3, '4', (1, 2, 3, 4), '3', '123', '5', '6'}

s.add 添加，重复内容不添加

s = {1,2,3,"123",False,(1,2,3,4),"玲玲"}
s.add("玲玲")
print(s)
s.add("玲玲")    # 重复的内容不不会被添加到set集合中
print(s)

set集合删除

s = {1,2,3,"123",False,(1,2,3,4),"玲玲"}
s.pop()                       #随机删除
s.remove(3)                   #直接删除元素,不存在这个元素. 删除会报错
s.clear()                     # 清空set集合.需要注意的是set集合如果是空的.,打印出来是set()因为要和 dict区分set()
del s                         #删除整个集合

set集合修改

set集合中的数据没有索引. 也没有办法去定位?一个元素. 所以没有办法进?行行直接修改.只可以采?用先删除后添加的?方式来完成修改操作

s = {1,2,3,"123",False,(1,2,3,4),"玲玲"}      # 把玲玲改成毛毛
s.remove("玲玲")
s.add("毛毛")
print(s)

set查询

set是?一个可迭代对象. 所以可以进?行行for循环
for el in s:
    print(el)

set集合其他操作

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)  # 子集

set集合去重

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

set集合本?身是可以发?生改变的. 是不可hash的. 我们可以使?用frozenset来保存数据. frozenset是不可变的. 也就是?一个可哈希的数据类型

s = frozenset([1,2,3,"123",False,(1,2,3,4),"玲玲"])
dic = {s:'123'} # 可以正常使?用了了
print(dic)

6.3 深浅拷贝

  1. 赋值：

多个变量指向的同一个内存地址。对于list,set,dict来说，直接赋值就是把内存地址交给变量，并不是复制一份内容。

l1 = [1,2,3,4,[5,6,7,]]
l2 = l1                    #赋值l2赋值与l1不是拷贝两个变量指向一个列内存地址
l1.append(8)
print(l1)                   #[1, 2, 3, 4, [5, 6, 7], 8]
print(l2)                   #[1, 2, 3, 4, [5, 6, 7], 8]

l1和l2的变量值都是指向同一个内存地址所以输出的结果是一样的。

  1. 浅拷贝：

浅拷贝，只会拷贝第一层，不会拷贝第二层，所以被称为浅拷贝

l1 = [1,2,3,4,[4,5,6]]
l2 = l1[:]              #表示浅拷贝
l2 = l1.copy()          #表示浅拷贝
print(l1)               #[1, 2, 3, 4, [5, 6, 7], 8]
print(l2)               #[1, 2, 3, 4, [5, 6, 7], 8]
print(id(l1[0]))
print(id(l2[0]))

  1. 浅拷贝会创建一个新的列表(容器),如[3,4,5]
  2. 新创建的L2列表中的元素和原列表L1的元素用的是同一个内存空间
li = [1,2,32,[3,4,5]]
l2 = li.copy()
li.append(8)
print(li)                  #[1, 2, 32, [3, 4, 5], 8]发生LI改变添加8元素
print(l2)                  #[1, 2, 32, [3, 4, 5]]   L2不变
l1 = [1,2,3,(1,2,3)]
l2 = l1.copy()
l2[-1] = 6
print(l1)                   #[1, 2, 3, (1, 2, 3)]
print(l2)                   #[1, 2, 3, 6]
l1 = [1,2,3,4,[5,6,7,]]
l2 = l1.copy()
l1[-1].append(8)        #L1向最后一位添加一个元素发生变化
print(l1)                #[1, 2, 3, 4, [5, 6, 7, 8]]
print(l2)                #[1, 2, 3, 4, [5, 6, 7, 8]] L2跟L1用的是同一个内存地址发生变化
l1 = [1,2,3,[4,5,6]]
l2 = l1.copy()
l2[-1] = 77
print(l1)           # [1, 2, 3, [4, 5, 6]]
print(l2)           # [1, 2, 3, 77]
  1. 深拷贝：
  2. 不可变的数据类型和原列表指向同一个空间，可变数据会创建一个新的空间。
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)

原文地址：https://www.cnblogs.com/yueling314/p/11041910.html

时间： 2024-10-06 11:23:34

python之深浅拷贝(基础四）的相关文章

针对Python的深浅拷贝问题

前些天做了个小程序,遇到了Python的深浅拷贝问题 感觉自己基础不够扎实,就翻了翻教程,真的是非常基础的知识...(各位大佬下手轻点2333) 下面简单说说: 首先有个字典a 1 a = {'A':1,'B':2,'C':3,'D':4} 然后我们把它赋值给另外一个空字典b 1 b = {} 2 b = a 当我们输出b时,可以看到a和b直观上看好像是相等了 按照常理,我们会认为a和b现在是两个值相等的字典,如果我们对其中一个操作,另外一个应该不会受到影响才对,所以我们试一下: 我们尝试删除b

Python的深浅拷贝

Python深浅拷贝 一丶引言 在python中,对象赋值实际上是对象的引用.当创建一个对象,然后把它赋给另一个变量的时候,python并没有拷贝这个对象,而只是拷贝了这个对象的引用 针对该列表 11 = ['a','b','c',['d','e','f']] 一般有三种方法,分别为:拷贝(赋值).浅拷贝.深拷贝 注意:拷贝/浅拷贝/深拷贝 都是针对数据可变类型数据而言的 1.1丶可变or不可变 id不变值可变,即在原值的基础上修改,则为可变数据类型:值变id也变,即重新申请一个空间放入新值,则

Python入门-深浅拷贝

首先我们在这里先补充一下基础数据类型的一些知识: 一.循环删除 1.前面我们学了列表,字典和集合的一些操作方法:增删改查,现在我们来看一下这个问题: 有这样一个列表: lst = ['周杰伦','周润发','周星驰','刘德华'] 如果现在要求我们删除带'周'的元素,我们下意识会这样做: lst = ['周杰伦','周润发','周星驰','刘德华'] for i in lst: if '周' in i: lst.remove(i) print(lst) #['周润发', '刘德华'] 但是结果却

【python之路13】python的深浅拷贝

深浅拷贝 一.数字和字符串 对于 数字 和 字符串 而言,赋值.浅拷贝和深拷贝无意义,因为其永远指向同一个内存地址. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 import copy # ######### 数字.字符串 ######### n1 = 123 # n1 = "i am alex age 10" print(id(n1)) # ## 赋值 ## n2 = n1 print(id(n2)) # ## 浅拷贝 ## n2 = copy.copy(

python 赋值 深浅拷贝

深浅拷贝 一.数字和字符串 对于 数字 和 字符串 而言,赋值.浅拷贝和深拷贝无意义,因为其永远指向同一个内存地址. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 import copy # ######### 数字.字符串 ######### n1 = 123 # n1 = "i am alex age 10" print(id(n1)) # ## 赋值 ## n2 = n1 print(id(n2)) # ## 浅拷贝 ## n2 = copy.copy(

python笔记--深浅拷贝

深浅拷贝 1.对于数字.字符串和元组而言,赋值.浅拷贝和深拷贝无意义,因为其永远指向同一个内存地址,例如: >>> n1=123 >>> import copy >>> n2=n1    #赋值 >>> print(id(n2)) 31427456 >>> print n2 123 >>> n2=copy.copy(n1)    #浅拷贝 >>> print(id(n2)) 314

Python 的深浅拷贝 终于明白了

python 深浅拷贝不之前一直不太理解,只是概念性的理解像 1,2 所说,敲完下面代码希望你可以理解. 1.copy.copy 浅拷贝 只拷贝父对象,不会拷贝对象的内部的子对象. 2. copy.deepcopy 深拷贝 拷贝对象及其子对象 >>> import copy >>> l1 = [1,3,5,['a','b','c']] >>> a = l1 >>> b = copy.copy(a) # 浅拷贝 >>>

我要学python之深浅拷贝原理

前言 在c++中参数传递有两种形式:值传递和引用传递.这两种方式的区别我不在此说,自行补上,如果你不知道的话.我先上python代码,看完我们总结一下,代码如下: # copy module import import copy # number and string a = 12 a1 = a a2 = copy.copy(a) a3 = copy.deepcopy(a) # look addr print("==========number=======") print(id(a)

python高级-深浅拷贝(16)

一.浅拷贝 浅拷贝是对一个对象的顶层拷贝,通俗地讲就是:拷贝了引用,并没有拷贝内容. a = [1,2,3] print(id(a)) b=a print(b) print(id(b)) a.append(4) print(a) print(b) 运行结果为: 1965053928072 [1, 2, 3] 1965053928072 [1, 2, 3, 4] [1, 2, 3, 4] 二.深拷贝 深拷贝是对于一个对象所有层次的拷贝,重新开辟内存地址. import copy a = [1,2,