Day9-元组和集合

Day9-元组和集合

1. 元组

1. 什么是元组(tuple)

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

# 1) 空元组
t1 = ()
print(t1, type(t1))             # () <class 'tuple'>

# 2) 只有一个元素的元组      -   必须在唯一的元素后面加逗号：(元素,)
print([10], {'a': 10})          # [10] {'a': 10}

t2 = (100)
print(t2, type(t2))             # 100 <class 'int'>

t3 = (100,)
print(t3, type(t3), len(t3))      # (100,) <class 'tuple'> 1

# 3) 正常的元组
t4 = (10, 20, 'abc, 30')
print(t4)                       # (10, 20, 'abc, 30')

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

t6 = 100, 200, 300, 400 * 2
print(t6)                       # (100, 200, 300, 800)

t7 = (100, 200, 300, 400) * 2
print(t7)                       # (100, 200, 300, 400, 100, 200, 300, 400)

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

2. 元组的使用

# 2. 元组的使用
# 1) 元组是不可变的列表      -   列表相关操作和应用中，除了可变相关内容，其他的元组都支持
# a. 获取元素   -   列表怎么获取元素，元组就可以怎么获取
t8 = ('狂飙', '黑暗荣耀', '回家的诱惑', '三国演义', '琅琊榜', '甄嬛传')
# 查单个
print(t8[0], t8[-1])                # 狂飙 甄嬛传

# 切片
print(t8[1:-1])                     # ('黑暗荣耀', '回家的诱惑', '三国演义', '琅琊榜')
print(t8[0::2])                     # ('狂飙', '回家的诱惑', '琅琊榜')

print('----------------------- 华丽的分割线-----------------------')
# 遍历
for x in t8:
    print(x)

print('----------------------- 华丽的分割线-----------------------')

for index in range(len(t8)):
    print(index, t8[index])

print('----------------------- 华丽的分割线-----------------------')

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

# b. 加、乘、比较大小、in 和 not in
t1 = (10, 20, 30)
t2 = (100, 200)
print(t1 + t2)

print(t1 * 2)

print(t1 > t2)

print(10 in t1)

print(10 not in t2)

# 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

t1 = (10, 20)
m, n = t1
print(m, n)                 # 10 20

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

print(list(enumerate(list1)))       # [(0, 100), (1, 200), (2, 300)]

for x in enumerate(list1):
    print(x)

list2 = [('小花', 18, '女'), ('小明', 20, '男'), ('张三', 30, '男')]
for name, age, gender in list2:
    print(name, age, gender)

2. 集合

1. 什么是集合(set)

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

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

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

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

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

# 4) 集合中的元素是唯一的(自带去重功能)
s3 = {10, 20, 30, 10, 10, 20}
print(s3)           # {10, 20, 30}

names = ['李四', '张三', '王五', '小明', '李四', '张三', '王五']
print(set(names))       # {'小明', '张三', '王五', '李四'}

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}

print({1} < {1, 2, 3})                  # True

# 注意：这里的比较运算符不是在比较大小
print({100, 200, 300, 400} > {1, 2})        # False

3. 字符串

1. 什么是字符串(str)

# 1. 什么是字符串(str)
"""
1) 字符串是容器型数据类型(能同时保存多个文字符号); 将单引号、双引号、三个单引号、三个双引号作为容器的标志，里面的每一个符号都是字符串中的元素

2) 字符串不可变; 字符串有序(顺序影响结果，支持下标操作)

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

"""

str1 = '小明'
str2 = "小明"
str3 = '''小明'''
str4 = """小明"""
print('----------------------- 华丽的分割线-----------------------')

msg = '床前明月光,' \
      '疑是地上霜'
print(msg)

msg = """床前明月光,
疑是地上霜"""
print(msg)

str5 = 'mK,.?X嘻嘻12345🙂'
print(str5)

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

str7 = '  '         # 引号里面加空格后，就不是空串了
print(str7, type(str7), len(str7))

2. 字符

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

str1 = 'abc123你好'
print(str1)

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

str3 = 'a\nbc\tasd'
print(str3)

str4 = 'it\'s ok'
print(str4)

str5 = "it's ok"
print(str5)

str6 = "她说：\"可以吃饭咯\""
print(str6)

str7 = '她说："可以吃饭咯"'
print(str7)

str8 = 'abc\\n123'
print(str8)

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

3. r字符

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

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

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