【笔记】《python语言程序设计》——组合数据类型

一、前言

学习就是一个不断的自下而上，自上而下的过程。

前段时间，学着用python实现网站的数据爬取，隐约get到python的一些语法和用法，感觉就是语法不难，关键在于解决问题的思维。

这是需求驱动后的学习。接下来，就需要对python进行系统地了解。

很早之前搜知乎的时候，就搜到MOOC上的一门《python语言程序设计》课程，讲得很好，而且，我还下载了课件，溜了一遍，感觉就挺有趣的。

趁着有了实战经验，就把这门入门课刷了一遍。果然是门好课！很适合小白入门，并系统学习，整个教学过程循序渐进，深入浅出，提纲挈领，很有意思！

课程是北京理工大学嵩天老师的《python语言程序设计》课程，现在已经开了11次课了。课程每个小视频短则几分钟，最长也不超过20分钟，不容易劝退。每章讲解有复习回顾及小结，在平台python123上有每章的练习和测试，直接反馈结果，激发继续学下去的兴趣。

个人感觉，老师说话速度慢了些，调成了2倍速播放，然后，花了大约3天的时间，把所有的视频，课件，练习和测试都刷了一遍，感觉对python的了解更系统了！

趁热打铁，把每章的知识点和练习、测试再进行整理回顾一下。

以下内容均来自课程：《python语言程序设计》 及平台python123，感兴趣的看课程视频，亲自练习，效果更好~

二、知识点

1.集合类型及操作

1. 集合类型定义

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

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

   ③集合元素不可更改，不能是可变数据类型

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

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

   ⑥建立空集合类型，必须使用set{}

   A={'python',123,('python',123)}
   B=set('pypy123')
   C={'python',123,'python',123}
   print(A)
   #结果：{'python',123,('python',123)}
   print(B)
   #结果：{'1','p','2','3','y'}
   print(C)
   #结果：{'python',123}
   

2. 集合操作符

   操作符及应用	描述
   S|T	并，返回一个新集合，包括在集合S和T中的所有元素
   S-T	差，返回一个新集合，包括在集合S但不在T中的元素
   S&T	交，返回一个新集合，包括同时在集合S和T中的元素
   S^T	补，返回一个新集合，包括集合S和T中的非相同元素
   S<=T或S	返回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中的非相同元素

A={'p','y',123}
B=set('pypy123')
print(A-B)
#结果：{123}
print(A&B)
#结果：{'p','y'}
print(A^B)
#结果：{'2',123,'3','1'}
print(B-A)
#结果：{'3','1','2'}
print(A|B)
#结果：{'1','p','2','y','3',123}

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(x)	移除S中所有元素
   S.pop(x)	随机返回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转变为集合类型

4. 集合类型应用场景

   ①包含关系比较

   'p' in {'p','y',123}
   #结果：True
   {'p','y'}>={'p','y',123}
   #结果：False
   

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

   ls=['p','p','y','y',123]
   s=set(ls)
   print(s)
   #结果：{'p','y',123}
   lt=list(s)
   #结果：['p','y',123]
   

2.序列类型及操作

1. 序列类型定义

   ①序列是具有先后关系的一组元素；一维元素向量，元素类型可以不同；元素间由序号引导，通过下标访问序列的特定元素；

   ②序列是一个基类类型：字符串，元组，列表类型；

   ③序号：正向递增序号和反向递减序号；

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为步长的元素子序列

   ②函数和方法

   函数和方法	描述
   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的总次数

3. 元组类型及操作

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

   ②元组一旦创建就不能被修改；

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

   ④可以使用或不适用小括号

4. 列表类型及操作

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

   ②列表创建后可以随意被修改；

   ③使用方括号[]或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中的元素反转

5. 序列类型应用场景

   ①数据表示：元组和列表；元组用于元素不改变的应用场景，更多用于固定搭配场景；列表更加灵活，是最常用的序列类型；

   ②元素遍历；

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

3.实例9：基本统计值计算

描述：计算总个数，求和，平均值，方差，中位数

#获取用户不定长度的输入
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+=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)-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.字典类型及操作

1. 字典类型定义

   ①字典类型是“映射”的体现；是键值对的集合；键值对之间无序；

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

   ③在字典变量中，通过键获得值：<值>=<字典变量>[<键>];<字典变量>[<键>]=<值>

2. 字典处理函数及方法

   函数或方法	描述
   del d[k]	删除字典d中键k对应的数据值
   k in d	判断键k是否在字典d中，如果在返回True，否则False
   d.keys()	返回字典d中所有的键信息
   d.values()	返回字典d中所有的值信息
   d.itmes()	返回字典d中所有键值对信息
   d.get(k,)	键k存在，则返回相应值，不在则返回值
   d.pop(k,)	键k存在，则取出相应值，不在则返回值
   d.popitem()	随机从字典d中取出一个键值对，以元组形式返回
   d.clear	删除所有键值对
   len(d)	返回字典d中元素的个数

3. 字典类型应用场景

   ①表达键值对数据，进而操作它们；

   ②元素遍历；

5.模块5：jieba库的使用

1. jieba库概述

   ①jieba是优秀的中文分词第三方库，需要额外安装(cmd命令行)pip install jieba

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

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

2. jieba库使用说明

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

   ②常用函数

   函数	描述
   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

6. 实例10：文本词频统计

描述：英文文本Hamlet英文词频统计，列出前10

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))

描述：《三国演义》人物出场统计，列出前10

import jieba
txt=open('threekingdoms.txt','r',encoding='utf-8').read()
exclude={'将军','却说','荆州','二人','不可','不能','如此'}
words=jieba.lcut(txt)
counts={}
for word in words:
    if len(word)==1:
        continue
    elif word in ['诸葛亮','孔明曰']:
        rword='孔明'
    elif word in ['关公','云长']:
        rword='关羽'
    elif word in ['玄德','玄德曰']:
        rword='刘备'
    elif word in ['孟德','丞相']:
        rword='曹操'
    else:
        rword=word
    counts[rword]=counts.get(rword,0)+1
for word in exclude:
    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))

三、练习

1. 实例9：基本统计值计算

同上

2.实例10：文本词频统计 -- Hamlet

同上

3. 人名独特性统计

描述：编程模板中给出了一个字符串，其中包含了含有重复的人名，请去重后给出独特性人名的统计。

输出模板中字符串共有多少个独特人名。

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

4. 字典翻转输出

描述：读入一个字典类型的字符串，反转其中键值对输出。

即，读入字典key:value模式，输出value:key模式。

输入格式

用户输入的字典格式的字符串，如果输入不正确，提示：输入错误。

输出格式

给定字典d，按照print(d)方式输出

d=eval(input())
if type(d)!=type({"a": 1, "b": 2}):
    print('输入错误')
else:
    k=list(d.values())
    v=list(d.keys())
    new={}
    for i in range(len(d)):
        new[k[i]]=v[i]
    print(new)

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

描述：附件是《沉默的羔羊》中文版内容，请读入内容，分词后输出长度大于2且最多的单词。

如果存在多个单词出现频率一致，请输出按照Unicode排序后最大的单词。

输入格式

文件

输出格式

字符串

import jieba
text=open('沉默的羔羊.txt','r',encoding='utf-8').read()
words=jieba.lcut(text)
counts={}
for w in words:
    if len(w)<=2:
        continue
    else:
        counts[w]=counts.get(w,0)+1
items=list(counts.items())
items.sort(key=lambda x:x[1],reverse=True)
maxfre=items[0][1]
maxwords=[]
for i in items:
    if i[1]==maxfre:
        maxwords.append(i)
    else:
        break
maxwords.sort(key=lambda x:x[0],reverse=True)
print(maxwords[0][0])

四、测试

1.选择题

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

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

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

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

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

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

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

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

   B 判断x是否是字典d中的键

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

   D 判断x是否是字典d中的值

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

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

3. 哪个选项是下面代码的输出结果？

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

A 3 B {'b':2} C 1 D 2

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

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

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

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

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

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

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

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

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

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

   A 字符串类型

   B 数组类型

   C 列表类型

   D 元组类型

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   B 元组中元素必须是相同类型

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

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

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

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

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

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

   C 返回序列s中x的长度

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

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

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

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

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

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

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

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

2.程序设计题

1. 数字不同数之和

描述：获得用户输入的一个整数N，输出N中所出现不同数字的和。

例如：用户输入 123123123，其中所出现的不同数字为：1、2、3，这几个数字和为6。

num=input()
l=[]
for i in num:
    l.append(eval(i))
l=set(l)
s=0
for i in l:
    s+=i
print(s)

2. 人名最多数统计

描述：编程模板中给出了一个字符串，其中包含了含有重复的人名，请直接输出出现最多的人名。

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

【笔记】《python语言程序设计》—Python基本语法元素

【笔记】《python语言程序设计》—Python基本图形绘制

【笔记】《python语言程序设计》——基本数据类型

【笔记】《python语言程序设计》——程序的控制结构

【笔记】《python语言程序设计》——函数和代码复用

【笔记】《python语言程序设计》——组合数据类型

【笔记】《python语言程序设计》——文件和数据格式化

【笔记】《python语言程序设计》——程序设计方法学

【笔记】《python语言程序设计》——python计算生态概览