day9-TupleAndSet

day9-TupleAndSet

01dict

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))   # 3

(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', 10), ('gender', '男')]))  # {'name': '小明', 'age': 10, 'gender': '男'}

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

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

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

(1) 字典.clear() - 清空字典
(2) 字典.copy() - 复制字典产生一个一模一样的新字典并且返回
(3) 字典.keys() - 去哦取字典所有的键，返回一个序列
字典.valus() - 获取字典所有的值，返回一个序列
字典.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) 字典.update(字典2) - 将字典2中所有的键值对都添加到字典1中

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

02tuple

1.什么是元组(tuple)

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

# 1) 空元组
t1 = ()
print(t1, type(t1))   # 因不可变 所以一直都是空元组

# 2) 只有一个元素的元组 - 必须在唯一的元素后面加逗号：(元素,)
t2 = (100)
t22 = (101,)
print(t2, type(t2), t22, type(t22))

# 3) 正常的元组
t3 = (10, 20, 'abc', 30)
print(t3)
print("----------------1.3)-----------------------")

# 4) 在没有歧义的情况下，元组的()可以省略 - 直接将多个数据用逗号隔开，也是一个元组
t4 = 100, 200, 300, 400
print(t4)
print("----------------1.4)-----------------------")
# 使用元组的实际情况：一般不会主动使用元组保存多个数据；但是在遇到元组时必须会使用元组。

2.元组的使用

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

t5 = ('狂飙', '黑暗荣耀', '回家的诱惑', '三国演义', '甄嬛传')
print(t5[0],t5[-1])
print(t5[1:-1])
print(t5[0::2])
# 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
c.相关函数：sum、max、min、sorted、len、tuple()
d.相关方法：元组.count(元素)、元组.index(元素)

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

(1) 让变量的个数和列表或者元组中元素的个数保持一致，来以此获取列表或者元组中的元素

list1 = [100, 200, 300]
x, y, z = list1
print(x, y, z)

t1 = (10, 20)
m, n = t1
print(m, n)
print("------------------------3.1)---------------------")

# [(0,100), (1,200), (2,300)]
# x = (0,100)
# x = (1,200)
# index, item = (0,100)
for x in enumerate(list1):
    print(x)

list2 = [('小花', 18, '女'), ('小名', 13, '男'), ('小王', 30, '男')]
for name, age, gender in list2:   #--------enumerate?
    print(name, age, gender)

03set

1.什么是集合(set)

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

# 1) 空集合
s1 = set()
print(s1, type(s1),len(s1))    # set() <class 'set'> 0

# 2) 集合是无序的
print({10, 20, 30} == {20, 10, 30})    # True

# 3) 集合的元素必须是不可变类型的数据
s2 = {'abc', 10, 12.3, (10, 20)}
print(s2)

# s22 = {'abc', 10, 12.3, [10, 20]}   # 报错
# print(s22)

# 4) 集合的元素是唯一的
s4 = {10, 20, 30, 10, 10, 20}
print(s4)            # {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}

# 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

04string

1.什么是字符串(str)

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

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

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

print(msg)
print('---------------------------------------华丽的分割线------------------------------------')
msg = '''床前
明月光,
疑是地
上霜。'''
print(msg)

str5 = 'mK,.?换手》？123😊'
print(str5)

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

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

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

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

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

str2 = '\tabc\n123'
print(str2)   # 	abc 换行 123

# 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\\n123'
print(str6)
print('---------------------------------------华丽的分割线------------------------------------')
path = 'C:\\names\\proms\\python\\test\\a.txt'
print(path)

3. r字符串

在字符串的引号前面加 r 或者 R，可以让字符串中所有的转换义字符功能消失(让所有字符都变成普通字符)

str1 = r'\tabc\n123'
print(str1)     # \tabc\n123

path = R'C:\names\proms\python\test\a.txt'
print(path)