文章目录
1 集合类型及操作
1.1 集合类型定义
集合是多个元素的无序组合
- 集合类型与数学中的集合概念一致
- 集合元素之间无序，每个元素唯一，不存在相同元素
- 集合元素不可更改，不能是可变数据类型
- 集合用大括号 {} 表示，元素间用逗号分隔
- 建立集合类型用 {} 或 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}
1.2 集合操作符
| 操作符及应用 | 描述 |
|---|---|
| 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 的包含关系 |
4 个增强操作符，和上面含义相同：S |= T，S -= T，S &= T 和 S ^= T
>>> A = {"p", "y", 123}
>>> B = set("pypy123")
>>> A-B
{123}
>>> B-A
{'3', '1', '2'}
>>> A&B
{'y', 'p'}
>>> A|B
{'1', '2', 'y', 'p', '3', 123}
>>> A^B
{'1', '2', 123, '3'}
1.3 集合处理方法
| 操作函数或方法 | 描述 |
|---|---|
| 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 转变为集合类型 |
>>> A = {"p", "y", 123}
>>> for item in A:
print(item, end = "")
y123p
>>>
>>>>
>>> try:
while True:
print(A.pop(), end = "")
except:
pass
y123p
>>> A
set()
1.4 集合类型应用场景
- 包含关系比较
>>> "p" in {"p", "y", 123}
True
>>> {"p", "y"} >= {"p", "y", 123}
False
- 数据去重：集合类型所有元素无重复
>>> ls = ["p", "p", "y", "y", 123]
>>> s = set(ls) # 利用了集合无重复元素的特点
>>> s
{'y', 123, 'p'}
>>> lt = list(s) # 还可以将集合转换为列表
>>> lt
['y', 123, 'p']
2 序列类型及操作（元组类型，列表类型）
2.1 序列类型定义
序列是具有先后关系的一组元素
- 序列是一维元素向量，元素类型可以不同，类似数学元素序列：s0，s1，… ，sn-1
- 通过下标访问序列的特定元素
序列是一个基类类型，由序列类型引申出字符串类型，元组类型和列表类型
序列类型的序号定义如下，存在正向递增和反向递减序号
2.2 序列处理函数及方法
序列类型通用操作符
| 操作符及应用 | 描述 |
|---|---|
| x in s | 如果 x 是序列 s 的元素，返回 True，否则返回 False |
| x not in s | 如果 x 是序列 s 的元素，返回 False，否则返回 True |
| s + t | 连接两个序列 s 和 t |
| s*n 或 n*s | 将序列 s 复制 n 次 |
| s[i] | 索引，返回 s 中的第 i 个元素，i 是序列的序号 |
| s[i: j] 或 s[i: j: k] | 切片，返回序列 s 中第 i 到 j 以 k 为步长的元素子序列 |
example:
>>> ls = ["python", 123, "12"]
>>> ls[::-1]
['12', 123, 'python']
>>> s = "python"
>>> s[::-1]
'nohtyp'
序列类型通用函数和方法
| 函数和方法 | 描述 |
|---|---|
| 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 的总次数 |
example:
>>> ls = ["python", 123, "12"]
>>> len(ls)
3
>>> s = "python"
>>> max(s)
'y'
2.3 元组类型及操作
元组是序列类型的一种扩展
- 一旦创建就不能被修改
- 使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔
- 小括号可有可无
函数返回 return 1, 2 返回的就是元组类型
example:
>>> creature = "cat", "dog", "tiger", "human"
>>> creature
('cat', 'dog', 'tiger', 'human')
>>> color = (0x1100, "blue", creature)
>>> color
(4352, 'blue', ('cat', 'dog', 'tiger', 'human'))
元组继承序列类型的全部通用操作，因为创建后不能修改，因此没有特殊操作
2.4 列表类型及操作
列表是序列类型的一种扩展
- 创建后可以随意被修改
- 使用方括号 [] 或 list() 创建，元素间用逗号 , 分隔
- 列表中各元素类型可以不同，无长度限制
example：列表类型定义
>>> ls = ["cat", "dog", "tiger", 1024]
>>> ls
['cat', 'dog', 'tiger', 1024]
>>> lt = ls
>>> lt
['cat', 'dog', 'tiger', 1024]
注意：这里 ls 和 lt 其实指向的时一个列表，赋值仅传递引用
列表类型操作函数和方法
| 函数或方法 | 描述 |
|---|---|
| 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 中的元素反转 |
example：列表类型操作
>>> ls = ["cat", "dog", "tiger", 1024]
>>> ls[1:2] = [1, 2, 3, 4]
>>> ls
['cat', 1, 2, 3, 4, 'tiger', 1024]
>>> del ls[::3]
>>> ls
[1, 2, 4, 'tiger']
>>> ls*2
[1, 2, 4, 'tiger', 1, 2, 4, 'tiger']
>>> ls = ["cat", "dog", "tiger", 1024]
>>> ls.append(1234)
>>> ls
['cat', 'dog', 'tiger', 1024, 1234]
>>> ls.insert(3, "human")
>>> ls
['cat', 'dog', 'tiger', 'human', 1024, 1234]
>>> ls.reverse()
>>> ls
[1234, 1024, 'human', 'tiger', 'dog', 'cat']
常用功能：
- 定义空列表 lt >>> lt = []
- 向 lt 新增 5 个元素 >>> lt += [1,2,3,4,5]
- 修改 lt 中第 2 个元素 >>> lt[2] = 6
- 向 lt中第 2 个位置增加一个元素 >>> lt.insert(2, 7)
- 从 lt 中第 1 个位置删除一个元素 >>> del lt[1]
- 删除 lt 中第 1-3 位置元素 >>> del lt[1:4]
- 判断 lt 中是否包含数字 0 >>> 0 in lt
- 向 lt 新增数字 0 >>> lt.append(0)
- 返回数字 0 所在 lt 中的索引 >>> lt.index(0)
- lt 的长度 >>> len(lt)
- lt 中最大元素 >>> max(lt)
- 清空 lt >>> lt.clear()
2.5 序列类型应用场景
数据表示：元组 和 列表
- 元组用于元素不改变的应用场景，更多用于固定搭配场景
- 列表更加灵活，它是最常用的序列类型
- 最主要作用：表示一组有序数据，进而操作它们
3 实例: 基本统计值计算
需求：给出一组数，求总个数、求和、平均值、方差、中位数
#CalStatisticsV1.py
def getNum(): #获取用户不定长度的输入
nums = []
iNumStr = input("请输入数字(回车退出): ")
while iNumStr != "":
nums.append(eval(iNumStr))
iNumStr = input("请输入数字(回车退出): ")
return nums
def mean(numbers): #计算平均值
s = 0.0
for num in numbers:
s = s + num
return s / len(numbers)
def dev(numbers, mean): #计算方差
sdev = 0.0
for num in numbers:
sdev = sdev + (num - mean)**2
return pow(sdev / (len(numbers)-1), 0.5)
def median(numbers): #计算中位数
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
n = getNum()
m = mean(n)
print("平均值:{},方差:{:.2},中位数:{}.".format(m, dev(n,m),median(n)))
4 字典类型及操作
4.1 字典类型定义
字典类型可以理解“映射”，是一种键(索引)和值(数据)的对应
- 键值对：键是数据索引的扩展
- 字典是键值对的集合，键值对之间无序
- 采用大括号{}和dict()创建，键值对用冒号: 表示
<字典变量> = {<键1>:<值1>, … , <键n>:<值n>}
通过键获得值，[ ] 用来向字典变量中索引或增加元素
- <值> = <字典变量>[<键>]
- <字典变量>[<键>] = <值>
example:
>>> d = {"中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
>>> d
{'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}
>>> d["中国"]
'北京'
>>> de = {}
>>> type(de) # type(x) 返回变量x的类型
<class 'dict'>
4.2 典处理函数及方法
| 函数或方法 | 描述 |
|---|---|
| del d[k] | 删除字典 d 中键 k 对应的数据值 |
| k in d | 判断键 k 是否在字典 d 中，如果在返回 True，否则 False |
| d.keys() | 返回字典 d 中所有的键信息 |
| d.values() | 返回字典 d 中所有的值信息 |
| d.items() | 返回字典 d 中所有的键值对信息 |
| – | – |
| d.get(k, <default>) | 键 k 存在，则返回相应值，不在则返回值 |
| d.pop(k, <default>) | 键 k 存在，则取出相应值，不在则返回值 |
| d.popitem() | 随机从字典 d 中取出一个键值对，以元组形式返回 |
| d.clear() | 删除所有的键值对 |
| len(d) | 返回字典 d 中元素的个数 |
example：字典类型操作
>>> d = { "中国":"北京" , "美国":"华盛顿" , "法国":"巴黎" }
>>> "中国" in d
True
>>> d.keys()
dict_keys(['中国', '美国', '法国'])
>>> d.values()
dict_values(['北京', '华盛顿', '巴黎'])
>>> d = { "中国":"北京" , "美国":"华盛顿" , "法国":"巴黎" }
>>> d.get("中国", "伊斯兰堡") # 存在键"中国"对应的值
'北京'
>>> d.get("巴基斯坦", "伊斯坦堡") # 不存在键"巴基斯坦"对应的值，返回默认值
'伊斯坦堡'
>>> d.popitem()
('法国', '巴黎')
常用功能：
- 定义空字典 d >>> d = {}
- 向 d 新增 2 个键值对元素 >>> d[“a”] = 1; d[“b”] = 2
- 修改第 2 个元素 >>> d[“b”] = 3
- 判断字符 “c” 是否是 d 的键 >>> “c” in d
- 计算 d 的长度 >>> len(d)
- 清空 d >>> d.clear()
4.3 字典类型应用场景
- 统计数据出现的次数，数据是键，次数是值
- 最主要作用：表达键值对数据，进而操作它们
5 jieba 库的使用
jieba 是优秀的中文分词第三方库
安装：
- (cmd命令行) pip3 install jieba
或者 - 先下载，随便解压到一个地方，cmd 进入对应文件夹后运行 python setup.py install
jieba分词的三种模式
- 精确模式：把文本精确的切分开，不存在冗余单词
- 全模式：把文本中所有可能的词语都扫描出来，有冗余
- 搜索引擎模式：在精确模式基础上，对长词再次切分
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) | 向分词词典增加新词 w >>>jieba.add_word( “蟒蛇语言” ) |
6 实例: 文本词频统计
需求：一篇文章，出现了哪些词？哪些词出现得最多？
- 英文文本： Hamet 分析词频
https://python123.io/resources/pye/hamlet.txt - 中文文本：《三国演义》 分析人物
https://python123.io/resources/pye/threekingdoms.txt
Hamlet英文词频统计
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("{:<10}{:>5}".format(word, count))
运行结果：
>>>
the 1138
and 965
to 754
of 669
you 550
i 542
a 542
my 514
hamlet 462
in 436
《三国演义》人物出场统计
import jieba
txt = open("threekingdoms.txt", "r", encoding = "utf-8").read()
excludes = {"将军","却说","荆州","二人","不可","不能","如此"}
words = jieba.lcut(txt)
counts = {}
for word in words:
if len(word) == 1:
continue
elif word == "诸葛亮" or word == "孔明曰":
rword = "孔明"
elif word == "关公" or word == "云长":
rword = "关羽"
elif word == "玄德" or word == "玄德曰":
rword = "刘备"
elif word == "孟德" or word == "丞相":
rword = "曹操"
else:
rword = word
counts[rword] = counts.get(rword, 0) + 1
for word in excludes:
del counts[word]
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))
小结
集合类型及操作
- 集合使用 {} 和 set() 函数创建
- 集合间操作：交 (&)、并 (|)、差 (-)、补 (^)、比较 (>=<)
- 集合类型方法：.add()、.discard()、.pop() 等
- 集合类型主要应用于：包含关系比较、数据去重
序列类型及操作
- 序列是基类类型，扩展类型包括：字符串、元组和列表
- 元组用 () 和 tuple() 创建，列表用 [] 和 set() 创建
- 元组操作与序列操作基本相同
- 列表操作在序列操作基础上，增加了更多的灵活性
字典类型及操作
- 映射关系采用键值对表达
- 字典类型使用{}和dict()创建，键值对之间用:分隔
- d[key] 方式既可以索引，也可以赋值
- 字典类型有一批操作方法和函数，最重要的是.get()
