字典

1.什么是字典

1）

字典是容器型数据类型（序列），将{}作为容器的标志，里面的元素用逗号隔开
特点：可变（支持增删改），无序（不支持下标操作）

2）字典中的元素

• 字典中的元素就是键值对，以‘键：值’的形式成对出现 - {键1：值1，键2：值2，...}
  key - value

• 字典存储数据主要是为了存值，键知识为了区分不同的值而存在的

• 键值对中的键 - 不可变（所以列表不行）、唯一的（同一个字典中必须只有一个）

• 键值对中的值 - 没有要求，和列表元素一样，任何数据类型都可以作为值

• print({'x': 1, 'y': 3, 'x': 4}) # 对于重复的键，打印会自动删去重复项

2.查 - 获取字典的值

• 切片只针对有序的序列才有效

1)获取单个元素的值

字典[key] - 获取字典中指定key对应的值;如果key不存在,会报错
字典.get(key)/字典.get(key,默认值) - 获取字典中指定的key对应的值;如果key不存在,返回None或者默认值

2)遍历

for key in 字典: 拿到的是字典中所有的key
for value in 字典.values： #拿到的是字典中所有的value
for key,value in 字典.itmes(): #拿到的是字典中所有的键和值

练习

# 1)获取单个元素
dog = {'name': '哈尼', 'age': 3, 'type': '金毛', 'color': '金色'}
print(dog['name'],dog['color'])
print(dog.get('weight', '没有该值'))  # 没有返回默认值

# 2)遍历
# 常用的遍历方式,最好用这种
for x in dog:
    print(x)     # 拿到字典中所有的key
# 不建议使用
for value in dog.values():
    print(value)    # 拿到字典中所有的值value
# 不建议使用
for key,value in dog.items():
    print(key,value)

3.增/改

• 增 - 添加键值对;
• 改 - 修改字典中某个key对应的值
• 语法: 字典[key] = 值 - 当key存在,为修改key对应的值;当key不存在,为添加键值对

dog = {'name': '哈尼', 'age': 3, 'type': '金毛', 'color': '金色'}
dog['weight'] = 34
print(dog)
dog['weight'] = 43
print(dog)

4.删 - 删除key对应的值

"""

1. del 字典[key] - 删除指定key对应的键值对
2. 字典.pop(key) - 取出指定key对应的值,但取出后,原字典中key对应的键值对也没有了

dog = {'name': '哈尼', 'age': 3, 'type': '金毛', 'color': '金色'}
del dog['color']
print(dog)   # {'name': '哈尼', 'age': 3, 'type': '金毛'}
type1 = dog.pop('type')
print(dog,type1)    # {'name': '哈尼', 'age': 3} 金毛

5.相关运算

• 字典不支持: +, *, <, >, >=, <=,
• 字典只支持: ==, != (字典中只要键值对都相等即为==,不考虑顺序)

print({'name': '哈尼', 'age': 3} == {'name': '哈尼', 'age': 3})  # True
print({'age': 3, 'name': '哈尼'} == {'name': '哈尼', 'age': 3})  # True

6.相关操作: in / not in; max,min,sum,len

• key in 字典 - 判断字典中是否存在某个键
• max,min,sum - 针对的是key的操作
• dict(数据) -将指定数据转换成字典
  • 数据的要求:
    • 1)数据本身是一个序列
    • 2)序列中元素必须是且只有两个元素的小序列
    • 如:[[元素1,元素2],[元素3,元素4]]

print(2 in {'a': 1, 'b': 2})  # False
print('a' in {'a': 1, 'b': 2})  # True

dict1 = {'a': 1, 'z': 2, 'c': 3}
print(max(dict1))  # z 求key的最大值

dict2 = {1: 'a', 2: 'z', 3: 'c'}
print(sum(dict2))  # 6
print(max(dict2))  # 3
print(min(dict2))  # 1
print(len(dict2))  # 3
print(list(dict2))  # [1, 2, 3]
print(dict([[1, 2], [2, 3], [3, 4]]))  # {1: 2, 2: 3, 3: 4}

7.相关方法

1. 字典.clear() - 清空字典
2. dict.fromkeys(序列,值=None) - 创建一个新的字典,将序列中的元素作为字典的key,将值作为每一个key对应的值
3. 字典.item() - 将字典转中的键值对转换成元祖作为容器中的元祖
4. 字典.values(),字典.keys() - 将值或者键全部取出来
5. 字典.setdefault(key,value=None) - 在字典中添加键值对(key存在的时候不会有修改的作用)
6. 字典1.update(字典2) - 将字典2中的键值对全部添加到字典1中

练习

# 2) dict.fromkeys(序列,值=None)  -  创建一个新的字典,将序列中的元素作为字典的key,将值作为每一个key对应的值
print(dict.fromkeys((1, 2, 3, 4), 0))  # {1: 0, 2: 0, 3: 0, 4: 0}
print(dict.fromkeys((1, 2, 3, 4)))  # {1: None, 2: None, 3: None, 4: None}

# 4) 字典.values(),字典.keys()   -   将值或者键全部取出来
dict2 = {1: 'a', 2: 'z', 3: 'c'}
print(dict2.values())   # dict_values(['a', 'z', 'c'])
print(dict2.keys())    # dict_keys([1, 2, 3])

# 5) 字典.setdefault(key,value=None)   -   在字典中添加键值对(key存在的时候不会有修改的作用)
dict2 = {1: 'a', 2: 'z', 3: 'c'}
dict2.setdefault(1, 'e')
dict2.setdefault(4, 'f')
print(dict2)  # {1: 'a', 2: 'z', 3: 'c', 4: 'f'}

# 6) 字典1.update(字典2)   -   将字典2中的键值对全部添加到字典1中
dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'x': 100, 'y': 200, 'a': 123}
dict1.update(dict2)
print(dict1)  # {'a': 123, 'b': 2, 'c': 3, 'x': 100, 'y': 200}
dict2.update([[2, 3], [3, 4]])  # 不一定是字典，可以转化为字典的序列也可以
print(dict2)  # { 'x': 100, 'y': 200, 'a': 123, 2: 3, 3: 4}

练习：用一个列表保存5只狗的信息，每只狗有：名字、年龄、颜色和体重 1）求5只狗的平均年龄 2）找到5只狗体重最大的狗的名字

dogs = [{'name': '哈尼', 'age': 3, 'color': '金色', 'weight': 13},
        {'name': 'lulu', 'age': 1, 'color': '棕色', 'weight': 8},
        {'name': 'TT', 'age': 1.5, 'color': '白色', 'weight': 7},
        {'name': '会长', 'age': 2, 'color': '棕色', 'weight': 13},
        {'name': 'lala', 'age': 2, 'color': '白色', 'weight': 6}]
ages = 0
weights = []
for dog in dogs:
    ages += dog['age']
    weights.append(dog['weight'])
print(weights.count(max(weights)))
print(weights.index(max(weights),weights.index(max(weights))+1,len(weights)))
print(ages/5, dogs[weights.index(max(weights))]['name'])

集合

1.什么是集合（set）

• 1)集合
  集合是容器型数据类型(序列);将{}作为容器的标志,多个元素用逗号隔开(和字典不一样,集合是独立的数据,不是键值对)
  特点:可变(增删) 、 无序(不支持下标操作)
  注意:{}表示的是空字典 set1 = set()才表示空集合
  如:{1,3,12,34}

• 2)元素 - 不可变的数据;同一个元素只能有一个(唯一性)
  - 集合自带去重功能

练习

# 1.空集合
set1 =set()
print(type(set1))

set2 = {12,'abs',(1,2)}
print(set2)

# set3 = {'abs',[1,2]}     # TypeError: unhashable type: 'list'
# set4 = {{'a':'b'},True}   # TypeError: unhashable type: 'dict'

# 集合自带去重功能（集合元素的唯一性）
scores = [65,23,34,45,54,23,45,65]
scores = list(set(scores))
print(scores)

2.集合元素的增删改查

1）查 - 只支持遍历，不能单独获取具体某一个元素

names = {'小明', '小米', '张三', '殷夫人'}
for item in names: # for in的遍历都是通过转化为列表,根据下标进行遍历
print(item)

2) 增:

• 集合.add(元素) - 在集合中添加一个元素
• 集合.update(不可变序列) - 将序列中所有的元素添加到集合中
  names.add('哪吒')
  print(names)
  names.update(['敖丙','龙王'])
  names.update('yes') # 会将字符串拆分后添加
  print(names)

3) 删除 - 删除元素

• 集合.remove(元素) - 删除集合中指定的元素
  names.remove('张三')
  print(names)

4) 改(集合不支持修改元素的操作)

2.数学的集合运算:

set1 = {1, 2, 3, 4, 5, 6}
set2 = {1, 2, 3, 4, 7, 9, 10}

1）求交集:集合1 & 集合2

print(set1 & set2) # {1, 2, 3, 4}

2）求并集：集合1 | 集合2

print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7, 9, 10}

3）求差集：集合1 - 集合2 获取集合1中除了集合2中的元素剩下的部分

print(set1-set2) # {5, 6}
print(set2-set1) # {9, 10, 7}

4) 求对称差集： 集合1 ^ 集合2 获取两个集合除了公共部分剩下的部分

print(set1 ^ set2) # {5, 6, 7, 9, 10}

5) 集合1 > 集合2 判断集合1中是否包含集合2

print({9, 10, 11, 12} > {1, 2, 3}) # False
print({9, 10, 11, 12} > {9,10}) # True

6) 集合1 < 集合2 判断集合2中是否包含集合1

print({9, 10, 11, 12} < {9,10}) # False
print({9, 10, 11, 12} < {9,10,11,12,13,14}) # True