day9 字典、元组、集合、字符串

day9 字典、元组、集合、字符串

字典

1. 排序高级用法

• 将学生信息按分数从大到小排序

stus = [
    {'name': '小明', 'age': 17, 'scores': 100, 'tel': '17867542300', 'gender': '男'},
    {'name': '喃喃', 'age': 28, 'scores': 60, 'tel': '965489558', 'gender': '女'},
    {'name': '小华', 'age': 18, 'scores': 93, 'tel': '165332300'},
    {'name': '小红', 'age': 16, 'scores': 45, 'tel': '1335642300', 'gender': '男'},
    {'name': '小李', 'age': 32, 'scores': 73, 'tel': '1064342308'},
    {'name': '小王', 'age': 33, 'scores': 58, 'tel': '1177542300', 'gender': '男'}

  ]

stus.sort(reverse=True, key=lambda i: i['scores'])
print(stus)

2.相关操作

• 字典不支持加法、乘法和比较大小

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

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

3. 相关函数

• len(字典) — 获取字典的长度

• dict(数据) — 将指定数据转换为字典

  ​ 对数据的要求：a. 数据本身必须是序列（容器）

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

  而转换为列表要求数据为序列

  长度为2的字符串、列表、元组、range都可以作为被转换为字典的原数据的元素。

  l2 = ['ab', [10, 20], range(2), ('name', '小明')]
  print(dict(l2))  # {'a': 'b', 10: 20, 0: 1, 'name': '小明'}
  

4. 相关方法

字典.xxx()

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

2. 字典.copy() — 复制字典，产生一个相同的新字典并返回

   以下三种方法返回的序列与列表相似，但并不是列表，可以遍历，但列表许多方法并不支持

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

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

5. 字典.items() — 将字典转成一个序列，序列中每个元素即是字典中的每一对键值对

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

   print(dict1)
   print(d1)
   dict1.update(d1)
   print(dict1)
   # 若有重复的，字典2中的会覆盖字典1中的。
   

元组（tuple)

1. 什么是元组

元组是一种容器型数据，以（）为容器标志，其中多个数据用逗号隔开

元组是不可变的，有序的

任何类型的数据都可以作为元组中的元组

1） 空元组

由于元组不可变，故空元组永远都是空的

t1 = ()

2）只有一个元素的元组

输出只有一个元素的元组时，须在元素后加一个逗号，否则输出的不是元组

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

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

3) 正常的元组

t4 = (10, 20, 304, 'abc')
print(t4)

4)在没有歧义的情况下，元组的()可以省略

t5 = 100, 4, 2, 'as', 0
print(t5)

如函数中：return 100, 200 意为返回元组(100, 200)

2. 使用元组

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

元组是不可变的列表

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

获取元素 — 列表怎么获取，元组就可以怎么获取

1. 元组[下标]

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

2. 切片

   元组切片获得的是小元组

   print(t5[1:-1])  # ('狂飙', '回家的诱惑', '琅琊榜', '三国演义')
   

3. 遍历

   for i in t5:
       print(i)  # 依次获取元组元素
   
   for i in range(len(t5)):
       print(t5[i])
   
   for i, item in enumerate(t5):
       print(i, item)
   

4. 加法、乘法、比较大小、in 和 not in

   t1 = (10, 0)
   t2 = (9, 1)
   print(t1+t2)
   print(t1 * 2)
   
   print(t1 > t2)   # True
   
   print(10 in t1)  # True
   

5. 相关函数

   sum 、max、sorted、len

   tuple(数据) ：类型转换时要求数据为序列

6. 相关方法

   元组.count(元素)

   元组.index(元素)

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)

print(list(enumerate(list1)))  # [(0, 100), (1, 200), (2, 300)]
for i in enumerate(list1):
    print(i)  # 依次获取下标和值组成的元组
# (0, 100)
# (1, 200)
# (2, 300)

list2 = [('花花', 18, '女'), ('小明', 20, '男'), ('小华', 12, '男')]
for name, age, gender in list2:
    print(name, age, gender)
# 花花 18 女
# 小明 20 男
# 小华 12 男

集合

1. 什么是集合

集合是容器型数据；将{}作为容器，多个数据用逗号隔开

集合是可变的，无序的

集合对元素的要求与字典对键的要求是一样的：不可变数据且唯一

1）空集合

s1=set()

不能用{}，因为{}表示空字典

2）集合是无序的

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

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

s2 = {'abc', 8, 0}
# s2 = {'abc', 8, [10,20]} # 列表可变会报错

4）集合的元素是唯一的

s3 = {'abc', 8, 0, 8}   
print(s3)  # {'abc', 8, 0}
# 有重复元素时不会报错，但只会保存一个
# 由此，集合自带去重功能

集合用于：去重、数学集合运算

2. 数学集合运算

数学集合运算：求交集、并集、差集、对称差集、子集、真子集等

l1 = {1, 2, 3, 4, 5, 6, 7}
l2 = {5, 6, 7, 8, 9, 10}

1）交集 — 就两个集合的重合部分

集合1 & 集合2

print(l1 & l2)
# {5, 6, 7}

2）并集 — 合并两个集合

集合1 | 集合2

print(l1 | l2)
# {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

3）差集 — 求一个集合去掉与另一集合重合部分

集合1 - 集合2

print(l1 - l2)  # {1, 2, 3, 4}
print(l2 - l1)  # {8, 9, 10}

4）对称差集 — 两集合并集去掉重合部分

集合1 ^ 集合2

print(l1 ^ l2)
# {1, 2, 3, 4, 8, 9, 10}

5）子集、真子集

例： {1，2，3}

子集(包含本身)：{}、{1}、{2}、{3}、{1,2}、{1,3}、{2,3}、{1,2,3}

真子集(不包含本身)：{}、{1}、{2}、{3}、{1,2}、{1,3}、{2,3}

子集：
集合1 >= 集合2 — 判断集合2 是否是集合1 的子集
集合1 <= 集合2 — 判断集合1 是否是集合2 的子集

真子集：
集合1 > 集合2 — 判断集合2 是否是集合1 的真子集
集合1 < 集合2 — 判断集合1 是否是集合2 的真子集

# 注意：这里的比较运算符不是比较大小
print({100, 200, 300} > {1, 2})  # False  后者不是前者的不是真子集

字符串

1. 什么是字符串

字符串是容器型数据类型(同时保存多个文字符号)

将单引号、双引号或三个双引号、三个单引号作为容器的标志，里面每个符号都是字符串的元素

字符串是不可变的，是有序的

字符串的元素：

​ 字符串引号中每一个独立的符号都是字符串的元素，字符串的元素又叫字符。任何文字符号都可以是字符串的元素(包括英文符号、中文符号、阿拉伯数字、表情符号……)

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

单引号、双引号内换行，输出时无法换行(需要用转译字符)
三个单引号、三个双引号内换行，输出时也是换行的效果

str5 = """鹅鹅鹅，
曲项向天歌"""

print(str5)
# 鹅鹅鹅，
# 曲项向天歌

str6='鹅鹅鹅，\
曲项向天歌'
print(str6)
# 鹅鹅鹅，曲项向天歌

# 三个单引号、三个双引号只有放在文件开头、函数开头、类的开头才是注释
# def func1():
#     """注释 函数说明文档"""
#     """字符串"""
#
# class A:
#     """注释类说明文档"""
#     """字符串"""

空串 即空的字符串，长度为0

而有一个空格的字符串不是空格，且长度为1

这一点和其他数据类型不同，如：列表的空列表和有一个空格符的列表都是空列表

2. 字符 — 字符串中每一个独立的符号

即是字符串的元素

字符串中的字符分为两种，分别是普通字符和转义字符

1）普通字符 – 在字符串中表示符号其本身的字符（即在引号中和打印出来的一样就是普通字符）
2）转义字符 – 在字符串中有特殊意义或者特殊功能的符号就是转义字符(在特定符号前加 \ 来表示特殊意义或功能的符号)：
转义字符必须以反斜杠（\）开头。且打印结果和其本身不同。

C语言中转义字符在python中还能用的只有：\n、\t、\、'、"

\n — 换行(相当于按了回车)
\t — 水平制表符(相当于按了tab键)
\ — 表示一个普通的反斜杠
’ — 表示一个普通的单引号
" — 表示一个普通的双引号

str1 = "it's ok!"
print(str1)

# 反斜杠用法：
str2 = 'it\'s ok!'
print(str2)

str3 = 'abc\n123'
print(str3)
# 不想\n表示换行,而要正常输出\n
str4 = 'abc\\n123'
print(str4)

# 写路径时：\可能会与文件名第一个字母（可能是n、t）形成转义字符
# 故需要给每个反斜杠前再加一个反斜杠
path ='D:\\dell\\Documents\\python2301\\name'
print(path)

3. r 字符

在字符串前加r 或 R 可以让字符串中所有转义字符功能消失(让所有字符变为普通字符)

str1 = 'D:\dell\time\python2301\name'
str2 = r'D:\dell\time\python2301\name'
str3 = R'D:\dell\time\python2301\name'
print(str2)
print(str3)
# D:\dell\Documents\python2301\name
# D:\dell\time\python2301\name
# D:\dell\time\python2301\name