06. 组合数据类型

发表于 更新于 分类于 ，

集合类型及操作

集合是多个元素的无序组合

  • 集合类型与数学中的集合概念一致
  • 集合元素之间无序，每个元素唯一
  • 集合元素不可更改，不能是可变数据类型

集合类型的定义

集合是多个元素的无序组合

  • 集合用大括号 {} 表示，元素间用逗号分隔
  • 建立集合类型用 {} 或 set()
  • 建立空集合类型，必须使用 set()
1
2
A = {"python", 123, ("python", 123)} # 使用{}建立集合
B = set("pypy123") #使用set()建立集合

集合间运算

集合间操作

集合操作符 描述
S | T 返回一个新集合，包括在集合 S 和T中的所有元素
S - T 返回一个新集合，包括在集合 S 但不在T中的元素
S & T 返回一个新集合，包括同时在集合 S 和 T 中的元素
S ^ T 返回一个新集合，包括集合 S 和 T 中的非相同元素
S <= T 或 S < T 返回 True/False，判断 S 和 T 的子集关系
S >= T 或 S > T 返回 True/False，判断 S 和 T 的包含关系
S |= T 更新集合 S，包括在集合 S 和 T 中的所有元素
S -= T 更新集合 S，包括在集合 S 但不在 T 中的元素
S &= T 更新集合 S，包括同时在集合 S 和 T 中的元素
S ^= T 更新集合 S，包括集合 S 和 T 中的非相同元素
集合操作函数或方法 描述
S.add(x) 如果 x 不在集合S中，将 x 增加到S
S.discard(x) 移除 S 中元素 x，如果 x 不在集合S中，不报错
S.remove(x) 移除 S 中元素 x，如果 x 不在集合S中，产生 KeyError 异常
S.clear() 移除 S 中所有元素
S.pop() 随机返回 S 的一个元素，更新S，若S为空产生 KeyError 异常
S.copy() 返回集合 S 的一个副本
len(S) 返回集合 S 的元素个数
x in S 判断 S 中元素 x，x 在集合 S 中，返回 True，否则返回 False
x not in S 判断 S 中元素 x，x 不在集合S中，返回False，否则返回 True
set(x) 将其他类型变量 x 转变为集合类型

集合遍历

1
2
3
4
5
6
7
8
9
10
11
# 推荐遍历方式
for item in setA:
    print(item, end="")

# 疯狂的死循环也能遍历
try:
    while True:
        item = setA.pop()
        print(item, end="")
except:
    pass

集合类型应用场景

  • 用于比较关系: S <= T 或 S > T 等等
  • 数据去重：集合类型所有元素无重复
1
2
3
>>> ls = ["p", "p", "y", "y", 123]
>>> s = set(ls) # 利用了集合无重复元素的特点
{'p', 'y', 123}

序列类型及操作

序列类型定义：序列是具有先后关系的一组元素。包含了列表、元组和字符串类型。

  • 序列是一维元素向量，元素类型可以不同。
  • 类似数学元素序列： s0 , s1 , … , sn-1
  • 元素间由序号引导，通过下标访问序列的特定元素

序号的定义

操作符及应用 描述
x in seq 如果 x 是序列 seq 的元素，返回 True，否则返回 False
x not in seq 如果 x 是序列 seq 的元素，返回 False，否则返回 True
seq + t 连接两个序列 seq 和 t
seq * n 或 n * seq 将序列 seq 复制 n 次
s[i] 索引，返回 seq 中的第 i 个元素，i 是序列的序号
s[i: j] 或 seq[i: j: k] 切片，返回序列 seq 中第 i 到 j 以 k 为步长的元素子序列

序列类型取反操作

1
2
ls = ["python", 123, ".io"]
print(ls[::-1])
序列类型通用函数和方法 描述
len(seq) 返回序列 seq 的长度
min(seq) 返回序列 seq 的最小元素，seq 中元素需要可比较
max(seq) 返回序列 seq 的最大元素，seq 中元素需要可比较
reversed(seq) 让你能够反向迭代序列
sorted(seq) 返回一个有序列表，其中包含指定序列中的所有元素
seq.index(x) 或 seq.index(x, i, j) 返回序列 seq 从 i 开始到 j 位置中第一次出现元素 x 的位置
seq.count(x) 返回序列 seq 中出现 x 的总次数

元组类型及操作

  • 元组是一种序列类型，一旦创建就不能被修改。
  • 用于元素不改变的应用场景，更多用于固定搭配场景。
  • 使用小括号 () 或 tuple() 创建，元素间用逗号分隔。
  • 可以使用或不使用小括号。

注意：如果元组里只有一个值，必须在它后面加上逗号。

元组类型操作：

  • 元组继承了序列类型的全部通用操作
  • 元组因为创建后不能修改，因此没有特殊操作
  • 使用或不使用小括号

如果不希望数据被程序所改变，可以转换成元组类型，起到了数据保护的作用。

1
2
ls = ["cat", "dog", "tiger", 1024]
lt = tuple(ls) # 结果为 ('cat', 'dog', 'tiger', 1024)

列表类型定义

列表是序列类型的一种扩展，非常灵活，是最常用的序列类型。

  • 列表是一种序列类型，创建后可随意修改
  • 使用方括号 [] 或 list() 创建，元素间用逗号分隔
  • 列表中各元素类型可以不同，无长度限制
列表类型操作函数和方法 描述
ls[i] = x 替换列表 ls 第 i 元素为 x
ls[i: j: k] = lt 用列表 lt 替换 ls 切片后所对应元素子列表
del ls[i] 删除列表 ls 中第 i 元素
del ls[i: j: k] 删除列表 ls 中第i到第j以k为步长的元素
ls += lt 更新列表 ls，将列表 lt 元素增加到列表 ls 中
ls *= n 更新列表 ls，其元素重复 n 次
ls.append(x) 在列表 ls 最后增加一个元素 x
ls.clear() 删除列表 ls 中所有元素
ls.copy() 生成一个新列表，赋值 ls 中所有元素
ls.insert(i, x) 在列表 ls 的第 i 位置插入元素 x
ls.pop(i) 将列表 ls 中第 i 位置元素取出并删除该元素
ls.remove(x) 将列表 ls 中出现的第一个元素 x 删除
ls.reverse() 将列表 ls 中的元素反转
ls.clear() 清空所有元素

列表的遍历

1
2
3
4
5
6
7
lst = [1, 2, 3, 4, 5]

for val in lst:   # 遍历元素
    print(val)

for idx, val in enumerate(lst):   # idx 从 0 开始
    print(idx, val)

基本统计值计算案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
def getNum():
    nums = list()
    while True:
        iNumStr = input("请输入数字(回车退出):")
        if iNumStr == "":
            break
        nums.append(eval(iNumStr))
    return nums;

def mean(numbers): # 计算平均数
    s = 0.0
    for num in numbers:
        s += num
    return s / len(numbers)

def dev(numbers, mean): #计算方差
    sdev = 0.0
    for num in numbers:
        sdev += (num - mean) ** 2
    return pow(sdev / len(numbers), 0.5)

def median(numbers): #计算中位数
    sorted(numbers)
    size = len(numbers)
    if size % 2 == 0:
        # 中位数这么玩
        med = (numbers[size//2-1] + numbers[size//2])/2
    else:
        med = numbers[size // 2]
    return med

numbers = getNum()
mean = mean(numbers)
dev = dev(numbers, mean)
median = median(numbers)

print("平均数:", mean)
print("方差:{:.2}".format(dev))
print("中位数:", median)

加餐：Python 中的可变 vs 不可变类型

不可变类型（创建后值/长度/哈希永不变）

  • 数值：int, float, complex, decimal.Decimal, fractions.Fraction
  • 布尔：bool
  • 字符串：str
  • 字节串：bytes
  • 元组：tuple（元素本身不可变才可哈希）
  • 冻结集合：frozenset
  • 范围：range

哈希值固定，可作为 dict 键或 set 元素；任何“修改”操作都会返回新对象。

可变类型（原地修改，id 不变）

  • 列表：list
  • 字典：dict（3.7+ 保持插入顺序）
  • 集合：set
  • 字节数组：bytearray
  • 数组模块：array.array
  • 自定义类（默认属性可增删改）
  • 大部分第三方容器（deque, pandas.DataFrame 等）

无稳定哈希，不能作为 dict 键或 set 元素；修改后原对象仍在，只是内容变化。

加餐：range() 方法

调用形式 生成序列 长度
range(stop) 0, 1, …, stop-1 stop
range(start, stop) start, start+1, …, stop-1 stop - start
range(start, stop, step) 从 start 开始，步长 step（可负） 长度为 max(0, (stop − start + step − 1) // step) 若 step > 0

示例

1
2
3
4
5
6
7
8
9
10
11
>>> list(range(5))        # 仅给终止
[0, 1, 2, 3, 4]

>>> list(range(2, 7))     # 起 + 终
[2, 3, 4, 5, 6]

>>> list(range(0, 10, 3)) # 指定步长
[0, 3, 6, 9]

>>> list(range(5, 0, -1)) # 负步长，倒序
[5, 4, 3, 2, 1]

字典类型及操作

可以理解为一种映射。是多对种键(索引)和值(数据)的对应关系。

  • 写法：<字典变量> = {<键1>:<值1>, … , <键n>:<值n>}
  • 字典是键值对的集合，键值对之间无序
  • 采用大括号 {} 或 dict() 创建，键值对用冒号表示。

<值> = <字典变量>[<键>] 取出值
<字典变量>[<键>] = <值> 新增或者更新值

字典类型操作函数和方法 描述
del d[k] 删除字典 d 中键 k 对应的数据值
k in d 判断键 k 是否在字典 d 中。存在为 True，否则 False
d.keys() 返回字典 d 中所有的键信息
d.values() 返回字典 d 中所有的值信息
d.items() 返回字典 d 中所有的键值对信息
d.get(k, ) 键 k 存在，则返回相应值，不在则返回 值
d.pop(k, ) 键 k 存在，则取出相应值，不在则返回 值
d.popitem() 随机从字典 d 中取出一个键值对，以元组形式返回
dict.update 是“把另一个字典（或键值对序列）里的内容一次性拷进来”，有则覆盖，无则新增，原地修改，无返回。
d.clear() 删除所有的键值对
len(d) 返回字典 d 中元素的个数

字典的元素遍历

1
2
for k in d:
    <语句块>

字典类型应用场景

  • 映射无处不在，键值对无处不在
  • 例如：统计数据出现的次数，数据是键，次数是值
  • 最主要作用：表达键值对数据，进而操作它们

jieba 库的使用

jieba 是优秀的中文分词第三方库

  • 中文文本需要通过分词获得单个的词语
  • jieba 是优秀的中文分词第三方库，需要额外安装
  • jieba 库提供三种分词模式，最简单只需掌握一个函数

jieba 库的安装
pip install jieba

jieba 分词的原理
Jieba 分词依靠中文词库

  • 利用一个中文词库，确定汉字之间的关联概率
  • 汉字间概率大的组成词组，形成分词结果
  • 除了分词，用户还可以添加自定义的词组

jieba 分词的三种模式
精确模式、全模式、搜索引擎模式

  • 精确模式：把文本精确的切分开，不存在冗余单词
  • 全模式：把文本中所有可能的词语都扫描出来，有冗余
  • 搜索引擎模式：在精确模式基础上，对长词再次切分

jieba库常用函数
jieba.lcut(s)
精确模式，返回一个列表类型的分词结果

1
2
jieba.lcut( "中国是一个伟大的国家" )
['中国', '是', '一个', '伟大', '的', '国家']

文本词频统计案例

Hamlet 词频统计（含 Hamlet 原文文本）普通版

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def getText():
    txt = open("hamlet.txt", "r").read()
    txt = txt.lower()
    for ch in '!"#$%&()*+,-./:;<=>?@[\\]^_‘{|}~':
        txt = txt.replace(ch, " ")   #将文本中特殊字符替换为空格
    return txt

hamletTxt = getText()
words  = hamletTxt.split()
counts = {}
for word in words:
    counts[word] = counts.get(word,0) + 1
items = list(counts.items())
items.sort(key=lambda x:x[1], reverse=True)
for i in range(10):
    word, count = items[i]
    print ("{0:<10}{1:>5}".format(word, count))

《三国演义》人物出场统计（上）（含《三国演义》原文文本） jieba 版

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import jieba

txt = open("threekingdoms.txt", "r", encoding='utf-8').read()
words  = jieba.lcut(txt)
counts = {}
for word in words:
    if len(word) == 1:
        continue
    else:
        counts[word] = counts.get(word,0) + 1
items = list(counts.items())
items.sort(key=lambda x:x[1], reverse=True)
for i in range(15):
    word, count = items[i]
    print ("{0:<10}{1:>5}".format(word, count))