day9-元素和集合

day9-元素和集合

字典

1. 相关操作

   1. in 和 not in

      字典的in和not in 判断的是键是否存在

      dict1 = {'a': 10, 'b': 20, 'c': 30}
      print(10 in dict1)      # False
      print('a' in dict1)     # True
      

2. 相关函数

   1. len(字典)–获取字典的长度

      print(len(dict1))
      

   2. dict(数据)-将指定的数据转换成字典

      对数据的要求:

      1. 数据必须是一个序列(容器)
      2. 序列中的每个元素必须是有且只有两个元素的小序列

      data1 = [[10, 20], [20, 30], ['a', 'b']]
      print(dict(data1))      # {10: 20, 20: 30, 'a': 'b'}
      
      print(dict(['ab', 'cd', '12']))     # {'a': 'b', 'c': 'd', '1': '2'}
      
      print(dict(['ab', [10, 20], range(2)]))     # {'a': 'b', 10: 20, 0: 1}
      

   3. list(字典) - 将字典转换成列表的时候，是将字典中所有的键作为列表的元素

   dict1 = {'a': 10, 'b': 20, 'c': 30}
   print(list(dict1))      # ['a', 'b', 'c']
   

3. 相关方法：字典.xxx()

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

   2. 字典.copy() - 复制字典产生一个一摸一样的新字典并且返回

   3. 字典.keys() - 获取字典所有的键，返回一个序列
      字典.values() - 获取字典所有的值，返回一个序列
      字典.item() - 将字典转成一个序列，序列中的元素是每个键值对对应的元组

      print(dict1.keys())     # dict_keys(['a', 'b', 'c'])
      print(dict1.values())   # dict_values([10, 20, 30])
      print(dict1.items())    # dict_items([('a', 10), ('b', 20), ('c', 30)])
      

   4. 字典1.update(字典2) - 将字典2中所有的键值对都添加到字典1中

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

元组

1. 什么是元组(tuple)

   1. 元组是容器型数据类型；将()作为容器的表示，里面多个元素用逗号隔开：(数据1， 数据2， 数据3, …)
   2. 元组是不可变的(不支持增删改)；元组是有序的(顺序影响结果；支持下标操作)
   3. 任何类型的数据都可以作为元组中的元素

   1)空元组

   t1 = ()
   print(t1)
   

   2)只有一个元素的元组 - 必须在唯一的元素后加逗号

   # print([10], {'a':10})
   t2 = (100,)
   print(t2, type(t2))
   

   3)正常的元组

   t3 = (10, 20, 'abc', 30)
   print(t3)
   

   4)在没有歧义的情况下，元组()可以省略 - 直接将多个数据用逗号隔开，也是一个元组

   t4 = 100, 200, 300, 400
   print(t4)
   

2. 元组的使用

   1. 元组是不可变的列表 - 列表相关操作和应用中，除了可变相关内容，其他元组都支持

      1. 获取元素 - 列表怎么获取元素，元组就可以怎么获取

         t5 = ('狂飙', '黑暗荣耀', '回家的诱惑', '三国演义', '琅琊榜', '甄嬛传')
         print(t5[0], t5[-1])
         print(t5[1:-1])
         print(t5[0:2])
         
         for index in range(len(t5)):
             print(index, t5[index])
         

      2. 加、乘、比较大小、in 和 not in

         t1 = (10, 20, 30)
         t2 = (100, 200)
         print(t1 + t2)  # (10, 20, 30, 100, 200)
         
         print(t1 * 2)  # (10, 20, 30, 10, 20, 30)
         
         print(t1 > t2)  # False
         
         print(10 in t1)  # True
         

      3. 相关函数:sum, max, min, sorted, len, tuple

      4. 相关方法:元组.count(元素)、元组.index(元素)

3. 获取元组和列表元素的另外一种方式

   list1 = [100, 200, 300]
   x, y, z = list1
   
   t1 = (10, 20)
   m, n = t1
   print(m, n)
   
   # [(0,100),(1,200),(2,300)]
   # x = (0, 100)
   # x = (1, 200)
   # index, item = (0, 100)
   for index, item in enumerate(list1):
       print(index, item)
   
   list2 = [('小花',18,'女'),('小明',20,'男'),('张三',30,'男')]
   for name,age, gender in list2:
       print(name,age, gender)
   

集合

1. 什么是集合(set)

   1. 集合是容器型数据类型;将1作为容器的标志里面多个数据用逗号隔开:{数据1，数据2，数据3，…}
   2. 集合是可变的(支持增删改);集合是无序的(顺序不影响结果；不支持下标操作)
   3. 集合对元素的要求和字典对键的要求一样:不可变类型的数据、是唯一的(集合自带去重功能)

   1)空集合

   s1 = set()
   print(s1, type(s1), len(s1))
   

   2)集合是无序的

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

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

   s2 = {'abc', 10, 12.3, 10, 20}
   # s2 = {'abc', 10, 12.3, [10, 20]}      # 报错
   

   4)集合的元素是唯一的

   s2 = {10, 20, 30, 10, 10, 20}
   print(s2)   # {10, 20, 30}
   
   names = ['张三','李四','张三','小明','张三','小明']
   print(set(names))   # {'小明', '李四', '张三'}
   

2. 数学集合运算: 交集、并集、差集、对称差集、子集和真子集

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

   1. 交集 - 求两个集合的公共部分

      # 集合1 & 集合2
      print(s1 & s2)      # {5, 6, 7}
      

   2. 并集 - 将两个集合合并成一个集合

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

   3. 差集 - 去掉一个集合中包含在另外一个集合的部分，剩下的部分

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

   4. 对称差集 - 去掉两个集合公共部分后剩下的部分

      # 集合1 ^ 集合2
      print(s1 ^ s2)      # {1, 2, 3, 4, 8, 9, 10}
      a.子集:
      集合1 >= 集合   -   判断集合2是否是集合1的子集
      集合1 <= 集合   -   判断集合1是否是集合2的子集
      
      b.真子集:
      集合1 > 集合   -   判断集合2是否是集合1的真子集
      集合1 < 集合   -   判断集合1是否是集合2的真子集
      

   5. 子集、真子集

      # {1，2，3}的子集:{}、{1}、{2},、{3}、{1，2}、{1，3}、{2，3}、{1，2，3}
      # {1，2，3}的真子集:{}、{1}、[2}、{3}、{1，2}、{1，3}、{2，3}
      #a.子集: 集合1 >= 集合2 - 判断集合2是否是集合1的子集
      
      # 注意:这儿的比较运算符不是比较大小
      print({100, 200, 300, 400} > {1, 2})        # False
      

字符串

1. 什么是字符串(str)

   1. 字符串是容器型数据类型(能同时保存多个文字符号);
      将单引号、双引号或者三个单引号、三个双引号作为容器的标志,里面的每一个符号都是字符串中的元素
   2. 字符串不可变；字符串有序
   3. 字符串的元素:
      字符串引号中每一个独立的符号都是字符串的元素，字符串的元素又叫字符；
      任何文字符号都可以是字符串的元素（包括英文符号、中文符号、阿拉伯数字、韩语、日语、 …、表情符号等）

   str1 = '小明'
   str2 = "小明"
   str3 = '''小明'''
   str4 = """小明"""
   
   msg = '''床前
   明月光,
   疑是地
   上霜。'''
   print(msg)
   
   # 空串    -   引号中没有任何符号的字符串(引号中有空格的树候不是空串)
   str6 = ''
   print(type(str6), len(str6))
   

2. 字符 - 字符串每一个独立的符号(字符串的元素)

   字符串中的字符分为两种:普通字符、转义字符
   1)普通字符-在字符串中表示符号本身的字符就是普通字符
   2)转义字符-在字符串中有特殊意义或者特殊功能的符号就是转义字符(在特定的符号前加来表示特殊意义或者特殊功能);
   \n - 换行(相当于按回车)
   \t - 水平制表符（相当于按一次tab键）
   ’ - 表示一个普通的单引号
   " - 表示一个普通的双引号
   \ - 表示一个普通的反斜杠

   str1 = 'abc12你好'
   print(str1)     # abc12你好
   
   str2 = '\m\h'
   print(str2)
   
   str2 = '\tabc\n123'
   print(str2)
   
   #str3 = 'it's ok! '
   str4= "it's ok!"
   print(str4)
   
   str4 = 'it\'s ok!'
   print(str4)
   
   str5 = "i say:\"good good study!\""
   print(str5)
   
   str6 = 'abc\ln123'
   print(str6)
   

3. r字符串

   #在字符串的引号前面加 r 或者 R ，可以让字符串中所有的转义字符功能消失(让所有字符都变成普通字符)
   str1 = r'\tabc\n123'
   print(str1)