元组和集合

一、字典

1. 相关操作

   1)字典不支持加法运算、乘法运算和比较大小

   2)字典的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(数据) - 将指定的数据转换成字典

   对数据的要求：

   a.数据必须是一个序列（容器）

   b.序列中的每个元素必须是有且只有两个元素的小序列

   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}
   print(dict([('name', '小明'), ('age', 18), ('gender', '男')]))
   print(dict([[0,20],[0,2]]))
   
   

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

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

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

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

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

   字典.keys() - 获取字典所有的键，返回一个序列

   字典.values() - 获取字典所有的值，返回一个序列

   字典.items() - 将字典转成一个序列，序列中的元素是每个键值对应的元组

   dict1 = {'a': 10, 'b': 20, 'c': 30}
   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}
   dict2 = {'xiao':'wu'}
   dict1.update({100:200,200:300,'a':100})
   print(dict1)# {'a': 100, 'b': 20, 'c': 30, 100: 200, 200: 300}
   dict1.update(dict2)
   print(dict1)
   

二、元组

1. 什么是元组(tuple)

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

   a.空元组

   t1 = ()
   print(t1, type(t1))
   

   b.只有一个元素的元组 - 必须在唯一的元素后加逗号：(元素,)

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

   c.正常的元组

   t3 = (10, 20, 'asd', 100)
   print(t3)
   

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

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

2. 元组的使用

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

   a.获取元组 - 和列表一样[三种：列表[下标]、列表[开始下标：结束下标：步长]、遍历]

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

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

   t1 = (10,20,30)
   t2 = (15,10)
   print(t1 + t2)
   

   c.相关函数：sum、max、min、sorted、len、tuple

   d.相关方法：元组.count(元素)、元组.index(元素)

三、集合

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

a.空集合

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

b.集合是无序的

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

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

s2 = {'zxc', 10, 12.3}
# s3 = {'zxc', 10, 12.3, [10,20]} #会报错，unhashable type: 'list'，list是可变类型的数据

d.集合的元素是唯一的（自带去重功能）

s2 = {1,2,3,4,5,2,1,3,4}
print(s2)

names = ['小爱','小爷','asc','as','asc','小爷']
print(set(names))

应用：1）去重；2）数学集合运算

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}

# 5)子集和真子集
"""
a.子集：
集合1 >= 集合2 - 判断集合2是否为集合1的子集
集合1 <= 集合2 - 判断集合1是否为集合2的子集

b.真子集
集合1 > 集合2 - 判断集合2是否为集合1的子集
集合1 < 集合2 - 判断集合1是否为集合2的子集

"""
# {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({1} < {1, 2, 3}) #True
# 注意：这里的比较运算符不是比较大小
print({100, 200, 300, 400} > {1, 2}) #False

四、字符串

1. 什么是字符串(str)

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

   str1 = '小爷'
   str2 = "小爷"
   str3 = '''小爷'''
   str4 = """小爷"""
   msg = '床前明月光，\n疑是地上霜'
   print(msg)
   
   print('-------------------------')
   msg = '''床前
   明月光，
   疑是地上霜
   '''
   print(msg)
   
   
   str5 = '10,20？( ⊙ o ⊙ )是的'
   print(str5)
   
   #空串 - 引号中没有任何符号的字符串(引号中有空格的时候不是空串)
   str6 = ''
   print(type(str6),len(str6))
   
   

2. 字符 - 字符串每一个独立的符号（字符串的元素）

   字符串中的字符分为两种：普通字符、转义字符
   1)普通字符 - 在字符串中表示符号本身的字符就是普通字符
   2)转义字符 - 在字符串中有特殊意义或者特殊功能的符号就是转义字符（在特定的符号前加\，来表示特殊意义或者特殊功能）

   # \n - 换行（相当于按回车）"
   # \t - 水平制表符（相当于按一次tab键）
   # \\ - 表示一个普通的反斜杠
   # \'  - 表示一个普通的单引号
   # \" - 表示一个普通的双引号
   

   str1 = 'asdf'
   print(str1) #asdf   打印结果和本身一样
   # 并不是所有的符号前面加\都会变成转义字符
   str2 = '\m\h'
   print(str2) # \m\h
   
   str3 = 'it\'s ok!'
   print(str3)
   str4 = "i say:\"good good study!\""
   print(str4)
   
   str5 = 'abc\n123'
   print(str5)
   str6 = 'abc\\n123'
   print(str6)
   

3. r字符串

# 在字符串的引号前面加r或者R，可以让字符串中所有的转义字符功能消失（让所有字符都有变成普通字符）
str1 = r'\tabc\n123'
print(str1) #\tabc\n123
path = R'C:\names\proms\python\test\a.txt'
print(path)