python元组、集合、字典

In [1]: min(3,4)
Out[1]: 3

In [2]: max(3,4)
Out[2]: 4

In [3]: sum(range(1,101))
Out[3]: 5050

In [4]: sum(range(1,101,2))
Out[4]: 2500

In [5]: sum(range(2,101,2))
Out[5]: 2550

"""
#枚举：返回索引值和对应的value值
# for i,v in enumerate('hello'):
# print(i,v)

#zip
s1 = 'abc'
s2 = '123'

for i in zip(s1,s2):
print(i)
print(''.join(i))

t = (1,2.3,True,'star')
print(t)
print(type(t))

#元组里面包含可变数据类型，可以间接修改元组的内容
t1 = ([1,2,3],4)
t1[0].append(4)
print(t1)

#元组如果只有一个元素的时候，后面一定要加逗号，否则数据类型不确定
t2 = ('hello',)
t3 = (1,)
print(type(t2))
print(type(t3))

allowUsers = ('root','westos','redhat')
allowPasswd = ('123','456','789')

#索引切片
print(allowUsers[0])
print(allowUsers[-1])
print(allowUsers[1:])
print(allowUsers[2:])
print(allowUsers[:-1])
print(allowUsers[::-1])

#重复
print(allowUsers * 3)

#连接
print(allowUsers + ('linux','python'))

#成员操作符
print('westos' in allowUsers)
print('westos' not in allowUsers)

#for循环
for user in allowUsers:
print(user)

for index,user in enumerate(allowUsers):
print('第%d个白名单用户: %s' %(index+1,user))

#zip:两个元组的元素之间一一对应
for user,passwd in zip(allowUsers,allowPasswd):
print(user,':',passwd)

t = (1,2.3,True,'westos','westos')
print(t.count('westos'))
print(t.index(2.3))

#变量交换数值
# a = 1
# b = 2
# b,a = a,b
# #1.先把(a,b)封装成一个元组(1,2)
# #2.b,a=a,b ---> b,a=(1,2)
# #b = (1,2)[0] a = (1,2)[1]
# print(a)
# print(b)

#打印变量的值
# name = 'westos'
# age = 11
# t = (name,age)
# print('name:%s , age:%d' %(name,age))
# print('name:%s , age:%d' %t)

#元组的赋值，有多少个元素，就用多少个变量接收
# t = ('westos',11,100)
# name,age,score = t
# print(name,age,score)

score = (100,89,45,78,65)
# scoreLi = list(score)
# scoreLi.sort()
# print(scoreLi)
scores = sorted(score)
# print(scores)
minscore,*middlescore,maxscore = scores
print(minscore)
print(middlescore)
print(maxscore)
print('最终成绩为: %.2f' %(sum(middlescore) / len(middlescore)))

#集合里面的元素是不可重复的
s = {1,2,3,1,2,3,4,5}
print(s)
print(type(s))

s1 = {1}
print(s1)
print(type(s1))

#如何定义一个空集合
# s2 = {}
# print(type(s2))
#
# s3 = set([])
# print(s3)
# print(type(s3))

#集合的应用
li = [1,2,3,1,2,3]
print(list(set(li)))

#集合只支持成员操作符 for循环

s = {1,2,3}
# print(s[0])
# print(s * 3)
# print(s + {4,5,6})
print(1 in s)

for i in s:
print(i,end='|')

for i,v in enumerate(s):
print('index: %s,value: %s' %(i,v))

#集合:无序的数据类型
#添加顺序和在集合中存储的顺序是不一定相同的

# s = {6,7,8,9}
#增加一个元素
# s.add(1)
# print(s)

#增加多个元素
# s.update({5,3,2})
# print(s)

#删除
# s.pop()
# print(s)

#删除指定元素
# s.remove(5)
# print(s)

s1 = {1,2,3}
s2 = {2,3,4}

#并集
print('并集:',s1.union(s2))
print('并集:',s1|s2)

#交集
print('交集:',s1.intersection(s2))
print('交集:',s1&s2)

#差集
print('差集:',s1.difference(s2)) #s1-(s1&s2)
print('差集:',s2.difference(s1)) #s2-(s1&s2)

#对等差分:并集-交集
print('对等差分:',s2.symmetric_difference(s1))
print('对等差分:',s1^s2)

s3 = {1,2}
s4 = {1,2,3}
#s3是否为s4的超集
#超集:如果s3中的每一个元素都在集合s4中,且s4中可能包含s3中没有的元素,
#那么s4就是s3的一个超集
print(s3.issuperset(s4))
print(s4.issuperset(s3))
#s3是否为s4的子集
print(s3.issubset(s4))
#两个集和是不是不相交
print(s3.isdisjoint(s4))

import random

"""
明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性
他先用计算机生成了N个1～1000之间的随机整数(N<=1000),N是用户输入>的，对于
其中重复的数字，只保留一个，把其余相同的数字去掉，不同的数对应着
不同的学生的学号，然后再把这些
数从小到大排序，按照排好的顺序去找同学做调查，请你协助明明完成“>去重”与排序工作
"""
s = set([])

for i in range(int(input('N:'))):
s.add(random.randint(1,1000))

print(s)
print(sorted(s))

#字典是一个无序的数据集合,使用print输出字典时
#通常输出的顺序和定义的顺序不一致

# users = ['user1','user2']
# passwd = ['123','456']
# print(zip(users,passwd))
# print(list(zip(users,passwd)))
# print(dict(zip(users,passwd)))

# s = {}
# print(type(s))

#字典:key-value 键值对
#value值可以是任意数据类型

# s = {
# 'linux':[100,99,88],
# 'westos':[190,564,645]
# }
#
# print(s)
# print(type(s))

#工厂函数
# d = dict()
# print(d)
# print(type(d))
#
# d1 = dict(a=1,b=2)
# print(d1)
# print(type(d1))

#字典的嵌套

students = {
'03113009':{
'name':'tom',
'age':18,
'score':80
},
'03113010':{
'name': 'laoli',
'age': 19,
'score':30
}
}

print(students['03113010']['name'])

#所有的key和value值是一样的情况
print({}.fromkeys({'1','2'},'03113009'))

print('1' in d)
print('1' not in d)

#for循环,默认遍历字典的key值
for key in d:
print(key)

#遍历字典
for key in d:
print(key,d[key])

for key,value in d.items():
print(key,value)

service = {
'http':80,
'ftp':21,
'ssh':22
}

#增加一个元素
#如果key值存在,则更新对应的value值
#如果key值不存在,则添加对应的key-value值
service['mysql'] = 3306
print(service)
service['http'] = 443
print(service)

#添加多个key-value值
service_backup = {
'https':443,
'tomcat':8080,
'http':8080
}

service.update(service_backup)
print(service)

service.update(flask=9000,http=8000)
print(service)

#setdefault添加key值
#如果key值存在,不做修改
#如果key值不存在,则添加对应的key-value
service.setdefault('http',9090)
print(service)
service.setdefault('oracle',44575)
print(service)

service = {
'http':80,
'ftp':21,
'ssh':22
}

# del service['http']
# print(service)

#pop删除指定key的key-value
#如果key存在,删除,并且返回删除key对应的value
#如果key不存在,报错
# item = service.pop('http')
# print(item)
# print(service)

#popitem删除最后一个key-value值
item = service.popitem()
print('删除的key-value对是:',item)
print(service)

#清空字典内容
service.clear()
print(service)

service = {
'http':80,
'ftp':21,
'ssh':22
}

#查看字典的key值
print(service.keys())

#查看字典的value值
print(service.values())

#查看key的value值;key不存在,报错
# print(service['https'])

#查看key的value值
#key不存在,默认返回None
#key不存在,有default,则返回default
print(service.get('https',443))
print(service.get('https'))

#遍历
# for k,v in service.items():
# print(k,'--->',v)

# print(service['https'])
if 'https' in service:
print(service['https'])
else:
print('key not exist')

#get方法获取指定key对应的value值
#如果key值存在,返回对应的value值
#如果key值不存在,默认返回None,如果需要指定返回值,传值即可
print(service.get('https','ket not exist'))

#数字重复统计:
1)随机生成1000个整数;
2)数字范围[20,100];
3)升序输出所有不同的数字及其每个数字重复的次数
"""

import random

all_nums = []
for item in range(1000):
all_nums.append(random.randint(20,100))

#对生成的1000个数进行排序,然后加到字典中
sorted_nums = sorted(all_nums)
num_dict = {}
for num in sorted_nums:
if num in num_dict:
num_dict[num] += 1
else:
num_dict[num] = 1
print(num_dict)

python元组、集合、字典

猜你喜欢