集合python_python 集合详解

union用法：

返回和多个集合合并后的新集合（如图所示A与B的相交部分）、

”|“： union的代表符号

update（*others）： 和多个集合合并，就地修改

update的用法：

= : update的代表符号

交集：

集合A和B由所有属于A且属于B的元素组成的集合（如下图所示）：

intersection(*others)

返回多个集合的交集（如下图所示）：

& ：intersection的代表符号

intersection_update(*others)

获取和多个集合的交集，并就地修改

&= ：intersection_updated 的表示符号

差集

差集

集合A和B，由所有属于A且不属于B的元素组成的集合（如图所示）：

diffrernce(*others)的用法

返回多个集合的差集

— ： 表示为 difference的符号

difference_(update):

获取和多个集合的差集并就地修改

—= : 表示为difference_(update)的符号

对称差集

对称差集：

集合A和B，由所有不属于A和B的交集元素组成的集合，记作(A-B)U(B-A):

symmetric_differece(other)

返回和另一个集合的差集

”^“ 表示为symmetric_differece的表示符号

symmetric_differece_update(other)

获取另一个集合的差集并就地修改

”^=“ 表示为symmetric_differece_update(other)的使用符号

issubset(other)、<=：

判断当前集合是否是另一个集合的子集

set1

判断set1是否是set2的真子集

issuperset(other)、>=

判断set1是否是set的真超集

isdisjoint(other)

当前集合和另一个集合没有交集；没有交集，返回True

集合练习：

共同好友；

你的好友A,B,C 他的好友C,B,D， 求共同好友：

交集问题： {'A','B','C'}.intersection({'B','C','D'})

微信群提醒：

XXX与群里其他人都不是微信朋友关系

并集：userid in (A|B|C|...)==FLASE, A , B , C等是好友的并集，用户ID不在这个并集中，说明他和任何人都不是朋友

权限判断：

有一个API，要求同时具备A,B,C权限才能访问，用户权限B,C,D，判断该用户能否访问该API

API集合为A，权限集合为P；A-P={},AP为空集，说明 P包含A

A.issubset（P）也行，A是P的子集

A&P=A也可以

有一个API，要求具备A,B,C任意一项权限就可访问，用户权限B,C,D ，判断该用户能否访问该API

一个总任务列表，储存所有任务，一个完成的任务列表。找出未完成的任务

设所有的工作为ALL，已完成的工作为COMPLETED 用所有的减去已完成的得出未完成的

集合练习:

随机产生2组各个数字的列表，如下要求：

每个数字取值范围[10,20]

统计20个数字中，一共有多少个不同的数字？

2组中，不重复的数字有几个？分别是什么？

2组中，重复的数字有几个？分别是什么？

答案依次为：

字典

字典：

字典为 key-vlaue 键值对的数据的集合；字典是可变的，无序的，key不重复

字典的定义，初始化：

字典常用的用法为 ： dict(**kwargs) 使用name=value 对一个字典初始化

dict（可迭代，**kwarg）使用可迭代对象和name=value对构造字典，不过可迭代对象的元素必须是一个二元结构

dict(mapping,**kwarg)使用一个字典构造另外一个字典

d={'a':10,'b':20,'c':None,'d':[1,2,3]}

字典元素的访问：

d[key]： 返回key对应的值value；key不存在抛KeyError异常

get(key,[,default])： 返回key对应的值value，key不存在返回缺省值，如果没有设置缺省值返回None

setdefault（key[,default]）：返回key对应的值value，key不存在，添加kv对.值为default，并返回default，如果default没有设置，缺省为None

字典增加和修改：

d[key]=value ：将key对应的值修改为value（新值），key不存在添加新的kv对

update([other])-->None：

使用另一个字典的kv对更新本字典；key不存在，就添加；key存在，覆盖已经存在的key对应的值；就地修改

字典删除：

pop(key[,default]):

key存在，移除它，并返回他的value

key不存在，返回给定的default

default未设置，key不存在则排除KeyError异常

popitem（）

移除并返回一个任意的键值对

字典为空，抛出KeyError异常

clear() 清空字典

字典删除：

del语句

字典练习：

第二题：

import random

randomnumber=[]

countlist=[]

randomdict={}

sortlist=[]

for p in range(100):

randomnumber.append(random.randrange(-1000,1000))

countlist.append(randomnumber.count(randomnumber[p]))

randomdict[randomnumber[p]]=countlist[p]

for k,v in randomdict.items():

sortlist.append((k,v))

sortlist.sort()

print(sortlist)

输出结果：

习题一：

nums=input('>>>')

count_list=[]

sort_list={}

sort_list1=[]

for i in range(len(nums)):

count_list.append(nums.count(nums[i]))

sort_list[nums[i]]=count_list[i]

for k,v in sort_list.items():

sort_list1.append((k,v))

print(sort_list1)

输出结果：

习题三：

import random

s1=[]

same_alpha=[]

count_list={}

diff_alpha=[]

alpha='abcdefghijklmnopqrstuvwxyz'

for _ in range(100):

s1.append(random.choice(alpha)+random.choice(alpha))

same_alpha.append(s1.count(s1[_]))

count_list[s1[_]]=same_alpha[_]

#进行排序

for k,v in count_list.items():

diff_alpha.append((k,v))

diff_alpha.sort(reverse=True)

print(diff_alpha)

输出结果为：

选择排序：

选择排序使用方法

简单选择排序：

属于选择排序，两两比较大小，找出最大值和最小值；被放在固定的位置，固定位置一般在某一端

结果分为升序和降序

降序：n个数由左至右，索引从0到-1，两两依次比较，并记录最大值，此轮所有数比较完毕，将最大数和索引0数比较，如果最大数就是索引1，不交换；第二轮由1开始比较，找到最大值，将它和索引1位置交换，如果他就在索引1则不叫唤，依次类推，每次左边都会固定下一个大数

升序：

和降序相反

简单排序总结：

简单排序需要 数据一轮轮比较，并在每一轮中发现极值

没有办法知道当前轮是否已经达到排序要求，但可以知道极值是否在目标索引位置上

遍历次数1，....，n-1和n（n-1）/2

时间复杂度为O(n的平方)

减少了交换次数，提高了效率，性能略好于冒泡法

选择排序练习：

将上述列表第二列利用选择排序进行排序

m_list=[[1,9,8,5,6,7,4,3,2],

[6,5,8,7,9,4,2,1,3],

[9,8,7,6,5,4,3,2,1]]

nums = m_list[1]

length=len(nums)

print(nums)

for i in range(length):

maxindex=i

for j in range(i+1,length):

if nums[maxindex] < nums[j]:

maxindex = j

# print(nums)

if i != maxindex: #第二次判断两个索引是否相等，若相等则说明该值已是最大，无需进行下面的命令操作，否则则进行下面的程序

tmp = nums[maxindex] #将列表中最大的值赋给另一个参数

nums[maxindex]=nums[i] #将列表中maxindex索引的值刷新为i索引的值

nums[i]=tmp #将列表中i的索引的值刷新为tmp的最大值

print(nums)

输出结果为：

回顾之前所学知识，并以新的所学知识做一些以前的习题：

求杨辉三角的第5列的第4个值

m=5

k=4

traingle=[]

for i in range(m):

row=[1]

traingle.append(row)

for j in range(1,i):

if i == 0:

continue

row.append(traingle[i-1][j-1]+traingle[i-1][j])

row.append(1)

traingle.append(row)

print(traingle)

print(traingle[m-1][k-1])

习题二：

lst=[[1,2,3],[4,5,6],[7,8,9]]

for i in range(len(lst)): #依次循环3个列表

for j in range(i): #本次循环的是列表中的索引值

lst[i][j],lst[j][i]=lst[j][i],lst[i][j] #将列表的值进行交换

print(lst)

for k in lst: #重新排序

print(k)

输出结果为：

习题3：

firstlist=[[1,2,3],[4,5,6]] #创建一个包含两列数的列表

secondlist=[] #创建一个空列表

m=len(firstlist) #将第一个列表的长度输出给m

for i in range(m+1): #

secondlist.append([0]*m)#循环三次，并开辟3个介为0的子列表

print(secondlist)

print(firstlist)

for i in range(m): #

for j in range(m+1): #利用两层循环来读取索引上的数值

secondlist[j][i]=firstlist[i][j] # 将对应索引上的值进行交换

print(secondlist)

输出结果为:

习题三：

随机生成10个数字；

每个数字的取值范围不超过20

分别统计重复与不重复的数字有几个：

import random

nums=[]

for _ in range(10):

nums.append(random.randrange(21))

print('nums1={}'.format(nums))

print()

随机生成10个20以内的数字

————————————————————————

length=len(nums)

samenums=[]

diffnums=[]

states = [0]*length

for i in range(length):

flag=False

if states[i]==1:

continue

for j in range(i+1,length):

if states[j]==1:

continue

if nums[i]==nums[j]:

flag=True

states[j]=1

if flag: #有重复

samenums.append(nums[i])

states[i]=1

else:

diffnums.append(nums[i])

print("Same numbers={1},counter={0}".format(len(samenums),samenums))

print("different numbers={1},counter={0}".format(len(diffnums),diffnums))

print(list(zip(states,nums)))

本文转载