【第6周笔记】组合数据类型

  课程笔记和选择题

notes

集合类型的定义

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

  集合类型与数学中的集合概念一致

  集合元素之间无序，每个元素唯一，不存在相同元素

  集合元素不可更改，不能是可变数据类型 为什么？

  集合用大括号 {} 表示，元素间用逗号分隔

  建立集合类型用 {} 或 set()

  建立空集合类型，必须使用 set()

# 举例
>>> A = {"python", 123, ("python",123)}     # 使用 {} 建立集合

# 输出
{123, 'python', ('python', 123)}

# 举例
>>> B = set("pypy123")     # 使用 set() 建立集合

# 输出
{'1', 'p', '2', '3', 'y'}

# 举例
>>> C = {"python", 123, "python",123}

# 输出
{'python', 123}

集合操作符

集合处理方法

集合类型应用场景

  包含关系比较

# 举例
>>> "p" in {"p", "y" , 123}

# 输出
True

# 举例
>>> {"p", "y"} >= {"p", "y" , 123}

# 输出
False

  数据去重：集合类型所有元素无重复

# 举例
>>> ls = ["p", "p", "y", "y", 123]
>>> s = set(ls)     # 利用了集合无重复元素的特点

# 输出
{'p', 'y', 123}

# 举例
>>> lt = list(s)     # 还可以将集合转换为列表

# 输出
['p', 'y', 123]

序列类型定义

  序列是具有先后关系的一组元素

  序列是一维元素向量，元素类型可以不同

  类似数学元素序列：$S_0, S_1, …, S_{n-1}$

  元素间由序号引导，通过下标访问序列的特定元素

  序列是一个基类类型

  序号的定义

序列类型通用操作符

  序列类型操作实例

# 举例
>>> ls = ["python", 123, ".io"]
>>> ls [::-1]

# 输出
['.io', 123, 'python']

# 举例
>>> s = "python123.io"
>>> s[::-1]

# 输出
'oi.321nohtyp'

序列类型通用函数和方法

  序列类型操作实例

# 举例
>>> ls = ["python", 123, ".io"]
>>> len(ls)

# 输出
3

# 举例
>>> s = "python123.io"
>>> max(s)

# 输出
'y'

元组类型定义

  元组是序列类型的一种扩展

  元组是一种序列类型，一旦创建就不能被修改

  使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔

  可以使用或不适用小括号

# 举例
>>> creature = "cat", "dog", "tiger", "human"
>>> creature

# 输出
('cat', 'dog', 'tiger', 'human')

# 举例
>>> color = (0x001100, "blue", creature)
>>> color

# 输出
(4352, 'blue', ('cat', 'dog', 'tiger', 'human'))

元组类型操作

  元组继承序列类型的全部通用操作

  元组因为创建后不能修改，因此没有特殊操作

  使用或不适用小括号

# 举例
>>> creature = "cat", "dog", "tiger", "human"
>>> creature[::-1]

# 输出
('human', 'tiger', 'dog', 'cat')

# 举例
>>> color = (0x001100, "blue", creature)
>>> color[-1][2]

# 输出
'tiger'

列表类型定义

  列表是序列类型的一种扩展，十分常用

  列表是一种序列类型，创建后可以随意被修改

  使用方括号 [] 或 list() 创建，元素间用逗号 , 分割

  列表中各元素类型可以不同，无长度限制

# 举例
>>> ls = ["cat", "dog", "tiger", 1024]
>>> ls

# 输出
['cat', 'dog', 'tiger', 1024]

# 举例
>>> lt = ls
>>> lt

# 输出
['cat', 'dog', 'tiger', 1024]

# 方括号 [] 真正创建一个列表，赋值仅传递引用

列表类型操作函数和方法

# 举例
>>> ls = ["cat", "dog", "tiger", 1024]
>>> ls[1:2] = [1, 2, 3, 4]

# 输出
['cat', 1, 2, 3, 4, 'tiger', 1024]

# 举例
>>> del ls[::3]

# 输出
[1, 2, 4, 'tiger']

# 举例
>>> ls*2

# 输出
[1, 2, 4, 'tiger', 1, 2, 4, 'tiger']

# 举例
>>> ls = ["cat", "dog", "tiger", 1024]
>>> ls.append(1234)

# 输出
['cat', 'dog', 'tiger', 1024, 1234]

# 举例
>>> ls.insert(3, "human")

# 输出
['cat', 'dog', 'tiger', 'human', 1024, 1234]

# 举例
>>> ls.reverse()

# 输出
[1234, 1024, 'human', 'tiger', 'dog', 'cat']

列表功能

lt = []     # 定义空列表 lt
lt += [1,2,3,4,5]     # 向 lt 新增 5 个元素
lt[2] = 6     # 修改 lt 中第 2 个元素
lt.insert(2,7)     # 向 lt 中第 2 个位置增加一个元素
del lt[1]     # 从 lt 中第 1 个位置删除一个元素
del lt[1:4]     # 删除 lt 中第 1-3 位置元素
0 in lt     # 判断 lt 中是否包含数字 0
lt.append(0)     # 向 lt 新增数字 0
lt.index(0)     # 返回数字 0 所在 lt 中的索引
len(lt)     # lt 的长度
max(lt)     # lt 中最大元素
lt.clear()     # 清空 lt

序列类型应用场景

  数据表示：元组和列表

  元组用于元素不改变的应用场景，更多用于固定搭配场景

  列表更加灵活，它是最常用的序列类型

  最主要作用：表示一组有序数据，进而操作它们

元素遍历

for item in ls :
    <语句块>
for item in tp :
    <语句块>

数据保护

  如果不希望数据被程序所改变，转换成元组类型

# 举例
>>> ls = ["cat", "dog", "tiger", 1024]
>>> lt = tuple(ls)
>>> lt

# 输出
('cat', 'dog', 'tiger', 1024)

字典类型定义

  映射是一种键（索引）和值（数据）的对应

  序列类型由 0…N 整数作为数据的默认索引，映射类型则由用户为数据定义索引

  字典类型是“映射”的体现

  键值对：键是数据索引的扩展

  字典是键值对的集合，键值对之间无序

  采用大括号 {} 和 dict() 创建，键值对用冒号 : 表示

{<键1>:<值1>, <键2>:<值2>, … , <键n>:<值n>}

字典类型的用法

  在字典变量中，通过键获得值

<字典变量> = {<键1>:<值1>, … , <键n>:<值n>}
<值> = <字典变量>[<键>]
<字典变量>[<键>] = <值>

# 举例
>>> d = {"中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
>>> d

# 输出
{'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}

# 举例
>>> d["中国"]

# 输出
'北京'

# 举例
>>> de = {} ; type(de)     # type(x) 返回变量 x 的类型

# 输出
<class 'dict'>

字典类型操作函数和方法

# 举例
>>> d = {"中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
>>> "中国" in d

# 输出
True

# 举例
>>> d.keys()

# 输出
dict_keys(['中国', '美国', '法国'])

# 举例
>>> d.values()

# 输出
dict_values(['北京', '华盛顿', '巴黎'])

# 举例
>>> d ={"中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
>>> d.get("中国","伊斯兰堡")

# 输出
'北京'

# 举例
>>> d.get("巴基斯坦","伊斯兰堡")

# 输出
'伊斯兰堡'

# 举例
>>> d.popitem()

# 输出
('美国', '华盛顿')

d = {}     # 定义空字典 d
d["a"] = 1; d["b"] = 2     # 向 d 新增 2 个键值对元素
d["b"] = 3     # 修改第 2 个元素
"c" in d     # 判断字符 "c" 是否是 d 的键
len(d)     # 计算 d 的长度
d.clear()     # 清空 d

字典类型应用场景

  映射的表达：映射无处不在，键值对无处不在

  例如：统计数据出现的次数，数据是键，次数是值

  最主要作用：表达键值对数据，进而操作它们

for k in d :     # 元素遍历
    <语句块>

jieba 库概述

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

中文文本需要通过分词获得单个的词语

jieba 是优秀的中文分词第三方库，需要额外安装

jieba 库提供三种分词模式，最简单只需掌握一个函数

pip install jieba     # 安装 jieba 库

jieba 分词的原理

  jieba 分词依靠中文词库

  利用一个中文词库，确定中文字符之间的关联概率

  中文字符间概率大的组成词组，形成分词结果

  除了分词，用户还可以添加自定义的词组

jieba 分词的三种模式

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

jieba 库常用函数

测验 6

1. 那个选项是下面代码的输出结果？C

d= {'a' : 1, 'b' : 2, 'b' : '3'}
print(d['b'])

A. {'b':2}

B. 2

C. 3

D. 1

• 创建字典时，如果相同键对应不同值，字典采用最后（最新）一个“键值对”。

2. 关于大括号 {}，以下描述正确的是：B

   A. 直接使用 {} 将生成一个元组类型

   B. 直接使用 {} 将生成一个字典类型

   C. 直接使用 {} 将生成一个集合类型

   D. 直接使用 {} 将生成一个列表类型

• 集合类型和字典类型最外侧都用 {} 表示，不同在于，集合类型元素是普通元素，字典类型元素是键值对。

• 字典在程序设计中非常常用，因此，直接采用{}默认生成一个空字典。

3. 以下不是 Python 序列类型的是：B

   A. 列表类型

   B. 数组类型

   C. 字符串类型

   D. 元组类型

• Python 内置数据类型中没有数组类型。

4. 关于 Python 的元组类型，以下选项错误的是：D

   A. 一个元组可以作为另一个元组的元素，可以采用多级索引获取信息

   B. 元组采用逗号和圆括号（可选）来表示

   C. 元组一旦创建就不能被修改

   D. 元组中元素必须是相同类型

• 序列类型（元组、列表）中元素都可以是不同类型。

5. 给定字典 d，哪个选项对 d.values() 的描述是正确的？B

   A. 返回一个集合类型，包括字典 d 中所有值

   B. 返回一种 dict_values 类型，包括字典 d 中所有值

   C. 返回一个元组类型，包括字典 d 中所有值

   D. 返回一个列表类型，包括字典 d 中所有值

• 运行如下代码：（其中d是一个预定义的字典）

d={"a":1, "b":2}
type(d.values())

• 输出结果是：<class ‘dict_values’>

• d.values() 返回的是 dict_values 类型，这个类型通常与 for..in 组合使用。

6. 关于 Python 组合数据类型，以下描述错误的是：C

   A. Python 的字符串、元组和列表类型都属于序列类型

   B. 组合数据类型能够将多个相同类型或不同类型的数据组织起来，通过单一的表示使数据操作更有序、更容易

   C. 序列类型是二维元素向量，元素之间存在先后关系，通过序号访问

   D. 组合数据类型可以分为3类：序列类型、集合类型和映射类型

• 序列类型总体上可以看成一维向量，如果其元素都是序列，则可被当作二维向量。

7. 序列 s，哪个选项对 s.index(x) 的描述是正确的？A

   A. 返回序列 s 中元素 x 第一次出现的序号

   B. 返回序列 s 中元素 x 所有出现位置的序号

   C. 返回序列 s 中 x 的长度

   D. 返回序列 s 中序号为 x 的元素

• 注意：s.index(x) 返回第一次出现 x 的序号，并不返回全部序号。

8. 给定字典 d，哪个选项对 x in d 的描述是正确的？D

   A. x 是一个二元元组，判断 x 是否是字典 d 中的键值对

   B. 判断 x 是否是字典 d 中的值

   C. 判断 x 是否是在字典 d 中以键或值方式存在

   D. 判断 x 是否是字典 d 中的键

• 键是值的序号，也是字典中值的索引方式。

• 因此，x in d 中的 x 被当作 d 中的序号进行判断。

9. 列表 ls，哪个选项对 ls.append(x) 的描述是正确的？A

   A. 只能向列表 ls 最后增加一个元素 x

   B. 向列表 ls 最前面增加一个元素 x

   C. 向 ls 中增加元素，如果 x 是一个列表，则可以同时增加多个元素

   D. 替换列表 ls 最后一个元素为 x

• ls.append(x)，如果 x 是一个列表，则该列表作为一个元素增加的 ls 中。

10. S 和 T 是两个集合，哪个选项对 S^T 的描述是正确的？C

    A. S 和 T 的差运算，包括在集合 S 但不在 T 中的元素

    B. S 和 T 的交运算，包括同时在集合 S 和 T 中的元素

    C. S 和 T 的补运算，包括集合 S 和 T 中的非相同元素

    D. S 和 T 的并运算，包括在集合 S 和 T 中的所有元素

• 集合“交并差补”四种运算分别对应的运算符是：& | - ^