day7-字典和元组

元组(tuple)

1.什么是元组

• 元组是容器型数据类型（序列），将()作为容器的标志，里面多个元素用逗号隔开：

(元素1, 元素2, 元素3, ...) 		# 元素：任何类型的数据

• 元组不可变(不支持增删改)
• 元组是有序的(支持下标操作)

t1 = (10, 20, 30)
print(t1, type(t1))		# (10, 20, 30) <class 'tuple'>

t2 = (10, 'abc', False, [10, 230])
print(t2)		# (10, 'abc', False, [10, 230])

t3 = ()
print(t3, type(t3))			# () <class 'tuple'>

2.元组就是不可变的列表

列表中除了和增、删、改相关操作以外的操作，元组都支持

例如：查、相关操作、相关方法（除了增删改相关的）、相关函数

t2 = (10, 23, 78, 9)
print(t2[-1])			# 9
print(t2[1:])			# (23, 78, 9)

for i in t2:
	print(i)    		# 10 23 78 9
for index in range(len(t2)):
    print(index, t2(index), sep=':')		# 0:10 1:23 2:78 3:9
    
print((10, 23) + (100, 200, 300))		# (10, 23, 100, 200, 300)
print(t2 * 2)		# (10, 23, 78, 9, 10, 23, 78, 9)

t2 = (10, 23, 78, 9, 10)
print(t2.count(10))		# 2
print(t2.index(23))		# 1
print(max(t2), min(t2))		# 78 9
print(sum(t2))			# 130
print(sorted(t2))		# [9, 10, 10, 23, 78]
print(tuple('abc'))		# ('a', 'b', 'c')
print(len(t2))			# 5

t2 = (10, 23, 78, 9, 10)
t3 = [i for i in t2 if i > 10]
print(t3)				# [23, 78]

3.元组特殊或者常用的操作

1）只有一个元素的元组：(元素,)

t1 = (10,)
print(t1, type(t1))		# (10,) <class 'tuple'>

2)元组在没有歧义的情况下可以省略()

直接用逗号将多个数据隔开，表示的也是一个元组

t2 = 10, 23, 45, 6
print(t2, type(t2))		# (10, 23, 45, 6) <class 'tuple'>

3)同时使用多个变量获取元组的元素(列表也支持)

• a.让变量的个数和元组中的元素的个数保持一致

t3 = ('小明', 18, 90)
name, age, score = t3
print(name, age, score)		# 小明 18 90
point = (10, 20)
x, y = point
print(x, y)					# 10 20

• b.让变量的个数小于元组元素的个数，但是必须在某个变量前加*

先让不带的变量按照位置获取元素，剩下的部分全部保存到带的变量对应的列表中

t3 = ('小明', 18, 170, 80, 99, 80, 76)
x, *y, z = t3
print(x, y, z)
x, y, *z, t = t3
print(x, y, z, t)

字典

1.什么是字典(dict)

1. 字典是容器型数据类型(序列)，将{}作为容器的标志，里面多个键值对用逗号隔开：

   键值对 - 键：值

{键1: 值1, 键2: 值2, 键3: 值3, ...}

2. 字典是可变的(支持增删改)；字典是无序的(不支持下标操作)
3. 元素 - 键值对
   1. 键 - 必须是不可变的数据，例如：元组、数字、字符串。键是唯一的
   2. 值(才是真正想要保存的数据) - 没有要求

1）空字典

dict1 = {}
print(dict1, type(dict1))		# {} <class 'dict'>

2)键是不可变的数据类型

dict2 = {'a': 10, 1: 20, (1, 2): 30}
print(dict2)				# {'a': 10, 1: 20, (1, 2): 30}
dict3 = {'a': 10, 1: 20, [1, 2]: 30}
print(dict3)				# 报错

3）键是唯一的

dict3 = {'a': 10, 1: 20, 'a': 30}
print(dict3)				# 报错

获取字典的值

1.查单个

1. 字典[键] - 获取字典中指定键对应的值；当键不存在的时候会报错
2. 字典.get(键) == 字典.get(键, None) - 获取字典中指定键对应的值；当键不存在不会报错，返回None
3. 字典.get(键, 默认值) - 获取字典中指定键对应的值；当键不存在不会报错，返回默认值

dog = {'name': '小黑', 'breed': '哈士奇', 'age': 3, 'color': '黑色'}
print(dog['name'])		# 小黑
print(dog['breed'])		# 哈士奇
print(dog.get('age'))	# 3
print(dog.get('color'))	# 黑色

student = {'name': '小明'}
print(student.get('age', 20))			# 20
print(student.get('gender', '男'))		# 男

2. 遍历

for 变量 in 字典:
    循环体
    
变量取到的是键

dog = {'name': '小黑', 'breed': '哈士奇', 'age': 3, 'color': '黑色'}
for i in dog:
    print(i, dog[i], sep=': ')

字典的增删改

1.增 - 添加键值对

2.改 - 修改键对应的值

语法：字典[键] = 值	-	当键存在时是修改，键不存在就是添加

goods = {
    'name': '泡面',
    'price': 3.5,
}
print(goods)
goods['count'] = 10
print(goods)
goods['price'] = 4
print(goods)

3.删

• 1）del 字典[键] - 删除字典中指定键对应的键值对

goods = {
    'name': '泡面',
    'price': 4,
    'count': 10
}
del goods['price']
print(goods)			# {'name': '泡面', 'count': 10}

• 2)字典.pop(键) - 取出字典中指定键对应的值

goods = {
    'name': '泡面',
    'price': 4,
    'count': 10
}
result = goods.pop('price')
print(goods)
print(result)