简述

掌握组合数据类型（集合、元组、列表、字典）的使用方法，掌握 jieba 库，能够处理一组数据，并处理中文文本。

课件

6.pdf

代码汇总

A = {"python", 123, ("python", 123)}
B = set("pypy123")
C = {"python", 123, "python",123}
print('A:', A)
print('B:', B)
print('C:', C)
''' 
A: {('python', 123), 123, 'python'}
B: {'y', 'p', '2', '1', '3'}
C: {123, 'python'}
'''

A = {"p", "y", 123}
B = set("pypy123")
print('A =>', A)
print('B =>', B)
print('A - B =>', A - B)
print('A & B =>', A & B)
print('A ^ B =>', A ^ B)
print('B - A =>', B - A)
print('A | B =>', A | B)
''' 
A => {'p', 123, 'y'}
B => {'p', '3', '1', '2', 'y'}
A - B => {123}
A & B => {'p', 'y'}
A ^ B => {'3', '1', 123, '2'}
B - A => {'1', '2', '3'}
A | B => {'p', '3', '1', 123, '2', 'y'}
'''

A = {"p", "y", 123}
print('A =>', A)
for item in A:
    print(item, end="")
''' 
A => {'p', 'y', 123}
py123
'''

A = {"p", "y", 123}
print('A =>', A)
try:
    while True:
        print(A.pop(), end="")
except:
    pass
''' 
A => {'p', 'y', 123}
py123
'''

print("p" in {"p", "y", 123})
print({"p", "y"} >= {"p", "y", 123})
print({"p", "y"} <= {"p", "y", 123})
''' 
True
False
True
'''

ls = ["p", "p", "y", "y", 123]
s = set(ls)  # 利用了集合无重复元素的特点
print('s =>', s)
lt = list(s)  # 还可以将集合转换为列表
print('lt =>', lt)
''' 
s => {123, 'p', 'y'}
lt => [123, 'p', 'y']
'''

ls = ["python", 123, ".io"]
print('ls[::-1] =>', ls[::-1])
print('len(ls) =>', len(ls))
s = 'python123.io'
print('s[::-1] =>', s[::-1])
print('max(s) =>', max(s))
''' 
ls[::-1] => ['.io', 123, 'python']
len(ls) => 3
s[::-1] => oi.321nohtyp
max(s) => y
'''

creature = "car", "dog", "trigger", "human" # 定义元组类型可不加小括号
print("creature =>", creature)
print("creature[::-1] =>", creature[::-1])
print("creature =>", creature)
color = (0x001100, "blue", creature)
print("color =>", color)
print("color[-1][2] =>", color[-1][2])
''' 
creature => ('car', 'dog', 'trigger', 'human')
creature[::-1] => ('human', 'trigger', 'dog', 'car')
creature => ('car', 'dog', 'trigger', 'human')
color => (4352, 'blue', ('car', 'dog', 'trigger', 'human'))
color[-1][2] => trigger
'''

ls = ['cat', 'dog', 'trigger', 1024]
print('ls =>', ls)
lt = ls # 引用赋值
print('lt =>', lt)
lt[0] = 'Cat'
print('ls =>', ls)
print('lt =>', lt)
''' 
ls => ['cat', 'dog', 'trigger', 1024]
lt => ['cat', 'dog', 'trigger', 1024]
ls => ['Cat', 'dog', 'trigger', 1024]
lt => ['Cat', 'dog', 'trigger', 1024]
'''
''' 
notes：
lt = ls
这种写法是引用赋值
意味着 lt、ls 指向的是同一块内存空间
当我们看到 [] 或者 list() 才意味着新开辟了一块内存
'''

ls = ['cat', 'dog', 'trigger', 1024]
ls[1:2] = [1, 2, 3, 4]
print('ls =>', ls)
del ls[::3]
print('ls =>', ls)
ls = ls * 2
print('ls =>', ls)
''' 
ls => ['cat', 1, 2, 3, 4, 'trigger', 1024]
ls => [1, 2, 4, 'trigger']
ls => [1, 2, 4, 'trigger', 1, 2, 4, 'trigger']
'''

ls = ['cat', 'dog', 'trigger', 1024]
ls.append(1234)
print('ls =>', ls)
ls.insert(3, 'human')
print('ls =>', ls)
ls.reverse()
print('ls =>', ls)
''' 
ls => ['cat', 'dog', 'trigger', 1024, 1234]
ls => ['cat', 'dog', 'trigger', 'human', 1024, 1234]
ls => [1234, 1024, 'human', 'trigger', 'dog', 'cat']
'''

lt = []
print('1. 定义空列表lt', lt)
lt += [1,2,3,4,5]
print('2. 向lt新增5个元素', lt)
lt[2] = 6
print('3. 修改lt中第2个元素（这里的“第2个”指索引为 2）', lt)
lt.insert(2, 7)
print('4. 向lt中第2个位置增加一个元素', lt)
del lt[1]
print('5. 从lt中第1个位置删除一个元素', lt)
del lt[1:4]
print('6. 删除lt中第1-3位置元素', lt)
rt7 = (0 in lt)
print('7. 判断lt中是否包含数字0', lt, rt7)
lt.append(0)
print('8. 向lt新增数字0', lt)
rt9 = lt.index(0)
print('9. 返回数字0所在lt中的索引', lt, rt9)
rt10 = len(lt)
print('10. lt的长度', rt10)
rt11 = max(lt)
print('11. lt中最大元素', lt, rt11)
lt.clear()
print('12. 清空lt', lt)
'''
1. 定义空列表lt []
2. 向lt新增5个元素 [1, 2, 3, 4, 5]
3. 修改lt中第2个元素（这里的“第2个”指索引为 2） [1, 2, 6, 4, 5]
4. 向lt中第2个位置增加一个元素 [1, 2, 7, 6, 4, 5]
5. 从lt中第1个位置删除一个元素 [1, 7, 6, 4, 5]
6. 删除lt中第1-3位置元素 [1, 5]
7. 判断lt中是否包含数字0 [1, 5] False
8. 向lt新增数字0 [1, 5, 0]
9. 返回数字0所在lt中的索引 [1, 5, 0] 2
10. lt的长度 3
11. lt中最大元素 [1, 5, 0] 5
12. 清空lt []
'''

# 如果不希望数据被程序所改变，转换成元组类型
ls = ['cat', 'dog', 'trigger', 1024]
lt = tuple(ls)
print(lt) # ('cat', 'dog', 'trigger', 1024)

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):  # 计算中位数
    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)))
''' 
请输入数字(回车退出): 10
请输入数字(回车退出): 20
请输入数字(回车退出): 30
请输入数字(回车退出): 
平均值:20.0,方差:1e+01,中位数:20.
'''

d = {"中国": "北京", "美国": "华盛顿", "法国": "巴黎"}
print("d =>", d)
print('d["中国"] =>', d["中国"])
print('type(d) =>', type(d))
''' 
d => {'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}
d["中国"] => 北京
type(d) => <class 'dict'>
'''

d = {"中国": "北京", "美国": "华盛顿", "法国": "巴黎"}
print('1.', "中国" in d)
print('2.', d.keys())
print('3.', d.values())
print('4.', d.get("中国", "伊斯兰堡"))
print('5.', d)
print('6.', d.get("巴基斯坦", "伊斯兰堡"))
print('7.', d)
print('8.', d.popitem())
print('9.', d)
''' 
1. True
2. dict_keys(['中国', '美国', '法国'])
3. dict_values(['北京', '华盛顿', '巴黎'])
4. 北京
5. {'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}
6. 伊斯兰堡
7. {'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}
8. ('法国', '巴黎')
9. {'中国': '北京', '美国': '华盛顿'}
'''

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

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))
''' 
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()
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))
''' 
曹操          953
孔明          836
将军          772
却说          656
玄德          585
关公          510
丞相          491
二人          469
不可          440
荆州          425
玄德曰         390
孔明曰         390
不能          384
如此          378
张飞          358
'''

import jieba
excludes = {"将军", "却说", "荆州", "二人", "不可", "不能", "如此"}
txt = open("threekingdoms.txt", "r", encoding='utf-8').read()
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))
''' 
曹操         1451
孔明         1383
刘备         1252
关羽          784
张飞          358
商议          344
如何          338
主公          331
军士          317
吕布          300
'''

s = '''双儿 洪七公 赵敏 赵敏 逍遥子 鳌拜 殷天正 金轮法王 乔峰 杨过 洪七公 郭靖 
       杨逍 鳌拜 殷天正 段誉 杨逍 慕容复 阿紫 慕容复 郭芙 乔峰 令狐冲 郭芙 
       金轮法王 小龙女 杨过 慕容复 梅超风 李莫愁 洪七公 张无忌 梅超风 杨逍 
       鳌拜 岳不群 黄药师 黄蓉 段誉 金轮法王 忽必烈 忽必烈 张三丰 乔峰 乔峰 
       阿紫 乔峰 金轮法王 袁冠南 张无忌 郭襄 黄蓉 李莫愁 赵敏 赵敏 郭芙 张三丰 
       乔峰 赵敏 梅超风 双儿 鳌拜 陈家洛 袁冠南 郭芙 郭芙 杨逍 赵敏 金轮法王 
       忽必烈 慕容复 张三丰 杨逍 令狐冲 黄药师 袁冠南 杨逍 完颜洪烈 殷天正 
       李莫愁 阿紫 逍遥子 乔峰 逍遥子 完颜洪烈 郭芙 杨逍 张无忌 杨过 慕容复 
       逍遥子 虚竹 双儿 乔峰 郭芙 黄蓉 李莫愁 陈家洛 杨过 忽必烈 鳌拜 王语嫣 
       洪七公 韦小宝 阿朱 梅超风 段誉 岳灵珊 完颜洪烈 乔峰 段誉 杨过 杨过 慕容复 
       黄蓉 杨过 阿紫 杨逍 张三丰 张三丰 赵敏 张三丰 杨逍 黄蓉 金轮法王 郭襄 
       张三丰 令狐冲 郭芙 韦小宝 黄药师 阿紫 韦小宝 金轮法王 杨逍 令狐冲 阿紫 
       洪七公 袁冠南 双儿 郭靖 鳌拜 谢逊 阿紫 郭襄 梅超风 张无忌 段誉 忽必烈 
       完颜洪烈 双儿 逍遥子 谢逊 完颜洪烈 殷天正 金轮法王 张三丰 双儿 郭襄 阿朱 
       郭襄 双儿 李莫愁 郭襄 忽必烈 金轮法王 张无忌 鳌拜 忽必烈 郭襄 令狐冲 
       谢逊 梅超风 殷天正 段誉 袁冠南 张三丰 王语嫣 阿紫 谢逊 杨过 郭靖 黄蓉 
       双儿 灭绝师太 段誉 张无忌 陈家洛 黄蓉 鳌拜 黄药师 逍遥子 忽必烈 赵敏 
       逍遥子 完颜洪烈 金轮法王 双儿 鳌拜 洪七公 郭芙 郭襄'''
ls = s.split()
ss = set(ls)
print(len(ss)) # 36

s = input()
try:
    d = eval(s)
    e = {}
    for k in d:
        e[d[k]] = k
    print(e)
except:
    print("输入错误")
''' 
{"a": 1, "b": 2}
{1: 'a', 2: 'b'}
'''

import jieba
f = open("沉默的羔羊.txt", encoding='utf-8')
ls = jieba.lcut(f.read())
d = {}
for w in ls:
    if len(w) >= 2:
        d[w] = d.get(w, 0) + 1
maxc = 0
maxw = ""
for k in d:
    if d[k] > maxc:
        maxc = d[k]
        maxw = k
    elif d[k] == maxc and k > maxw:
        maxw = k
print(maxw) # 史达琳
f.close()

n = input()
ss = set(n)
s = 0
for i in ss:
    s += eval(i)
print(s)
''' 
123123123
6
'''

s = '''双儿 洪七公 赵敏 赵敏 逍遥子 鳌拜 殷天正 金轮法王 乔峰 杨过 洪七公 郭靖 
       杨逍 鳌拜 殷天正 段誉 杨逍 慕容复 阿紫 慕容复 郭芙 乔峰 令狐冲 郭芙 
       金轮法王 小龙女 杨过 慕容复 梅超风 李莫愁 洪七公 张无忌 梅超风 杨逍 
       鳌拜 岳不群 黄药师 黄蓉 段誉 金轮法王 忽必烈 忽必烈 张三丰 乔峰 乔峰 
       阿紫 乔峰 金轮法王 袁冠南 张无忌 郭襄 黄蓉 李莫愁 赵敏 赵敏 郭芙 张三丰 
       乔峰 赵敏 梅超风 双儿 鳌拜 陈家洛 袁冠南 郭芙 郭芙 杨逍 赵敏 金轮法王 
       忽必烈 慕容复 张三丰 赵敏 杨逍 令狐冲 黄药师 袁冠南 杨逍 完颜洪烈 殷天正 
       李莫愁 阿紫 逍遥子 乔峰 逍遥子 完颜洪烈 郭芙 杨逍 张无忌 杨过 慕容复 
       逍遥子 虚竹 双儿 乔峰 郭芙 黄蓉 李莫愁 陈家洛 杨过 忽必烈 鳌拜 王语嫣 
       洪七公 韦小宝 阿朱 梅超风 段誉 岳灵珊 完颜洪烈 乔峰 段誉 杨过 杨过 慕容复 
       黄蓉 杨过 阿紫 杨逍 张三丰 张三丰 赵敏 张三丰 杨逍 黄蓉 金轮法王 郭襄 
       张三丰 令狐冲 赵敏 郭芙 韦小宝 黄药师 阿紫 韦小宝 金轮法王 杨逍 令狐冲 阿紫 
       洪七公 袁冠南 双儿 郭靖 鳌拜 谢逊 阿紫 郭襄 梅超风 张无忌 段誉 忽必烈 
       完颜洪烈 双儿 逍遥子 谢逊 完颜洪烈 殷天正 金轮法王 张三丰 双儿 郭襄 阿朱 
       郭襄 双儿 李莫愁 郭襄 忽必烈 金轮法王 张无忌 鳌拜 忽必烈 郭襄 令狐冲 
       谢逊 梅超风 殷天正 段誉 袁冠南 张三丰 王语嫣 阿紫 谢逊 杨过 郭靖 黄蓉 
       双儿 灭绝师太 段誉 张无忌 陈家洛 黄蓉 鳌拜 黄药师 逍遥子 忽必烈 赵敏 
       逍遥子 完颜洪烈 金轮法王 双儿 鳌拜 洪七公 郭芙 郭襄 赵敏'''
ls = s.split()
d = {}
for i in ls:
    d[i] = d.get(i, 0) + 1
max_name, max_cnt = "", 0
for k in d:
    if d[k] > max_cnt:
        max_name, max_cnt = k, d[k]
print(max_name) # 赵敏

第6章 辅学内容

课前复习

.mp4%22%2C%22size%22%3A50621704%2C%22taskId%22%3A%22u3481fb69-00cf-46ca-bc5b-fa80dee062b%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480652094-aaac5a22-d505-4371-8ab6-d6e78f04052b.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22SPFYt%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#SPFYt)

本课概要

.mp4%22%2C%22size%22%3A37234562%2C%22taskId%22%3A%22uea7003db-2d80-4d8e-83c0-b16ea1724d1%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480653521-28e77a0d-eaaf-40e7-9cde-89a9835e1ff9.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22TUgBi%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#TUgBi) 介绍 Python 中 3 种主流组合数据类型的使用方法，掌握处理一组数据的能力：

• 集合类型
• 序列类型
• 字典类型

集合类型及操作

单元开篇

.mp4%22%2C%22size%22%3A8564340%2C%22taskId%22%3A%22ue69264f3-2748-4260-b3bd-e961d1f3c31%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480632871-f18f433c-5206-4fc9-aaa7-08ebd078c938.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22lIlpa%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#lIlpa)

集合类型定义

.mp4%22%2C%22size%22%3A72592723%2C%22taskId%22%3A%22ue0b0ab90-df5d-4f1a-a14e-d7b1cfd814b%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480632906-47f5a393-bfd6-40d2-80a5-77da344f2abd.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22ZYv7T%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#ZYv7T) 集合是多个元素的无序组合

• 集合类型与数学中的集合概念一致
• 集合元素是无序的
• 集合中每个元素唯一，不存在相同元素
• 集合元素不可更改，不能是可变数据类型
• 集合用大括号 {} 表示，元素之间用逗号分隔
• 建立集合类型用 **{}** 或 **set()**
• 建立空集合类型，必须使用 **set()**

A = {"python", 123, ("python", 123)}
B = set("pypy123")
C = {"python", 123, "python",123}
print('A:', A)
print('B:', B)
print('C:', C)
''' 
A: {('python', 123), 123, 'python'}
B: {'y', 'p', '2', '1', '3'}
C: {123, 'python'}
'''

集合操作符

.mp4%22%2C%22size%22%3A68565704%2C%22taskId%22%3A%22u72a5c24b-7935-4eac-8149-320c6b4f49f%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480632878-0b64b6d5-15a4-4028-99c6-e1c2ce6b0c2e.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22A8i0m%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#A8i0m) 集合类型之间的 4 种运算：

A = {"p", "y", 123}
B = set("pypy123")
print('A =>', A)
print('B =>', B)
print('A - B =>', A - B)
print('A & B =>', A & B)
print('A ^ B =>', A ^ B)
print('B - A =>', B - A)
print('A | B =>', A | B)
''' 
A => {'p', 123, 'y'}
B => {'p', '3', '1', '2', 'y'}
A - B => {123}
A & B => {'p', 'y'}
A ^ B => {'3', '1', 123, '2'}
B - A => {'1', '2', '3'}
A | B => {'p', '3', '1', 123, '2', 'y'}
'''

集合处理方法

.mp4%22%2C%22size%22%3A107702783%2C%22taskId%22%3A%22u46ecb504-4941-4964-a670-90e087f2343%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480632895-6a856190-eebc-4b0b-bdc1-b5da2be99a2a.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22Xsagj%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#Xsagj)

A = {"p", "y", 123}
print('A =>', A)
for item in A:
    print(item, end="")
''' 
A => {'p', 'y', 123}
py123
'''

A = {"p", "y", 123}
print('A =>', A)
try:
    while True:
        print(A.pop(), end="")
except:
    pass
''' 
A => {'p', 'y', 123}
py123
'''

集合类型应用场景

.mp4%22%2C%22size%22%3A44270347%2C%22taskId%22%3A%22u955f46e3-6aa9-487a-a889-418619c6d7c%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480632895-976e4b51-a926-4a9b-9e99-87e78ff68e0d.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22k3gJN%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#k3gJN)

print("p" in {"p", "y", 123})
print({"p", "y"} >= {"p", "y", 123})
print({"p", "y"} <= {"p", "y", 123})
''' 
True
False
True
'''

ls = ["p", "p", "y", "y", 123]
s = set(ls)  # 利用了集合无重复元素的特点
print('s =>', s)
lt = list(s)  # 还可以将集合转换为列表
print('lt =>', lt)
''' 
s => {123, 'p', 'y'}
lt => [123, 'p', 'y']
'''

单元小结

.mp4%22%2C%22size%22%3A17823760%2C%22taskId%22%3A%22uc18f0c8a-2aa4-4585-899f-13e2d0103b3%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480639093-484c94e8-d6a2-40f3-af30-66c0bf2f90d4.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22PwSt7%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#PwSt7)

序列类型及操作

单元开篇

.mp4%22%2C%22size%22%3A13949001%2C%22taskId%22%3A%22u304a040c-b870-4143-8412-71b180997b7%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480679393-bc180d08-8978-4152-a7be-f7ff86081b6c.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22ndBnR%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#ndBnR) 序列类型非常常用，掌握好序列类型，基本上就可以处理绝大多数组合数据类型所需要的应用场景。

序列类型定义

.mp4%22%2C%22size%22%3A25749715%2C%22taskId%22%3A%22udf875daf-bbc8-42c2-b722-6ce1dcb1ed3%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480679386-cd633166-0402-47c2-9082-f8dafdd5bc7f.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22acT5S%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#acT5S) 序列是具有先后关系的一组元素

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

序列是一个基类类型，包括：

• 字符串类型
• 元组类型
• 列表类型

序列处理函数及方法

.mp4%22%2C%22size%22%3A72237816%2C%22taskId%22%3A%22ueedbe1e1-2c80-48dc-a114-86f84b3b533%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480679413-9fa2be26-469f-4789-a0bc-fc4ae2b7b7ab.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22ahfFe%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#ahfFe)

ls = ["python", 123, ".io"]
print('ls[::-1] =>', ls[::-1])
print('len(ls) =>', len(ls))
s = 'python123.io'
print('s[::-1] =>', s[::-1])
print('max(s) =>', max(s))
''' 
ls[::-1] => ['.io', 123, 'python']
len(ls) => 3
s[::-1] => oi.321nohtyp
max(s) => y
'''

元组类型及操作

.mp4%22%2C%22size%22%3A63926826%2C%22taskId%22%3A%22ue2915687-618d-4615-85f7-9bbc4ed7e5f%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480679409-e5ac318f-e3ab-4862-8bd0-adc94bfbce37.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22p1bbv%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#p1bbv)

• 元组是序列类型的一种扩展，它也是一种序列类型
• 元组类型一旦创建就不能被修改，因此没有针对元组的特殊操作去修改元组类型的值
• 使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔（小括号可以使用也可以不使用）
• 元组继承了序列类型的全部通用操作（元组本身也是一种序列类型，因此序列能用的元组也 ok）

creature = "car", "dog", "trigger", "human" # 定义元组类型可不加小括号
print("creature =>", creature)
print("creature[::-1] =>", creature[::-1])
print("creature =>", creature)
color = (0x001100, "blue", creature)
print("color =>", color)
print("color[-1][2] =>", color[-1][2])
''' 
creature => ('car', 'dog', 'trigger', 'human')
creature[::-1] => ('human', 'trigger', 'dog', 'car')
creature => ('car', 'dog', 'trigger', 'human')
color => (4352, 'blue', ('car', 'dog', 'trigger', 'human'))
color[-1][2] => trigger
'''

列表类型及操作

.mp4%22%2C%22size%22%3A180071922%2C%22taskId%22%3A%22uddc3f712-43cd-4845-af70-7159a90ecd6%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480679411-7a4deaf5-ae01-42a0-a251-3d9975283966.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22ariEh%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#ariEh)

ls = ['cat', 'dog', 'trigger', 1024]
print('ls =>', ls)
lt = ls # 引用赋值
print('lt =>', lt)
lt[0] = 'Cat'
print('ls =>', ls)
print('lt =>', lt)
''' 
ls => ['cat', 'dog', 'trigger', 1024]
lt => ['cat', 'dog', 'trigger', 1024]
ls => ['Cat', 'dog', 'trigger', 1024]
lt => ['Cat', 'dog', 'trigger', 1024]
'''
''' 
notes：
lt = ls
这种写法是引用赋值
意味着 lt、ls 指向的是同一块内存空间
当我们看到 [] 或者 list() 才意味着新开辟了一块内存
'''

ls = ['cat', 'dog', 'trigger', 1024]
ls[1:2] = [1, 2, 3, 4]
print('ls =>', ls)
del ls[::3]
print('ls =>', ls)
ls = ls * 2
print('ls =>', ls)
''' 
ls => ['cat', 1, 2, 3, 4, 'trigger', 1024]
ls => [1, 2, 4, 'trigger']
ls => [1, 2, 4, 'trigger', 1, 2, 4, 'trigger']
'''

ls = ['cat', 'dog', 'trigger', 1024]
ls.append(1234)
print('ls =>', ls)
ls.insert(3, 'human')
print('ls =>', ls)
ls.reverse()
print('ls =>', ls)
''' 
ls => ['cat', 'dog', 'trigger', 1024, 1234]
ls => ['cat', 'dog', 'trigger', 'human', 1024, 1234]
ls => [1234, 1024, 'human', 'trigger', 'dog', 'cat']
'''

lt = []
print('1. 定义空列表lt', lt)
lt += [1,2,3,4,5]
print('2. 向lt新增5个元素', lt)
lt[2] = 6
print('3. 修改lt中第2个元素（这里的“第2个”指索引为 2）', lt)
lt.insert(2, 7)
print('4. 向lt中第2个位置增加一个元素', lt)
del lt[1]
print('5. 从lt中第1个位置删除一个元素', lt)
del lt[1:4]
print('6. 删除lt中第1-3位置元素', lt)
rt7 = (0 in lt)
print('7. 判断lt中是否包含数字0', lt, rt7)
lt.append(0)
print('8. 向lt新增数字0', lt)
rt9 = lt.index(0)
print('9. 返回数字0所在lt中的索引', lt, rt9)
rt10 = len(lt)
print('10. lt的长度', rt10)
rt11 = max(lt)
print('11. lt中最大元素', lt, rt11)
lt.clear()
print('12. 清空lt', lt)
'''
1. 定义空列表lt []
2. 向lt新增5个元素 [1, 2, 3, 4, 5]
3. 修改lt中第2个元素（这里的“第2个”指索引为 2） [1, 2, 6, 4, 5]
4. 向lt中第2个位置增加一个元素 [1, 2, 7, 6, 4, 5]
5. 从lt中第1个位置删除一个元素 [1, 7, 6, 4, 5]
6. 删除lt中第1-3位置元素 [1, 5]
7. 判断lt中是否包含数字0 [1, 5] False
8. 向lt新增数字0 [1, 5, 0]
9. 返回数字0所在lt中的索引 [1, 5, 0] 2
10. lt的长度 3
11. lt中最大元素 [1, 5, 0] 5
12. 清空lt []
'''

序列类型应用场景

.mp4%22%2C%22size%22%3A54976738%2C%22taskId%22%3A%22ufccfe83f-a121-465e-bee5-5f29c928d5b%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480687768-a23f94e3-1386-4a38-9a30-d91f9eb962c3.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22HCq6z%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#HCq6z) 序列类型数据的表现形式：

1. 元组
2. 列表

应用场景

• 元组用于元素不改变的应用场景，更多用于固定搭配场景
• 列表更加灵活，它是最常用的序列类型
• 最主要作用：表示一组有序数据，进而操作它们

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

# 如果不希望数据被程序所改变，转换成元组类型
ls = ['cat', 'dog', 'trigger', 1024]
lt = tuple(ls)
print(lt) # ('cat', 'dog', 'trigger', 1024)

单元小结

.mp4%22%2C%22size%22%3A18043408%2C%22taskId%22%3A%22u26e98092-efcc-4502-b823-e739cc9fcb2%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480692869-0a73257f-7dff-44bf-aacf-2251e61c4ac8.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22MbxMM%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#MbxMM)

实例9: 基本统计值计算

问题分析

.mp4%22%2C%22size%22%3A29584596%2C%22taskId%22%3A%22u9596d22b-0779-46c9-b579-b14be50ec21%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480706661-96b627a2-924b-4af6-bf3b-ea3bb815f16b.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22RmVhX%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#RmVhX) 基本统计值是什么？

实例讲解

.mp4%22%2C%22size%22%3A111982759%2C%22taskId%22%3A%22u495d6938-af17-4c23-b13c-269bdf8aa18%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480707278-a899b730-bb02-4e7c-8fc6-7ec530f8afbf.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22gmzzX%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#gmzzX)

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):  # 计算中位数
    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)))
''' 
请输入数字(回车退出): 10
请输入数字(回车退出): 20
请输入数字(回车退出): 30
请输入数字(回车退出): 
平均值:20.0,方差:1e+01,中位数:20.
'''

举一反三

.mp4%22%2C%22size%22%3A36532762%2C%22taskId%22%3A%22ufecd3725-54a7-4d63-acd8-85e563779ae%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480710327-fbb87d79-27a0-4618-a7e0-42243cd55cca.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22mzVI7%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#mzVI7) 通过本节介绍的实例，掌握以下几点：

• 获取多个数据：从控制台获取多个不确定数据的方法
• 分隔多个函数：模块化设计方法
• 充分利用函数：充分利用 Python 提供的内置函数

字典类型及操作

单元开篇

.mp4%22%2C%22size%22%3A9612023%2C%22taskId%22%3A%22ud248f45f-1072-46f5-95dd-496405a06a0%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480712626-2ca88088-fddd-49f3-9c69-a8185cda797a.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22fQcaV%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#fQcaV)

字典类型定义

.mp4%22%2C%22size%22%3A99996662%2C%22taskId%22%3A%22u17b7bcf5-7264-41db-89ba-b8b1f71bdca%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480720721-adcf5c19-823f-4a00-97f4-b24ab956d15d.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22CBN6T%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#CBN6T) 理解“映射”：映射是一种键（索引）和值（数据）的对应

字典类型是“映射”的体现，在字典变量中，通过键获得值

• 键值对：键是数据索引的扩展
• 字典是键值对的集合，键值对之间无序
• 采用大括号 {} 和 dict() 创建，键值对用冒号 : 表示

<字典变量> = {
    <键1>:<值1>,
    <键2>:<值2>,
    …,
    <键n>:<值n>
}
<值1> = <字典变量1>[<键1>]
<值2> = <字典变量1>[<键2>]
<值n> = <字典变量1>[<键n>]
# 中括号 [ ] 用来向字典变量中索引或增加元素

d = {"中国": "北京", "美国": "华盛顿", "法国": "巴黎"}
print("d =>", d)
print('d["中国"] =>', d["中国"])
print('type(d) =>', type(d))
''' 
d => {'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}
d["中国"] => 北京
type(d) => <class 'dict'>
'''

字典处理函数及方法

.mp4%22%2C%22size%22%3A106611247%2C%22taskId%22%3A%22u7a65b52d-479b-4e06-8776-507441b496a%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480720931-8d44ea09-e16d-46f3-9db8-7cacdeeeb9fc.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22qAnsV%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#qAnsV)

d = {"中国": "北京", "美国": "华盛顿", "法国": "巴黎"}
print('1.', "中国" in d)
print('2.', d.keys())
print('3.', d.values())
print('4.', d.get("中国", "伊斯兰堡"))
print('5.', d)
print('6.', d.get("巴基斯坦", "伊斯兰堡"))
print('7.', d)
print('8.', d.popitem())
print('9.', d)
''' 
1. True
2. dict_keys(['中国', '美国', '法国'])
3. dict_values(['北京', '华盛顿', '巴黎'])
4. 北京
5. {'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}
6. 伊斯兰堡
7. {'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}
8. ('法国', '巴黎')
9. {'中国': '北京', '美国': '华盛顿'}
'''

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

字典类型应用场景

.mp4%22%2C%22size%22%3A23264812%2C%22taskId%22%3A%22u9fbc30e6-cacb-48f6-ba5f-37c4aba4f56%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480728249-ede627fa-64cd-4182-bfbe-a11b67e5d10d.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22exJ4d%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#exJ4d) 字典类型的应用场景：映射的表达

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

for k in d:
    <语句块>

本周介绍的集合类型，主要解决的问题就是对一组数据的处理，我们需要掌握：如何合理地使用集合类型来表达一组数据，并管理这一组数据。

单元小结

.mp4%22%2C%22size%22%3A16620534%2C%22taskId%22%3A%22udab0e2f3-6b5a-48e5-9f53-edb98f7d249%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480744413-43b8d574-ba0f-4b09-95e4-20a7164dd20c.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22eCuy5%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#eCuy5)

• 映射关系采用键值对表达
• 字典类型使用 {} 和 dict() 创建，键值对之间用 : 分隔
• d[key] 方式既可以索引，也可以赋值
• 字典类型有一批操作方法和函数，最重要的是 .get()

模块5: jieba 库的使用

jieba 库基本介绍

.mp4%22%2C%22size%22%3A35116866%2C%22taskId%22%3A%22u67d60dee-d0cb-4fe5-974e-a0a2a392c94%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480749383-205c0547-edd1-4f5c-84da-9a4298033816.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22eae00%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#eae00) jieba 是优秀的中文分词第三方库

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

jieba 库的安装：pip install jieba

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

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

jieba 库使用说明

.mp4%22%2C%22size%22%3A69777454%2C%22taskId%22%3A%22udfcd8b1d-8d9d-4e9c-a5de-22c66f79c7c%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480752476-fd903ab3-c520-4607-8c63-bb9b2ae0877a.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22cT3v2%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#cT3v2) jieba 分词的三种模式：精确模式、全模式、搜索引擎模式

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

重点：jieba.lcut(s)

实例10: 文本词频统计

问题分析

.mp4%22%2C%22size%22%3A20491334%2C%22taskId%22%3A%22u8ab8b573-f7e0-4985-88e4-1a67d929f47%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480753746-808f0d8f-a9d9-45f5-bce3-a96b4e7bd2b8.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22qa8re%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#qa8re) 文本词频统计

需求：一篇文章，出现了哪些词？哪些词出现得最多？

该怎么做呢？
先分析文本是英文文本还是中文文本

素材：

• 英文文本：Hamet 分析词频 https://python123.io/resources/pye/hamlet.txt
• 中文文本：《三国演义》 分析人物 https://python123.io/resources/pye/threekingdoms.txt

实例讲解

.mp4%22%2C%22size%22%3A123828580%2C%22taskId%22%3A%22ub7bb16ce-c4fd-425e-b399-a2b711badbe%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480762044-984b48e3-2a54-4660-aa3e-4e20fd7ab179.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22Zkw7Q%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#Zkw7Q)

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))
''' 
the        1138
and         965
to          754
of          669
you         550
i           542
a           542
my          514
hamlet      462
in          436
'''

这是一个简单的词频统计程序，用于分析《哈姆雷特》剧本的文本数据。下面是每一部分的详细解释：

1. getText 函数读取存储在 “hamlet.txt” 文件中的哈姆雷特文本。它将所有字符转换为小写，然后将所有特殊字符（如标点符号和其他非字母数字字符）替换为空格。
2. hamletTxt 是从 “hamlet.txt” 文件中获取的处理过的文本。
3. words 是一个列表，其中包含 hamletTxt 中的所有单词。单词是通过将文本字符串 hamletTxt 按空格字符分割得到的。
4. counts 是一个字典，用于存储每个单词及其出现的次数。
5. 接下来的 for 循环遍历 words 列表中的每个单词。对于列表中的每个单词，如果它不在 counts 字典中，就将它添加到字典中并设置其计数为1。如果它已经在字典中，就将其计数增加1。
6. 然后，将 counts 字典转换为一个包含键值对（单词和计数）的列表 items。
7. 通过 sort 方法对 items 列表进行排序，按照每个元素的第二个值（即单词出现的次数）进行降序排序。
8. 最后，打印出现频率最高的前10个单词及其出现次数。

整体来说，该程序的目的是找出哈姆雷特文本中最常出现的单词。

实例讲解（上）

(1).mp4%22%2C%22size%22%3A47706817%2C%22taskId%22%3A%22ua2538291-6dd9-4dcf-87da-8d3a92fc3b0%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480764141-792e9ac7-7381-4e49-8612-0cea0f9a1a1b.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22j16yo%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#j16yo)

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))
''' 
曹操          953
孔明          836
将军          772
却说          656
玄德          585
关公          510
丞相          491
二人          469
不可          440
荆州          425
玄德曰         390
孔明曰         390
不能          384
如此          378
张飞          358
'''

这个程序是用于分析《三国演义》文本的词频统计程序，它基于 Python 的 jieba 模块，这是一个用于中文分词的库。下面是每一部分的详细解释：

1. 首先，程序打开 “threekingdoms.txt” 文件并读取所有的文本内容。该文件应该包含《三国演义》的全部或部分文本。
2. 然后使用 jieba.lcut() 函数将全文进行分词。分词的结果是一个列表，其中每个元素都是一个单词或短语。
3. counts 是一个字典，用于存储每个词及其出现的次数。
4. 程序通过 for 循环遍历 words 列表中的每个词。如果一个词的长度为1（即，它是一个单个的中文字符），则程序将跳过这个词并继续下一个词。否则，程序将检查这个词是否已经存在于 counts 字典中。如果不存在，将它添加到字典中并设置其计数为1。如果存在，就将其计数增加1。
5. 然后，将 counts 字典转换为一个包含键值对（即词和计数）的列表 items。
6. 接下来，使用 sort() 函数对 items 列表进行排序，排序的依据是每个元素的第二个值（即词出现的次数）。reverse=True 指定按降序排序。
7. 最后，打印出现频率最高的前15个词及其出现次数。

总的来说，该程序的目的是找出《三国演义》中最常出现的词或短语。这个程序利用了 jieba 库的中文分词能力，所以它能够处理复杂的中文文本数据。

实例讲解（下）

(1).mp4%22%2C%22size%22%3A101458861%2C%22taskId%22%3A%22ufd2c18cb-87ec-4bb2-b743-f36c5f71622%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480764180-d742a8b5-2cbf-4424-b3c8-3c70fc59c299.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22py7f0%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#py7f0)

import jieba
excludes = {"将军", "却说", "荆州", "二人", "不可", "不能", "如此"}
txt = open("threekingdoms.txt", "r", encoding='utf-8').read()
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))
''' 
曹操         1451
孔明         1383
刘备         1252
关羽          784
张飞          358
商议          344
如何          338
主公          331
军士          317
吕布          300
'''

这个程序是对 “CalThreeKingdomsV1.py” 的改进。它同样用于分析《三国演义》文本的词频统计，但增加了更多的功能。

1. 程序首先定义了一个 excludes 集合，这个集合包含一些我们想要从统计结果中排除的词。
2. 然后，程序打开 “threekingdoms.txt” 文件并读取所有的文本内容。该文件应该包含《三国演义》的全部或部分文本。
3. 使用 jieba.lcut() 函数将全文进行分词。分词的结果是一个列表，其中每个元素都是一个单词或短语。
4. counts 是一个字典，用于存储每个词及其出现的次数。
5. 程序通过 for 循环遍历 words 列表中的每个词。如果一个词的长度为1（即，它是一个单个的中文字符），则程序将跳过这个词并继续下一个词。程序对一些特殊的词进行处理，比如将 “诸葛亮” 和 “孔明曰” 都视为 “孔明”。这样做的目的是处理文本中的同一实体可能有多种表示方法的问题。然后，程序将检查这个词（或者处理过的词）是否已经存在于 counts 字典中。如果不存在，将它添加到字典中并设置其计数为1。如果存在，就将其计数增加1。
6. 在统计完所有词的出现次数之后，程序遍历 excludes 集合中的每一个词，并从 counts 字典中删除它们。这是为了在最后的统计结果中排除这些词。
7. 然后，将 counts 字典转换为一个包含键值对（即词和计数）的列表 items。
8. 使用 sort() 函数对 items 列表进行排序，排序的依据是每个元素的第二个值（即词出现的次数）。reverse=True 指定按降序排序。
9. 最后，打印出现频率最高的前10个词及其出现次数。

总的来说，该程序的目的是找出《三国演义》中最常出现的词或短语（排除一些常见但并不重要的词）。这个程序利用了 jieba 库的中文分词能力，并进行了更复杂的处理，以便更准确地分析中文文本。

举一反三

.mp4%22%2C%22size%22%3A27621144%2C%22taskId%22%3A%22u385b113a-0727-4de6-bd9a-b3ecdea9371%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480764249-d4d491e8-5447-4c29-ae20-ea3ecb114e9c.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22FffKs%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#FffKs)

作业与练习

.mp4%22%2C%22size%22%3A4608993%2C%22taskId%22%3A%22u98fddeb5-77c4-4d9f-883d-88594825beb%22%2C%22taskType%22%3A%22upload%22%2C%22url%22%3Anull%2C%22cover%22%3Anull%2C%22videoId%22%3A%22inputs%2Fprod%2Fyuque%2F2023%2F2331396%2Fmp4%2F1688480780756-cf0a7fa1-b998-4409-a8f5-2eae343ce740.mp4%22%2C%22download%22%3Afalse%2C%22__spacing%22%3A%22both%22%2C%22id%22%3A%22FT3pM%22%2C%22margin%22%3A%7B%22top%22%3Atrue%2C%22bottom%22%3Atrue%7D%2C%22card%22%3A%22video%22%7D#FT3pM)

单选题

人名独特性统计

s = '''双儿 洪七公 赵敏 赵敏 逍遥子 鳌拜 殷天正 金轮法王 乔峰 杨过 洪七公 郭靖 
       杨逍 鳌拜 殷天正 段誉 杨逍 慕容复 阿紫 慕容复 郭芙 乔峰 令狐冲 郭芙 
       金轮法王 小龙女 杨过 慕容复 梅超风 李莫愁 洪七公 张无忌 梅超风 杨逍 
       鳌拜 岳不群 黄药师 黄蓉 段誉 金轮法王 忽必烈 忽必烈 张三丰 乔峰 乔峰 
       阿紫 乔峰 金轮法王 袁冠南 张无忌 郭襄 黄蓉 李莫愁 赵敏 赵敏 郭芙 张三丰 
       乔峰 赵敏 梅超风 双儿 鳌拜 陈家洛 袁冠南 郭芙 郭芙 杨逍 赵敏 金轮法王 
       忽必烈 慕容复 张三丰 杨逍 令狐冲 黄药师 袁冠南 杨逍 完颜洪烈 殷天正 
       李莫愁 阿紫 逍遥子 乔峰 逍遥子 完颜洪烈 郭芙 杨逍 张无忌 杨过 慕容复 
       逍遥子 虚竹 双儿 乔峰 郭芙 黄蓉 李莫愁 陈家洛 杨过 忽必烈 鳌拜 王语嫣 
       洪七公 韦小宝 阿朱 梅超风 段誉 岳灵珊 完颜洪烈 乔峰 段誉 杨过 杨过 慕容复 
       黄蓉 杨过 阿紫 杨逍 张三丰 张三丰 赵敏 张三丰 杨逍 黄蓉 金轮法王 郭襄 
       张三丰 令狐冲 郭芙 韦小宝 黄药师 阿紫 韦小宝 金轮法王 杨逍 令狐冲 阿紫 
       洪七公 袁冠南 双儿 郭靖 鳌拜 谢逊 阿紫 郭襄 梅超风 张无忌 段誉 忽必烈 
       完颜洪烈 双儿 逍遥子 谢逊 完颜洪烈 殷天正 金轮法王 张三丰 双儿 郭襄 阿朱 
       郭襄 双儿 李莫愁 郭襄 忽必烈 金轮法王 张无忌 鳌拜 忽必烈 郭襄 令狐冲 
       谢逊 梅超风 殷天正 段誉 袁冠南 张三丰 王语嫣 阿紫 谢逊 杨过 郭靖 黄蓉 
       双儿 灭绝师太 段誉 张无忌 陈家洛 黄蓉 鳌拜 黄药师 逍遥子 忽必烈 赵敏 
       逍遥子 完颜洪烈 金轮法王 双儿 鳌拜 洪七公 郭芙 郭襄'''
ls = s.split()
ss = set(ls)
print(len(ss)) # 36

去重需求由集合类型来完成。

字典翻转输出

s = input()
try:
    d = eval(s)
    e = {}
    for k in d:
        e[d[k]] = k
    print(e)
except:
    print("输入错误")
''' 
{"a": 1, "b": 2}
{1: 'a', 2: 'b'}
'''

《沉默的羔羊》之最多单词

附件：沉默的羔羊.txt

import jieba
f = open("沉默的羔羊.txt", encoding='utf-8')
ls = jieba.lcut(f.read())
d = {}
for w in ls:
    if len(w) >= 2:
        d[w] = d.get(w, 0) + 1
maxc = 0
maxw = ""
for k in d:
    if d[k] > maxc:
        maxc = d[k]
        maxw = k
    elif d[k] == maxc and k > maxw:
        maxw = k
print(maxw) # 史达琳
f.close()

数字不同数之和

n = input()
ss = set(n)
s = 0
for i in ss:
    s += eval(i)
print(s)
''' 
123123123
6
'''

注意，字符串可以通过list()直接变成列表，或通过set()直接变成集合。

人名最多数统计

s = '''双儿 洪七公 赵敏 赵敏 逍遥子 鳌拜 殷天正 金轮法王 乔峰 杨过 洪七公 郭靖 
       杨逍 鳌拜 殷天正 段誉 杨逍 慕容复 阿紫 慕容复 郭芙 乔峰 令狐冲 郭芙 
       金轮法王 小龙女 杨过 慕容复 梅超风 李莫愁 洪七公 张无忌 梅超风 杨逍 
       鳌拜 岳不群 黄药师 黄蓉 段誉 金轮法王 忽必烈 忽必烈 张三丰 乔峰 乔峰 
       阿紫 乔峰 金轮法王 袁冠南 张无忌 郭襄 黄蓉 李莫愁 赵敏 赵敏 郭芙 张三丰 
       乔峰 赵敏 梅超风 双儿 鳌拜 陈家洛 袁冠南 郭芙 郭芙 杨逍 赵敏 金轮法王 
       忽必烈 慕容复 张三丰 赵敏 杨逍 令狐冲 黄药师 袁冠南 杨逍 完颜洪烈 殷天正 
       李莫愁 阿紫 逍遥子 乔峰 逍遥子 完颜洪烈 郭芙 杨逍 张无忌 杨过 慕容复 
       逍遥子 虚竹 双儿 乔峰 郭芙 黄蓉 李莫愁 陈家洛 杨过 忽必烈 鳌拜 王语嫣 
       洪七公 韦小宝 阿朱 梅超风 段誉 岳灵珊 完颜洪烈 乔峰 段誉 杨过 杨过 慕容复 
       黄蓉 杨过 阿紫 杨逍 张三丰 张三丰 赵敏 张三丰 杨逍 黄蓉 金轮法王 郭襄 
       张三丰 令狐冲 赵敏 郭芙 韦小宝 黄药师 阿紫 韦小宝 金轮法王 杨逍 令狐冲 阿紫 
       洪七公 袁冠南 双儿 郭靖 鳌拜 谢逊 阿紫 郭襄 梅超风 张无忌 段誉 忽必烈 
       完颜洪烈 双儿 逍遥子 谢逊 完颜洪烈 殷天正 金轮法王 张三丰 双儿 郭襄 阿朱 
       郭襄 双儿 李莫愁 郭襄 忽必烈 金轮法王 张无忌 鳌拜 忽必烈 郭襄 令狐冲 
       谢逊 梅超风 殷天正 段誉 袁冠南 张三丰 王语嫣 阿紫 谢逊 杨过 郭靖 黄蓉 
       双儿 灭绝师太 段誉 张无忌 陈家洛 黄蓉 鳌拜 黄药师 逍遥子 忽必烈 赵敏 
       逍遥子 完颜洪烈 金轮法王 双儿 鳌拜 洪七公 郭芙 郭襄 赵敏'''
ls = s.split()
d = {}
for i in ls:
    d[i] = d.get(i, 0) + 1
max_name, max_cnt = "", 0
for k in d:
    if d[k] > max_cnt:
        max_name, max_cnt = k, d[k]
print(max_name) # 赵敏

这是传统解法，先使用字典建立”姓名与出现次数”的关系，然后找出现次数最多数对应的姓名。

补充

基本统计值是什么？

在编程中，“基本统计值”（basic statistical measures）是指用于描述和分析数据集的一组常见统计量。这些统计量提供了有关数据集中数据分布、中心趋势和变异程度的信息，有助于了解数据的特征和性质。

以下是一些常见的基本统计值：

1. 平均值（Mean）：数据集中所有数值的总和除以数据的数量，用于衡量数据的中心趋势。
2. 中位数（Median）：将数据集中的数值按升序排列，取中间位置的数值作为中位数，用于衡量数据的中心趋势。
3. 众数（Mode）：数据集中出现次数最多的数值，可能有一个或多个众数。
4. 标准差（Standard Deviation）：衡量数据的离散程度或变异程度，表示数据值与其平均值之间的差异。
5. 范围（Range）：数据集中最大值与最小值之间的差异，用于衡量数据的变化范围。
6. 四分位数（Quartiles）：将数据集按升序排列后，将其划分为四个等分点，分别是第一四分位数（25%分位数）、第二四分位数（中位数，50%分位数）和第三四分位数（75%分位数）。

这些基本统计值可以提供对数据集的总体概述和特征描述，有助于数据分析、可视化和做出决策。

需要注意的是，基本统计值只是数据分析中的一部分，还有其他更高级的统计方法和概念可以应用于数据集。

为什么嵩老师不建议低龄儿童学编程？

全国计算机等级考试二级 Python 科目