让我们了解下python中集合都包含什么吧 全是干货哦

歡喜_
366 阅读10分钟

1 集合

1.1 List列表

  • 列表（List）是一种有序和可更改的集合。允许重复的成员。

  • 列表是一个有序且可更改的集合。在 Python 中，列表用方括号编写。

  • 通过引用索引号来访问列表项

  • 更改特定项的值

  • 遍历列表

  • in

  • 列表长度

  • 添加项

    • append
    • insert

  • 删除项

    • remove
    • pop

  • 复制

    • copy

  • 合并

    • extend

  • 列表方法

    • sort
    • reverse

代码例子

#List列表 - 是一种有序的可以更改的集合，列表中的元素可以重复
# 创建列表可以使用[] 或者 list()

# 创建空的列表
# nums = [] 
nums = list() 
# print(nums)  

#非空的列表
nums = [2,4,6,8,8]
print(nums)    #[2, 4, 6, 8, 8]   存放有序，允许有重复的元素

ss = ['hello','python','web','web',20]    
print(ss)   #['hello', 'python', 'web', 'web', 20]

'''
列表每一个元素都分配一个整数，称为索引，左边从0开始（正索引），右边从-1开始（负索引） 
['hello','python','web','web',20] 
    0        1      2     3    4
    -5      -4     -3    -2   -1
'''
#使用[索引]访问列表中的元素
# print(ss[0]) 
# print(ss[-5]) 
# print(ss[-1]) 


#for in - 遍历列表
# for s in ss:
#     print(s)

#len() - 获取列表长度
print(len(ss)) 
print(len([]))   

#修改列表中的元素
ss[2]='java' 
print(ss) 

# in  - 检查列表中是否包含给定的元素
print('java' in ss)   #True
print('js' in ss)   #False

print(type(ss))   #返回变量的类型  list


# +   列表拼接，生成新的列表
# print(id(ss))  # id() - 返回变量的内存地址
ss2=ss+[40,69]
print(ss) 
print(ss2) 
print(len(ss2))
# print(id(ss))  

# append()   列表的末尾添加一个元素 - 追加
# print(id(ss))  # id() - 返回变量的内存地址
# ss.append([33,51])
# print(id(ss))  
# print(ss)
# print(len(ss))

# extend() 列表末尾逐个添加给定集合中的元素 - 合并
# ss.extend([33,51])
# print(ss)
# print(len(ss)) 

#insert()   指定索引位置上插入一项
# ss.insert(1,[33,51])
# print(ss) 
#print(ss[10])   #IndexError: list index out of range

#remove()  删除给定的一个元素，（如果有多个，只删除左边开始第一个）
# ss.append('web')
# print(ss) 
# ss.remove('web')
# print(ss) 
# ss.remove("js")   #ValueError: list.remove(x): x not in list

#pop()   弹出指定位置的一个元素，并且返回弹出的元素   默认是最右边的元素
# print(ss) 
# s = ss.pop(1) #参数指定位置（索引）
# print(s)
# print(ss) 

# 新建变量指向的是同一个列表
# ss2 = ss 
# print(id(ss))
# print(id(ss2)) 

# copy()  - 复制，新建了一个列表，并且把原列表的元素复制进新的列表
# ss2 = ss.copy()
# print(id(ss))
# print(id(ss2)) 
# print(ss)
# print(ss2)  

nums=[20,21,6,18]

#reverse  - 列表元素反转
nums.reverse()
print(nums)   #[18, 6, 21, 20]

# sort() - 列表中元素排序，升序排序
nums.sort()
print(nums)  

# list*n   - 列表元素复制n次 , 原来列表不变
print(nums*4)

# max() - 返回列表中最大的元素
# min() - 返回列表中最小的元素
# sum() - 返回列表中所有元素的和
print(max(nums),min(nums),sum(nums))

练习1

已知一个列表
lst = [1,2,3,4,5]

求列表的长度
判断6 是否在列表中
lst + [6, 7, 8] 的结果是什么？
lst*2 的结果是什么
列表里元素的最大值是多少
列表里元素的最小值是多少
列表里所有元素的和是多少
在索引1的位置新增一个的元素10
在列表的末尾新增一个元素20

练习2

lst = [1,2,3]
lst2 = [4,5,6]
不使用 + 号运算符，将lst2合并到lst的末尾，并思考，这个过程中，是否产生了新的列表

练习3

lst = [2, 5, 6, 7, 8, 9, 2, 9, 9]
请写程序完成下列操作

在列表的末尾增加元素15
在列表的中间位置插入元素20
将列表[2, 5, 6]合并到lst中
移除列表中索引为3的元素
翻转列表里的所有元素
对列表里的元素进行排序，从小到大一次，从大到小一次

练习4

lst = [1, 4, 5, [1, 3, 5, 6, [8, 9, 10, 12]]]

不写任何代码，仅凭思考推理来回答下列问题

列表lst的长度是多少
列表lst中有几个元素
lst[1] 的数据类型是什么
lst[3]的数据类型是什么
lst[3][4] 的值是什么
如果才能访问到 9 这个值
执行lst[3][4].append([5, 6])后，列表lst的内容是什么，手写出来
lst[-1][-1][-2]的值是什么
lst[-2]的值是什么
len(lst[-1]) 的值是什么
len(lst[-1][-1])的值是什么
lst[-1][1:3] 的值是什么
lst[-1][-1][1:-2]的值是什么

练习. 求列表最大值

题目要求：实现函数get_max，函数最终返回列表lst的最大值,不要使用max函数

def get_max(lst):
    """
    返回列表lst的最大值
    :param lst:
    :return:
    """
    pass


lst = [4, 2, 1, 6, 7, 9]
max_value = get_max(lst)
print(max_value)

1.2 Tuple元组

  • 元组是有序且不可更改的集合。在 Python 中，元组是用圆括号编写的。
  • 通过引用方括号内的索引号来访问元组项
  • 创建元组后，您将无法更改其值。
  • 使用 for 循环遍历元组项
  • in
  • 元组长度
  • 创建仅有一个元素的元组
  • 合并两个元组

代码例子

#Tuple - 元组，是一种有序且不可更改的集合

#创建一个元组可以使用() 或者 tuple() 
#空的元组
# nums=()
# nums = tuple()  
# print(nums) 

#非空的元组
# nums=(2,4,6,8,8)  
# nums=tuple([2,4,6,8,8])   #新建一个元组，将列表中的元素依次存放进来
# print(nums)     #(2, 4, 6, 8, 8)   存放有序 ，元素可以重复  

ss=('python','java','web',20) 
print(ss)  

# in  检查元组是否包含给定的元素
print('js' in ss)  #False

#len() 元组长度
print(len(ss)) 

#for in 遍历
for x in ss:
    print(x) 

#[索引]获取元组中的元素
print(ss[0]) 
print(ss[-1]) 

#元组中的元素不能重新赋值
#ss[0] = 'js'   #TypeError: 'tuple' object does not support item assignment

# +   合并，生成新的元组，原来的元组是不变的 
ss2=ss+(3,5)
print(ss)  
print(ss2) 

# *n  元素复制  原来的元组不变
print(ss*2)


# 下面创建的是一个int
# ts=(1)
# 创建仅有一个元素的元组
# ts=(1,)
# print(ts,type(ts)) 

#tuple->list
# ls = list((20,21,6,18))    #创建一个列表，将元组中的元素依次添加到列表中
# ls.sort()
# print(ls) 


ts=('hello','python','java','web','js')
print(max(ts),min(ts))     


# tuple用处
# 函数返回值用tuple存放
# 可变参数

def test(*args):
    print(args)
    
test(2,5,3,4) 


dd = ('python',[2,4],20)
print(dd[1][1])
dd[1][1]=33
print(dd) 
# dd[1]=[2,33]  #TypeError: 'tuple' object does not support item assignment

练习1

写出下面代码的执行结果和最终结果的类型

(1, 2)*2
(1, )*2
(1)*2

1.3 Set集合

  • 集合是无序和无索引的集合。在 Python 中，集合用花括号编写。

  • 使用 for 循环遍历

  • in

  • 添加项

    • add
    • update

  • 集合长度

  • 删除

    • remove

  • 合并两个集合

    • union

  • 集合方法

    • defference
    • intersection

代码例子

# set - 集合是一组不能重复的元素的集合。集合是无序的，使用{}定义集合。

# set() - 创建一个空的set,不使用{}
# s = set()
# print(s,type(s)) 

# 包含元素的set 重复的元素保留一个，存放无序
# s = {'python','java','web','web'} 
# print(s,type(s))

# 把一个列表元素存成一个set
s = set(['python','java','web','web'])  #{'web', 'python', 'java'}
print(s) 

#set 无法用[]获取元素
#print(s[0]) 

# for in 语句遍历
for c in s:
    print(c)  

# add() 增加元素
# s.add('php') 
# s.add('java') 
# print(s) 

# remove() 删除给定的元素
# s.remove('java') 
# print(s) 

# pop()  - 随机从set中删除一个元素   
s.pop()  
print(s)

set操作

#创建空的set
s = set()
# update() - 添加多个元素 
s.update({100,99,95,94}) 
print(s)  
s.update(['python','java'])  
print(s) 

# len() - 返回set中元素的个数
print(len(s)) 

s1 = set('apple')
print(s1) 
s2 = set('banana')
print(s2) 

# - difference  差集
print(s1-s2)  #把s2中包含的元素从s1中删除
print(s1.difference(s2))  #把s2中包含的元素从s1中删除
print(s2.difference(s1))  #把s1中包含的元素从s2中删除

# symmetric_difference 对称求差别
print(s1.symmetric_difference(s2))  
print(s2.symmetric_difference(s1))  

# intersection() - 交集
print(s1.intersection(s2)) 

# union() - 并集
print(s1.union(s2))

练习

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

1.4 Dictionary字典

  • 字典是一个无序、可变和有索引的集合。在 Python 中，字典用花括号编写，拥有键和值。

  • 通过在方括号内引用其键名来访问字典的项

  • 通过引用其键名来更改特定项的值

  • 使用 for 循环遍历字典

  • values()-返回字典的值

  • items()-返回键和值

  • in

  • 字典长度

  • 添加项

  • 删除项

    • pop

  • 字典方法

    • get
    • keys

代码例子

#Dictionary - 字典   

#用{}创建字典,键（key）和值(value)之间用冒号(:)分割，键值对之间用逗号(,)分割
d1 =  {100:"hello","python":[2,4,6]} 
print(d1,type(d1))     #    dict-字典
#创建一个空的字典用dict()函数
d2 = dict() 
print(d2,type(d2))  
#{}创建空的字典
d3 = {}   
print(d3,type(d3))  


#创建字典
user={'username':'zhang','age':20}
print(user)  

#[key]获取key对应的value
print(user['username'],user['age'])   

#print(user['sex'])  #KeyError: 'sex'

#新建一个键值对
user['sex']='男'   #'sex'在字典中不存在
print(user)

#根据键修改值
user['age']=22     #'age'在字典中已存在
print(user) 

# user['username']='xiaoming'
# user['age']=18
# user['sex']='女'
# print(user)

#update(dict)    - 用给定的字典同时增加或修改原字典）
xm = {'username':'xiaoming','age':18,'no':1001} 
user.update(xm)
print(user)  


#同一个字典中键不能重复，不可变的类型（如：数字、字符串、元组）可以作为键   
d3 = {'hello':100,'python':100,('java',):100}     #列表是可变的，不能作为键
print(d3) 

print(d3.get('age',20) )    #get() - 根据关键字获取值，但是关键字不存在，不报错，返回指定的值，默认返回None

 
#pop(key) - 根据键删除键值对 
value = d3.pop('hello')    #返回键对应的值，如果键不存在，抛出错误KeyError
print(value)
print(d3) 

#clear() - 清空
d3.clear()
print(d3)

字典遍历

scores={'python':100,'java':100,'web':99}
scores['js']=98 
print(scores) 

#keys() - 获取键 ,返回的类型是dict_keys
print(scores.keys(),type(scores.keys()))   
#list() -  dict-keys -->list
ks = list(scores.keys() )
print(ks[0])  

#values() - 获取值 ,返回dict_values
vs = scores.values()
print(vs,type(vs))  
vs = list(vs)
print(vs) 

# for in  语句遍历
for k in scores:
    print(k,scores[k])    #字典中的键

# scores['php']=97
# scores['php']=0  
# print(scores) 
sc = scores.setdefault('php',0)
print(scores) 
print(sc)

字典存放列表数据

names = ['zhang','lisi','xiaoming','zhao','liu'] 
scores = [95,88,99,90,95,10]  

students={}
for i in range(0,len(names)):
    students[names[i]]=scores[i]

print(students) 
print(students['liu']) 

#zip() - 拉链
z = zip(names,scores)
stu = dict(z)  
print(stu) 


#copy() - 拷贝
stu2 = stu.copy()  #创建新的字典
# stu2 = stu   # 不创建新的字典
print(stu,id(stu)) 
print(stu2,id(stu2)) 

#hash() -  哈希函数
# print(hash('zhang'))  
# print(hash('zhang'))  
# print(hash('lisi'))  


# stu3={}
# stu4 = stu3.fromkeys(names)   #创建一个新的字典并返回  把names中的元素作为键
# print(stu4)
# print(stu3.fromkeys(names,0))  #指定键对应的值，如果不指定，默认值是None

#items() - 返回dict_items
its = stu2.items()
print(its,type(its))  
its = list(its)   #[('zhang', 95), ('lisi', 88), ('xiaoming', 99), ('zhao', 90), ('liu', 95)]
it =its[0]     #('zhang', 95)
print(it[0],it[1])   

# in  - 检查字典中是否有给定的键
print('zhou' in stu2)   #False
print('lisi' in stu2)   #True

#len(dict) - 返回字典中键的数量
print(len(stu2))   # 一个键值对算一个

练习

dic = {
    'python': 95,
    'java': 99,
    'c': 100
}
用程序解答下面的题目

字典的长度是多少
请修改'java' 这个key对应的value值为98
删除 c 这个key
增加一个key-value对，key值为 php, value是90
获取所有的key值，存储在列表里
获取所有的value值，存储在列表里
判断 javascript 是否在字典中
获得字典里所有value 的和
获取字典里最大的value
获取字典里最小的value
字典 dic1 = {'php': 97}， 将dic1的数据更新到dic中

练习2. 求学生最高分数科目和分数

题目要求：实现函数get_max_score， 执行程序，最终输出： 英语 98

def get_max_score(score_dic):
    """
    返回学生考试成绩的最高分的科目和分数
    :param score_dic:
    :return:
    """
    pass

dic = {
    '语文': 90,
    '数学': 97,
    '英语': 98
}

course, score = get_max_score(dic)
print(course, score)

1.5 案例

案例1：过滤掉列表[3, 9, -1, 10, 20, -2, ...] 中的负数

案例3：筛出集合{77, 89, 34, 20, 21...}中能被3整除的元素

avatar
文章
阅读
粉丝