Python中集合的应用

笑笑猫爱小小鱼
315 阅读8分钟

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

练习. 求列表最大值

题目要求：实现函数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)

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

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

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))    一个键值对算一个

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

题目要求：实现函数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)
avatar
文章
阅读
粉丝