python基础知识（五）

1.小数据池

小数据池 – 缓存机制（驻留机制）

is ---- 是

a = 10
b = 10
print(a is b)

结果：
True

is 判断基于内存地址进行判断

id(对象) – 查看对象的内存地址

a = 10
b = 10
print(id(a))
print(id(b))

结果：
1922657600
1922657600

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

支持：
数字：在同一代码块下 只要内容相同就采用相同的内存地址（-5以后就不是）
数字在做乘法的时候范围 -5 ~ 256
数字在做乘法时不能使用浮点数
字符串：在同一代码块下 只要内容相同就采用相同的内存地址
在乘法的时候总长度不能超过20
在乘法的时候中文，特殊符号乘以1或者0
布尔值：在同一代码块下 只要内容相同就采用相同的内存地址

a = "aleasdasfsafsaf" * 2
b = "aleasdasfsafsaf" * 2
print(id(a))
print(id(b))
print(a is b)
1532662810464
1532662965952
False

小数据池：

数字：-5 ~ 256 （记）
字符串：
在同一代码块下 只要内容相同就采用相同的内存地址
在乘法的时候总长度不能超过20 （记）
在乘法的时候中文，特殊符号乘以0
布尔值：在同一代码块下 只要内容相同就采用相同的内存地址

小数据池的验证方法，必须脱离代码块才能进行验证
先执行代码块的规则，在执行小数据

== 判断等号两边的值是否相等 （记）
is 判断is两边的内存地址是否相等（记）

2.深浅拷贝

赋值：
多个变量名指向同一个内存地址
一个变量对其进行操作，其他变量查看时都变动

浅拷贝：数据半共享（复制其数据独立内存存放，但是只拷贝成功第一层）

lst = [1,2,3,[4,5,6]]
lst1 = lst.copy()       # 开辟一个新的空间给lst1
lst.append(1)
print(lst)
print(lst1)

浅拷贝的时候，只会开辟一个新的容器列表，新列表中的元素使用的都是源列表中的元素

lst = [1,2,3,[4,5,6]]
lst1 = lst.copy()
lst1[-1][0] = 0
print(id(lst))
print(id(lst1))
print(lst)
print(lst1)

结果：
'''
2305690904136
2305690904904
[1, 2, 3, [0, 5, 6]]
[1, 2, 3, [0, 5, 6]]
'''

lst = [1,2,3,[4,5,6]]
lst1 = lst.copy()
lst1[-1].append(0)
print(lst)
print(lst1)

结果：
'''
[1, 2, 3, [4, 5, 6, 0]]
[1, 2, 3, [4, 5, 6, 0]]
'''

# dic = {"alex":[1,2,3,[5,6]]}
# dic1 = dic.copy()
# dic["alex"][0] = "56"
# print(dic)
# print(dic1)

结果：
'''
{'alex': ['56', 2, 3, [5, 6]]}
{'alex': ['56', 2, 3, [5, 6]]}
'''

深拷贝：数据完全不共享（复制其数据完完全全放独立的一个内存，完全拷贝，数据不共享）

import copy     # 导入
lst = [1,2,3,[4,5,[7,8]]]
lst1 = copy.deepcopy(lst)   # 深拷贝
lst1[1] = 0
print(id(lst[1]))
print(id(lst1[1]))
print(lst)
print(lst1)
结果：
'''
1922657344
1922657280
[1, 2, 3, [4, 5, [7, 8]]]
[1, 0, 3, [4, 5, [7, 8]]]
'''

import copy
lst = [1,2,3,[4,5,[7,8]]]
lst1 = copy.deepcopy(lst)
lst[1] = 0
print(lst)
print(lst1)
结果：
'''
[1, 0, 3, [4, 5, [7, 8]]]
[1, 2, 3, [4, 5, [7, 8]]]
'''

import copy
lst = [1,2,3,[4,5,[7,8]]]
lst1 = copy.deepcopy(lst)
lst[-1].append(0)
print(lst)
print(lst1)
结果：
'''
[1, 2, 3, [4, 5, [7, 8], 0]]
[1, 2, 3, [4, 5, [7, 8]]]
'''

import copy
lst = [1,2,3,[4,5,[7,8]]]
lst1 = copy.deepcopy(lst)
lst1[-1][-1][0] = 0
print(lst)
print(lst1)
结果：
'''
[1, 2, 3, [4, 5, [7, 8]]]
[1, 2, 3, [4, 5, [0, 8]]]

'''

• 总结:

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

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

注意：浅拷贝和深拷贝的不同仅仅是对组合对象来说，所谓的组合对象就是包含了其它对象的对象，如列表，类实例。而对于数字、字符串以及其它“原子”类型，没有拷贝一说，产生的都是原对象的引用。

3.集合

集合 – set
没有值得字典 无序 – 不支持索引
本身就带有去重的作用 — 独有的特点

定义一个集合:

s = {1,'alex',False,(1,2,3)}
print(s)
{False, 1, 'alex', (1, 2, 3)}  # 输出是没有规律的

lst = [1,2,3,1,2,4,6,4,5,6]
print(list(set(lst)))   # 将lst中的重复值去除
[1, 2, 3, 4, 5, 6]

增：

s = {1,'alex',False,(1,2,3)}
s.add('你好')
print(s)
{False, 1, '你好', 'alex', (1, 2, 3)}

s = {1,'alex',False,(1,2,3)}
s.update('你好')    #迭代添加
print(s)
{False, 1, '好', (1, 2, 3), '你', 'alex'}

删:

s = {1,'alex',False,(1,2,3)}
print(s.pop())   # 随机删除
print(s)

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

改:

先删后增

查:

s = {1,'alex',False,(1,2,3)}
for i in s:
print(i)

其他操作：

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

s = {1,'alex',False,(1,2,3)}
print(frozenset(s))    # 冻结集合
dic = {frozenset(s):1}
print(dic)