一、元祖

元祖(tuple)就是不可变的列表
列表中除了增加、修改和删除相关的操作，其他的都适用于元祖
什么时候用？就是存到容器里的数据，不能被修改的时候使用
例如：星期几的对应的值

• 1.声明元祖

  tuple1 = (1, 2, 3, 4, 'a', True)
  print(tuple1)
  

• 2.元祖的查

  print(tuple1[0])
  print(tuple1[-1])
  

切片

  print(tuple1[:3])  

遍历

  for item in tuple1:
      print(item)

长度

  for index in range(len(tuple1)):
      print(tuple1[index])

• 3. + 和 *

  print((1, 2, 3) + ('a', 'b', 'c'))
  print((1, 'a') * 3)
  

• 4.in, not in

  a = 10
  print(a in (10, 2, 9, 9))
  print(a not in (10, 2, 9, 9))
  

练习：输入1~7的数字，对应输出是星期几，例如：输入1，就输出星期几。

  tuple1 = ('星期一', '星期二', '星期三', '星期四', '星期五', '星期六', '星期日')
  while True:
      input_value = int(input('请输入1~7'))
      print(tuple1[input_value-1])

二、字典

字典是一个容器类的数据类型，以键值对(key:value)的形式存储数据

键值对：键：值的形式存在。
值：可以是任何类型的数据；
键：理论上只能是不可变的数据类型的数据，实际开发中一般用字符串作为key(键)

字典是可变的(说明可以增、删、改、查)，但是是无序的(不能用下标来访问元素)

• 1.声明字典(dict)：

声明了一个字典对象，有两个键值对

  dict1 = {'name': '罗昊', 'age': 18}
  dict2 = {'score': 100, 10: 'aaa', (1, 3): [10, 23]}
  print(dict2)

注意：

  dict3 = {[10, 12]: 'abc'}  报错：可变的数据不能作为字典的key
  print(dict3)

声明一个字典，存储小明的姓名、年龄、成绩、颜值

  dict1 = {'name': '小明', 'age': 18, 'score': '优', 'face': 80}
  print(dict1)

• 2.查

• a.获取单个元素的值

通过key取获取值:字典名[key值]

  print(dict1['age'])

注意：使用字典名[key]的形式去获取字典中的元素时。
key值必须是在字典中存在的，否则报错

  print(dict1['abc'])  报错：KeyError: 'abc'

• b.通过get方法获取值：字典名.get(key值)

获取字典中，不确定key对应键值对的值是否存在时，就用get获取

  print(dict1.get('name'))

None:python中的一个特殊值，表示没有，类似c语言中的NULL

  print(dict1.get('abc'))   # 结果是None

获取字典中的'grade'对应的值，如果grade不存在就打印不存在，否则直接打印对应的值

  dict1 = {'name': '小明', 'age': 18, 'score': '优', 'face': 80}
  value = dict1.get('grade')
  if None == value:
      print('不存在')
  else:
      print(value)

• c.字典中的遍历元素(遍历字典)

  for x in dict1:
      print(x)    # 拿的是字典中所有的键
  
  for key in dict1:
      print(key, dict1[key])   # 拿的是元素
  

---

  print(dict1.items())   #dict_items([('name', '小明'), ('age', 18), ('score', '优'), ('face', 80)])

因为在获取键值对前需要一些转换的操作，对CPU的消耗很大，实际开发不建议用

  for key, value in dict1.items():
      print(key, value)

• 2.修改

通过key去拿到对应的元素，然后重新赋值

  dict5 = {'a': 1, 'b': 2, 'c': 3}
  dict5['a'] = 10
    print(dict5)

练习：将上面的字典中所有的值变为原来的三倍

  for key in dict5:
      dict5[key] *= 3
  print(dict5)

• 3.增加

通过key取值，然后赋值
(如果这个key不存在，就是添加。如果存在，就是修改key对应的值)
增加键值对：'d':4

  dict5['d'] = 4
  print(dict5)

  dict6 = {}
  dict6['name'] = '张三'
  dict6['color'] = 'red'
  dict6['color'] = 'green'
  print(dict6)    # {'name': '张三', 'color': 'green'}

注意：字典里的key是唯一的

  dict7 = {'a': 1, 'b': 2, 'a': 10}
  print(dict7)     # {'a': 10, 'b': 2}

• 4.删除(删除的是键值对)

a.del语句

格式：del 字典[key]

  dict1 = {'a': 10, 'b': 10.3, 'c': False, 'd': [1, 2, 3]}
  del dict1['b']
  print(dict1)    # {'a': 10, 'c': False, 'd': [1, 2, 3]}

b.pop方法

格式：字典.pop(key)

  dict1 = {'a': 10, 'b': 10.3, 'c': False, 'd': [1, 2, 3]}
  result = dict1.pop('a')
  print(dict1, result)   # {'b': 10.3, 'c': False, 'd': [1, 2, 3]} 10

popitem方法：随机删除(取出)一个元素

  dict1 = {'a': 10, 'b': 10.3, 'c': False, 'd': [1, 2, 3]}
  dict1.popitem()
  print(dict1)    # {'a': 10, 'b': 10.3, 'c': False}

练习：删除所有值为字符串的元素

  dict1 = {'a': 10, 'str': 'string', 'b': 10.3, 'c': False, 'd': [1, 2, 3]}
  for key in dict1.copy():
     value = dict1[key]   # 取键值对的值
      if isinstance(value, str):  # 判断是否是字符串
          dict1.pop(key)    # 移除key对应的键值对
  print(dict1)    # {'a': 10, 'b': 10.3, 'c': False, 'd': [1, 2, 3]}

三、补充

• 1.keys和values方法

  dict1 = {'a': 1, 'b': 2, 'c': 3}
  print(dict1)   # {'a': 1, 'b': 2, 'c': 3}
  

字典.keys():获取字典中所有的key，结果是一个列表

  print(dict1.keys())    # dict_keys(['a', 'b', 'c'])

字典.values():获取字典中所有的值，结果是一个列表

  print(dict1.values())    # dict_values([1, 2, 3])

• 2.update()

字典1.update(字典2)：用字典2中的元素去更新字典1中的元素

如果字典2中的键值对字典1中没有，就直接添加；如果有的话就修改。

  dict1.update({'d': 123, 'e': 'hhh', 'a': 100})
  print(dict1)    # {'a': 100, 'b': 2, 'c': 3, 'd': 123, 'e': 'hhh'}

• 3.in 和 not in

判断字典中是否有指定的key

  print('a' in dict1)   # True
  print(100 in dict1)   # False

四、集合

集合是一种容器类型，并且是无序的，元素的值是唯一的（不能重复），是可变的
是通过{}来储存元素，多个元素之间用逗号隔开。

• 1.声明集合(set)

  set1 = {1, 2, 3, 4, 1, 10}
  print(set1)    # {1, 2, 3, 4, 10}
  

将其他数据类型转换成集合时，有自带去重功能

将字符串转换成集合

  set2 = set('abcdefadkgkfl')
    print(set2)    # {'c', 'd', 'k', 'e', 'b', 'g', 'f', 'l', 'a'}

将列表转换成集合

  set3 = set([1, 2, 3, 4, 5, 6])
  print(set3)   # {1, 2, 3, 4, 5, 6}

将字典转换成集合(是将字典的key取出来作为集合的元素)

  set4 = set({'a': 1, 'b': 2})
  print(set4)   # {'a', 'b'}

练习：将字符串str1 = 'ajfdkcnckdsc'去重

  str1 = 'ajfdkcnckdsc'
  # list1 = list(str1)   # 将字符串转换成列表
  # set1 = set(list1)    # 将列表转换成集合
  # list1 = list1(set1)  # 将集合转换成列表
  set1 = set(str1)
  str1 = ''
  for item in set1:
      str1 += item
  print(str1)   # kdjsnfac

• 2.查

不能单独的获取某一个元素，只能通过遍历的方式去获取每一个元素

  set1 = set('12345678cvbh')
  for item in set1:
      print(item)

• 3.增加

a.集合1.update(集合2):将集合2中的元素添加到集合1中，自带去重

  set1 = set('123456')
  set2 = set('abcd1')
  set1.update(set2)
  print(set1)  # {'2', '6', 'd', '4', '5', 'c', '1', 'b', '3', 'a'}

b.add

集合.add(元素):将指定的元素添加到指定的集合中

  set1.add('aaa')
  print(set1)  # {'3', '1', 'd', 'a', '4', '5', 'aaa', '6', 'b', '2', 'c'}

• 4.删除

集合.remove(元素):将指定的元素从集合中删除

  set1.remove('1')
  print(set1)   # {'2', 'a', 'aaa', 'd', '6', '3', '4', '5', 'c', 'b'}

• 5.判断包含关系:>=、<=

python中的集合除了拥有作为容器相关操作以外，还拥有数学中集合的相关操作

集合1 >= 集合2：判断集合1是否包含集合2，结果是布尔值

  set1 = set('abcdef')
  set2 = set('abc')
  print(set1 >= set2)  # True

集合1 <= 集合2：判断集合2是否包含集合1，结果是布尔值

  print(set1 <= set2)

• 6. |, &, -, ^

  set1 = set('123456')
  set2 = set('456789')
  

a. |:求集合的并集

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

b. &:求交集，求set1和set2的公共部分

  print(set1 & set2)  # {'5', '4', '6'}

c. -:求的差集，在set1中，但是不在set2中的所有的元素

  print(set1 - set2)  # {'2', '3', '1'}

d. ^:获取set1和set2 中，除了公共部分以外的所有元素

  print(set1 ^ set2)   # {'1', '8', '7', '3', '2', '9'}

• 7. copy:将set1中所有元素取出来，创建一个新的集合

  print(set1.copy())   # {'2', '4', '3', '1', '5', '6'}
  

什么时候用集合：功能涉及到数学集合相关的操作的时候，就要想到用集合