资源简介

(共165张PPT)
第12章　Python的数据类型及其操作
知识与技能要点 考试条目 考试水平(A/B/C/D)
数值型 1.整型 C
2.布尔型 C
3.浮点型 C
4.复数型 C
知识与技能要点 考试条目 考试水平(A/B/C/D)
序列 1.序列概述 B
2.序列索引 C
3.序列切片 C
4.序列基本操作 C
5.Python对象的比较 C
6.和序列相关的内置函数 C
知识与技能要点 考试条目 考试水平(A/B/C/D)
字符串 1.字符串的表示与创建 C
2.字符串的常用操作 C
列表 1.列表的表示与创建 D
2.列表索引 D
3.列表的常用操作方法 D
知识与技能要点 考试条目 考试水平(A/B/C/D)
元组 1.元组的表示与创建 D
2.元组的常用基本操作 D
字典 1.字典的概念 D
2.字典的创建 D
3.字典的基本操作 D
4.字典常用的函数 D
知识与技能要点 考试条目 考试水平(A/B/C/D)
集合 1.集合的概念 B
2.集合的定义 D
3.集合的常用方法与运算 D
复习建议
本章内容在职教高考中序列、字典、集合是Python的特色,也是学习的重难点之一,它变化多,应用灵活,对中职生而言必须对照资料把基本概念、基本方法与操作、常见应用场景等在反复练习的基础上方能真正掌握,否则很难做到。一句话,多看、多练、多上机是唯一的捷径。
Python内置的数值类型有很多,整型和浮点型是最为常用的两种。布尔型可以认为是特殊的整型。
考点1
数值型
备考讲义
1.整型(C)
整数类型共有4种进制表示方法,分别为十进制、二进制、八进制和十六进制。默认情况是十进制,其他进制则需要增加引导符号。在Python语言中,整数类型定义为int一类,我们可以通过int函数来生成一个整数。
(1)表达形式
①十进制：
即数学意义上的满十进一数。
②二进制类型,以0B或0b开头。
二进制由1和0两个数字组成,满2向前进一位,如0B1010,0b100等。
③八进制类型,以0O或0o开头。
八进制单位最大数字为7,满8向前进一位,如0O7,0o12等。
④十六进制类型,以0X或0x开头。
十六进制单位最大数字为15,但由于无法用单一数字表示,因此利用英文字母A~F分别表示 10~15,如0X1F,0x11A等。
(2)进制转化
在Python程序当中,如果想知道与其他进制数对应的十进制数,只需直接在程序中输入即可,因为程序默认以十进制数返回,因而会自动把数字转化为十进制数。
2.布尔型(C)
(1)布尔数据类型概述
Python 布尔数据类型,简称布尔类型,在 Python 中用bool表示。bool 类是 int 类的子类。布尔类型提供了两个布尔值来表示真(对)或假(错),在 Python 中分别用 True(真或对)或False(假或错)来表示。True 和 False 是 Python 的关键字,在使用时,一定要注意首字母要大写,否则解释器会报错。
(2)注意事项
bool 类是 int 类的子类,其他类不能继承它,它只有False 和 True 两个值。在 Python 中,任何对象都可以进行真假值的判断。布尔类型的布尔值可以当作整数对待,但在日常开发中是不建议这么用的,实属不妥。布尔值可以当作整数来对待,即 True 相当于整数值 1,False 相当于整数值 0。
(3)相关函数 bool()
class bool([x])
返回一个布尔值,True 或者 False。如果 x 是假的或者被省略,返回 False;其他情况返回 True。在Python 3.7 版更改后 x 现在只能作为位置参数。
print(bool(2>4))　# x 参数为假
运行结果：False
(4)运算规则
x　and　y #　x的值为真则返回y的值,x的值为假则返回x的值
x　or　y #　x的值为真则返回x的值,x的值为假则返回y的值
not　x #　x的值为真则返回False,x的值为假则返回True
3.浮点型(C)
浮点型用来表示小数,是带小数点的数字,用float表示。浮点数有两种表达方式——十进制和科学计数的方式。在Python语言中,利用float定义浮点数类型,可以用float函数来生成一个浮点数。
如float() #　0
float(10) #　10.0
(1)十进制
Python浮点型数据默认的就是十进制。
(2)科学计数
当数字小数位数过多时,如果按普通的十进制写法就十分麻烦,这时就需要科学记数法帮助简化写法,如：
31415926可以写为3.1415926 * 107,在程序中表达为3.1415926E(e)+7;
0.005可以写作5 * 10-3,程序中表达为5E(e)-3
3.1415926E+7 #31415926.0
5e-3 #0.005
注意：直接使用==比较浮点数的话会对最终的结果产生影响。
4.复数型(C)
复数类型表示数学意义上的复数,在Python语言中,利用complex定义复数类型,可以利用complex函数来创建一个复数,其中虚数部分通过后缀“J”或“j”表示,可以用complex.real和complex.imag分别获取复数的实部和虚部部分,其中实部和虚部的数值都是浮点数类型。
c1=complex(6,2)
c1#(6+2j)
c1.real #6.0
c1.imag #2.0
5.Python内置数值函数
(1)数值运算函数
函数　　 功能
abs(x)　　 #计算并返回x的绝对值
divmod(x,y)　 #以二元组的形式返回(x //y,x%y)
pow(x,y)　　 #返回x的y次幂,同x**y
pow(x,y,z)　　 #返回(x**y)% z
round(x [,ndigits ]) #对x进行四舍五入操作,保留ndigits位小
数。round(x)则返回整数值
min(x1,x2,……,xn) #返回x1 ~xn中最小值
max(x1,x2,……,xn) #返回x1 ~xn中最大值
(2)数值类型转换函数
Python的这些操作都会产生不同数据类型的数据。例如两个整数做 “/”运算就会产生浮点数的结果。针对这个情况Python提供了内置的数值类型转换函数,可以让两个数据进行数值类型转换。
函数 功能
int(x) #将x的数值类型转化为整数,x可以是浮点数,字符串
float(x)　　 #将x转化为浮点数,x可以是字符串,
可以是整数
complex(x [,im])　 #生成一个复数x(其实部为x,im为可
选虚部,默认为0),其中x可以为整数、
浮点数、字符串;im可以是整数、浮
点数,但是不能为字符串。
6.数值运算注意事项
(1)数字存在的意义就是通过相互之间的运算从而得出自己想要的结果。Python语言提供了内置的运算符和内置的函数来实现数值间的运算。
(2)运算规则
不同的数值类型之间是可以相互进行运算的,为了能够在这种情况下让返回的数值类型有一个固定类型,有了以下运算规则。
①整数间运算,如果数学意义上结果是小数,那么结果类型为浮点数类型。
9/3 #3.0
12/5 #2.4
②整数与浮点数之间进行混合运算,结果为浮点数类型。
12*2.0 #24.0
5+6.0 #11.0
③整数或浮点数与复数进行混合运算,结果为复数。
6+12+8j #18+8j
8.0*4+9j #32+9j
例1　X=5-12j,分别写出X的实部、虚部和它的绝对值并分别判读输出的值。
【试题分析】 这道题全面考查学生对数值型数据中的复数类型(complex)基础知识点的掌握,特别注意要审好题,先问的是实部、虚部及绝对值怎么表示,再问的是实部、虚部及绝对值输出的值,在概念清晰的情况下要细心,实部、虚部、绝对值的输出结果类型是浮点数,不能写成整型,输出复数虚部值时不能加虚数单位j。
【解析】 Python中复数由实部和虚部组成,实部用对象名.real表示,虚部用对象名.imag表示,复数的绝对值就是复数的模,用abs(对象名)表示。
答案：X的实部X.real,输出的值为5.0
X的虚部X.imag,输出的值为-12.0
X的绝对值abs(X),输出的值为13.0
变式训练1　(1)print(0b101)的结果为________,Print(0o745)
的结果为________,Print(0×678)的结果为________。
5
485　
1656
【试题分析】 本题考查学生对整型数据的掌握情况,注意结果必须是十进制数。
【解析】 根据以上分析0b101是二进制整数,0o745是八进制整数,0x678是十六进制整数,因此结果分别是5、485、1656。
(2)power(3,3,3)的结果为________,round(271828182846,-7)的结果为____________________,complex(1,-1)的结果为________。
0
271830000000　
1-1j
【试题分析】 本题考查学生对数值型数据常用处理函数的掌握情况,特别注意函数中可选参数的实际含义。
【解析】 pow(x,y,z)表示x的y次幂后除以z的余数,因此power(3,3,3)的结果为0,round(number, ndigits)中,number为需要进行四舍五入的数字,ndigits为保留的小数位数,默认为0。如果ndigits为正数,则表示保留小数点后ndigits位；如果ndigits为负数,则表示将number四舍五入到最近的10的ndigits次方的整数倍,因此round(271828182846,-7)的结果为271830000000。complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串,则不需要指定第二个参数,因此complex(1,-1)的结果为1-1j。
(3)(0.01+0.02)==(0.05-0.02)的结果为________。
False
【试题分析】 本题的主要考查学生对浮点型数据运算的结果比较,因浮点型数据运算时要转换为二进制数,有误差,所以比较的结果是False。
【解析】 根据以上分析可知结果为False。
1.序列概述(B)
序列是一块用于存储多个值的连续内存空间,这些值按一定顺序排列,每个值(元素)都分配一个数字,称为索引或位置,通过该索引可以取出相应的值。常见的序列有元组和列表等。
考点2
序列
备考讲义
2.序列索引(C)
序列中,每个元素都有属于自己的编号(索引)。从起始元素开始,索引值从 0 开始递增。
图12-1　序列索引值示意图
除此之外,Python 还支持索引值是负数,此类索引是从右向左计数,换句话说,从最后一个元素开始计数,从索引值 -1 开始。
图12-2　负值索引示意图
注意,在使用负值作为序列中各元素的索引值时,是从 -1 开始,而不是从 0 开始。无论是采用正索引值,还是负索引值,都可以访问序列中的任何元素。
3.序列切片(C)
切片操作是访问序列中元素的另一种方法,它可以访问一定范围内的元素,通过切片操作,可以生成一个新的序列。序列实现切片操作的语法格式如下。
sname[start ： end ： step]
其中,各个参数的含义分别是：sname表示序列的名称;start表示切片的开始索引位置(包括该位置),此参数也可以不指定,会默认为 0,也就是从序列的开头进行切片;end表示切片的结束索引位置(不包括该位置),如果不指定,则默认为序列的长度;step表示在切片过程中,隔几个存储位置(包含当前位置)取一次元素,也就是说,如果step的值大于1,则在进行切片取序列元素时,会“跳跃式”地取元素。如果省略设置 step 的值,则最后一个冒号就可以省略。
4.序列基本操作(C)
(1)序列相加
Python 中,支持两种类型相同的序列使用“+”运算符做相加操作,它会将两个序列进行连接,但不会去除重复的元素。这里所说的“类型相同”,指的是“+”运算符的两侧序列要么都是列表类型,要么都是元组类型,要么都是字符串。
print(“C语言”+“中文网：”+“c.”) # 输出结果为：C语言中文网：c.
(2)序列相乘
Python 中,使用数字 n 乘以一个序列会生成新的序列,其内容为原来序列被重复 n 次的结果。例如：
print(“C语言中文网”*3) # 输出结果为：C语言中文网C语言中文网C语言中文网
注意：比较特殊的是列表类型在进行乘法运算时,还可以实现初始化指定长度列表的功能。例如如下的代码,将创建一个长度为 5 的列表,列表中的每个元素都是 None,表示什么都没有。
list=[None]*5
print(list)#输出结果为：[None,None,None,None,None]
(3)检查元素是否包含在序列中
Python 中,可以使用 in 关键字检查某元素是否为序列的成员,其语法格式为：
value in sequence
其中,value 表示要检查的元素,sequence 表示指定的序列。
例如,检查字符‘c’是否包含在字符串“c.”中,可以执行如下代码：
print('c'in“c.”)　　#运行结果为True
和 in 关键字用法相同,但功能恰好相反的,还有 not in 关键字,它用来检查某个元素是否不包含在指定的序列中,比如说：
print('c' not in“c.”)　　#运行结果为False
5.Python对象的比较(C)
等于(==)和is是Python中对象比较常用的两种方式。简单来说,“==”操作符比较对象之间的值是否相等,表示比较变量 A 和 B 所指向的值是否相等。而“is”操作符比较的是对象的身份标识是否相等,即它们是否是同一个对象,是否指向同一个内存地址。
在 Python 中,每个对象的身份标识,都能通过函数 ID(object) 获得。因此,“is”操作符,相当于比较对象之间的 ID 是否相等,如下面的例子。
A.=10
B.=10
A.==B.
True
ID(A)
4427562448
ID(B)
4427562448
A is B
True
注意：Python会更高效地缓存字符串和小整数,所以这两种数据类型的ID会存在值相同即ID相同的情况,但其他数据类型不适应此规则。比较操作符“==”表示比较对象间的值是否相等,而“is”表示比较对象的标识是否相等,即它们是否指向同一个内存地址。比较操作符“is”效率优于“==”,而“==”操作符则会递归地遍历对象的所有值,并逐一比较。
6.和序列相关的内置函数(C)
Python提供了几个内置函数,可用于实现与序列相关的一些常用操作。
表12—1　Python内置函数
函数 功能
len() 计算序列的长度,即返回序列中包含多少个元素
max() 找出序列中的最大元素。注意,对序列使用 sum() 函数时,做加和操作的必须都是数字,不能是字符或字符串,否则该函数将抛出异常,因为解释器无法判定是要做连接操作(+运算符可以连接两个序列),还是做加和操作
函数 功能
min() 找出序列中的最小元素
list() 将序列转换为列表
str() 将序列转换为字符串
sum() 计算元素和
sorted() 对元素进行排序
reversed() 反向序列中的元素
enumerate() 将序列组合为一个索引序列,多用在 for 循环中
zip(iter1 [,iter2[…]]) 返回一个zip对象,是一个迭代器,该迭代器的第n个元素是由每个可迭代对象的第n个元素组成的元组
例2　若seasons=['Spring','Summer','Fall','Winter'],则list(enumerate(seasons))的结果为________。
【答案】 [(0,'Spring'),(1,'Summer'),(2,'Fall'),(3,'Winter')]
【试题分析】 这道题全面考查学生对enumerate()函数基础知识点的掌握,特别注意enumerate()函数返回的结果是enumerate对象,是不能直接输出的,因此必须在最外层加一个强制转换函数(如list()),才能输出结果。
【解析】 enumerate()函数将序列组合为一个索引序列,使用时如果没有start参数指定起始索引值,则默认从0开始,第一个元素的元组中的索引值就从0开始一(0,Spring'),如果指定start的值为1(如list(enumerate(seasons,start=1))),即第1个元素在元组中的索引值为(1,'Spring'),结果变为[(1,'Spring'),(2,'Summer'),(3,'Fall'),(4,'Winter')]。
例3　list(zip('hello','world'))的结果为______________________________。
【答案】 [('h','w'),('e','o'),('l','r'),('l','l'),('o','d')]
【试题分析】 这道题全面考查学生对zip()函数基础知识点的掌握,特别注意zip()函数返回的结果是zip对象,是不能直接输出的,因此必须在最外层加一个强制转换函数(如list()),才能输出结果。
【解析】 zip()函数拆分重组(打包)参数列表中的n个迭代器,返回的迭代器中的第i个是由n个迭代器的第i个元素组成的元组。从代码执行结果来看,zip()函数就像拉链,把左排拉链和右排拉链拉起来变成两两一对组合的一排。
变式训练2　(1)任意长度的序列对象最后一个元素的下标为________。
-1
【试题分析】 本题主要考查学生对序列反向序号的理解与记忆。
【解析】 根据以上分析可知序列对象最后一个元素的下标为-1。
(2)在字符串对象x的第三个元素后加入一个字符”3”的代码为___________________。
x[0:3]+”3”+x[3:]
【试题分析】 本题主要考查学生对序列中字符型数据的理解,注意字符型数据属于不可变序列,不能直接更改其中的某一个元素,因此只能用字符串切片+连接的方法来实现这样的操作。
【解析】 根据以上分析可知结果为x[0:3]+”3”+x[3:]。
1.字符串的表示与创建(C)
(1)字符串是字符的序列,Python中字符串的表达方式有以下几种：
①使用单引号(‘’)：
'Hello,lily'
考点3
字符串
备考讲义
②使用双引号(“”)：
"Hello,lily"
③使用三引号("' "')：
'''Hello,lily'''
三引号有一点区别上面两点的功能是能标记多行字符串,比如：
'''hello,
my name is lucy,
what's your name '''
注意：字符串是不可变的。所以当获得内存空间分配后该内存空间中的字符串内容是不可修改的。若想修改,可以采用切片和连接运算从其他字符串中截取片段构造新字符串。
(2)字符串中的转义字符使用
表12—2　转义字符
转义字符 含义 转义字符 含义
\\ 单个\ \r 回车
\\n 换行 \' 单引号
\\t 制表符 \" 双引号
\\0 空字符 \\(在行尾时) 续行符
\\ooo 值为八进制数的字符 \\xhh 值为十六进制数的字符
2.字符串的常用操作(C)
(1)字符串长度
sStr1=‘strlen’
len(sStr1)　#返回字符串长度
(2)截取字符串
str='0123456789'
str[0：3]　#截取第一位到第三位的字符
str[：]　#截取字符串的全部字符
str[6：]　#截取第七个字符到结尾
str[：-3]　#截取从头开始到倒数第三个字符之前
str[2]　#截取第三个字符
str[-1]　#截取倒数第一个字符
str[：：-1]　#创造一个与原字符串顺序相反的字符串
str[-3：-1]　#截取倒数第三位与倒数第一位之前的字符
str[-3：]　#截取倒数第三位到结尾
str[：-5：-3]　#逆序截取,“96”
(3)去空格
s.strip()　#同时去掉字符串中左边和右边的空格
lstrip()　#去掉字符串中左边的空格
rstrip(‘,’)　#去掉字符串中右边的空格
(4)连接字符串
#strcat(sStr1,sStr2)
sStr1=‘strcat’
sStr2=‘append’
sStr1+=sStr2
(5)字符串中的搜索和替换
S.find(substr,[start,[end]])　#返回S中出现substr的第一个字母的标号,如果S中没有substr则返回-1
start和end作用就相当于在S[start：end]中搜索。
sStr1=‘abcdefg’
sStr2=‘cde’
sStr1.find(sStr2)　#返回在字符串sStr1中子字符串sStr2出现的第一个位置,如没有找到,则返回-1
S.index(substr,[start,[end]])　#与find()相同,只是在S中没有substr时,会返回一个运行时错误
sStr1=‘strchr’
sStr2=‘s’
nPos=sStr1.index(sStr2)　#返回在字符串sStr1中子字符串sStr2出现的第一个位置,如没有找到时会产生异常
S.count(substr,[start,[end]])　#计算substr在S中出现的次数
S.replace(oldstr,newstr,[count])　#把S中的oldstar替换为newstr,count为替换次数
(6)字符串中的大小写转换
S.lower()　#英文字符串全部转化为小写
S.upper()　#英文字符串全部转化为大写
S.capitalize()　#英文字符串首字母大写
(7)字符串在输出时的对齐
S.ljust(width,[fillchar])　#输出width个字符,S左对齐,不足部分用fillchar填充,默认的为空格
S.rjust(width,[fillchar])　#输出width个字符,S右对齐,不足部分用fillchar填充,默认的为空格
S.center(width,[fillchar])　#输出width个字符,S中间对齐,不足部分用fillchar填充,默认的为空格
(8)字符串的分割和组合
分割：S.split([sep,[maxsplit]])　#以sep为分隔符,把S分成一个list,maxsplit表示分割的次数
默认的分割符为空白字符。
组合：S.join(seq)　#把seq代表的序列——字符串序列,用S连接起来
(9)字符串的测试、判断函数
这一类函数在string模块中没有,这些函数返回的都是bool值。
S.isalnum()　#是否全是字母和数字,并至少有一个字符
S.isalpha()　#是否全是字母,并至少有一个字符
S.isdigit()　#是否全是数字,并至少有一个字符
S.isspace()　#是否全是空白字符,并至少有一个字符
S.islower()　#S中的字母是否全是小写
S.isupper()　#S中的字母是否全是大写
注意字符串对象是不可改变的,也就是说在Python创建一个字符串后,你不能把这个字符中的某一部分改变。任何上面的函数改变了字符串后,都会返回一个新的字符串,原字符串并没有变。其实这也是有变通的办法的,可以用S=list(S)这个函数把S变为由单个字符为成员的list,这样的话就可以使用S[3]='a’的方式改变值,然后再使用S="".join(S)还原成字符串。
例4　请把字符串”hello,world”中的重复字段去掉,并按顺序排列输出。
【试题分析】 本题主要考查字符串和集合的常用处理函数,可以先利用集合把重复元素去掉,再用sorted方法按默认的升序排序。
【解析】 在Python中利用集合是有效去除序列重复元素的基本方法,然后再利用排序函数对序列元素进行排序,最后用print()函数输出结果。
答案： str1=”hello,world”;s=set(str1);print(sorted(s))
例5　a=”\\101\\t\\x41\\n”;b=”\\141\\t\\x61\\n”,print(a,b)的结果是________。
【答案】
A　　A
a　　a
【试题分析】 本题主要考查字符串的常见转义字符这个知识点,字符串输出时首先判断有无转义字符,该字符串中有转义字符“\\t”表示制表符,“\\n”表示换行。“\\101”是八进制表示,“\\x41”是十六进制表示,同样“\\141”也是八进制表示,“\\x61”是十六进制表示。
【解析】 “\\101”是八进制表示,输出ASCII码对应的字符A,“\\t”是制表符,“\\x41”是十六进制表示,输出ASCII码对应的字符A,“\\n”是换行符。“\\141”是八进制表示,输出ASCII码对应的字符a,“\\t”是制表符,“\\x41”是十六进制表示,输出ASCII码对应的字符a,“\\n”是换行符。
变式训练3　(1)x为一个字符串,它的逆序字符串可表示为________。
x[::-1]
【试题分析】 本题主要考查学生对序列逆序的理解与记忆。
【解析】 根据以上分析可知结果为x[::-1]。
(2)x=”abcdefg”,则x[ ： ： 2]的结果为________,则x[ ： ：-2]的结果为________。
”aceg”
“geca”
【试题分析】 本题主要考查学生对序列切片操作的理解与记忆。序列切片的书写形式:对象名[i : i + n : m],其中i为切片的起始索引,为列表首位时可以忽略。i + n是列表的结束位置,为列表末位时可以忽略。索引范围为[i, i+n),m可以不提供,默认值时1,不允许为0。当m为负数时,列表翻转。
【解析】 根据以上分析可知结果分别为”aceg”、“geca”。
(3)Python语句 ''x.join(list('hello world!'))"执行的结果是____________________。
hello world!
【试题分析】 本题主要考查学生对字符串常用操作函数的理解与记忆,newstr=str.join(iterable)操作中newstr:表示合并后生成的新字符串；str:用于指定合并时的分隔符；terable:做合并操作的源字符串数据,允许以列表、元组等形式提供。
【解析】 根据以上分析可知结果为hello world!,注意问的是执行结果,要看清题目,不能加字符串的定界符。
(4)请用顺序结构的程序把字符串a=“i am chinese”中的每个单词首字母改为大写,其他字母保持不变。
【答案】 x=”i　am　chinese”；print(x.title())
【试题分析】 本题主要考查学生对字符串常用操作方法的理解与记忆,title() 函数的作用是将输入字符串的所有首字母大写, 其余字母小写。
【解析】 根据以上分析可知结果为x=“i　am　chinese”；print(x.title())。
1.列表的表示与创建(D)
(1)通过方括号“[ ]”直接创建列表
使用“[ ]”创建列表后,一般使用“=”将它赋值给某个变量,具体格式如下。
考点4
列表
备考讲义
listname=[element1,element2,element3,…,elementn]
其中,listname 表示变量名,element1 ~ elementn 表示列表元素。
另外,使用此方式创建列表时,列表中元素可以有多个,也可以一个都没有,例如：
emptylist=[ ],这表明,emptylist 是一个空列表。
(2)通过list() 函数创建列表
除了使用“[ ]”创建列表外,Python 还提供了一个内置的函数 list(),使用它可以将其他数据类型转换为列表类型。例如：
list1=list(“hello”)　#将字符串转换成列表
tuple1=('Python','Java','C++','JavaScript')　#将元组转换成列表
list2=list(tuple1)
dict1={'a'：100,'b'：42,'c'：9}　#将字典转换成列表
list3=list(dict1)
range1=list4=list(range(1,6))　#将range对象转换成列表
list()　#创建空列表
2.列表索引(D)
列表是 Python 序列的一种,我们可以使用索引(Index)访问列表中的某个元素(得到的是一个元素的值),也可以使用切片访问列表中的一组元素(得到的是一个新的子列表)。使用索引访问列表元素的格式为：listname[i]
其中,listname 表示列表名字,i 表示索引值。列表的索引可以是正数,也可以是负数。
使用切片访问列表元素的格式为：
listname[start ： end ： step]
其中,listname 表示列表名字,start 表示起始索引,end 表示结束索引,step 表示步长。
3.列表的常用操作方法(D)
(1)列表添加元素的方法
①使用“+”运算符可以将多个序列连接起来：
列表是序列的一种,所以也可以使用“+”进行连接,这样就相当于在第一个列表的末尾添加了另一个列表。例如：info=[“Python”,“C++”,“Java”]+[1991,1998,1995]
注意从运行结果可以发现,使用“+”会生成一个新的列表,原有的列表不会被改变。“+”更多的是用来拼接列表,而且执行效率并不高,如果想在列表中插入元素,应该使用下面几个专门的方法。
②append()方法添加元素：
append() 方法用于在列表的末尾追加元素,该方法的语法格式如下。
listname.append(obj)
其中,listname 表示要添加元素的列表;obj 表示要添加到列表末尾的数据,它可以是单个元素,也可以是列表、元组等。请看下面的演示。
l=['Python','C++','Java']
l.append('PHP')　#追加元素
t=('JavaScript','C#','Go')
l.append(t)　#追加元组,整个元组被当成一个元素
l.append(['Ruby','SQL'])　#追加列表,整个列表也被当成一个元素
可以看到,当用 append() 方法传递列表或者元组时,此方法会将它们视为一个整体,作为一个元素添加到列表中,从而形成包含列表和元组的新列表。
③extend()方法添加元素：
extend() 和 append() 的不同之处在于extend() 不会把列表或者元组视为一个整体,而是把它们包含的元素逐个添加到列表中。
extend() 方法的语法格式如下。
listname.extend(obj)
其中,listname 指的是要添加元素的列表;obj表示要添加到列表末尾的数据,它可以是单个元素,也可以是列表、元组等,但不能是单个的数字。
l=['Python','C++','Java']
l.extend('C')　#添加元素
t=('JavaScript','C#','Go')
l.extend(t)　#添加元组,元组被拆分成多个元素
l.extend(['Ruby','SQL'])　#添加列表,列表也被拆分成多个元素
④insert()方法添加元素：
如果希望在列表中间某个位置插入元素,那么可以使用 insert() 方法。insert() 的语法格式如下。
listname.insert(index,obj)
其中,index 表示指定位置的索引值。insert() 会将 obj 插入到 listname 列表第 index 个元素的位置。当插入列表或者元组时,insert() 也会将它们视为一个整体,作为一个元素插入到列表中,这一点和 append() 是一样的。例如：
l=['Python','C++','Java']
l.insert(1,'C')　#插入元素
t=('C#','Go')
l.insert(2,t)　#插入元组,整个元组被当成一个元素
l.insert(3,['Ruby','SQL'])　#插入列表,整个列表被当成一个元素
l.insert(0,“http：//c.”)　#插入字符串,整个字符串被当成一个元素
提示,insert()函数主要用来在列表的中间位置插入元素,如果你仅仅希望在列表的末尾追加元素,那我更建议使用 append()函数和extend()函数。
(2)列表删除元素的方法
①del方法：根据索引值删除元素：
del方法 可以删除列表中的单个元素,语法格式为：
del listname[index]
其中,listname 表示列表名称,index 表示元素的索引值。
del 也可以删除中间一段连续的元素,语法格式为：
del listname[start ： end]
其中,start 表示起始索引,end 表示结束索引。del 会删除从索引 start 到 end 之间的元素,不包括 end 位置的元素。
例如：使用 del 删除单个列表元素：
lang=[“Python”,“C++”,“Java”,“PHP”,“Ruby”,“MATLAB”]
del lang[2]　#使用正数索引
del lang[-2]　#使用负数索引
使用 del 删除一段连续的元素：
lang=[“Python”,“C++”,“Java”,“PHP”,“Ruby”,“MATLAB”]
del lang[1： 4]
②pop()方法：根据索引值删除元素：
Python pop()方法用来删除列表中指定索引处的元素,具体语法格式如下。
listname.pop(index)
其中,listname 表示列表名称,index 表示索引值。如果不写 index 参数,默认会删除列表中的最后一个元素,类似于数据结构中的“出栈”操作。pop() 用法举例：
nums=[40,36,89,2,36,100,7]
nums.pop(3)
nums.pop()
③remove()方法：根据元素值进行删除,该方法会根据元素本身的值来进行删除操作。
需要注意的是,remove() 方法只会删除第一个和指定值相同的元素,而且必须保证该元素是存在的,否则会引发 ValueError 错误。
④clear()方法：用来删除列表的所有元素,也即清空列表。
url=list(“http：//c./Python/”)
url.clear()　#清空url列表
(3)列表修改元素
Python 提供了两种修改列表(list)元素的方法,你可以每次修改单个元素,也可以每次修改一组元素(多个)。
①修改单个元素：
修改单个元素非常简单,直接对元素赋值即可。请看下面的例子：
nums=[40,36,89,2,36,100,7]
nums[2]=-26　#使用正数索引
nums[-3]=-66.2　#使用负数索引
使用索引得到列表元素后,通过赋值就改变了元素的值。
②修改一组元素：
Python 支持通过切片语法给一组元素赋值。在进行这种操作时,如果不指定步长(step 参数),Python 就不要求新赋值的元素个数与原来的元素个数相同。这意味,该操作既可以为列表添加元素,也可以为列表删除元素。下面的代码演示了如何修改一组元素的值。
nums=[40,36,89,2,36,100,7]
nums[1：4]=[45.25,-77,-52.5]　#修改第 1~4 个元素的值(不包括第4个元素)
(4)列表查找元素
①index() 方法：
index() 方法用来查找某个元素在列表中出现的位置(也就是索引),如果该元素不存在,则会导致 ValueError 错误,所以在查找之前最好使用 count() 方法判断一下。index() 的语法格式如下。
listname.index(obj,start,end)
其中,listname 表示列表名称,obj 表示要查找的元素,start 表示起始位置,end 表示结束位置。start 和 end 参数用来指定检索范围。start 和 end 可以都不写,此时会检索整个列表;如果只写 start 不写 end,那么表示检索从 start 到末尾的元素;如果 start 和 end 都写,那么表示检索 start 和 end 之间的元素。index() 方法会返回元素所在列表中的索引值。例如：
nums=[40,36,89,2,36,100,7,-20.5,-999]
nums.index(2)　#检索列表中的所有元素
nums.index(100,3,7)　#检索3~7之间的元素
nums.index(7,4)　#检索4之后的元素
print(nums.index(55))　#检索一个不存在的元素
②count()方法：
count() 方法用来统计某个元素在列表中出现的次数,基本语法格式如下。
listname.count(obj)
其中,listname 代表列表名,obj 表示要统计的元素。如果 count()函数返回 0,就表示列表中不存在该元素,所以 count()函数也可以用来判断列表中的某个元素是否存在。例如：
nums=[40,36,89,2,36,100,7,-20.5,36]
nums.count(100)　#统计元素100出现的次数
(5)列表反转元素
reverse() 方法反转元素的排序顺序。
语法格式：list.reverse()
L1=['Google','Runoob','Taobao','Baidu']
L1.reverse()　#结果为['Baidu','Taobao','Runoob','Google']
(6)Sort( )方法
Python列表的sort()方法是一个就地排序方法,这意味着它将直接修改原列表,而不是创建一个新的排序过的列表。它可以接受一个关键字参数key,该参数接受一个函数,该函数用于从列表中的每个元素中提取比较键。以下是一些使用Python列表sort()方法的示例：
①基本的列表排序：
nums=[3,1,4,1,5,9,2,6,5,3,5]
nums.sort()
print(nums)　# 输出：[1,1,2,3,3,4,5,5,5,6,9]
②使用key参数进行自定义排序：
students=[('john','A'), ('jane','B'), ('dave','B')]
students.sort(key=lambda x： x[1])
print(students)　# 输出：[('jane','B'), ('dave','B'), ('john','A')]
在这个例子中,我们使用了一个lambda函数作为key参数,该函数提取每个学生元组的第二个元素(即学生的等级),并根据等级对学生列表进行排序。
③降序排序：
nums=[3,1,4,1,5,9,2,6,5,3,5]
nums.sort(reverse=True)
print(nums)　# 输出：[9,6,5,5,5,4,3,3,2,1,1]
在这个例子中,我们使用了reverse参数来指定我们想要进行的降序排序。
④自定义比较函数：
nums=[3,1,4,1,5,9,2,6,5,3,5]
nums.sort(key=lambda x： x,reverse=True)
print(nums)　# 输出：[9,6,5,5,5,4,3,3,2,1,1]
在这个例子中,我们使用了一个lambda函数作为key参数,该函数简单地返回输入(即原样返回元素),然后我们再次使用reverse参数来指定我们想要进行的降序排序。
例6　两个列表进行合并操作(ls1=[1,2,3,4,5,6],ls2=[7,8,9,10,11]),合并后的结果为[1,2,3,4,5,6,7,8,9,10,11],常用的方法一是________,方法二是________________________。
【答案】 ls1+ls2　ls1.extend(ls2)(不分先后)
【试题分析】 本题主要考查学生对列表常用操作的掌握熟练程度。
【解析】 两个列表合并成一个列表的方法是ls1+ls2,另一个方法是ls1.extend(ls2),特别注意不能用ls1.append(ls2),列表的extend()方法是将可迭代对象中的每一个元素添加到列表的末尾,而append()方法是把ls2作为一个列表的元素追加到ls1的末尾,所以append()方法不适用。
例7　实现列表ls=[1,56,25,35,84]反转的方法为________,列表的降序排序方法为________。
【答案】 ls[：：-1]　ls.sort()
【试题分析】 本题主要考查学生对列表常用操作的掌握熟练程度。
【解析】 对于序列反转都可以用对象名[：：-1]的方法实现,这是最常考的考点之一,同学们必须熟记。列表的排序用sort()方法或sorted()方法都能实现,sort()方法默认的是升序,如果要求降序则要加reverse=True这个参数,再同学们还要记住sort()方法和sorted()方法的区别,这两种方法都能对列表排序,但sort()方法排序后原对象中元素的排列改变了,而sorted()方法排序后原对象中元素的排列没有改变。最后reverse这个参数只能用在sort()方法中,不能在sorted()方法中用。
变式训练4
(1)请利用程序将list中的重复数据去重,至少使用两种方法。
方法一用set消除重复元素
ls=[10,20,25,20,60,65,25]
for　i in ls :
ls2=list(set(ls))
print("去重后的元素为:%s"%ls2)
方法二:
ls=[1,3,3,5,6,6,7]
ls2=[]
for i in ls:
　　　if　i　not in　ls2:
　　　　　ls2.append(i)
print("去重后的元素为:%s"%ls2)
【试题分析】 本题主要考查学生对序列的理解与应用。要消除重复元素一种可以利用集合来消除重复元素,再可以利用元素是否包含在序列里去除重复元素。
【解析】 根据以上分析,可以利用循环遍历列表,重复元素自然不会加入集合,也可以再设一个空列表,遍历原列表时,非重复元素才准许加入新列表。
(2)给定一个列表[10,20,25,45,50,55,13,23],求最大值(不能使用系统函数),求最小值,求平均值,求和。
ls=[10,20,25,45,50,55,13,23]
max_num=ls[0] # 最大值
for i in ls :
　　if i>max_num:
　　　 max_num=i
print("最大值为:%s"%max_num)
min_num=ls[0] # 最小值
for i in ls:
　　if i < min_num:
　　　　min_num=i
print("最小值是:%s"%min_num)
avg_num=0 # 平均值
for i in ls :
　　avg_num+=i
print("和是:%s"%(avg_num/len(ls)))
sun_num=0 # 和
for i in ls :
　　sun_num+=i
print("和是:%s"%(sun_num))
【试题分析】 本题主要考查学生对列表的常用操作的理解与应用能力。不用列表函数,通过遍历列表,一样可以实现相关操作要求。
【解析】 根据以上分析,可以编写以上程序。
1.元组的表示与创建(D)
Python的元组与列表类似,不同之处在于元组的元素不能修改,元组使用小括号,列表使用方括号,元组创建很简单,只需要在小括号中添加元素,并使用逗号隔开即可。
备考讲义
考点5
元组
tup1=('physics','chemistry',1997,2000)
tup2=(1,2,3,4,5)
tup3=“a”,“b”,“c”,“d”
创建空元组。
tup1=()
元组中只包含一个元素时,需要在元素后面添加逗号来消除歧义。
tup1=(50,)
元组与字符串类似,下标索引从0开始,可以进行截取,组合等。
2.元组的常用基本操作(D)
(1)访问元组
元组可以使用下标索引来访问元组中的值,如下实例：
tup1=('physics','chemistry',1997,2000)
tup2=(1,2,3,4,5,6,7)
tup1[0]　#访问tup1第一个元素'physics'
tup2[1：5]　#访问tup2第二至第五个元素[2,3,4,5]
(2)修改元组
元组中的元素值是不允许修改的,但我们可以对元组进行连接组合,如下实例：
tup1=(12,34.56)
tup2=('abc','xyz')
tup1[0]=100　#这样企图修改元组元素操作是非法的
tup3=tup1+tup2　#创建一个新的元组tup3,它的值为(12,34.56,'abc','xyz')
(3)删除元组
元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组,如下实例：
tup=('physics','chemistry',1997,2000)
del tup　#删除tup元组
(4)元组运算符
与字符串一样,元组之间可以使用“+”号和“*”号进行运算。这就意味着他们可以组合和复制,运算后会生成一个新的元组。
(5)元组索引
因为元组也是一个序列,所以我们可以访问元组中的指定位置的元素,也可以截取索引中的一段元素,如下实例：
tuple_1=('a','b','c','d','e','f','g','h')
tuple_1[0]　#访问tuple_1第一个元素
tuple_1[-1]　#当索引下标为负数时,-1表示最右端元素,从右向左依次递减
(6)元组内置函数
Python元组包含了以下内置函数。
①len(tuple)：计算元组元素个数。
②max(tuple)：返回元组中元素最大值。
③min(tuple)：返回元组中元素最小值。
④tuple(seq)：将列表转换为元组。
例8　已用元组保存咖啡馆里的咖啡名称,COFFEENAME=('蓝山','卡布奇诺','曼特宁','摩卡','巴西','哥伦比亚'),因为巴西咖啡断货,所以店长想要把它换成土耳其咖啡,如何实现
【试题分析】 本题主要考查元组的常见操作,由于元组是不可变序列,所以不能对它单个值进行修改,因此要么重新赋值,要么用元组的连接操作来完成。
【解析】 由以上分析可知,常见两种方法,重新赋值或者用元组的连接操作来完成。
答案：方法一：COFFEENAME=('蓝山','卡布奇诺','曼特宁','摩卡','土耳其','哥伦比亚')
方法二：COFFEENAME[：4]+('土耳其')+COFFEENAME[5：]
变式训练5　使用元组实现每两行一句输出古诗《长歌行》。
print("长歌行")
verse=("青青园中葵","朝露待日晞","阳春布德泽","万物生光辉","常恐秋节至","焜黄华叶衰","百川东到海","何时复西归","少壮不努力","老大徒伤悲")
for index,item in enumerate(verse):
　　if index%2==0:　# 判断是否为偶数,为偶数时不换行
　　　　print(item+",", end=")
　　else:
　　　　print(item+"。")　# 换行输出
【试题分析】 本题主要考查学生对序列常见操作的理解与综合应用能力。先用循环遍历enumerate(verse)对象,若 index值为奇数就换行,否则不换行,这样实现题目的要求。
【解析】 根据以上分析,可以得到以上程序。
1.字典的概念(D)
字典可以建立对象之间的映射关系,是Python中唯一内建的映射类型。字典中每个元素可以形成key-value对(键值对),key是键,value是对应的值。其中键是唯一的。字典是键值对的无序
备考讲义
考点6
字典
可变序列。可以通过键对象实现快速获取、删除、更新对应的值对象。字典中通过键对象找到对应的值对象。键是任意的不可变数据,比如：整数、浮点数、字符串、元组。但是列表、字典、集合这些可变对象,不能作为键。并且键不可重复。值可以是任意的数据,并且可重复。
2.字典的创建(D)
(1)直接创建字典
phonebook={'Alice'：'2341','Beth'：'9102','Ceil'：'3258'}
字典由多个键及与其对应的值构成的对组成。每个键和它的值之间用冒号隔开,项之间用逗号隔开,而整个字典由一对大括号括起来。
空字典：{}
(2)用dict()函数创建字典
可以用dict()函数通过映射(比如其他字典)或者(键,值)这样的序列建立字典。
items=[('name','Gumby'),('age'.42)]
d=dict(items)　#结果为{'age'：42,'name'：'Gumby'}
(3)用fromkeys()函数创建字典
fromkeys()函数使用给定的键建立新的字典,每个键默认对应的值None,可以直接在所有字典的类型dict上调用此函数。如果不想使用默认值,也可以自己提供值。
{}.fromkeys(['name','age'])　#value的默认值为None
{'age'：None,'name'：None}
dict.fromkeys(['name','age'],'unknow')　#value的值为'unknow'
{'age'：'unknow','name'：'unknow'}
3.字典的基本操作(D)
aInfo={“mayun”：3000,“lilin”：4500,“wuyun”：8000}
(1)len(d)返回d中项(键值对)的数量
len(aInfo)　#返回值为3
(2)字典更新
aInfo[”lilin”]=9000
aInfo　#返回值为{“mayun”：3000,“lilin”：9000,“wuyun”：8000}
(3)添加字典元素
aInfo[”liuxi”]=6000
aInfo　#返回值为{“mayun”：3000,“lilin”：9000,“wuyun”：8000,“liuxi”：6000}
(4)字典成员判断;
“liuxi”　in　aInfo　#返回值为True
(5)删除字典;
del aInfo　#删除字典aInfo
(6)删除字典元素
del aInfo[“mayun”]　#删除字典键值对“mayun”：3000
4.字典常用的函数(D)
(1)clear()
如果想清空原始字典中所有的元素,必须用clear()函数。
aInfo={“mayun”：3000,“lilin”：4500,“wuyun”：8000}
aInfo.clear()
aInfo　#结果为{}空字典
(2)copy()
copy()函数返回一个具有相同键值对的新字典。
x={'a'：1,'b'：2}
y=x.copy()
y #结果为{'a'：5,'b'：2}
(3)keys()、values()和items()
keys()函数返回字典所有键,values()函数返回字典所有值,items()函数返回字典所有键值对。
aInfo={“mayun”：3000,“lilin”：4500,“wuyun”：8000}
aInfo.keys()
dict_keys([“mayun”,“lilin”,“wuyun”])
aInfo.values()
dict_values([3000,4500,8000])
aInfo.items()
aInfo.items([(“mayun”：3000),(”lilin”：4500),(”wuyun”：8000)])
(4)get()
get()函数返回键对应的值。
aInfo={“mayun”：3000,“lilin”：4500,“wuyun”：8000}
aInfo.get(“mayun”)　#返回值为3000
(5)pop()
pop()函数用来返回键对应的值,并同时将键值对在字典中删除。
aInfo={“mayun”：3000,“lilin”：4500,“wuyun”：8000}
aInfo.pop(”wuyun”)
aInfo　#结果为{“mayun”：3000,“lilin”：4500}
(6)update()
update()函数可以用来添加字典的键值对,也可以更新已有的键值对。
d={'a'：1,'b'：2,'c'：3}
x={'a'：5,'d'：6}
d.update(x)
d　#结果为{'a'： 5,'c'： 3,'b'： 2,'d'： 6}
(7)setdefault()
如果字典中包含此键,则返回该键对应的键值,否则返回该键设置的默认值。
aInfo={“mayun”：3000,“lilin”：4500,“wuyun”：8000}
aInfo.setdefault(“qiqi”：None)
aInfo　　#结果为{“mayun”：3000,“lilin”：4500,“wuyun”：8000,“qiqi”：None }
例9　请编程统计original.txt英文文章中单词出现的频率。
【试题分析】 本题主要考查学生对字符串和字典两种数据类型常见操作的掌握熟练程度及综合应用能力。首先用open(r'路径\\文件名,'r',encoding='utf-8')语句读入文章,再将文本中的句子分割成一个一个单词,去除标点符号后存入word_list列表中,最后用字典数据结构统计单词出现的频率。
【解析】 按上面的分析引导且能熟练掌握序列和字典的基本操作,可以得到以下程序,否则很难完成该程序。
程序如下：
original_words=open(r'C：\\Users\\itour\\Desktop\\words-original.txt','r',encoding='utf-8')
#文件路径按实际情况修改
word_list=[]　#先将文本中的句子分割成一个一个的单词,去除标点符号后存入word_list列表中
for lines in original_words：
　　word=lines.replace('\\n','').split('')
　　for reduce_word in word：
　　　　word_list.append(reduce_word.strip(',').strip(' ').strip('.'))　
#去除文章中的标点符号
word_dict={}　#使用字典数据结构统计单词出现的频率
for w in word_list：
　　if w in word_dict.keys()：
　　　　word_dict[w]+=1
　　else：
　　　　word_dict[w]=1
例10　有一个列表words=['data','science','machine','learning'],用字典解析式创建一个字典。
【试题分析】 本题主要考查学生对字典解析式的理解及综合应用能力,在这里我们用到迭代器,它是一个名为“words”的列表。在字典解析式中,我们需要根据迭代来指定键和值。返回的字典中包含单词作为键和它们的长度作为值。字典解析式的基本语法是：
Dictionary={expression for key,value in iterable (if conditional)}
【解析】 按上面的分析,可以得到{i：len(i)for i in words}
答案：{i：len(i)for i in words}
运行结果：{'data'： 4,'science'： 7,'machine'： 7,'learning'： 8}
变式训练6
(1)以下不能创建一个字典的语句是(　　　)
A.dict={} B.dict={(4,5,6)：‘dictionary’}
C.dict={4： 6} D.dict=[[4,5,6]：‘dictionary’}
D
【试题分析】 本题主要考查学生对字典基本概念的理解与掌握,字典的键值类型不能为列表。
【解析】 根据以上分析,可知应选D。
(2)已知x={'b'：1,'a'：2},那么执行语句x.update({ ‘a’：3,‘d’：4}) 之后,表达式sorted(x.items()) 的值为________________________。
{“a”:3,“b”:1,“d”:4}
【试题分析】 本题主要考查学生对字典常见操作的理解与记忆。重点考查字典的更新与排序操作。
【解析】 根据以上分析,先更新,再排序,因此结果为{“a”:3,“b”:1,“d”:4}。
(3)假设有列表a=['name','age','sex'] 和 b=['Dong',38,'Male'],请使用一个语句将这两个列表的内 容转换为字典,并且以列表a中的元素为“键”,以列表b中的元素为“值”,这个语句可以
写为____________________。
dict(zip(a,b))
【试题分析】 本题主要考查学生将两个相关序列转化为字典的操作,需先用zip()函数转化为zip对象,再把zip对象转化为字典。
【解析】 根据以上分析,可知方法为dict(zip(a,b))。
1.集合的概念(B)
Python语言中的集合是无序的、不可变的容器类对象,所有元素放在一对大括号中,元素之间使用逗号分隔,同一个集合内的每个元素都是唯一的,不允许重复。集合中只能包含数字、字
备考讲义
考点7
集合
符串、元组等不可变类型或可哈希的数据,不能包含列表、字典等可变类型或不可哈希的数据,包含列表等可变类型数据的元组也不能作为集合的元素。集合中的元素不存在“位置”或“索引”的概念,不支持使用下标直接访问指定位置上的元素,不支持使用切片访问其中的元素。
2.集合的定义(D)
集合的元素是不可重复的,例如：
s={1,2,3,1,2,3,4,5}
print(s)　　#集合去重,结果为{1,2,3,4,5}
集合只支持成员操作符和for循环。
s={1,2,3}
Print(1 in s)　　#此时的返回值为True
3.集合的常用方法与运算(D)
(1)增加
增加一个元素.add()
s={6,7,8,9}
s.add(1)　　#此时的返回值为{1,6,7,8,9}
增加一个集合.update()
s={6,7,8,9}
s.update({2,3,5})　　#此时的返回值为{2,3,5,6,7,8,9}
(2)删除
remove()删除
s={6,7,8,9}
s.remove(6)　　#此时的返回值为{8,9,7}
pop()删除
s={6,7,8,9}
s.pop()　　#此时的返回值为{9,6,7}
clear()删除
s={6,7,8,9}
s.clear()　　#此时的返回值为{ }
(3)交集
s1={6,7,8,9}
s2={3,4,5,6}
s1 & s2　　#求s1和s2的交集
(4)并集
s1={6,7,8,9}
s2={3,4,5,6}
s1 | s2　　#求s1和s2的并集
(5)差集
s1={6,7,8,9}
s2={3,4,5,6}
s2-s1　　#求s1和s2的差集
(6)对等差分：并集减差集
s1^s2　　#求s1和s2的对称差分
例11　小张想在学校中请一些同学一起做一项问卷调查,为了实验的客观性他先用计算机生成了N个1~1000之间的随机整数(N<=1000),N是用户输入的,对于其中重复的数字,只保留一个,把其余相同的数字去掉,不同的数对应着不同的学生的学号,然后再把这些数从小到大排序,按照排好的顺序去找同学做调查,请你协助小张完成去重与排序工作。
【试题分析】 本题主要考查学生对random库及循环结构的综合理解及应用能力,当然也要能熟练掌握集合的常用操作。首先导入随机库并定义一个集合(初始为空),再利用循环向集合中添加随机数(集合会自动消除重复元素),最后再利用排序方法对集合进行排序。
【解析】 根据上面的分析,先导入random库并定义一个集合用来存放结果,再利用循环向集合中添加元素,最后用sorted方法对集合进行排序。这道题关键是学生对集合的基本操作要熟练。
答案：
import random
s=set([])
for i in range(int(input('N：')))：
　　s.add(random.randint(1,1000))
print(s)
print(sorted(s))
变式训练7
用三个集合表示三门学科的选课学生姓名(一个学生可以同时选多门课)
S_HISTORY={'小明','张三','李四','王五','LILY',"BOB"}
S_POLITIC={'小明','小花','小红','小周'}
S_ENGLISH={'小明','LILY','BOB','DAVIL','李四'}
a.求选课学生总共有多少人。
求选课学生总共有多少人。
print("选课学生总共有", len(s_english | s_politic | s_history), '人')
b.求只选了第一个学科的人的数量和对应的名字。
求只选了第一个学科的人的数量和对应的名字。
print('只选了第一个学科的人的数量:', len(s_history-s_politic-s_english), '姓名:', s_history-s_politic-s_english)
c.求只选了一门学科的学生的数量和对应的名字。
求只选了一门学科的学生的数量和对应的名字。
s1=s_history-s_politic-s_english
s2=s_english-s_politic-s_history
s3=s_politic-s_english-s_history
print('只选了一门学科的学生的数量:', len(s1 | s2 | s3), '姓名:', s1 | s2 | s3)
d.求只选了两门学科的学生的数量和对应的名字。
求只选了两门学科的学生的数量和对应的名字。
s=s_english & s_history & s_politic
s1=s_history & s_politic-s
s2=s_english & s_politic-s
s3=s_history & s_english-s
print('只选了两门学科的学生的数量:', len(s1 | s2 | s3), '姓名:', s1 | s2 | s3)
e.求选了三门学科的学生的数量和对应的名字。
求选了三门学科的学生的数量和对应的名字
print('选了三门学科的学生的数量:', len(s_english & s_politic & s_history), '姓名:', s_english & s_politic & s_history)
【试题分析】 本题主要考查学生对常见集合操作的理解与应用能力。选课总人数实际是求3个集合的并集,只选了一门学科的学生实际是在并集的基础上减去另两个集合的差集,只选了两门学科的学生可以先求三个集合的交集,再分别用两个集合的交集减去三个集合的交集,最后求选了三门学科的学生即求三个集合的交集。当然方法不唯一。
【解析】 根据以上分析,可得到上面的解决方案。
一、填空题
1.list(map(str,[1,2,3]))的执行结果为______________。
[‘1’, ‘2’, ‘3’]
2.已知x={1：1},那么执行语句x[2]=2之后,len(x)的值为________。
2
3.语句x=3==3,5执行结束后,变量x的值为____________。
(True, 5)
二、单项选择题
4.以下程序的输出结果是(　　　)
astr=‘0\\n’
bstr=‘A\\ta\\n’
print(”{1}{0}".format(astr,bstr))
A.A a B.0 C.a　A D.0
0　　　 a　A　　　　 　 0　　　　　A　a
A
5.以下程序的输出结果是(　　　)
L2=[[1,2,3,4],[5,6,7,8]]
L2.sort(reverse=True)
print(L2)
A.[5,6,7,8],[1,2,3,4] B.[[8,7,6,5],[4,3,2,1]]
C.[8,7,6,5],[4,3,2,1] D.[[5,6,7,8],[1,2,3,4]]
D
6.关于Python的元组类型,以下选项中描述错误的是(　　　)
A.一个元组可以作为另一个元组的元素,可以采用多级索引获取信息
B.元组一旦创建就不能被修改
C.Python中元组采用逗号和圆括号(可选)来表示
D.元组中元素不可以是不同类型
D
7.将一个字典的内容添加到另一个字典中的方法是(　　　)
A.update() B.keys()
C.items() D.get()
A
三、读程题
8.下面代码的输出结果是________。
no=[1001,1002,2001,1003,3001]
course=[“math”,“english”,“Python”,“physics”,“PE”]
data=dict(zip(no,course))
result=data.get(2001)
print(result)
Python　
9.下面代码的输出结果是________。
d={“1”：1,“2”：2,“3”：3,“4”：4}
d2=d
d[“2”]=5
print(d[“2”]+d2[“2”])
10
四、编程题
10.输入一段中文,统计中文字符串中的字符频率,并按从大到小顺序输出字频最高的前三个。
解:str1=input("请输入中文字符串:")
dict1={}
for zf in str1:
　　tsfh=[",","。"," ","!"]+list(range(10))
　　if zf not in tsfh:
　　　　dict1[zf]=dict1.get(zf,0)+1
print(dict1)
list1=list(zip(dict1.values(),dict1.keys()))
list1.sort()
list1.reverse()
for i in range(3):
　　print(list1[i][1]+":"+str(list1[i][0]))

展开更多......

收起↑