20201128_第七讲

1.元组简介
 1.1.元组表现形式tuple
 1.2.元组是一个不可变序列(一般当我们希望数据不改变时，我们使用元组，其他情况下基本都用列表)
 1.3.使用()创建元素
 1.4.元组不是空元组至少有一个 逗号(,) 当元组不是空元组时括号可以省略
 元组解包指将元组当中的每一个元素都赋值给一个变量

#tuple()
# my_tuple = (1,2,3,4)
# print(my_tuple,type(my_tuple))
# print(my_tuple[2])  #索引

#如果元组不是空元组，那么它至少得有一个都好
# tuple1 = (10,)    #加了逗号就是元组
# print(tuple1,type(tuple1))

#len()
#max()  min()
#in     not in
#count()
#index()

#元组的拆包
# a,b,c,d= my_tuple
# print(a,b,c,d)  #将元组中的内容拆分出来
# *a,b,c= my_tuple
# print(a,b,c)  #将元组中的内容拆分出来 [1, 2] 3 4
#在对一个元组拆包的时候，变量的数量和元组中元素的数量要保持一直。
#如果变量和元素不一致，就可以在变量前面加上一个*，这样会获取元组中剩余的元素，以列表的形式返回

#字符串拆包
# s = 'abcdef'
# a,b,*c = s
# print(a,b,c)

#列表拆包
# list1 = [1,2,3,4]
# a,b,*c = list1
# print(a,b,c)

#元组中的元素值是不允许删除的，但可以使用del语句来删除整个元组
my_tuple = (1,2,3,4)
print(my_tuple)
del my_tuple

#元组之间可以使用+号和*号进行运算。意味着可以组合和复制，运算后会生成一个新的元组
# print((1,2,3) + (4,5,6))  #连接
# print(('Hi!',)*4)     #复制

#将可迭代系列转换为元组
# list1 = ['Google', 'Taobao', 'Runoob', 'Baidu']
# tuple1 = tuple(list1)
# print(tuple1)

2.字典
 2.1.字典的基本介绍
  2.1.1.字典属于一种新的数据结构称为映射(mapping)
  2.1.2.字典的作用和列表类似，都是用来存储对象的容器
  2.1.3.列表存储数据的性能好，但是查询数据的性能差，字典正好与之相反
  2.1.4.在字典中每一个元素都有唯一的名字，通过这个唯一的名字可以找到指定的元素
  2.1.5.这个唯一的名字我们称之为key 通过key可以快速查询value 也可以称之为值
  2.1.6.字典我们也称之为键值对(key-value)结构
  2.1.7.每个字典中都可以有多个键值对，而每一个键值对我们称其为一项(item)
  2.1.8.创建一个有数据的字典 语法 {key:value}
  2.1.9.字典的值可以是任意对象 字典的键可以是任意的不可变对象(int str bool tuple…)
  2.1.10.字典的键是不能重复的，如果出现重复的后面的会替换前面的
 2.2.字典的使用
  2.2.1.dict()函数来创建字典
  2.2.2.get(key[,default]) 根据键来获取字典的值。第二个参数可以指定一个默认值，当获取不到值的时候会返回默认值
  2.2.3.update() 将其他字典的key-value添加到当前的字典当中
  2.2.4.del 删除字典中的key-value
  2.2.5.popitem() 删除字典最后的一个key-value 这个方法是有返回值的。删除之后它会将删除的key-value作为返回值返回
  2.2.6.pop(key[,default]) 根据key删除自定中的value。第二个参数可以指定一个默认值，当获取不到值的时候会返回默认值
 2.3.copy()
  2.3.1.copy() 方法用来对字典进行潜复制（注意:潜复制只会复制字典本身，如果字典中还有个字典是不会进行复制的）
 2.4.遍历字典
  我们主要可以通过3种方式对字典进行遍历
  2.4.1.values() 该方法返回一个序列 序列中保存有字典的值
  2.4.2.items() 该方法会返回字典中所有的项 它返回一个序列，序列中包含有双值子序列 双值分别是 字典中的key和value

d = {
    'name' : "刘亦菲",
     'age':18,
     'gender':'女神',
}

# #len()
# print(len(d))
# #in     not in
# print('name' in d)
# #字典没有索引，只能取键值
# print(d['age'])

#查
#get(key,default)   default为默认值
#如果是没有这个key,返回None，不会报错
#也可以指定一个默认值，来作为第二个参数，这样获取不到key值可以返回默认值
# print(d.get('name'))

#修改字典
# d[key] = value
# d['age'] = 16
# print(d)
# 没有这个key-value就是添加
# d['height'] = 174
# print(d)

#添加 setdefault(key,default)
#如果这个key已经存在于字典中，则返回value值，不会对字典造成影响
#如果不存在，则向字典中添加key-value
# res = d.setdefault('name','周慧敏')
# res = d.setdefault('height','170')
# print(res)

#添加 update()
#将其他字典当中的key-value添加到当前的字典当中
# d1 = {1:'1',2:'2'}
# d.update(d1)
# print(d)

#删除  del   删除字典中的key-value
# del d['age']
# print(d)

#删除  pop  pop(key,default)
res = d.pop('age')
print(res)
res = d.pop('height','不存在')
print(res)
print(d)

#没有remove

#popitem()  随机删除一个键值对，一般都是删除最后一个
#它会将删除后的键值对作为返回值返回
# res = d.popitem()
# print(res)
# print(d)


#clear()    清空字典

# 列表    字典      [x,x,x,x,x,x,x]
# {key:value}   可以通过key查询到value这个值，所以我们也称之为键值对，每一个键值对称呼为一项
#{}
# d = {}
# print(d,type(d))

#当字典中key有重复的时候，后面的数据会替换前面的数据
d = {
    'name' : "刘亦菲",
     'age':18,
     'gender':'女神',
     'name':'周慧敏'
}
print(d['name'])
d1 = dict(name = '刘亦菲',age = 18)
print(d1)

#双值子序列
#双值序列   [1,2],(1,2),'ab'
#子序列    ['a']   #数据类型嵌套
#双值子序列  [(1,2),(3,4)]
# list1 = [(1,2),(3,4)]
# d =dict(list1)
# print(d)

d = {
    'name' : "刘亦菲",
     'age':18,
     'gender':'女神'
    }

print(d.keys())
print(d.values())
print(type(d.items()))    #以列表返回可遍历得（键，值）元组数组
for k in d.keys():  #取得所有value
    print(d[k])
for k,v in d.items():   #取得所有
    print(k, '=' ,v)
for k in d.items():
    print(k,type(k))

3.集合
 3.1.集合简介
  3.1.1.集合表现形式set 集合和列表非常相似
  3.1.2.不同点：集合只能存储不可变对象；集合中存储的对象是无序的；集合不能出现重复元素
  3.1.3.使用{}来创建集合
  3.1.4.可以通过set()来将序列和字典转换成集合
  3.1.5.len() 使用len()来获取集合中元素的数量
  3.1.6.add()像集合中添加元素
  3.1.7.update()将一个集合中的元素添加到另一个集合当中
  3.1.8.pop()随机删除集合中的一个元素一般是删除最后一个元素
  3.1.9.remove() 删除集合中指定的元素
  3.1.10.clear() 清空集合

# s = {}
# print(type(s))
# s = set()   #创建集合的方式
# print(s,type(s))
# s = {6,8}
# a,b = s
# print(a)
# print(b)
# print(s)  #无序性

#集合只能存储不可变对象(sting,元组,int)，但是集合是可变的
#集合中存储的对象是无序的，无索引
#集合不能出现重复元素     #用集合做去重的操作

# s = {1,2,3,'asdd',(1,2)}   #不能存储可变对象
# print(s)

# list1 = [1,2,3,4,4,3,2,1]
# print(list(set(list1)))   #将列表中重复元素去重,再添加进一个新的列表中

#增
s = set()   #set()用来创建一个空集合,括号内只能添加一个元素
#in     not in      len()
#add()  添加元素进集合
s.add(1)
print(s)

#update()   将一个集合中的元素添加进另一个集合中
s1 = {2,3,4,(1,2)}
s.update(s1)
print(s)

#pop()  随机删除
# s.pop()
# print(s)

#remove()   指定删除元素
s.remove((1,2))
print(s)

#clear()

thisset = {"Google", "Runoob", "Taobao"}
thisset.add("Facebook")
print(thisset)

4.深拷贝和浅拷贝

d = {
    'name' : "刘亦菲",
     'age':18,
     'gender':'女神',
    'friend':{
        'name':'唐嫣',
        'age':32
    }
}

#浅拷贝：第二层数据的id一样，拷贝之后的对象和原对象id不一样
#第二层的数据只能引用
d1 = d.copy()
print(id(d),id(d1))
print(id(d['friend']),id(d1['friend']))

#深拷贝    把所有层次的数据重新拷贝成为一个新的对象
import copy
#浅拷贝
d2 = copy.copy(d1)
print(d2,id(d1), id(d2))

# d2 = copy.deepcopy(d)
# print(id(d),id(d2))
# print(id(d['friend']),id(d2['friend']))

5.作业

#有如下值集合[11,22,33,44,55,66,77,88,99,90], 将所有大于66的值保存至字典的第一个key的值中，将小于66值保存至第二个key的值中。
li = [11,22,33,44,55,66,77,88,99,90]
dic = {}
n = []
m = []
for i in li:
    if i > 66:
        n.append(i)
    if i < 66:
        m.append(i)
dic.update(k1 = m, k2 = n)

#找到python1/python2/python3
a = {"name":"123","data":{"result":[{"src":"python1"},{"src":"python2"},{"src":"python3"}]}}
i = 0
while True:
    print(a["data"]["result"][i]["src"])
    i += 1
    if i == 3:
        break

#自学练习
# 功能要求：
# 要求用户输入总资产，例如：2000
# 显示商品列表，让用户根据序号选择商品，加入购物车购买，如果商品总额大于总资产，提示余额不足，否则，购买成功。
goods = [
    {"name": "电脑", "price": 1999},
    {"name": "鼠标", "price": 10},
    {"name": "游艇", "price": 20},
    {"name": "美女", "price": 998}
]
admin_money = int(input("请输入您现有的钱："))
goods_dict = {}
goods_dict1 = {}
j = 0
k = []
for i in goods:
    j += 1
    goods_dict[j] = i["name"]
print(goods_dict)
for m in goods:
    goods_dict1.setdefault(m['name'],m['price'])
j = 0
admin_goods = 0
while True:
    k.append(int(input("以下添加想要商品的序号，添加完成按0确认:")))
    if k[j] == 0:
        k.remove(k[j])
        for i in k:
            admin_goods += goods_dict1[goods_dict[i]]
        else:
            print("购物车中商品价格：",admin_goods)
            if admin_goods >= admin_money:
                print("not enough money")
            else:
                print("enough")
            break
    else:
        j += 1