day9-TupleAndSet总结

day9-TupleAndSet总结

01.review

1.1 字典

# 1)同时保存多个意义不同数据
# 2)什么是字典（dict）
# 容器{键1:值1, 键2:值2, ....}
# 可变的；无序的
# 键 -   不可变类型数据；唯一
# 值 -   任何类型

# 3)增删改查
# a.查   -   查单个(字典[键]、字典.get(键)、字典.get(键,默认值)、遍历)
# b.增   -   字典[键]   =   值、字典。setdefault(键，值)
# c.删   -   del 字典[键]、字典.pop(键)
# d.改   -   字典[键]   =   值

02.dict - 字典

2.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.2 相关函数

# 1)len(字典) -   获取字典的长度
# 2)dict()  -   将指定的数据转换成字典
# 对数据的要求：
# a.数据必须是一个序列(容器)
# b.序列中每个元素必须是有且只有两个元素的小序列

data = [[10,20],[20,30],['a','b']]
print(dict(data))   # {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','男')]))  # {'name': '小明', 'age': 18, 'gender': '男'}

# 3) list(字典)   -   将字典转换成列表的时候，是将字典中所有的键作为列表的元素
dict1 = {'a': 10 ,'b': 20, 'c': 30}
print(list(dict1))  # ['a', 'b', 'c']

2.3 相关方法：字典.xxx（）

# 1)字典.clear()  -   清空字典
# 2)字典.copy()   -   复制字典产生一个一模一样的新字典并且返回
# 3)
# 字典.key()  -   获取字典所有的键，返回一个序列
# 字典.values()   -   获取字典所有的值，返回一个序列
# 字典.items()    -   将字典转换成一个序列，序列中的元素是每个键值对应的元组

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)    # {'a': 100, 'b': 20, 'c': 30, 100: 200, 200: 300}

03.tuple - 元组

3.1 什么是元组

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

3.1.1 空元组

t1 = ()
print(t1)

3.1.2 只有一个元素的元组

# 必须在唯一的元素后面加逗号：(元素,)
t2 = (100,)
print(t2,type(t2),len(t2))  # (100,) <class 'tuple'> 1

3.1.3 正常的元组

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

# 4)在没有歧义的情况下，元组的()可以省略 -   直接将多个数据用逗号隔开也是一个元组
t4 = 100, 200 ,300 ,400
print(t4)

# 使用元组的实际情况：一般不会主动使用元组保存多个数据；但遇到元组的时候必须会使用元组。

3.2 元组的使用

# 1)元组是不可变的列表   -   列表相关操作和应用中，除了可变相关内容，其他元组都支持
# a.获取元素    -   列表怎么获取元素，元组就可以怎么获取

print(t5[0],t5[-1]) # 狂飙 甄嬛传
print(t5[1:-1])
print(t5[0::2])
for x in t5:
    print(x)

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 = (100 , 200)
print(t1 + t2)  # (10, 20, 30, 100, 200)

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

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

3.3 获取元组和列表元素的另一种方式

# 1)让变量的个数和列表或者元组中的个数保持一致，来依次获取列表或者元组的元素
list1 = [100 ,200 ,300]
x , y, z =list1
print(x,y,z)    # 100 200 300

for index,item in enumerate(list1):
    print(index,item)

04.set - 集合

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

4.1 空集合

s1 = set()
print(s1,type(s1),len(s1))  # set() <class 'set'> 0

4.1.2集合是无序的

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

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

# s1  =   {'abc',10 ,12.3,[10, 20]}
s2  =   {'abc',10 ,12.3,(10, 20)}

4.1.4 集合的元素是唯一的

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

4.2 数学集合运算：交集、并集、差集、对称差集、子集和真子集

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

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

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

4.2.2 并集 - 将两个集合合并成一个集合

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

4.2.3 差集 - 去掉一个集合中包含在另一个集合的部分剩下的部分

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

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

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

4.3.5 子集、真子集

"""
a.子集：
集合1 >= 集合2  -   判断集合2是否是集合1的子集
集合1 <= 集合2  -   判断集合1是否是集合2的子集

b.真子集
集合1 > 集合2  -   判断集合2是否是集合1的真子集
集合1 < 集合2  -   判断集合1是否是集合2的真子集
"""
print({1} < {1,2,3})    # True

# 注意:这里的比较运算符比较的不是比较大小

05.string - 字符串

5.1 什么是字符串

"""
1）字符串是容器型数据类型(能同时保存多个文字符号);
   将单引号、双引号或者三个单引号、三个双引号作为容器的标志

2)字符串不可变；字符串有序

3)字符串的元素:
    字符串引号中每一个独立的符号都是字符串的元素，字符串的元素又叫字符；
    任何文字符号都可以是字符串的元素(包括英文符号、中文符号、阿拉伯数字、韩语、日语...表情符号等)
"""

str1 = '小明'
str2 = "小明"
str3 = '''小明'''
str4 = """小明"""

msg = '''床前明月光，
疑是地上霜。'''

print(msg)

# 空串    -   引号中没有任何符号的字符串(引号中有空格的时候不是空串)
str6 = ''
print(type(str6),len(str6))

5.2 字符

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

str1 = 'abc12你好'
print(str1) # abc12你好

str2 = '\tabc\n123'
print(str2)

# 并不是所有的符号前加 \ 都会变成转义字符
str2 = '\h\m'
print(str2) # \h\m

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