小渣渣学习笔记 python day04【字典 setdefault 字典pop 可以设置返回值 clear 查可以索引 也可以get （get可设置报错值） 集合 copy】

字典学习继续

• 增

dic = dict({'first':1,'second':2,'third':3})
dic['four']=4
print(dic)  #return {'first': 1, 'second': 2, 'third': 3, 'four': 4}

• 增加容易有重复键

dic = dict({'first':1,'second':2,'third':3})
dic.setdefault('five')
print(dic)  #{'first': 1, 'second': 2, 'third': 3, 'five': None}

dic = dict({'first':1,'second':2,'third':3})
dic.setdefault('five',5)
print(dic)  #{'first': 1, 'second': 2, 'third': 3, 'five': 5}

• setdefault 有就不变，无就增加，与索引改键的值是不一样的，索引改键值是覆盖的

• 字典的键类似于索引

• 删除 pop

dic = dict({'first':1,'second':2,'third':3})
dic.pop('third')
print(dic)  #return {'first': 1, 'second': 2}

• pop删除的键 万一没有呢，可以设置报错内容，pop是有返回值的

dic = dict({'first':1,'second':2,'third':3})
result = dic.pop('five','nothing')
print(result) #nothing
print(dic)  #return {'first': 1, 'second': 2}

• clear（）清空

dic = dict({'first':1,'second':2,'third':3})
dic.clear()
print(dic)  #return {}

• del() 删除字典表里没有的内容，就会报错，建议用pop 可以设置报错内容

dic = dict({'first':1,'second':2,'third':3})
del dic['third']
print(dic)  #return {'first': 1, 'second': 2}

• 改

dic = dict({'first':1,'second':2,'third':3})
dic['first']=11
print(dic)  #return {'first': 11, 'second': 2, 'third': 3}

• 查 除了用键（索引）直接获取，还可以用get（）

dic = dict({'first':1,'second':2,'third':3})
ll = dic.get('first')
print(ll)  #return 1

• get 不到键，还可以设置报错值

dic = dict({'first':1,'second':2,'third':3})
ll = dic.get('first111','nothing')
print(ll)  #return nothing

• 字典表中特殊方法 keys（）返回所有键，values（）返回所有值，items（）返回所有

dic = dict({'first':1,'second':2,'third':3})
print(dic.keys())  #return dict_keys(['first', 'second', 'third'])

dic = dict({'first':1,'second':2,'third':3})
for key in dic.keys():print(key)

• 循环打印出key 还可以写成for key in dic 效果一样
• items()

dic = dict({'first':1,'second':2,'third':3})
print(dic.items())  #return dict_items([('first', 1), ('second', 2), ('third', 3)])

结果得到3个元组，可以拆包

dic = dict({'first':1,'second':2,'third':3})
for key,value in dic.items():
    print(key,value)

• a,b值的交换 a,b = b,a 太简便了

字典的嵌套

dic = {
    'name':'汪',
    'age':40,
    'wife':[{'name':'章','age':38}],
    'children':{'girl1':'大女儿','girl2':'小女儿'}
}
# 获取汪名字
print(dic['name'])
#获取字典{'name':'章','age':38}
print(dic['wife'][0])
#获取汪妻子的名字
print(dic['wife'][0]['name'])
#获取汪第二个孩子的小名
print(dic['children']['girl2'])

• 总结：字典查询速度快，数据的关联性强

补充

• 元组切片也是元组，不能增删改，但是可以切片，查询
• 列表切片还是列表

内存 id

i=[1,2,3]
i2=[1,2,3]
print(id(i))    #2331467983552 id是地址，id相同，值一定相同，值相同，id不一定相同
print(id(i2))   #2331468149376
print(i == i2)  #True 值相等
print(i is i2)  #False 地址不同

代码块

• 一个模块，一个函数，一个类，一个文件都是代码块
• python程序是由代码块构成的。
• 交互方式输入的每一个命令行都是一个代码块，一行就是一个文件

代码块缓存机制

• 同一个代码块内
• 机制内容

i1 = 100 #变量的创建就是初始化命令 同时在内存中划分空间存储100，系统创建一个字典 {i1:100}
i2 = 100 #创建变量i2  会先检查字典表，存在100 就把地址给i2
i3 = 300 # i3 也一样 ，内存里只有一个100 

• 目的优点: 节省内存，提升性能

• 适用对象: int (float) ,bool ,str,用列表[1,2,3] [1,2,3] 2个是2个地址，几乎所有的字符串

• 不同代码块下缓存机制：小数据池（部分内容创建变量的时候地址一致）

• 小数据池中缓存 -5-256 以及满足规则的字符串 不同代码块这些变量 指向同一个值

集合set（知道大概就行）重点 字典 列表 字符串

• python的基础数据类型之一
• 容器型数据类型，还有字典， 列表，元组
• 要求里面的元素不可变的数据，可哈希，但是它本身是可变的，元素是 int bool str
• 集合是无序的
• 集合的作用：

​ 1、列表的去重

​ 2、关系测试：交集，并集

• 创建

set = {1,3,'abc','中国','33c'}
print(set) #return {1, 3, '33c', '中国', 'abc'}

print({},type({})) #空字典   return {} <class 'dict'>
set1= set() #空集合

#增
set1={1,2,4,'aaa','@zh','中国啊'}
set1.add(4)
print(set1)  #return {1, 2, '中国啊', 'aaa', 4, '@zh'}

#删 （集合是无序的，不能按照索引删除，pop 可以随机的删除）
set1={1,2,4,'aaa','@zh','中国啊'}
set1.pop()
print(set1) #return {2, '@zh', 4, 'aaa', '中国啊'}

#交集
set1={1,2,3,4,5}
set2={4,5,6,7}
print(set1 & set2)  #return {4, 5}

#并集
set1={1,2,3,4,5}
set2={4,5,6,7}
print(set1 | set2)  #return {1, 2, 3, 4, 5, 6, 7}

#差集
set1={1,2,3,4,5}
set2={4,5,6,7}
print(set1 - set2)  #return {1, 2, 3}

#反交集
set1={1,2,3,4,5}
set2={4,5,6,7}
print(set1 ^ set2) #return {1, 2, 3, 6, 7}

#子集 和超集
set1={1,2,3,4,5}
set2={1,2,3,4,5,6,7}
print(set1<set2)  #return true

#列表去重
l1=[1,1,2,3,4,5,5,5]
print(list(set(l1))) #return [1, 2, 3, 4, 5]

深浅copy

#赋值运算
l1 = [1,3,4,5,[4,5,6]]
l2 = l1
l1.append(666)
print(l1) # return  [1, 3, 4, 5, [4, 5, 6], 666]
print(l2)  #return [1, 3, 4, 5, [4, 5, 6], 666]

# 浅copy
l1 = [1,3,4,5,[4,5,6]]
l2 = l1.copy() # 开辟了新空间
l1.append(666) #单纯的把l1列表里增加了一个地址槽，但是l2没有增加
print(l1) # return  [1, 3, 4, 5, [4, 5, 6], 666]
print(l2) #return [1, 3, 4, 5, [4, 5, 6]]

# 浅copy
l1 = [1,3,4,5,[4,5,6]]
l2 = l1.copy() # 开辟了新空间
l1[-1].append(666) #这里把l1 和 l2 里共有的小列表增加了一个元素666，所以 两个列表都增加
print(l1) # return  [1, 3, 4, 5, [4, 5, 6], 666]
print(l2) #return  [1, 3, 4, 5, [4, 5, 6], 666]

l1 = [1,2,3]
l1[0]=4  #这个操作，实际上是把4在内存中的地址放到列表l1的第一个位置

#深copy
import copy #引进copy库
l1 = [1,2,3,[4,5,6]]
l2 = copy.deepcopy(l1) # 深copy ，
l1[-1].append(666)
print(l1)  #return [1, 2, 3, [4, 5, 6, 666]]
print(l2)  #return [1, 2, 3, [4, 5, 6]]

• python 对深copy做了优化，把不可变的数据沿用之前的，可变的比如列表元素，就开辟新空间

#考察切片，全切是深copy还是浅copy?浅
l1 = [1,2,3,[4,5,6]]
l2 = l1[:]
l1[-1].append(555)
print(l1)  #return [1, 2, 3, [4, 5, 6, 555]]
print(l2)  #return [1, 2, 3, [4, 5, 6, 555]]

v={}
for index in range(10):
    v['users'] = index
print(v)  #return {'users': 9}

测试

goods=[
    {'name':'键盘','price':'44'},
    {'name':'鼠标','price':'55'},
    {'name':'计算器','price':'22'},
    {'name':'尺子','price':'4'}
]
'''
1，显示每个商品，如下格式；
    1 键盘  44
    2 鼠标  55
    。。。。。
2,用户输入选择的商品序号，然后打印商品名称及商品价格
3，如果用户输入商品序号有误，提示有误，重新输入
4，用户输入Q或q,退出
'''
count = 1
for i in goods:
    print (count,i['name'],i['price'])
    count+=1
while 1:
    index = input('Entry your num:').strip() #去空格
    if index.upper()=='Q':break
    if index.isdecimal():
        if int(index) >len(goods) or int(index) <1:
            print('your num wrong!')
            continue
        else:
            print (goods[int(index)-1]['name'],goods[int(index)-1]['price'])
    else:print('your num wrong!')