Python 数据结构与字典操作-优快云博客

本文链接：https://blog.youkuaiyun.com/tangyuhao30/article/details/114645452

2021.03.10

总结

1.列表相关方法

2.元组(tuple)

序列， (元素1, 元素2, …)
不可变；有序

元组是不可变的列表

t1 = (10,)
t2 = 19, 2, 34, 5
print(t2)

t3 = (10, 89)
print(t3[0], t3[1])
x, y = t3
print(x, y)

t4 = (19, 23, 45, 67, 78, 89)
*x, y = t4
print(y, x)

x, y, *z = t4

3.字典

序列，{键1:值1, 键2:值2,…}

可变的; 无序的

键 - 不可变的数据；唯一的
值 - 任何类型的数据

查 - 获取值

查单个：字典[key] / 字典.get(key) / 字典.get(key, 默认值)

for 变量 in 字典:
变量取到的是字典的key

4.列表推导式

1）序列元素整体变换
[表达式 for 变量 in 序列]

2）按两种不同的方式来变换
[表达式1 if 条件语句 else 表达式2 for 变量 in 序列]

3）提取满足条件的元素，然后进行变换
[表达式 for 变量 in 序列 if 条件语句]

# [12, 34, 56, 78, 89]  ->  [1212, 3434, 5656, 7878, 8989]
nums = [12, 34, 56, 78, 89]
result = [x*100+x for x in nums]
print(result)   # [1212, 3434, 5656, 7878, 8989]

# [19, 80, 76, 4, 3]  ->  [38, 40, 38, 2, 6]
nums = [19, 80, 76, 4, 3]
result = [x*2 if x % 2 else x // 2 for x in nums]
print(result)

nums = [12, 34, 56, 78, 89]   # -> [89]
result = [x for x in nums if x % 2]
print(result)

字典：增、改

字典[key] = 值 - 当key存在的时候就是修改指定key对应的值，当key不存在的时候添加键值对

dog = {'name': '财财', 'age': 2, 'breed': '土狗'}
print(dog)     # {'name': '财财', 'age': 2, 'breed': '土狗'}

dog['gender'] = '母狗'
print(dog)      # {'name': '财财', 'age': 2, 'breed': '土狗', 'gender': '母狗'}

dog['breed'] = '中华田园犬'
print(dog)      # {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}

删

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

dog = {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}
del dog['gender']
print(dog)      # {'name': '财财', 'age': 2, 'breed': '中华田园犬'}

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

dog = {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}
result = dog.pop('age')
print(dog, result)      # {'name': '财财', 'breed': '中华田园犬', 'gender': '母狗'}

字典相关操作

1)字典不支持+、* 和比较大小，只支持比较是否相等的运算

2)in 和 not in - 判断字典中是否存在指定的key

print('a' in {'name': 'a', 'age': 18})   # False
print('name' in {'name': 'a', 'age': 18})       # True

3)dict、len

dict(数据) - 将数据转换成字典
a. 数据必须是序列
b. 序列中元素必须是小序列, 而且小序列有且只有两个元素，第一个元素必须是不可变的

list1 = [(10, 20), 'ab', range(2)]
print(dict(list1))   # {10: 20, 'a': 'b', 0: 1}

dog = {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}
result = list(dog)
print(result)   # ['name', 'age', 'breed', 'gender']

print(len(dog))     # 4

字典推导式

{表达式1:表达式2 for 变量 in 序列}
{表达式1:表达式2 for 变量 in 序列 if 条件语句}

dict(表达式 for x in 序列) - 表达式必须是有且只有两个元素的序列，第一个元素必须是不可变的

result = {x: x**2 for x in range(3)}
print(result)       # {0:0, 1:1, 2:4}

result = {x: None for x in ['name', 'age', 'gender']}
print(result)       # {'name': None, 'age': None, 'gender': None}

result = {x: x//2 for x in range(11, 20) if x % 2 == 0}
print(result)       # {12:6, 14:7, 16:8, 18:9}

dog = {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}
result = {dog[x]: x for x in dog}
print(result)       # {'财财': 'name', 2: 'age', '中华田园犬': 'breed', '母狗': 'gender'}

result = dict((dog[x], x) for x in dog)
print(result)       # {'财财': 'name', 2: 'age', '中华田园犬': 'breed', '母狗': 'gender'}

字典相关方法

1) 字典.clear() - 清空字典

dog = {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}
dog.clear()
print(dog)      # {}

2) 字典.copy() - 复制字典产生一个一模一样的新字典

dog = {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}
dog1 = dog
dog2 = dog.copy()
print(dog1)     # {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}
print(dog2)     # {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}

dog.clear()
print(dog, dog1, dog2)        # {} {} {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}

3) (了解)dict.fromkeys(序列) - 创建一个字典，将序列中所有的元素作为字典key，值默认都是None

result = dict.fromkeys('abcd')
print(result)   # {'a': None, 'b': None, 'c': None, 'd': None}

result = dict.fromkeys(['name', 'age', 'gender'], 100)
print(result)       # {'name': 100, 'age': 100, 'gender': 100}

4） values、keys、items

字典.values() - 获取字典中所有的值；返回的不是列表另是一种序列
字典.keys() - 获取字典中所有的键；返回的不是列表另是一种序列
字典.items() - 获取字典中键值对；返回的时候序列，序列中的元素是每个键值对对应的元组

dog = {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}
result = dog.values()
print(result)       # dict_values(['财财', 2, '中华田园犬', '母狗'])
print(list(result))

print(dog.keys())       # dict_keys(['name', 'age', 'breed', 'gender'])

print(dog.items())      # dict_items([('name', '财财'), ('age', 2), ('breed', '中华田园犬'), ('gender', '母狗')])
print('===========================================================')
for x in dog.items():
    print(x)

print('===========================================================')
for x, y in dog.items():
    print('x:', x, 'y:', y)

5) 字典.setdefault(key, value) - 在字典中添加键值对(不会在key存在的时候进行修改操作)

dog = {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}
dog.setdefault('weight', 20)
print(dog)      # {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗', 'weight': 20}

dog.setdefault('name', '小黑')
print(dog)      # {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗', 'weight': 20}

6)字典.update(序列) - 将序列中所有的元素作为键值对添加到字典中。序列必须是可以转换成字典的序列

字典1.update(字典2) - 将字典2中的键值对全部添加到字典1中

dict1 = {'a': 10}
dict1.update({'b': 20, 'c': 30})
print(dict1)        # {'a': 10, 'b': 20, 'c': 30}

dict1.update(['ab', ('name', '张三'), ['age', 100]])
print(dict1)

集合（set）

集合是容器型数据类型；将{}作为容器的标志，多个元素之间用逗号隔开：{元素1, 元素2, 元素3, …}
集合是可变的；集合是无序的
元素：必须是不可变的数据；元素是唯一的

空集合： {}不是空集合，是空字典

set1 = set()
print(type(set1), len(set1))    # <class 'set'>

集合是无序的

print({1, 2, 3} == {3, 1, 2})    # True

集合的元素必须是不可变的类型的数据

set2 = {23, 'abc', (2, 3)}
print(set2)

集合的元素是唯一的

集合自带去重功能，但是只能去元素是不可变的序列的重

set4 = {10, 20, 30, 10, 10}
print(set4)     # {10, 20, 30}

names = ['张三', '李四', '张三', '王二', '李四', '张三'] #{'张三', '李四', '王二'}
print(set(names))

增删改查

1) 查：集合只能遍历

boll = {'乒乓球', '篮球', '羽毛球', '高尔夫', '网球'}
for x in boll:
    print(x)

2) 增

集合.add(元素) - 在集合中添加指定元素

boll.add('足球')
print(boll)

集合.update(序列) - 将序列中的元素全部添加到集合中

set5 = set()
set5.update('abc')
print(set5)    # {'a', 'b', 'c'}

set5.update({'name': '小明', 'age': 18})
print(set5)   # {'name', 'c', 'age', 'b', 'a'}

3) 删

集合.remove(元素) - 删除指定元素，如果元素不存在就报错

集合.discard(元素) - 删除指定元素，如果元素不存在不报错

boll = {'乒乓球', '篮球', '羽毛球', '高尔夫', '网球'}
boll.remove('高尔夫')
print(boll)   # {'网球', '羽毛球', '乒乓球', '篮球'}

boll.discard('网球')
print(boll)     # {'乒乓球', '羽毛球', '篮球'}

# boll.remove('桌球')     # KeyError: '桌球'
boll.discard('桌球')

4）改 - 不能直接修改某个元素，只能先删除再添加

学集合运算：交集、并集、差集、对称差集、子集和真子集

s1 = {1, 2, 3, 4, 5, 6, 7}
s2 = {5, 6, 7, 8, 9}

1）交集：&

集合1 & 集合2 - 获取两个集合公共的部分

print(s1 & s2)      # {5, 6, 7}

2）并集：|

print(s1 | s2)      # {1, 2, 3, 4, 5, 6, 7, 8, 9}

3）差集：-

集合1 - 集合2 - 获取在集合1中但是不在集合2中的所有的元素

print(s1 - s2)     # {1, 2, 3, 4}
print(s2 - s1)     # {8, 9}

4）对称差集: ^

集合1 ^ 集合2 - 获取只在集合1和只在集合2中的所有的元素

print(s1 ^ s2)     # {1, 2, 3, 4, 8, 9}

5）子集和真子集

集合1 >= 集合2 - 判断集合2是否是集合1的子集

集合1 > 集合2 - 判断集合2是否是集合1的真子集

print({100, 200, 300} >= {1, 2})   # False
print({1, 2, 3, 100, 200} >= {1, 2})      # True

集合相关操作

1) in 和 not in

print(10 in {10, 20, 30})    # True

2)max、min、sorted、sum、set、len

print(max({10, 3, 94}))    # 94
print(sorted({23, 9, 89, 67, 34}))      # [9, 23, 34, 67, 89]
print(sum({23, 45, 78, 9}))     # 155

print(len({23, 34, 56, 23, 23}))    # 3

作业

3.用三个集合表示三门学科的选课学生姓名(一个学生可以同时选多门课)
a. 求选课学生总共有多少人
b. 求只选了第一个学科的人的数量和对应的名字
c. 求只选了一门学科的学生的数量和对应的名字
d. 求只选了两门学科的学生的数量和对应的名字
e. 求选了三门学生的学生的数量和对应的名字

math={'小a','小b','小c','小e','小h'}
basketball={'小a','小d','小e','小f'}
sports={'小c','小d','小f'}

print(math | basketball | sports)

s=math -basketball -sports
print(s)

s=math - basketball - sports
m=basketball-math-sports
y=sports-math-basketball
print((s|m|y),len(s|m|y))

s=math & basketball-sports
m=math & sports-basketball
y=basketball & sports-math
print(len(s | m | y),(s | m | y))

s=math & basketball & sports
print(len(s),s)