day8总结
一、元祖
1.什么是元祖(tuple)
python提供的容器型数据类型,不可变并且有序。（元祖就是不可变的列表）
不可变 - 不支持增删改,只支持查
有序 - 每个元素对应一个确定的下标
2.字面量和元素
(元素1, 元素2, 元素3...)
其中的元素可以是任何类型的数据，并且类型可以不一样，同样的元素可以有多个
point = (100, 30)
print(point, type(point))
# 1.空的元祖: ()
tuple1 = ()
print(type(tuple1))
# 2.只有一个元素的元祖
tuple2 = (100,)
print(tuple2, type(tuple2))
# 3.直接将多个元素用逗号隔开，不加小括号表示也是一个元祖
tuple3 = 1, 2, 3
print(tuple3, type(tuple3))
3.元祖获取元素和列表一样
元祖[下标] - 获取列表中指定下标对应的元素
tuple4 = ('成都', '达州', '绵阳', '南充', '广元')
# 获取单个元素
print(tuple4[1], tuple4[-1])
获取部分元素(切片) - 结果是元祖
列表[开始下标:结束下标:步长]
# 获取部分
print(tuple4[0:3])
print(tuple4[::-1])
遍历
for city in tuple4:
print(city)
for index in range(len(tuple4)):
print(tuple4[index])
特殊的获取方式
- 变量1,变量2... = 元祖 -- 用前面的变量依次获取元祖元素的值。(要求前面变量的个数和元祖元素的个数一致)
point = (100, 200, 10)
x, y, z = point # x,y = (100, 200) <==> x, y = 100, 200
print(x, y, z)
- 变量1, 变量2 = 元祖 -- 通过带的变量获取元祖中剩余的部分;
注意：这个结构中带的变量只能有一个，不带的变量可以有多个
name, *scores = ('小明', 100, 89, 67, 99)
print(name, scores)
name, num, *scores = ('小明', 100, 89, 67, 99)
print(name, num, scores)
*info, num1, num2 = ('小明', 100, 89, 67, 99)
print(info, num1, num2)
info1, *nums, num1 = ('小明', 100, 89, 67, 99)
print(nums)
补充：*的用法
取元祖和列表中的数据
nums = (1, 2, 3)
nums2 = [11, 22, 33]
print(*nums, *nums2)
4、相关运算(和列表一样)
支持：
| 运算 | 方法 |
|---|---|
| + | 将两个元祖中的元素合并在一起产生一个新的元祖 |
| * | 元祖中的元素重复N次，产生一个新的元祖 |
| in | 判断元祖中是否存在指定的元素 |
| not in | 判断元祖中是否不存在指定的元素 |
| len() | 获取元祖中元素的个数 |
| max() | 获取序列中值最大的元素 |
| min() | 获取序列中值最小的元素 |
| sum() | 求序列中所有元素的和 |
| tuple() | tuple(数据) - 将其他数据转换成元祖;只有序列才可以转换成列表，并且所有的序列都能转化成元祖; |
tuple1 = (1, 2, 3)
tuple2 = ('aa', 'bb')
print(tuple1 + tuple2)
print(tuple1*3)
print('aaa' in tuple2)
join的使用
字符串.join(序列) - 将序列中的元素取出，用指定的字符串连接在一起。要求序列中的元素必须是字符串
new_str = ''.join(['aks', 'bos', 'cous'])
print(new_str, type(new_str))
二、字典
1.什么是字典(dict)
python提供的容器型数据类型，可变并且无序
可变 - 支持元素的增删改
无序 - 不支持下标操作
2.字面量和元素
用大括号括起来，里面多个键值对，每个键值对用逗号隔开。键值对就是字典的元素。
{key1:value1, key2:value2, key3:value3...}
键值对- 键/key:值/value(键值对); 键值对必须成对出现，而且脱离字典单独出现没有意义
键/key - 必须是不可变的, 而且是唯一的。实际一般将字符串作为键
值/value - 可以是任意类型的数据
注意，字典存储数据，实质是通过值来存储的。key是值对应的标签和获取值的方式
dict1 = {} # 空字典
print(type(dict1))
dict1 = {'a': 100, 10: 200, (1, 2): 'abc', 'a': 111, 'a': [1, 11, 111]}
print(dict1) # {'a': [1, 11, 111], 10: 200, (1, 2): 'abc'}, key唯一
# dict2 = {[1, 2]: 120} # TypeError: unhashable type: 'list'
3.什么时候使用字典：
多个没有相同意义的数据（需要区分）,就使用字典。例如：保存一个人的不同信息，一辆车的不同信息
存储的多个数据是有相同意义的数据(不需要区分),就使用列表.例如：保存一个班的学生信息，保存所有的价格
person = ['xiaohua', 18, 'girl', 160, 90, 89]
print(person[1])
person[-2]
person = {'name': 'xiaohua', 'age': 18, 'sex': 'girl', 'height': 160, 'weight': 90, 'score': 89}
print(person['age'])
4.字典元素的增删改查
1.查(获取值)
注意：字典中的键值对单独拎出来没有任何意义
a.字典[key] - 获取字典中key对应值
注意: 当key不存在的时候，会报KeyError
car = {'color': '黄色', 'type': '跑车', 'price': 500000}
print(car['color'])
print(car['price'])
# print(car['speed']) # KeyError: 'speed'
b.字典.get(key) - 获取字典中key对应值; 当key不存在的时候不会报错，并且取到一个默认值None
字典.get(key,值1) - 获取字典中key对应值;当key不存在的时候不会报错,并且取到指定的值1
print(car.get('type'))
print(car.get('speed'))
print(car.get('color', '红色')) # 黄色
print(car.get('speed', 0)) # 0
c.遍历字典
注意: 直接通过for-in遍历字典取到的是key
dict1 = {'a': 100, 'b': 200, 'c': 300}
# 遍历字典取到的是key(推荐使用)
for key in dict1:
# key
print(key, end=' ')
# value
print(dict1[key])
遍历字典的values(),获取所有的值
for value in dict1.values():
print(value)
遍历字典的items(),直接获取key和value（不建议使用）
for key, value in dict1.items():
print(key, value)
2.增、改
字典[key] = 值 - 当key不存在就是添加键值对; 当key存在的时候就是修改key对应的值
movie = {'name': '喜羊羊与灰太狼', 'type': '卡通', 'time': 120}
# 添加
movie['score'] = 7.9
print(movie)
# 修改
movie['type'] = '搞笑'
print(movie)
3.删(删除键值对)
a.del 字典[key] - 删除字典中指定的key对应的键值对
del movie['time']
print(movie)
b.字典.pop(key) - 取出字典中key对应的值
name = movie.pop('name')
print(movie, name)
5.字典支持的运算
| 运算 | 方法 |
|---|---|
| ==/!= | 判断两个字典是否相等，判断两个字典是否相等，只看键值对是否一样，不管键值对的顺序; |
| in | 判断元祖中是否存在指定的元素 |
| not in | 判断元祖中是否不存在指定的元素 |
| len() | 获取元祖中元素的个数 |
| max() | 获取序列中值最大的元素 |
| min() | 获取序列中值最小的元素 |
print({'a': 11, 'b': 22} == {'b': 22, 'a': 11}) # True
dict1 = {'a': 1, 'z': 2, 'c': 3}
print('a' in dict1) # True
print(1 in dict1) # False
# 获取字典中键值对的个数
print(len(dict1))
# 获取字典中key的最大值/最小值
print(max(dict1), min(dict1))
6.相关方法
1.将列表转换成字典
print(dict([(1, 2), ('a', 'b'), [10, 'abc']]))
2.字典转列表/元祖/集合都是将字典中的key取出来作为列表/元祖/集合的元素
dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}
print(list(dict2)) # ['name', 'color', 'height']
3.字典.clear() - 清空字典
注意：清空容器推荐使用clear操作，而不是重新赋一个空的容器
dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}
print(id(dict2))
dict2.clear()
print(dict2, id(dict2))
# 只有容器本身不存在的时候，可以使用
dict2 = {}
print(id(dict2))
4.字典.copy() - 复制字典的中的元素，产生一个新的字典
直接赋值，修改其中一个的元素，会影响另外一个
dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}
dict3 = dict2
print(dict3)
dict3['name'] = '小明'
print(dict3)
print(dict2)
拷贝赋值，会产生新的地址，赋值后相互不影响
dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}
dict4 = dict2.copy()
print(dict4)
del dict4['color']
print(dict4)
print(dict2)
- dict.fromkeys(序列, 值) -- 以序列中所有的元素作为key，指定的值作为value创建一个新的字典
new_dict = dict.fromkeys('abc', (10, 20, 30))
print(new_dict)
new_dict = dict.fromkeys(['name', 'age', 'tel'], 0)
print(new_dict)
6.字典.keys() - 将字典所有的key取出产生一个新的序列
7.字典.values() - 将字典所有的value取出产生一个新的序列
8.字典.items() - 将字典所有的key和value做为一个元祖取出产生一个新的序列
dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}
print(dict2.keys(), dict2.values(), dict2.items())
9.字典.setdefault(key, value=None)
字典.setdefault(key) - 当key不存在的时候，添加键值对key:None
字典.setdefault(key, value) - 当key不存在的时候，添加键值对key:value
注意：这个操作当key存在的时候，不会修改
dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}
dict2.setdefault('name2', '小胡')
dict2.setdefault('sex')
print(dict2)
- 字典1.update(字典2) - 使用字典2中的键值对去更新字典1;
如果字典2中的key，字典1中本身存在就是修改,不存在就添加
dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}
dict2.update({'height': 180, 'age': 18})
print(dict2)
dict2.update([('a', 100), ('age', 30)])
print(dict2)
三、集合
1.什么是集合（set）
可变的，无序的; 元素是唯一并且不可变
2.字面量
{元素1, 元素2, 元素3...}
set1 = {1, 23, 'abc'}
print(set1)
# set1 = {1, 23, 'abc', [1, 2]} # TypeError: unhashable type: 'list'
# 表示空集合
set2 = set()
print(type(set2))
# 集合自带去重功能
list1 = [1, 2, 1, 2, 2]
list1 = list(set(list1))
print(list1)
3.增删改查
1.查
集合不能单独的获取单个元素，只能一个一个的遍历
for item in set1:
print(item)
2.增
a.集合.add(元素) - 在集合中添加指定的元素
b.集合.update(序列) - 将序列中的元素添加到集合中
set1 = {1, 38, 90, 8}
set1.add('abc')
print(set1)
set1.update('abc')
print(set1)
set1.update({'aa': 10, 'bb': 20})
print(set1)
3.删
集合.remove(元素) --- 删除集合中指定的元素
set1 = {1, 38, 90, 8}
set1.remove(90)
print(set1)
4.数学集合运算
| 运算符 | 方法 |
|---|---|
| 交集(&) | 获取两个集合公共的元素产生一个新的集合 |
| 并集(丨) | 将两个集合中的元素合并在一起产生一个新的集合 |
| 差集(-) | 集合1 - 集合2：去掉集合1中包含集合2的部分,剩下的产生一个新的集合 |
| 补集(^) | 将两个集合合并在一起，去掉公共部分，剩下的部分产生一个新的集合 |
| 子集的判断 | 集合1>集合2 -> 判断集合1中是否包含集合2, 集合1<集合2 - 判断集合1中是否包含集合2 |
set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8}
# 交集
print(set1 & set2) # {4, 5, 6}
# 并集
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7, 8}
# 差集
print(set1 - set2) # {1, 2, 3}
# 补集
print(set1 ^ set2) # {1, 2, 3, 7, 8}
print({1, 2, 3, 9, 18} > {1, 2, 3, 0}) # False
print({1, 2, 3, 9, 18} > {1, 2, 3}) # True、
print({1, 2, 3} > {1, 2, 3}) # False
print({1, 2, 3} >= {1, 2, 3}) # True
