呦呼！戴上眼镜，学习学习(￣▽￣)～■干杯！
我秃头，我快乐✧＼ ٩(눈౪눈)و /／✧加油啊喂
前几周，咱们对列表的相关知识进行了学习总结，本周，我将对元组与字典进行总结（｡ò ∀ ó｡）
目录
一、例题
老师又给了几个练习题呢，我们一起来看看吧︿(￣︶￣)︿
1.1 例一、编写购物程序
购物车类型为列表类型，列表的每个元素为一个列表类型，列表中包括商品名称和价格。购物车里面的商品可以自行设置。
例如：goods=[ [”电脑”,5999], [”鼠标”,66], [“手机”, 888], [“口红”,599],[“NIKE”, 299]]
实验的具体要求：要求用户从键盘输入用户资产，输出用户能够买得起的商品名称。每次都询问用户是否要继续购买商品，如果要继续购买，请输入要购买的商品序号；如不继续购买，则退出。若商品价格大于用户资产，提示用户余额不足，否则购买成功，购买成功之后显示余额。
if __name__ == '__main__':
goods=[["电脑",5999],
["鼠标",66],
["手机",888],
["口红",599],
["NIKE",299]]
salary_user = float(input("请输入您的资产："))
for a,b in enumerate('good'):
if salary_user > goods[a][1]:
print("您可以购买以下产品：",(a,b))
while True:
choice = input("您是否需要继续购买商品？")
if choice == "是":
while True:
x = int(input("请输入商品序号："))
if x < len(goods):
goods_money = goods[x][1]
break
else:
print("无该商品！")
continue
if salary_user >=goods_money:
salary_user -= goods_money
print("购买成功，你当前余额为",salary_user)
continue
else:
print("余额不足")
continue
elif choice == "否":
print("购物结束，欢迎下次光临！")
break
1.2 例二、对学生按照成绩降序排序，又不破坏对应关系
考虑一个场景：你正在处理一些学生的成绩，有这样两个列表：
names = [‘John’, ‘Amy’, ‘Jack’]
scores = [98, 100, 85]
分数和名字是一一对应的如果你想对它们按照成绩降序排序，又不想破坏对应关系的话，怎么实现呢？
if __name__ == '__main__':
names = ['John','Amy','Jack']
scores = [98,100,85]
a = list(zip(scores,names))
b=sorted(a,reverse=True)
print(b)
1.3 例三、按表格计算每月利润
假设你有这样一个表格
| 一月 | 二月 | 三月 | |
|---|---|---|---|
| 销售额 | 52,000.00 | 51,000.00 | 48,000.00 |
| 成本 | 46,800.00 | 45,900.00 | 43,200.00 |
利润 = 销售额 - 成本，怎么计算每月的利润呢？
if __name__ == '__main__':
xiaoshoue=[52000.00,51000.00,48000.00]
chengben=[46800.00,45900.00,43200.00]
for a,b in zip(xiaoshoue,chengben):
lirun=float(a-b)
print(lirun)
二、元组
元组属于不可变序列。
2.1、元组的创建与删除
- 使用“＝”将一个元组赋值给变量，就可创建一个元组变量。
如：
>>> a_tuple = ('a', 'b', 'mpilgrim', 'z', 'example')
>>> a_tuple
#('a', 'b', 'mpilgrim', 'z', 'example')
>>> a = (3)
>>> a
#3
>>> a = (3,) #包含一个元素的元组，最后必须多写个逗号
>>> a
#(3,)
>>> x = () #空元组
- 如果要创建只包含一个元组的元组，只把元素放在括号里，是不行的，还需要在元素后面加一个逗号“，”，而创建包含多个元素的元组没有这个限制。
- 可以使用tuple()函数将列表、字符串、字典、集合、map对象等其它类型可迭代对象转化为元组。
如：
>>> tuple('abcdefg') #把字符串转换为元组
#('a', 'b', 'c', 'd', 'e', 'f', 'g')
>>> aList
#[-1, -4, 6, 7.5, -2.3, 9, -11]
>>> tuple(aList) #把列表转换为元组
#(-1, -4, 6, 7.5, -2.3, 9, -11)
>>> s = tuple() #空元组
>>> s
#()
- 对于元组而言，只能使用del命令删除整个元组对象，不能只删除元组中的部分元素，因为元组属于不可变序列。
2.2、元组与列表的区别
- 元组中的数据一旦定义，就不允许通过任何方式更改。
- 元组没有提供append()、extend()和insert()的方法，无法向元组中添加元素。
- 元组也没有remove()和pop()方法，也不支持对元组元素进行del操作。只能使用del命令删除整个元组。
- 元组支持切片操作，但只能通过切片来访问元组中的元素，而不支持使用切片来修改元组中元素的值，也不支持使用切片操作来为元组增加或删除元素。
2.2.1、元组的优点
- 元组的访问和处理速度比列表更快。
- 元组对不需要修改的数据进行“写保护”，从内部实现上不允许修改其元素值，从而使得代码更加安全。
- 元组可用作字典的“键”，而列表永远不能当作字典键使用，因为列表不是不可变的。
- 如果元组中包含列表、字典、集合或其他可变类型的对象，这样的元组不能作为字典的“键”或集合的元素。
2.3、序列解包
- 可以使用序列解包功能对多个变量同时赋值
如：
>>> x, y, z = 1, 2, 3 #多个变量同时赋值
>>> v_tuple = (False, 3.5, 'exp')
>>> (x, y, z) = v_tuple
>>> x, y, z = v_tuple #与上一行代码等价
- 序列解包可用于列表和字典，但是对字典使用时，默认是对字典“键”操作，如果需要对“键:值对”操作，需要使用字典的items()方法说明，如果需要对字典“值”操作，则需要使用字典的values()方法明确指定。
如：
>>> s = {'a':1, 'b':2, 'c':3}
>>> b, c, d = s.items()
>>> b
#('c', 3)
>>> b, c, d = s #使用字典时不用太多考虑元素的顺序
>>> b
#'c'
>>> b, c, d = s.values()
>>> print(b, c, d)
#1 3 2
- 序列解包遍历多个序列
如：
>>> keys = ['a', 'b', 'c', 'd']
>>> values = [1, 2, 3, 4]
>>> for k, v in zip(keys, values):
print((k, v), end=' ')
#('a', 1) ('b', 2) ('c', 3) ('d', 4)
- 使用序列解包遍历enumerate对象
如：
>>> x = ['a', 'b', 'c']
>>> for i, v in enumerate(x):
print('The value on position {0} is {1}'.format(i,v))
#The value on position 0 is a
#The value on position 1 is b
#The value on position 2 is c
- 在调用函数时，在实参前面加上一个或两个星号（*）也可以进行序列解包，从而实现将序列中的元素值依次传递给相同数量的形参。
2.4、生成器表达式
- 生成器推导式的结果是一个生成器对象。使用生成器对象的元素时，可以根据需要将其转化为列表或元组，也可以使用生成器对象next()或__next__()方法进行遍历，或者直接将其作为迭代器对象来使用。
如：
>>> g = ((i+2)**2 for i in range(10)) #创建生成器对象
>>> g
#<generator object <genexpr> at 0x0000000003095200>
>>> tuple(g) #将生成器对象转换为元组
#(4, 9, 16, 25, 36, 49, 64, 81, 100, 121)
>>> list(g) #生成器对象已遍历结束，没有元素了
#[]
>>> g = ((i+2)**2 for i in range(10)) #重新创建生成器对象
>>> g.__next__() #使用生成器对象的__next__()方法获取元素
#4
>>> g.__next__() #获取下一个元素
#9
- 生成器对象具有惰性求值的特点，只在需要时生成新元素，比列表推导式具有更高的效率，空间占用非常少，尤其适合大数据处理的场合。
- 不管用哪种方法访问生成器对象，都无法再次访问已访问过的元素，必须重新创建该生成器对象。
三、字典
- 字典是无序、可变序列。
- 定义字典时，每个元素的“键”和“值”用冒号分隔，相邻元素之间用逗号分隔，所有元素放在一对大括号“｛｝”中。
- 字典中的键可以是Python中任意不可变数据，比如整数、实数、复数、字符串、元组等等。
- globals()返回包含当前作用域内所有全局变量和值的字典
- locals()返回包含当前作用域内所有局部变量和值的字典
3.1、字典创建与删除
- 使用“=”将一个字典赋值给一个变量。
如：
>>> a_dict = {'server': 'db.diveintopython3.org','database':'mysql'}
- 使用dict利用已有数据创建字典。
如：
>>> keys = ['a', 'b', 'c', 'd']
>>> values = [1, 2, 3, 4]
>>> dictionary = dict(zip(keys, values))
>>> x = dict() #空字典
>>> x={} #空字典
- 使用dict根据给定的“键:值”创建字典。
如：
>>> d = dict(name='Dong', age=37)
>>> d
#{'age': 37, 'name': 'Dong'}
- 以给定内容为“键”，创建“值”为空的字典
如：
>>> adict = dict.fromkeys(['name', 'age', 'sex'])
>>> adict
#{'age': None, 'name': None, 'sex': None}
- 可以使用del删除整个字典
3.2、字典元素的读取
- 使用字典的“键”作为下标来访问字典元素的“值”，若指定的“键”不存在则抛出异常。
如：
>>> aDict = {'name':'Dong', 'sex':'male', 'age':37}
>>> aDict['name']
'Dong'
>>> aDict['tel'] #键不存在，抛出异常
KeyError: 'tel'
- 使用字典对象的get()方法可以获取指定“键”对应的“值”，并且可以在指定“键”不存在的时候返回指定值，如果不指定，则默认返回None。
如：
>>> print(aDict.get('address'))
#None
>>> print(aDict.get('address', 'SDIBT'))
#SDIBT
- 使用字典对象的items()方法可以返回字典的“键:值”对，使用字典对象的keys()方法可以返回字典的“键”，使用字典对象的values()方法可以返回字典的“值”。
3.3、字典元素的添加与修改
- 以指定“键”为下标为字典赋值时，若该“键”存在，则表示修改该“键”的值，若不存在，则表示添加一个“键:值”对，也就是添加一个新元素。
如：
>>> aDict['age'] = 38 #修改元素值
>>> aDict
#{'age': 38, 'name': 'Dong', 'sex': 'male'}
>>> aDict['address'] = 'SDIBT' #增加新元素
>>> aDict
#{'age': 38, 'address': 'SDIBT', 'name': 'Dong', 'sex': 'male'}
- 使用字典对象的update()方法将另一个字典的“键:值”对一次性全部添加到当前字典对象，如果两个字典中存在相同的“键”，则以另一个字典中的“值”为准对当前字典进行更新。
- 使用del删除字典中指定键的元素，也使用字典对象的clear()方法来删除字典中所有元素，或者使用字典对象的pop()方法删除并返回指定键的元素，或者使用字典对象的popitem()方法删除并返回字典中的一个元素。
3.4、例题
首先生成包含1000个随机字符的字符串，然后统计每个字符的出现次数。
import string
import random
x = '0123456789'
#y = [random.choice(x) for i in range(1000)]
y = random.choices(x, k=1000)
z = ''.join(y)
d = dict() #使用字典保存每个字符出现次数
for ch in z:
d[ch] = d.get(ch, 0) + 1
print(d)
over！
下班下班(ノ๑`ȏ´๑)ノ︵⌨上课上课(=￣ ρ￣=) …zzZZ
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
