Python学习——Day06

python学习——Day06

1.id is ==

1.id

变量在内存中的地址

i = 100
s = 'a'
print(id(i))
print(id(s))

运行结果:

140720040685040
1893144063728

第二次运行

140719965842928
2208559722224

int类型在内存中的地址是固定的, 但是str类型是不固定的

2.==

比较运算符 ----用来判断两个变量是否 值相等

i1 = 100
i2 = 100
print(i1 == i2)		#True

3.is

用来判断两个变量是否 地址相同

i1 = 100
i2 = 100
s1 = 'a'
s2 = 'a'
l1 = [1,2,3]
l2 = [1,2,3]
print(id(i1))	#140719965842928
print(id(i2))	#140719965842928
print(id(s1))	#1993600265968
print(id(s2))	#1993600265968
print(id(l1))	#1993570865544
print(id(l2))	#1993570866056
print(i1 is i2)	#True
print(s1 is s2)	#True
print(l1 is l2)	#False

2.代码块

• 所有的代码都需要依赖代码块执行

• 一个文件就是一个代码块

• 交互式命令一行就是一个代码块

  ​ 两个代码块

3.两个机制

• 同一个代码块下,遵循一个机制,不同的代码块下,遵循另一个机制

1.同一个代码块内的缓存机制(字符串驻留机制)

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

​ 所以在文件执行同一个代码块时,会把i1, i2两个变量指向同一个对象,满足缓存机制则他们在内存中只存在一个,即: id相同

适用对象: int bool str

2.不同代码块内的缓存机制: 小数据池

机制内容: Python自动将-5~256的整数进行了缓存，当你将这些整数赋值给变量时，并不会重新创建对象，而是使用已经创建好的缓存对象。

​ python会将一定规则的字符串在字符串驻留池中，创建一份，当你将这些字符串赋值给变量时，并不会重新创建对象， 而是使用在字符串驻留池中创建好的对象。

​ 无论是缓存还是字符串驻留池，都是python做的一个优化，就是将~5-256的整数，和一定规则的字符串，放在一个‘池’（容器，或者字典）中，无论程序中那些变量指向这些范围内的整数或者字符串，那么他直接在这个‘池’中引用，言外之意，就是内存中之创建一个。

适用对象: int (float), str,, bool

4.集合

• 容器型的数据类型, 要求它里面的元素是不可变的数据, 但是它本身是可变的数据类型. 集合是无序的. 用{}括起来
• 集合的作用:
  • 列表的去重
  • 关系测试: 交集, 并集, 差集....

1.集合创建

s1 =  set({1, 2, 'aaa', False})
s2 = {1, 2, 'aaa', False}	#常用

2.空集合

print(type({}))     #<class 'dict'>

• {}是空字典 不是空集合

set()---空集合

print(type(set()))      #<class 'set'>

5.集合的基本操作

1.增

set1 = {'aa', 'ss', 'dd'}
set1.add('xx')      #{'xx', 'dd', 'ss', 'aa'}

输出乱序是因为集合是无序的!!!

set1.update('qwe') 
#{'q', 'dd', 'aa', 'e', 'w', 'xx', 'ss'}

update() ---迭代着增加

2.删

• remove() ---- 按照元素删除

set1.remove('aa')  
#{'dd', 'q', 'e', 'xx', 'ss', 'w'}

• pop() ----随机删除

set1.pop()          #{'ss', 'dd', 'e', 'w', 'xx'}

3.变相改值

可以将一个值删除, 然后增加新的值

4.交集 (& )

s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}
print(s1 & s2)      #{4, 5}

5.并集 (|)

print(s1 | s2)      #{1, 2, 3, 4, 5, 6, 7, 8}

6.差集(-)

print(s1 - s2)      #{1, 2, 3}

7.反交集(^)

print(s1 ^ s2)      #{1, 2, 3, 6, 7, 8}

8.子集(<)

s1 = {1,2,3}
s2 = {1,2,3,4,5}
print(s1 < s2)      #True

9.超集(>)

s1 = {1,2,3}
s2 = {1,2,3,4,5}
print(s2 > s1)      #True

10.列表的去重

转化为集合

l1 = [1,2,2,2,3,3,3,4,5,5,6,6,6]
set1 = set(l1)
print(set1)     #{1, 2, 3, 4, 5, 6}

再将集合转换为列表

l1 = list(set1)
print(l1)       #[1, 2, 3, 4, 5, 6]

6.深浅copy

1.赋值运算

l1 = [1,2,3,[22,33]]
l2 = l1
l1.append(66)
print(l1)
print(l2)
#[1, 2, 3, [22, 33], 66]
#[1, 2, 3, [22, 33], 66]

l1 l2 指向同一个内存地址

2.浅copy

l1 = [1,2,3,[22,33]]
l2 = l1.copy()
l1.append(66)
print(l1,id(l1))
print(l2,id(l2))
#[1, 2, 3, [22, 33], 66]  1768673137544
#[1, 2, 3, [22, 33]]   1768674415880

l1 = [1,2,3,[22,33]]
l2 = l1.copy()
l1[-1].append(66)
print(id(l1[-1]))
print(id(l2[-1]))
#1443906539912
#1443906539912

print(id(l1[0]))	#140720062374288
print(id(l2[0]))	#140720062374288

• 另一种写法:

import copy
l1 = [1,2,3,[33,44]]
l2 = copy.copy(l1)

3.深copy

import copy
l1 = [1,2,3,[22,33]]
l2 = copy.deepcopy(l1)
print(id(l1))	#1616669126280
print(id(l2))	#1616669042568

l1[-1].append(666)
print(l1)	#[1, 2, 3, [22, 33, 666]]
print(l2)	#[1, 2, 3, [22, 33]]

python对深copy做了一个优化, 将不可变的数据类型沿用同一个

总结:深copy会在内存中开辟新空间,将原列表以及列表里面的可变的数据类型重新创建一份,不可变的数据类型则沿用之前的.

归纳:

• 浅copy : list dict : 嵌套的可变的数据类型是同一个
• 深copy : list dict : 嵌套的可变的数据类型不是同一个

所谓的嵌套的数据类型是 比如 一个列表中存在一个小的列表