组合数据类型

一、集合类型及操作

1.熟悉集合类型
2.掌握集合操作方法
3.熟悉集合类型应用场景

集合类型的定义：集合是多个元素的无序组合

• ​ 集合类型与数学中的集合概念一致
• ​ 集合元素之间无序，每个元素唯一，不存在相同的元素
• ​ 集合用{}表示，元素间用逗号分隔
• ​ 建立集合类型用{}或set()

#{}创建集合
A={"python",1,("python",1)}
#使用set创建集合
B=set("python")

集合操作符

"""
有两个列表
lst1
lst2
1.哪些整数既在lst1中，也在lst2中
2.哪些整数在lst1中，不在lst2中
3.两个列表一共有哪些整数
"""
lst1=[1,2,3,5,6,3,2]
lst2=[2,5,6,7]

#第一即求交集
print(set(lst1) & set(lst2))
#第二 差集
print(set(lst1) - set(lst2))
#第三 并集
print(set(lst1) | set(lst2))

集合处理方法

lst=set()
lst.add('python')
lst.add('java')
lst.add('c')
lst.remove('c')
print(len(lst))

# in  和 not in
my_set={"python",'java',1,2,4}
print('python' in my_set)#True
print('c' in my_set)#False

集合应用场景

1.去重

"""
字符串去重排序
输入一个空字符串，去除重复的字符后，从小到大排序输出一个新字符串
"""

s=list(set(input()))#先set去重 后list变为列表
s.sort()#排序
print(" ".join(s))

2.加密字符串

"""

输入一个字符串做密钥（去重大写和26个大写字母差）
输入一个需要加密的字符串
"""
import string

upperLetter=string.ascii_uppercase
s=input().upper()#输入做密钥的字符串
code=list(set(upperLetter)-set(s))
code.sort()

ls=list(set(s))
ls.sort(key=s.index)#按输入字符串顺序排序
keys=''.join(ls+code)
decode=input().upper()#要输入加密的字符串
table=''.maketrans(upperLetter,keys)#maketrans() 字符映射转换表
print(decode.translate(table))

二、序列类型及操作

1.掌握序列类型的定义
2.掌握序列类型的方法
3.掌握序列类型使用的场景

序列类型定义

​ ·序列是具有先后关系的一组元素

​ ·序列是一维元素向量，元素类型可以不同

​ ·序列类型包括字符串类型、元组类型、列表类型

序列处理函数及方法

操作符	描述
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为步长的元素子序列

序列类型通用函数和方法

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

"""
在两行中分别输入一个字符串 a 和 b，按要求完成以下功能：

1. 输出两个字符串的拼接结果

2. 输出字符串 a 重复3次的结果

3.输出字符串 b 中第3个字符和最后一个字符，结果用空格分隔

4.输出字符串 a 中序号1至4之间的字符

5. 输出字符串 a 、b的长度，结果用逗号分隔

6. 输出字符串 a 的中字符的最小值和 b 中元素的最大值

"""

a=input()
b=input()
print(a+b)
print(a*3)
print(b[2],b[-1],sep=' ')
print(a[1:4])
print(len(a),len(b),sep=',')
print(min(a),max(b))

元组类型

• 元组是序列类型的一种扩展，一旦创建就不能修改

• ​ 使用小括号（）或tuple（）创建，元素间用逗号，分隔

• 元组继承了序列类型的通用操作

#完美立方数
"""
编写一个程序，对于任意给定的正整数 N（N<=100），寻找所有的四元组（a,b,c,d），满足 a**3 = b**3 + c**3 + d**3
其中 1 < a,b,c,d <=N
"""

#枚举法
N=int(input())
ls=[]
for i in range(1,N+1):#将i的三次方存与列表
    ls.append(i*i*i)
for a in range(2,N+1):#a从2-n
    for b in range(2,a):#b，c，d都不会大于a，减少计算量
        for c in range(b,a):#c大于等于b
            for d in range(c,a):#d大于等于b
                if ls[a-1]==ls[b-1]+ls[c-1]+ls[d-1]:
                    print("Cube={}，Triple=({},{},{})".format(a,b,c,d))

列表类型

• 列表类型是一种序列类型，创建后随意可以被修改

• 使用[]或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次

"""
在两行中分别输入一个字符串，分别将其转换为列表 a 和 b，按要求完成以下功能：
1. 输出两个列表的拼接结果
2. 输出列表 a 重复3次的结果
3.输出列表 b 中第3个元素和最后一个元素
4.输出列表 a 中序号1至4之间的元素
5. 输出列表 a 、b的长度，结果用逗号分隔
6. 输出列表 a 的中元素的最小值和 b 中元素的最大值
"""
a=list(input())
b=list(input())
print(a+b)
print(a*3)
print(b[2],b[-1])
print(a[1:4])
print(len(a),len(b),sep=",")
print(min(a),max(b))

函数或方法	描述
ls.append(x)	在列表ls中最后添加一个元素x
ls.clear()	删除列表中所有的元素
ls.copy()	生成一个新列表，赋值ls中所有的元素
ls.insert(i,x)	在列表第i个位置增加x元素
ls.pop(i)	将列表ls中第i个位置元素取出并删除改元素
ls.remove(x)	将列表中第一个出现的x元素删除
ls.reverse()	将列表中的元素反转

"""
初始化一个空列表，输入一个正整数 n，你将被要求读入 n 个输入（输入形式如下所示），每得到一个输入后，根据输入进行操作。
insert i e: # 在第 i 个位置插入整数 e。
print:      # 输出列表
remove e:   # 删除第一次出现的整数 e .
append e:   # 在列表的末尾插入整数 e.
sort:       # 按默认规则排序.
pop:        # 弹出列表最后一一个元素
reverse:    # 列表元素逆序.
"""
"""
输入
12
insert 0 5
insert 1 10
insert 0 6
print
remove 6
append 9
append 1
sort
print
pop
reverse
print
"""
def main(n):
    ls=[]
    for i in range(n):
        lsinput=input().split()
        operate=lsinput[0]
        if operate=="insert":
            ls.insert(int(lsinput[1]),int(lsinput[2])
        elif operate=="remove":
                      ls.remove(int(lsinput[1]))
        elif operate == 'append':
			ls.append(int(lsinput[1]))
		elif operate == 'sort':
			ls.sort()
		elif operate == 'pop':
			ls.pop() # 无参数时，弹出最后一个元素
		elif operate == 'reverse':
			ls.reverse()
		elif operate == 'print':
			print(ls)
           
if __name__=='__main__':
                      N=int(input())
                      main(N)
                      

序列类型应用场景

• 元组用于元素不改变的应用场景

• 列表灵活，是最常用的序列类型

  • 元素遍历

  • 数据保护

三、字典类型及操作

1.理解字典的定义
2.掌握字典处理函数和方法
3.了解字典类型应用场景

字典类型定义

• 键值对：键是数据索引的扩展

• ​字典是键值对的集合，键值对之间无序

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

f_language={"1":"python","2":"JAVA","3":"C"}

字典类型操作函数和方法

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

"""
输入两个整数，在这两个整数组成的闭区间范围内生成100个随机整数，并统计出现数据的次数，出现0次的数字不输出（而不是输出0）。为满足评测需要，程序必须使用seed函数将随机种子设为10，并使用randint函数生成随机数。
"""


import random

dic={}
m,n=map(int,input().split())
random.seed(10)

for i in range(100):
    key=random.randint(m,n)
    if key in dic:
        dic[key]+=1
    else:
        dic[key]=1
  
for i in sorted(dic.keys()):
    print("{} {}".format(i,dic[i]))

"""
总理有诗云：两湖两广两河山，五江云贵福吉安，四西二宁青甘陕，还有内台北上天。中国各省、直辖市、自治区和特别行政区的字典数据如下:
capitals = {'湖南':'长沙','湖北':'武汉','广东':'广州','广西':'南宁','河北':'石家庄','河南':'郑州','山东':'济南','山西':'太原','江苏':'南京','浙江':'杭州','江西':'南昌','黑龙江':'哈尔滨','新疆':'乌鲁木齐','云南':'昆明','贵州':'贵阳','福建':'福州','吉林':'长春','安徽':'合肥','四川':'成都','西藏':'拉萨','宁夏':'银川','辽宁':'沈阳','青海':'西宁','海南':'海口','甘肃':'兰州','陕西':'西安','内蒙古':'呼和浩特','台湾':'台北','北京':'北京','上海':'上海','天津':'天津','重庆':'重庆','香港':'香港','澳门':'澳门'}
设计程序，接收用户输入的省、直辖市、自治区和特别行政区名称，输出对应的省会名称，当输入错误时输出“输入错误”。程序可以重复接收用户输入，直接输入回车时退出程序。
"""

capitals = {'湖南':'长沙','湖北':'武汉','广东':'广州','广西':'南宁','河北':'石家庄','河南':'郑州','山东':'济南','山西':'太原','江苏':'南京','浙江':'杭州','江西':'南昌','黑龙江':'哈尔滨','新疆':'乌鲁木齐','云南':'昆明','贵州':'贵阳','福建':'福州','吉林':'长春','安徽':'合肥','四川':'成都','西藏':'拉萨','宁夏':'银川','辽宁':'沈阳','青海':'西宁','海南':'海口','甘肃':'兰州','陕西':'西安','内蒙古':'呼和浩特','台湾':'台北','北京':'北京','上海':'上海','天津':'天津','重庆':'重庆','香港':'香港','澳门':'澳门'}

while True:
    province = input()
    if province == '':
        break
    else:
        print(capitals.get(province,'输入错误'))

字典类型应用场景

• ​统计次数
• ​元素遍历

习题巩固

1.以下程序的输出结果是（）

ss=set("htslbht")
sorted(ss)
for i in ss:
    print(i,end="")

A hlbst

B htslbht

C tsblth

D hhlstt

2.不是Python组合数据类型的是（）

A元组类型

B 字符串类型

C 数组类型

D 列表类型

3.以下程序的输出结果是（）

ls=['绿茶'，'乌龙茶'，'红茶'，'白茶'，'黑茶']

x=“乌龙茶”

print(ls.index(x,0))

A -3

B 0

C 2

D 1

4.关于字典的描述，错误的是（）

A 字典的元素以键为索引进行访问

B 字典的一个键可以对应多个值

C 字典的长度是可变的

D 字典是键值对的结合，键值对之间没有顺序

5.以下程序输出的结果

dd={'a':90,'b':87,'c':93}
print([[dd[x],x]] for x in sorted(dd))

A [[93,‘c’],[90,‘a’].[‘87’,‘b’]]

B [[90,‘a’],[87,‘b’].[‘93’,‘c’]]

C [[87,‘b’],[90,‘a’].[‘93’,‘c’]]

D [[90,a],[87,b].[93,c]]

6.以下语句输出的结果是（）

dd={‘chinese’:200,'pe':187,'Gana':930}

print(sorted(dd.keys()))

A dict_keys([‘Gana’,‘chinese’,‘pe’])

B ‘Gana’,‘Chinese’,‘pe’

C [‘Gana’,‘chinese’,‘pe’]

D 报错

7.以下语句的执行结果是（）

d={1:10,2:2,3:30}
print(d.get(3,99))

A 99

B 100

C 30

D 2

8.以下程序的输出结果是（）

ls=[]
def run(n):
    ls.append(n)
run(5)
print(ls)

A [10]

B UnboundLocallError

C [10,5]

D None

9.以下程序输出的结果是（）

ls=[1,2,3]
lt=[4,5,6]
print(ls+lt)

A [1,2,3,4,5,6]

B [1,2,3,[4,5,6]]

C [4,5,6]

D [5,7,9]

10.下面语句执行的结果是（）

example=‘Baidu Translation is an online translation service’
print(len(example.split('a')))

A 6

B 8

C 7

D 9

11.以下语句执行结果是（）

dic={90:"Aele",87:'Bob',93:'laba'}
print(dic.pop(90,-1),len(dic))

A Aele 3

B -1 3

C Aele 2

D -1 2

12.以下关于Python的描述正确的是()

A 字典的创建必须使用 dict（）函数

B 列表和字符串属于序列，但元组不属于序列

C Python只有一种内置的映射类型，就是字典

D 字符串可以进行切片赋值

13.以下程序的输出结果是（）

ss=['e','h','b','s','I','p']
for i in range(len(ss)):
    print(max(ss),end='',)
    ss.remove(max(ss))

A s,p,l,

B s,p,l,h,e,b

C s,p,l,h,e,b,

D s,p,l

14.设s1={1,2,4,7}，s2={2,3,4} ,s1-s2的值是（）

A {2，4}

B {1,3,7}

C {1,7}

D {1,2,3,4,7}

15.执行下面代码，输出的结果是（）

aSet={1,5,7,8}
bSet={2,4,5,7}
print(aSet & bSet)
print(bSet -aSet)

A {5,7} {2,4}

B {1,2,4,5,7} {1,2,4,8}

C {2,4} {5,7}

D {5,7} {1,2,4,8}

16.下面选项中关于列表和字符串说法错误的是（）

A 列表是一个有序的集合，没有固定大小

B 用于统计字符串string长度的方法是string.length()

C 列表可以存放不同类型的数据

D 字符串具有不可变性，创建后其值不能改变

17.下列不属于处理Python中字典的方法是（）

A pop

B replace

C get（）

D popitem()

18.下列说法正确的是（）

A set()可以将任何类型转为集合类型

B remove（）方法删除集合中的元素，不管元素存在不存在都不报错

C 集合中的元素不可重复，元素类型只能是不可变数据类型

D 集合元素是有序

19.下面关于元组描述正确的是（）

A 元组和列表相似，所有能对列表进行操作都可以对元组进行

B 创建元组时，若元组中仅包含一个元素，在这个元素后面可以不添加逗号

C 元组中的元素不能被修改

D 多个元素不能进行连接

20.下面关于Python描述正确的是（）

A列表的下标是从1开始

B 元组的元素可以修改、删除、连接

C 字典中的键只能是整数、字符串

D 集合分为可变集合和不可变集合，可变集合的元素可以添加、删除

21.下面关于Python列表描述错误的是（）

A 列表元素可以被修改

B 列表元素没有长度限制

C 列表元素的个数不限

D 列表元素的数据类型必须一致

22.下面关于Python元组类型，以下选项中描述错误的是（）

A 元组不可以被修改

B Python中元组使用圆括号和逗号表示

C 元组中的元素要求是相同类型

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

23.S和T是两个集合，对S&T的描述正确的是（）

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

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

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

D S和T的补运算，包括几个S和T中的非相同元素

---

答案

1.A 考查集合去重 通过去重结果就可以确定答案 为A

2.C Python组合数据类型有字符串、元组、列表类型，没有数组类型 答案选C

3.D 考查列表index方法，index方法定位位置，乌龙茶在第二个位置，所以选择D

4.B 字典键值对是一一对应的，一个键不可以对应多个值，所以选择B

5.B sorted从小到大排序 根据print（[dd[x]],x）即选择B项

6.C sorted排序从小到大排序，从第一字符开始 G

7.C 考查字典get方法,如果存在则输出对应的值，否则输出get的第二个参数，选择C

8.C 考查列表方法、局部变量和全局变量 ls=[]声明的是全局 则在run函数中没有声明则默认全局 所以选择C项

9.A 两个列表相加 答案为A

10.C 通过’a’进行分隔，其中example中a有6个 len()包含一个空格字符 则长度为7

11.C 考查字典中pop（）方法，90对应的值是Aele 剔除后，长度为2 则选择C

12.C 字典的创建的方法有多种，可以通过dict（），也可以通过{}进行创建，元组和列表、字符串都属于可切片的序列，字符串能切片但不能赋值。所以选择C

13.C 循环6次，其结果也得有六次，加上,输出 则选择C

14.C 考查集合的运算 s1-s2的值即剔除s1和s2共有的值，保留s1值，则选C

15.A 考查集合的运算 &取交集 -取差 即A项

16.B 用于统计字符串的长度用len()方法 故选择B

17.B 考查Python字典方法，replace不是字典里的方法，用于替换

18.C set除了自身，其它类型转为集合类型 ，remove（）不存在要报错，集合是无序的，所以选择C

19.C 元组不能被修改，序列类型有的功能，元组都有

20.D 列表从0开始，元组不能被修改，字典的键不限格式，所以选择D

21.D 列表元素的数据类型不一定一致。选择D项

22.C 元组里的类型没有要求，不需要相同的类型，选C项

23.A S&T及交集 包含S和T中的元素。

注:Python基础课件完整电子书版可添加下面微信获取