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

2022-04-11
2022-04-20
12 min read
Hits

  课程笔记和选择题

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}

集合操作符

操作符及应用动作描述
S | T返回一个新集合,包括在集合 S 和 T 中的所有元素
S - T返回一个新集合,包括在集合 S 但不在 T 中的元素
S & T返回一个新集合,包括同时在集合 S 和 T 中的元素
S ^ T返回一个新集合,包括集合 S 和 T 中的非相同元素
S <= T 或 S < T返回 True/Fale判断 S 和 T 的子集关系
S >= T 或 S > T返回 True/Fale判断 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 中,返回 True,否则返回 False
set(x)将其他类型变量 x 转变为集合类型

集合类型应用场景

  包含关系比较

# 举例
>>> "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}$

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

  序列是一个基类类型

  序号的定义

反向递减序号-5-4-3-2-1
举例“BIT”3.14151024(2,3)[“中国”,9]
正向递增序号01234

序列类型通用操作符

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

  序列类型操作实例

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

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

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

# 输出
'oi.321nohtyp'

序列类型通用函数和方法

函数和方法描述
len(s)返回序列 s 的长度,即元素个数
min(s)返回序列 s 的最小元素,s 中元素需要可比较
max(s)返回序列 s 的最大元素,s 中元素需要可比较
s.index(x) 或 s.index(x, i, j)返回序列 s 从 i 开始到 j 位置中第一次出现元素 x 的位置
s.count(x)返回序列 s 中出现 x 的总次数

  序列类型操作实例

# 举例
>>> 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[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 = ["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'>

字典类型操作函数和方法

函数或方法描述
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(d, )键 k 存在,则取出相应值,不在则返回
d.popitem()随机从字典 d 中取出一个键值对,以元组形式返回
d.clear()删除所有的键值对
len(d)返回字典 d 中元素的个数
# 举例
>>> 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 库常用函数

函数描述举例结果
jieba.lcut(s)精确模式,返回一个列表类型的分词结果jieba.lcut(“中国是一个伟大的国家”)[‘中国’, ‘是’, ‘一个’, ‘伟大’, ‘的’, ‘国家’]
jieba.lcut(s,cut_all=True)全模式,返回一个列表类型的分词结果,存在冗余jieba.lcut(“中国是一个伟大的国家”,cut_all=True)[‘中国’, ‘国是’, ‘一个’, ‘伟大’, ‘的’, ‘国家’]
jieba.lcut_for_search(s)搜索引擎模式,返回一个列表类型的分词结果,存在冗余jieba.lcut_for_search(“中华人民共和国是伟大的”)[‘中华’, ‘华人’, ‘人民’, ‘共和’, ‘共和国’, ‘中华人民共和国’, ‘是’, ‘伟大’, ‘的’]
jieba.add_word(w)向分词词典增加新词 wjieba.add_word(“蟒蛇语言”)

测验 6

  1. 那个选项是下面代码的输出结果?C
d= {'a' : 1, 'b' : 2, 'b' : '3'}
print(d['b'])
A. {'b':2}

B. 2

C. 3

D. 1
  • 创建字典时,如果相同键对应不同值,字典采用最后(最新)一个“键值对”。
  1. 关于大括号 {},以下描述正确的是:B

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

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

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

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

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

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

  1. 以下不是 Python 序列类型的是:B

    A. 列表类型

    B. 数组类型

    C. 字符串类型

    D. 元组类型

  • Python 内置数据类型中没有数组类型。
  1. 关于 Python 的元组类型,以下选项错误的是:D

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

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

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

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

  • 序列类型(元组、列表)中元素都可以是不同类型。
  1. 给定字典 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 组合使用。

  1. 关于 Python 组合数据类型,以下描述错误的是:C

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

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

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

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

  • 序列类型总体上可以看成一维向量,如果其元素都是序列,则可被当作二维向量。
  1. 序列 s,哪个选项对 s.index(x) 的描述是正确的?A

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

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

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

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

  • 注意:s.index(x) 返回第一次出现 x 的序号,并不返回全部序号。
  1. 给定字典 d,哪个选项对 x in d 的描述是正确的?D

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

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

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

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

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

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

  1. 列表 ls,哪个选项对 ls.append(x) 的描述是正确的?A

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

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

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

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

  • ls.append(x),如果 x 是一个列表,则该列表作为一个元素增加的 ls 中。
  1. 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 中的所有元素

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

Hui.Ke

❤ Cyber Security | Safety is a priority.