小数据池、深浅拷贝、集合

0、pycharm是代码块、黑窗口是小数据池、如下图：

1、驻留机制（长得像的共用一个内存地址）分小数据池缓存机制：后期开发时能明确知道、为什么不能正常使用、把经常用的东西放入规则（黑窗口）里。

　　　　　　　　　　　　数字是：-5-256（超范围后报错）。

　　　　　　　　　　　　

　　　　　　　　　　　　字符串：定义时内容（除去中文和特殊符号）、长度不限、内容相同、就进行驻留。

　　　　　　　　　　　　　　　　python3.6解释器字符串进行乘法时、总长度不能超过20。

　　　　　　　　　　　　　　　　python3.7解释器字符串进行乘法时、总长度不能超过4096。

　　　　　　　　　　　　布尔值：

驻留机制的意义：节省内存、提高效率。

图解如下：

　　　　　　  代码块缓存机制：一个py文件、一个函数、一个模块、一个类、交互模式下的每一行。

执行顺序：　　  　　  先执行代码块（pycharm）、后执行小数据池（黑窗口）。

2、is（是）判断两边的内容是不是一个、is是通过内存地址进行判断的。

3、==（判断等号两边的内容是否相同）

赋值就是一个容器有多个标签、lst列表中有标签lst和标签lst1、两个标签同属于一个内存地址。

lst2是新开辟的空间、浅拷贝只拷贝第一层元素、浅拷贝只把列表中记录的内存地址拿到一个新开辟列表中。

lst2中没有添加9、是因为只拷贝了一层、浅拷贝把原列表中有的内存地址复制了一份放到新开辟的空间中、后期对原列表添加的内容新列表是不会有的。

浅拷贝和深拷贝在最后列表的位置内存地址不一样、深拷贝是自己单独开辟了一个新的空间、修改原列表和新开辟的列表没有任何影响。

 

• • 赋值:
    • 两个或多个变量名指向同一个内存地址,有一个操作内存地址的值进行改变,其余的变量名在查看的时候都进行更改
  • 浅拷贝:
    • 只拷贝列表中第一层的内存地址,原列表修改了不可变数据类型,新开辟的列表不进行变动,因为只是在原列表中将内存地址进行修改了,新开辟的列表中的内存地址还是用的之前的内存地址
    • 原列表对可变数据类型进行了添加,新开辟的列表中存放就是可变数据类型的地址,在去查看的时候就发现进行更改了
  • 深拷贝:
    • 不管你修改原数据的不可变类型还是可变类型,新开辟的空间中都不会进行改变,因为可变数据类型新开辟了一个空间
    • 数字没有append方法

赋值：多个变量名指向同一个内存地址。

浅拷贝：只拷贝第一层的元素内存地址、可变和不可变的数据都是共用的。
例一：

a = [11,22,33,[44,55],66]
c = a.copy()
a.append(77)
print(a)
print(c)
结果：[11, 22, 33, [44, 55], 66, 77]
　　　[11, 22, 33, [44, 55], 66]
例二：

a = [11,22,33,[44,55],66]
c = a.copy()
a[-2].append(77)
print(a)
print(c)
结果：[11, 22, 33, [44, 55, 77], 66]
      [11, 22, 33, [44, 55, 77], 66]
例三：

a = [11,22,33,[44,55],66]
c = a[:]
a.append(77)
print(a)
print(c)
结果：[11, 22, 33, [44, 55], 66, 77]
      [11, 22, 33, [44, 55], 66]
例四：

a = [11,22,33,[44,55],66]
c = a[:]
a[-2].append(77)
print(a)
print(c)
结果：[11, 22, 33, [44, 55, 77], 66]
      [11, 22, 33, [44, 55, 77], 66]
例五：

import copy
a = [11,22,33,[44,55],66]
c = copy.copy(a)
a.append(77)
print(a)
print(c)
结果：[11, 22, 33, [44, 55], 66, 77]
      [11, 22, 33, [44, 55], 66]
例六：

import copy
a = [11,22,33,[44,55],66]
c = copy.copy(a)
a[-2].append(77)
print(a)
print(c)
结果：[11, 22, 33, [44, 55, 77], 66]
      [11, 22, 33, [44, 55, 77], 66]
例七：

a = [11,22,33,[44,55],66]
c = a.copy()
c.append(77)
print(a)
print(c)
结果：[11, 22, 33, [44, 55], 66]
      [11, 22, 33, [44, 55], 66, 77]
例八：

a = [11,22,33,[44,55],66]
c = a.copy()
c[-2].append(77)
print(a)
print(c)
结果：[11, 22, 33, [44, 55, 77], 66]
      [11, 22, 33, [44, 55, 77], 66]

深拷贝：对于不可变的数据、元素是共用的、可变的数据、开辟新的空间、不管嵌套多少层。

例一：

import copy
a = [11,22,33,[44,55],66]
c = copy.deepcopy(a)
a.append(77)
print(a)
print(c)
结果：[11, 22, 33, [44, 55], 66, 77]
      [11, 22, 33, [44, 55], 66]
例二：

import copy
a = [11,22,33,[44,55],66]
c = copy.deepcopy(a)
a[-2].append(77)
print(a)
print(c)
结果：[11, 22, 33, [44, 55, 77], 66]
      [11, 22, 33, [44, 55], 66]

==：判断等号两边的值是否相同。

is：判断两边的值内存地址是否相同。

4、集合特点：去重、集合关系、

5、空集合set（）

6、定义集合：S = {1,2,3,4}

7、一行代码进行去重：

lst = [11,11,11,22,33,44,55]
print(list(set(lst)))　　　　　　#去重并再此转换成列表
结果：[33, 11, 44, 22, 55]
8、集合就是一个没有值的字典。
9、集合的元素是不可变的（可哈希）
10、具有唯一特性
11、集合是无序的、可变、可迭代。
--------------------------------------增-----------------------------------------------
12、集合迭代添加update：

s = set()
s.update("alex")
print(s)
结果：{'a', 'e', 'l', 'x'}
13、集合add添加：

s = set()
s.add("alex")
print(s)
结果：{'alex'}
-------------------------------------删----------------------------------------------
14、pop随机删除并返回值：

s = {"a","b",3,"c"}
print(s.pop())
print(s)
结果：　3

　　　　  {'b', 'a', 'c'}

15、remove指定元素删：

s = {"a","b",3,"c"}
s.remove("b")
print(s)
结果：{'a', 3, 'c'}
16、clear清空后的显示方式：

s = {"a","b",3,"c"}
s.clear()
print(s)
结果：set()
--------------------------------------改----------------------------------------------
17、先删后加
　　转换数据类型进行修改
--------------------------------------查----------------------------------------------
18、for循环
--------------------------------------集合关系------------------------------------------
19、并集|管道符：

python = {"海绵","孙一帆","岳新力","大圣"}
linux = {"海绵","大圣","meet","alex"}
print(python | linux)
结果：{'岳新力', 'alex', '海绵', 'meet', '孙一帆', '大圣'}
交集&：

python = {"海绵","孙一帆","岳新力","大圣"}
linux = {"海绵","大圣","meet","alex"}
print(python & linux)
结果：{'大圣', '海绵'}
差集-减号：

python = {"海绵","孙一帆","岳新力","大圣"}
linux = {"海绵","大圣","meet","alex"}
print(python - linux)
print(linux - python)
结果：{'岳新力', '孙一帆'}

　　　　{'meet', 'alex'}

并集减去交集用上尖号^ 补集/反差集/对称集：

python = {"海绵","孙一帆","岳新力","大圣"}
linux = {"海绵","大圣","meet","alex"}
print(python ^ linux)
结果：{'岳新力', 'meet', 'alex', '孙一帆'}
判断用超集/父集和子集：

python = {"海绵","孙一帆","岳新力","大圣"}
linux = {"海绵","大圣","meet","alex"}
print(python > linux)
结果：False
作业题：

# 1.有如下
v1 = {'郭宝元','alex','海绵','王二麻子'}
v2 = {'alex','王二麻子'}
# 请得到 v1 和 v2 的交集并输出
print(v1 & v2)
# 请得到 v1 和 v2 的并集并输出
print(v1 | v2)
# 请得到 v1 和 v2 的 差集并输出
print(v1 - v2)
# 请得到 v2 和 v1 的 差集并输出
print(v2 - v1)
# 2.循环提示用户输入，并将输入内容追加到列表中（如果输入N或n则停止循环）
li = []
while True:
    a = input("请输入内容输入N或n就停止：")
    if a.upper() == "N":
        break
    li.append(a)
print(li)
# 3.写代码实现
v1 = {'alex','武sir','黑哥'}
v2 = []
# 循环提示用户输入，如果输入的内容在v1中存在，则追加到v2中，如果v1中不存在，则添加到v1中。（如果输入N或n则停止循环）
while True:
    a = input("请输入内容输入N或n就停止：")
    if a.upper() == "N":
        break
    if a in v1:
        v2.append(a)
    else:
        v1.add(a)
print(v1)
print(v2)
# 4.通过观察判断以下值那个能做字典的key？那个能做集合的元素？
1                                   #能
-1                                  #能
""                                  #能
None                                #能
[1,2]                               #不能
(1,)                                #能
{11,22,33,4}                        #不能
{'name':'wupeiq','age':18}          #不能
# 5.is 和 == 的区别？
# is是判断的内存地址、==是判断两边的内容
# 6.type使用方式及作用？
# 查看数据类型
# 7.id的使用方式及作用？
#查看内存地址
# 8.看代码写结果并解释原因
v1 = {'k1':'v1','k2':[1,2,3]}
v2 = {'k1':'v1','k2':[1,2,3]}
result1 = v1 == v2
result2 = v1 is v2
print(result1)
print(result2)
# 9.看代码写结果并解释原因
v1 = {'k1':'v1','k2':[1,2,3]}
v2 = v1
result1 = v1 == v2
result2 = v1 is v2
print(result1)
print(result2)
# 10.看代码写结果并解释原因
v1 = {'k1':'v1','k2':[1,2,3]}
v2 = v1
v1['k1'] = 'meet'
print(v2)
# 结果：{'k1': 'meet', 'k2': [1, 2, 3]}
# 11.看代码写结果并解释原因
v1 = '人生苦短，我用Python'
v2 = [1,2,3,4,v1]
v1 = "人生苦短，用毛线Python"
print(v2)
# 结果：[1, 2, 3, 4, '人生苦短，我用Python']
# 12.看代码写结果并解释原因
info = [1,2,3]
userinfo = {'account':info, 'num':info, 'money':info}
info.append(9)
print(userinfo) #{'account':[1,2,3,9], 'num':[1,2,3,9], 'money':[1,2,3,9]}
info = "题怎么这么多"
print(userinfo) #{'account':[1,2,3,9], 'num':[1,2,3,9], 'money':[1,2,3,9]}
# 13.看代码写结果并解释原因
info = [1,2,3]
userinfo = [info,info,info,info,info]
info[0] = '不仅多，还特么难呢'
print(info,userinfo)    #['不仅多，还特么难呢'`,2,3],[['不仅多，还特么难呢',2,3],['不仅多，还特么难呢',2,3],['不仅多，还特么难呢',2,3],['不仅多，还特么难呢',2,3],['不仅多，还特么难呢',2,3]]
# 14.看代码写结果并解释原因
info = [1,2,3]
userinfo = [info,info,info,info,info]
userinfo[2][0] = '闭嘴'
print(info,userinfo)    #(['闭嘴',2,3],[['闭嘴',2,3],['闭嘴',2,3],['闭嘴',2,3],['闭嘴',2,3],['闭嘴',2,3]])
# 15.看代码写结果并解释原因
info = [1, 2, 3]
user_list = []
for item in range ( 10 ):
    user_list.append ( info )
info[1] = "是谁说Python好学的？"
print ( user_list )#[[1, '是谁说Python好学的？', 3], [1, '是谁说Python好学的？', 3], [1, '是谁说Python好学的？', 3], [1, '是谁说Python好学的？', 3], [1, '是谁说Python好学的？', 3], [1, '是谁说Python好学的？', 3], [1, '是谁说Python好学的？', 3], [1, '是谁说Python好学的？', 3], [1, '是谁说Python好学的？', 3], [1, '是谁说Python好学的？', 3]]
# 16.看代码写结果并解释原因
data = {}
for i in range(10):
    data['user'] = i
print(data)#{'user': 9}
# 17.看代码写结果并解释原因
data_list = []
data = {}
for i in range(10):
    data['user'] = i
    data_list.append(data)
print(data_list)#[{'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}]
# 18.看代码写结果并解释原因
data_list = []
for i in range(10):
    data = {}
    data['user'] = i
    data_list.append(data)
print(data_list)#[{'user': 0}, {'user': 1}, {'user': 2}, {'user': 3}, {'user': 4}, {'user': 5}, {'user': 6}, {'user': 7}, {'user': 8}, {'user': 9}]
# 19.使用循环打印出一下效果：
# 格式一
# *
# **
# ***
# ****
# *****
# 代码：for i in range(1,6):
#         print(i * "*")
# 格式二
# ****
# ***
# **
# *
#代码：for i in range(4,0,-1):
#           print(i * "*")
# 格式三
# *
# ***
# *****
# *******
# *********
#代码：for i in range(1,10):
#           if i % 2 == 1:
#               print(i * "*")
# 20.敲七游戏. 从1开始数数. 遇到7或者7的倍数（不包含17,27,这种数）要在桌上敲⼀下. 编程来完成敲七. 给出⼀个任意的数字n. 从1开始数. 数到n结束. 把每个数字都放在列表中, 在数的过程中出现7或 者7的倍数（不包含17,27,这种数）.则向列表中添加⼀个'咣'
# 例如, 输⼊10. lst = [1, 2, 3, 4, 5, 6, '咣', 8, 9, 10]
lst = []
num = input("请输入数字：")
if num.isdecimal():
    num = int(num)
    for i in range(1,num + 1):
        if i % 7 == 0:
            lst.append("咣")
        else:
            lst.append(i)
else:
    print("输入错误请输入数字")
print(lst)
# 21.模拟购物车
# 要求:
# 1,用户先给自己的账户充钱：比如先充3000元。
# 2,有如下的一个格式:
# goods = [{"name": "电脑", "price": 1999},
# {"name": "鼠标", "price": 10},
# {"name": "游艇", "price": 20},
# {"name": "美女", "price": 998},]
# 3,页面显示 序号 + 商品名称 + 商品价格，如：
# 1 电脑 1999
# 2 鼠标 10
# 4,用户输入选择的商品序号，然后打印商品名称及商品价格,并将此商品，添加到购物车(自己定义购物车)，用户还可继续添加商品。
# 5,如果用户输入的商品序号有误，则提示输入有误，并重新输入。
# 6,用户输入N为购物车结算，依次显示用户购物车里面的商品，数量及单价，若充值的钱数不足，则让用户删除某商品，直至可以购买，若充值的钱数充足，则可以直接购买。
# 7,用户输入Q或者q退出程序。
# 8,退出程序之后，依次显示用户购买的商品，数量，单价，以及此次共消费多少钱，账户余额多少，并将购买信息显示。
goods = [
{"name": "电脑", "price": 1999},
{"name": "鼠标", "price": 10},
{"name": "游艇", "price": 20},
{"name": "美女", "price": 998},
]
dic2 = []   #存储已经购买的商品
dic = {}    #存储未购买的商品
shopping_money = 0  #初始消费金额
money = input("请输入您要充值的金额：")    #让用户输入充值金额
if money.isdecimal() and int(money) > 0:    #判断这个充值的金额是否是合法的
    insert_money = int(money)   #记录一下充值的金额
    while True:
        for i in range(len(goods)): #拿到长度
            print(i + 1,goods[i]["name"],goods[i]["price"]) #通过下标找到商品名字和价格
        choose = input("请选择您要购买的商品序号（N结算|Q退出）：")    #要购买的商品序号
        if choose.isdecimal() and len(goods) >= int(choose) > 0:    #判断用户输入的商品序号是否合法
            choose = int(choose) - 1    #自动减1是之前已经自动加1了
            print(goods[choose]["name"],goods[choose]["price"]) #打印用户输入序号的商品和价格
            # 获取到用户输入的商品序号对应的商品名字
            shopping_name = goods[choose]["name"]
            # 获取到用户输入的商品序号对应的商品价格
            shopping_price = goods[choose]["price"]
            #定义一个购物车的数据结构：{"电脑":{"money":1999,"num":1}}
            if goods[choose]["name"] in dic:
                #如果用户选择的商品序号对应的商品存在购物车中
                dic[shopping_name]["num"] += 1
                #将该商品绑定的数量进行加1
            else:
                #组成一个购物车的数据结构
                dic[shopping_name] = {"money":shopping_price,"num":1}
                #字典名[键] = 值
        elif choose.upper() == "Q":
            print("-----------购买清单-----------------")
            for item in dic2:
                for i in item:
                    print(f"商品:{i} 单价：{item[i]['money']} 数量：{item[i]['num']}")
            print(f"消费金额：{insert_money - money} 余额：{money}")
            break
        elif choose.upper() == "N":
            print("-----------购物车中的商品列表-----------------")
            shopping_money = 0  #记录消费总金额
            for i in dic:
                print(f"商品:{i} 单价:{dic[i]['money']} 数量:{dic[i]['num']}")
                shopping_money += dic[i]["money"] * dic[i]["num"]
                #边展示边计算购物车中所有商品的价格
            if int(money) - shopping_money >= 0:
                #判断用户充值的金额是否大于消费金额
                money = int(money) - shopping_money
                #计算用户余额
                dic2.append(dic)
                #将已购的商品添加到已购的列表中
                dic = {}
                #清空购物车
                print("结算成功！")
                #提示用户结算成功
            else:
                print("-----------请选择您要删除的商品-----------------")
                for i in dic:
                    print(f"商品：{i} 单价：{dic[i]['money']} 数量：{dic[i]['num']}")
                name = input("请选择要删除的商品名称：")
                if name in dic:
                    if dic[name]["num"] == 1:
                        del dic[name]   #把整个商品信息删掉
                    else:
                        dic[name]["num"] -= 1   #对应删除商品对应的数量减1
                else:
                    print("请正确输入")
        else:
            print("输入错误，亲重新输入！")
else:
    print("请输入数字！")