day 09 元祖、字典、集合
Date:2019.4.24
内容纲要：
xmind09.jpg
一、元祖（tuple）
1.什么是元祖（tuple）
元素是python提供的容器型数据类型（序列），不可变，有序
元祖就是不可变的列表，一般保存一些不让修改的数据
（元素1，元素2，元素3，...）
2.元祖中的元素
空的元祖:
tuple1 = ()
print(tuple1, type(tuple1))
1）元素个数是1的元祖：如果一个元祖中只有一个元素，这个元素后面必须加逗号！
tuple2 = (10,)
print(tuple2, type(tuple2))
2）元祖数据中小括号可以省略。（多个数据直接用逗号隔开，表示的是一个元祖）
tuple3 = 10, 23, 89, 10
print(tuple3, type(tuple3))
3.获取元素：和列表一样
tuple2 = ('周一', '周二', '周三', '周四', '周五')
print(tuple2[1])
print(tuple2[1:])
for item in tuple2:
print(item)
1)让变量的个数和元祖中元素的个数保持一致，来一一获取元祖中每个元素的值
point = (100, 50)
x, y = point
print('x:', x, 'y:', y)
a, b, c = 10, 20, 30 # a, b, c = (10, 20, 30)
2)让多个变量同时获取元祖中多个元素的时候，可以在一个变量前加*将这个变量变成一个列表，来获取不带 *的变量获取后剩下的数据。（【注】：带 *的变量只能有一个’）
student = ('小明', 18, 89, 68, 89, 90, 100)
name, age, *scores = student
print(name, age, scores)
name, *scores, age = student
print(name, age, scores)
*items, a, b =student
print(items, a, b)
二、字典
1.什么是字典（dict）
字典是python提供的容器型数据类型（序列），可变，无序
2.字典中的元素
- {键值对1，键值对2，键值对3，...} - 字典的元素就是键值对
- 键值对 - 以'键：值'的形式成对出现
- 键（key） - 要求不可变，唯一(建议用字符串作为key，用来对值进行说明和区分的)
- 值（value） - 任何类型的数据都可以作为值，
dict1 = {10: 100, 'name': 100, (1, 2): 100}
print(dict1)
用一个变量保存一个学生的信息：
student = ['李卓然', 18, '女', 'stu001', 89, 155, 50]
student2 = ['李卓然', 30, '女', 'stu001', 33, 155, 50]
print(student[0], student[1])
student = {'name': '李卓然', 'age': 18, 'gender': '男', 'scores': 20}
print(student['name'], student['age'], student['scores'])
3.元素的操作
1）查 - 获取值
- 字典[key] - 获取字典中key对应的value。（如果key不存在会报错！）
- 字典.get(key) - 获取字典中key对应的value。（如果key不存在不报错，结果是None）
- 字典.get(key, 默认值) - 获取字典中key对应的value。（如果key不存在不报错，结果是默认值）
dog = {'name': '旺财', 'color': '黄色', 'age': 3, 'type': '柯基'}
print(dog['type'])
# print(dog['gender']) #keyError: 'gender'
print(dog.get('name'))
print(dog.get('gender'))
print(dog.get('age', 100))
print(dog.get('gender', '公狗'))
2）.遍历字典
直接通过for循环遍历字典的时候，获取到的是所有的key
# 1.直接遍历
for key in dog:
print(key, dog[key])
for value in dog.values():
print(value)
print('==================')
for key, value in dog.items():
print(key, value)
3)增、改
字典[key] = value - 如果key存在，修改key对应的值；如果key不存在，添加键值对
class1 = {'name': 'py1902', 'address': '19楼5教室'}
print(class1)
class1['num'] = 50
print(class1)
# 改
class1['name'] = 'python1902'
print(class1)
4)删
- del 字典[key] - 删除字典中指定key对应的键值对，若果key不存在会报错
- 字典.pop(key) - 取出字典中key对应的值。如果key不存在会报错
class2 = {'name': 'python1902', 'address': '19楼5教室', 'num': 50}
del class2['num']
print(class2)
name = class2.pop('name')
print(class2, name)
4.字典相关操作
1)运算符：不支持数学运算，比较运算符只支持比较相等不支持比较大小
print({'a': 100, 'b': 10} == {'a': 100, 'b': 10})
print({'a': 100, 'b': 10} == {'b': 10, 'a': 100})
2）in /not in
key in 字典 - 字典中是否存在指定的key
class2 = {'name': 'python1902', 'address': '19楼5教室', 'num': 50}
print('name' in class2)
print(50 not in class2)
3)len
print(len(class2))
4)dict
能转换成字典的数据要求：数据本身是序列序列中的每个元素也是长度是2的序列，并且小序列中第一个元素是不可变的
data = [(1, 2), ['a', 23]]
print(dict(data))
dict2 = {'a': 10, 'b': 20}
print(list(dict2))
5.相关方法
1）clear
字典.clear() - 清空字典
dict2 = {'a': 10, 'b': 20}
dict2.clear()
print(dict2)
2)copy
**字典.copy() ** - 拷贝字典中的键值对产生一个新的字典
dict2 = {'a': 10, 'b': 20}
dict3 = dict2
dict3['a'] = 100
print(dict2) # {'a': 100, 'b': 20}
dict2 = {'a': 10, 'b': 20}
dict3 = dict2.copy()
dict3['a'] = 100
print(dict2) # {'a': 10, 'b': 20}
3)fromkeys(序列，值)
dict.fromkeys(序列，值) - 创建一个新的字典，字典的key是序列的元素，key对应的value是值
new_dict = dict.fromkeys('hello', 100)
print(new_dict)
4) keys, values, items
- 字典.keys() - 获取字典中所有的key，结果是一个序列
- 字典.values() - 获取字典中所有value，结果是一个序列
- 字典.item() - 获取字典中的key和value，key和value以元祖的方式返回
students = {'name':'张三', 'age': 18, 'stu_id': 'stu001','gender': '女'}
print(students.keys())
print(students.values())
print(students.items())
5)setdefault
字典.setdefault(key,value) - 添加键值对
students.setdefault('tel','18648606874')
print(students)
6)update
字典1.update（字典2） - 使用字典2中的键值对取更新字典1（不存在添加、存在修改）
dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'b': 200, 'd': 300,'e': 400}
dict1.update(dict2)
print(dict1) #{'a': 1, 'b': 200, 'c': 3, 'd': 300, 'e': 400}l
三、集合
1.什么是集合（set）
容器型数据类型（序列），可变、无序
2.集合中的元素
{元素1， 元素2， 元素3，...}
元素：不可变、唯一（自带去重功能）
【注】{}不能表示空集合，set（） - 空集合
set1 = set()
set2 = {1, 'abc', (1, 3), False, 1, 1, 1} # {False, 1, 'abc', (1, 3)}
print(set2)
str1 = 'hekldskjflsadsaaa'
print(set(str1))
list1 = [1, 34, 34, 2, 2]
print(list(set(list1))) # [1, 34, 2]
3.元素相关操作
1）查
集合不能单独获取指定的某一个元素，只支持遍历
set3 = {12, 34, 56, 2, 7, 88}
for x in set3:
print(x)
2) 增
集合.add(元素) - 往集合中添加一个元素
集合.update(序列) - 将序列中的元素添加到结合中去（自带去重）
set1 = {1}
print(set1)
set1.add(100)
print(set1)
set1.update('abc')
print(set1)
set1.update({'name': '张三', 'age': 20})
print(set1)
3）删
集合.remove(元素) - 删除集合中制定的元素（元素不存在会报错）
set4 = {1, 'a', 100, 'b', 'name', 'age', 'c'}
set4.remove(100)
print(set4)
4.数学集合运算（*）
1)并集：|
集合1|集合2 -- 将两个集合中的元素合并产生新的集合
set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8}
print(set1 | set2)
2）交集：&
求两个集合公共的部分
set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8}
print(set1 & set2)
3）差集：-
集合1 - 集合2 -- 获取集合1中除了集合2以外的部分
set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8}
print(set1 - set2)
print(set2 - set1)
4）对称差集：^
集合1^集合2 - 两个集合除了公共部分以外的部分
set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8}
print(set1 ^ set2)
5)包含关系
集合1 >= 集合2 - 集合1中是否包含集合2
集合1 <= 集合2 - 集合2中是否包含集合1
set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8}
print({5, 6, 7, 8, 9} >= {1, 2, 3})
print({5, 6, 7, 8, 9} >= {5, 9})
