元组类型、字典类型以及内置方法

#元组类型
#一：基本使用
# 1 用途：元组是不可变的列表，能存多个值，但多个值只有取的需求，而没有改的需求，那么用元组最合理
#
# 2 定义方式:在()内用逗号分割开，可以存放任意类型的值
# names=('alex','egon','wxx') #names=tuple(('alex','egon','wxx'))
# print(type(names))
# 强调: 当元组内只有一个元素时，务必记住加一个逗号
# x=('egon',)
# print(type(x))

# 3 常用操作+内置的方法
#1、按索引取值(正向取+反向取)：只能取
# names=('alex','egon','wxx')
# names[0]='sb'


#2、切片(顾头不顾尾，步长)
# names=('alex','egon','wxx','lxx','cxxx')
# print(names[1:3]
# )

#3、长度
# names=('alex','egon','wxx','lxx','cxxx')
# print(len(names))
#4、成员运算in和not in
# names=('alex','egon','wxx','lxx','cxxx')
# print('alex' in names)

#5、循环
# names=('alex','egon','wxx','lxx','cxxx')
# for item in names:
#     print(item)


# #二：该类型总结
# 1 存一个值or存多个值
#     可以存多个值，值都可以是任意数据类型
#
# 2 有序or无序
#有序
# 3 可变or不可变
#不可变

names=('alex','egon','wxx','lxx','cxxx','lxx')
# del names[0]         #会报错，原因是元组不能被修改 ：TypeError: 'tuple' object doesn't support item deletion
# names[0]='sb'
# print(names.count('lxx'))       #count统计元组中指定元素的个数
# print(names.index('wxx',0,3))   #index统计指定切片内，指定元素的索引

# names=('alex','egon','wxx','lxx','cxxx','lxx')
# names=1          #这不叫改元组值，只是对一个元组重新赋值

# l=[1,243,3]        #
# # l=3333
# l=['a','b','c']
# print(id(l))
# print(id(l[0]))       #改变列表中元素的值，列表的id不会改变，但是列表中元素的id会改变
# l[0]='A'
# print(id(l))
# print(id(l[0]))     #列表可变是指内存地址是
# names=('a','b','c')

# 列表可变的底层原理：
#指的是索引所对应的值的内存地址是可以改变的

# 元组不可变的底层原理：
#指的是索引所对应的值的内存地址是不可以改变的
#或者反过来说，只要索引对应值的内存地址没有改变，那么元组始终是没有改变的

# t1=(['a','b','c'],'wc','office')
#
# print(id(t1[0]))         #元组中三个元素对应的id是不同的，id=2135396392648
# print(id(t1[1]))
# print(id(t1[2]))
# #
# t1[0][0]='AAAA'        #本质修改的是元组中列表中元素的值，并不是整体修改元组中一个元素的值
# print(t1)
# #
# print(id(t1[0]))      #id=2135396392648  修改了元组中第一个列表中的值所以id是不变的

#练习
#队列：先进先出
# l=[]
# # 入队
# # l.append('王苗鲁')
# # l.append('王成龙')
# # l.append('大脑门')
# #出队
# print(l.pop(0))
# print(l.pop(0))
# print(l.pop(0))
#堆栈：先进后出
# l=[]
# #入栈
# l.append('王苗鲁')
# l.append('王成龙')
# l.append('大脑门')
# #出栈
#
# print(l.pop())
# print(l.pop())
# print(l.pop())




msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}

shopping_cart=[]
while True:
    for k in msg_dic:
        info='商品名：%s 价钱：%s' % (k, msg_dic[k])
        print(info.center(50,' '))
    name=input('请输入商品名>>: ').strip()
    if name not in msg_dic:
        # 输入的商品名不合法，打印提示信息并且直接进入下一次循环
        print('输了些什么玩儿。。。重输')
        continue
    # else:
    #     #输入的商品品合法，结束循环
    #     break

    while True:
        count=input('请输入购买个数：').strip()
        if count.isdigit():
            #输入个数合法
            count=int(count)
            break
        else:
            print('商品的个数必须为整数')
            # continue # 不加continue也会跳入下一次

#    name,count
    for item in shopping_cart:
        # print(item)
        if name == item['name']:
            item['count']+=count
            break
    else:
        price=msg_dic[name]
        info={'name':name,'count':count,'price':price}
        shopping_cart.append(info)
    print(shopping_cart)

字典类型
#一：基本使用
# 1 用途：用来存多个值，但每一个值都有一个key与之对应，key对值有描述性的功能
#        当存储多个值表示的不同的状态时，
#
# 2 定义方式:{}内用逗号分隔开多个元素，每一个元素都是key：value的形式
#value可以是任意数据类型，但是key必须为不可变类型，key通常应该是字符串类型，
# d={'x':1,'y':2} #d=dict({'x':1,'y':2})
# d=dict(a=1,b=2,c=3)       #通过dict可以创建字典
# print(d)


dic={1:'a',0:'b',1.1:'c',(1,2,3):'d'}
# print(dic[1])        #数字也可以当做key值，但是这样会与索引产生误解，不能明确是通过key取value
# print(dic[0])
# print(dic[1.1])       #不可变类型都可以作为key值，但是通常我们使用字符串作为key值
# print(dic[(1,2,3)])
# dic={[1,2,3]:'a'}      #可变类型不可以作为key
# dic={{'x':1}:'a'}

#
# 3 常用操作+内置的方法
#优先掌握的操作：
#1、按key存取值：可存可取
# d={'y':2}
# d['x']=100         #通过key来向字典中加入key：value，如果已经存在key：value，则会在原来的基础上对key对应的value值做替换
# print(d)       #{'y': 2, 'x': 100}

# d['z']=3
# print(d)

# d={'x':1,'y':2}
# d['x']=100         #通过key来向字典中加入key：value，如果已经存在key：value，则会在原来的基础上对key对应的value值做替换
# print(d)     #{'x': 100, 'y': 2}

# l=['a','b']
# l[2]='c'       #而列表不能通过索引添加值，报错是因为索引超出范围，IndexError: list assignment index out of range
# l[1]='c'     #通过索引改变列表中指定位置的值
# print(l)

#2、长度len
# d={'x':1,'y':2}
# print(len(d))      #len也可以统计字典中元素的个数
#3、成员运算in和not in
# d={'x':1,'y':2}
# print('x' in d)     #in判断一个字符是否在字典中的key值

#4、删除
# d={'x':1,'y':2}
# del d['x']          #del通过key值来删除字典中的key：value
# # print(d)
# res=d.pop('y')         #pop通过key删除字典中的key：value，但会拿到删除'y':2中value的值2
# print(d)
# print(res)

# res=d.popitem()     #popitem（）默认会删除右边的key:value,也会拿到一个返回值，以key，value元组的形式返回('y', 2)
# print(d)
# print(res)

# d={'a':1,'b':2,'c':3,'d':4}
# for k in d:             #通过for循环取出字典中所有的key值
#     print(k)

# l=[1,2,3]            # del通过索引删除列表中的元素
# del l[1]
# print(l)

#5、键keys()，值values()，键值对items()
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
# names=[]
# for k in msg_dic:  #通过for循环把字典中的key值取出来，在通过append把取出的key值添加到空列表中
#     names.append(k)
# print(names)         #['apple', 'tesla', 'mac', 'lenovo', 'chicken']
# values=[]
# for k in msg_dic:    #通过for循环取出key值，在通过append将value加入到空列表中
#     values.append(msg_dic[k])
# print(values)

# keys=msg_dic.keys()    #通过keys取出一只老母鸡dict_keys(['apple', 'tesla', 'mac', 'lenovo', 'chicken'])
# print(keys)
# for k in keys:     #在循环老母鸡就可以取出字典中的key值
#     print(k)
# l=list(keys)        #通过list可以将老母鸡转换成一个列表['apple', 'tesla', 'mac', 'lenovo', 'chicken']
# print(l)
#
# vals=msg_dic.values()    #通过values取出一只老母鸡dict_values([10, 100000, 3000, 30000, 10])
# print(vals)
# print(list(vals))    #同过list将老母鸡的value转换成一个列表[10, 100000, 3000, 30000, 10]

# print(msg_dic.items())    #通过items取出一只老母鸡dict_items([('apple', 10), ('tesla', 100000), ('mac', 3000), ('lenovo', 30000), ('chicken', 10)])
# print(list(msg_dic.items()))   #通过list将老母鸡转换成一个列表，列表中的元素以小元组的形式存在[('apple', 10), ('tesla', 100000), ('mac', 3000), ('lenovo', 30000), ('chicken', 10)]
#6、循环
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
# 只取key
# for k in msg_dic:      #循环字典本质就是循环字典中的key值
#     print(k,msg_dic[k])

# for k in msg_dic.keys():
#     print(k,msg_dic[k])

# 只取value
# for v in msg_dic.values():  #通过点values循环出字典中的所有value值
#     print(v)

#取key和value
# for k,v in msg_dic.items(): #k,v=('apple', 10)  变量的解压
#     print(k,v)       #通过点items取出加for循环取出字典中的key和value值

# 需要掌握的内置方法（****）
# d={'x':1,'y':2,'z':3}
# v=d.get('xxxx')         #点get的方法和通过key取value值得功能一样，只是get通过key取值是如果key不存在，不会报错
# print(v)
# print(d['xxxxxxx'])   #key值不存在，取不到value就会报错KeyError: 'xxxxxxx'

# d={'x':1,'y':2,'z':3}
# d1={'a':1,'x':1111111}
# d.update(d1)     #update会更新原有字典中的key：value，存在则更新，不存在加入到原字典中
# print(d)        #{'x': 1111111, 'y': 2, 'z': 3, 'a': 1}

# l=['name','age','sex']
# d={}
# for k in l:
    # d[k]=None
# print(d)            #打印结果{'name': None, 'age': None, 'sex': None}

# d=dict.fromkeys(l,None)    #不使用for循环，使用dict.fromkey也可以实现将一个列表转换成字典，并给不同的key加上默认的value值
# d=dict.fromkeys(l,18)      #{'name': 18, 'age': 18, 'sex': 18}
# print(d)


# info.setdefault
# info={'name':'egon','age':18,'sex':'male'}

# 如果字典中有setdefault指定的key，那么不改该key对应的值，返回原的value
# res=info.setdefault('name','EGON_NB')
# print(info)
# print(res)

# 如果字典中没有setdefault指定的key，那么增加一个key:value,返回新的value
# info.setdefault('height',1.80)
# print(info)
#
# info={'age':18,'sex':'male'}
# v=info.setdefault('name','浩哥')       #因为字典中没有('name','浩哥'),setdefault就会将其放入字典中，并将新的value值返回
# print(v)          #浩哥
# print(info)       #{'age': 18, 'sex': 'male', 'name': '浩哥'}



# 统计串中各个单词的个数
# s='hello alex alex say hello sb sb'
# l=s.split()         #split将字符串切分成列表
# print(l)           #['hello', 'alex', 'alex', 'say', 'hello', 'sb', 'sb']
# d={}
# for word in l: #word=  'hello'         #循环列表拿到每一个单词
#     if word not in d:                  #判断单词是否在字典中
#         d[word]=1 #{'hello':2, 'alex':2,'say':1}     #不在则说明是一个新的单词，将其以key:value的形式刚入到字典中去
#     else:
#         d[word]+=1                            #字典中已经存在的单词，对其value加一操作，即单词的个数
# print(d)             #{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}


# s='hello alex alex say hello sb sb'
# l=s.split()
# print(l)
# d={}
# d={'hello':2,'alex':2}
# for word in l: #word='alex'        #循环取出列表中的单词
#     # d[word]=l.count(word) #d['alex']=2     #通过count统计列表中某个单词的个数，将写进到字典中单词对应的value值（方法一）
#     d.setdefault(word,l.count(word))      #将key，value放到字典中（方法二）
# print(d)


# #二：该类型总结
# 1 存一个值or存多个值
#     可以存多个值，值都可以是任意类型，而key必须是不可变类型，通常应该是不可变类型中字符串类型
#
# 2 有序or无序
# 无序
#
# 3 可变or不可变

# d={'x':1,'y':2}
# print(id(d))
# d['x']=1111
# print(id(d))

# d=123