元组,集合以及字典

元组

#不可变数据类型，不可以增删改查
#可以存储任意数据类型
#如果元组里包含可变数据类型，可以修改该数据类型达到间接修改元组的目的
#当元组只有一个元素的时候记得在该元素后面加, eg: i = (1,)

1.元组的特性

t = (1, 1.1, True, ‘wests’, [2, 3, 4])

#索引
print(t[0], t[-1])

#切片
print(t[2:])
print(t[:2])
print(t[:-1])
print(t[::-1])

#连接
#除了数值类型，别的数据类型，不同数据类型之间无法连接
print(t + (‘a’, ‘b’, ‘c’))
#print(t + [1,2]) 错误

#重复
print(t * 5)

#for循环
for i in t:
print(i)

#成员操作符
print(1 in t)
print([‘a’, ‘b’, ‘c’] not in t)

#查看元素的索引值
print(t.index(1.1))

#查看元素在元组中出现的次数
print(t.count(‘a’))

2.元组的场景应用

“”"
1.变量交换数值

a = 1
b = 2
b,a = a,b
“”"
1.先把(a,b)封装成了一个元组 (1,2)
2.b,a = a,b ===> b,a = (1,2)
3.b = (1,2)[0] a =(1,2)[1]
“”"
print(a,b)

2.打印变量值

name = ‘westos’
age = 11
t = (name,age)
print(‘name:%s,age:%d’ %(name,age))
print(‘name:%s,age:%d’ %t)

3.元组的赋值：有多少个元素，就用多少个变量接收

t = (‘Westos’,10,100)
name,age,score = t
print(name,age,score)

4.元组的排序

scores = (100,89,45,78,65)
scoreli = list(scores)
scoreli.sort()
print(scoreli)

scores_sort = sorted(scores)
print(scores_sort)

5.比赛计分器

scores = (100,89,98,60,90,67)
scores = sorted(scores)
#python2中*middle不能使用的
min_score,*middle,max_score = scores
#*的意思是除开赋值过的元素外所有的元素
print(min_score,’’,*middle, '~~’,max_score)
print(‘最终成绩为:%s’ %(sum(middle)/4))

深拷贝与浅拷贝

copy.copy() #浅拷贝
copy.deepcopy() #深拷贝

如果copy.copy()拷贝的是元组,那么它不会进行浅拷贝,仅仅是指向
因为元组是不可变数据类型,那么意味着数据一定不能修改,因此用copy.copy的
时候它会自动判断,是指向
如果,用copy.deepcopy()对一个全部是不可变类型的数据进行
数据拷贝,那么copy.deepcopy()是拷贝
如果拷贝的是一个多层可变类型的数据,那么deepcopy依然是深拷贝,而copy.copy
对外层是拷贝，对深层还是指向

集合

#集和里面的元素是不可重复的

#如何定义一个空集和

s2 = {} #默认情况是dict,称为字典

#定义一个空集和

s3 = set([])

#集和应用1:列表去重

li = [1,2,3,4,1,2,3]
print(list(set(li)))

集合的特性

集和支持的特性只有 成员操作符(索引 切片 重复 连接 均不支持)

s = {1,2,3}

print(1 in {1,2,3})
print(1 not in s)

#for循环
for i in s:
print(i,end=’ ')

#for + index
for i,v in enumerate(s):
print(‘index: %s,value:%s’ %(i,v))

集合添加元素

集合为可变数据类型
#添加顺序,和在集合中存储的顺序不同

s = {6,7,3,1,2,3}
#增加
s.add(8)
s.add(4)
print(s)

#增加多个元素

s.update({9,10,11})

集合删除元素

#pop()默认删除最后面的元素

s.pop()

#删除指定元素(元素要存在)

s.remove(3)

交集 并集 差集

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

#并集

print(‘并集:’, s1.union(s2))
print(‘并集:’, s1 | s2)

#交集

print(‘交集:’,s1.intersection(s2))
print(‘交集:’,s1 & s2)

#差集
#可以理解为s1中有哪些s2中没有的元素

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

#可以理解为s2中有哪些s1中没有的元素

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

#对等差分:并集 - 交集

print(‘对等差分:’,s1.symmetric_difference(s2))
print(‘对等差分:’,s1^s2)

s3 = {1,2}
s4 = {1,2,3}

#s3是否为s4的子集

print(s3.issubset(s4))

#s3是否为s4的超集(A为B的子集，B就是A的超集)

print(s3.issuperset(s4))

#两个集和是不是不相交

print(s3.isdisjoint(s4))

字典

1.字典的创建

#字典:key-value 键值对存储的一种数据结构
#value值可以是任意数据类型:int float long list tuple set dict
#尽量不要使用数字作为key

d = {
‘王超’:[18,‘男’,‘玩手机’],
‘王凯’:[18,‘男’,‘修手机’]
}
d2 = {
‘a’:1,
‘b’:2
}
d3 = {
‘a’:{1,2,3},
‘b’:{2,3,4}
}

#字典的嵌套

students = {
‘06163012’:{
‘name’:‘王凯’,
‘age’:18,
‘score’:90
},
‘03162003’:{
‘name’:‘管良虎’,
‘age’:19,
‘score’:80
}
}

#工厂函数

d5 = dict(a=1,b=2)

2.字典的特性

d = {
‘1’:‘a’,
‘8’:‘b’,
‘2’:‘a’
}

#字典不支持索引,但可以通过key值来索引value值
#字典不支持切片
#字典的重复和连接是无意义的，字典的key是唯一的

#成员操作符：判断的是 某个值是否为字典的key

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

3.字典的添加

1.增加一个元素
1).如果key值存在，则更新对应的value值
2).如果key值不存在，则添加对应的key-value值

services[‘mysql’] = 3306
services[‘http’] = 443

2.添加多个key-value值
1).如果key值存在，则更新对应的value值
2).如果key值不存在，则添加对应的key-value值

service_backup = {
‘tomcat’:8080,
‘https’:443,
‘http’:8888
}
services.update(service_backup)
services.update(flask=9000,http=999)

3.setdefault添加key值:
1).如果key值存在,则不做修改
2).如果key值不存在,则添加对应的key-value值

services.setdefault(‘http’,9000)
services.setdefault(‘oracle’,44575)

4.字典的删除

1.del关键字

del services[‘http’]

2.pop删除指定的key的key-value值
1.)如果key存在,删除,并且返回删除key对应的value值
2.)如果key不存在,直接报错

item = services.pop(‘http’)

3.popitem删除最后一个key-value

item = services.popitem()

4.清空字典内容

services.clear()

5.字典的查看

查看字典里面的key值

print(service.keys())

#查看字典里面的所有value值

print(service.values())

#遍历字典

for k,v in service.items():

print(k,’---->’,v)

for k in service:

print(k,’---->’,service[k])

#查看指定key对应的value值
#key值不存在,程序会报错

print(service[‘http’])

get 方法获取指定key对应的value值
如果key值存在,返回对应的value值
如果key值不存在,默认返回None,如果需要指定返回的值,传值即可

print(service.get(‘https’))

is与==的区别

id:在内存中存储的位置
type：变量的类型
value:变量的值
== :type,value
is:type,value,id

结论：
is 表示两个变量的值是否在同一块内存空间
== 表示的是值是否相等

总结: is 返回的值是True ==返回的一定是true

练习

1.华为笔试编程

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

import random
box=set([])
N=int(input(‘请输入生成随机数个数：’))
for i in range(N):

m=random.randint(1,1000)
box.add(m)

print(sorted(box))

结果展示：

2.字典的练习1

重复的单词: 此处认为单词之间以空格为分隔符， 并且不包含，和.；
1. 用户输入一句英文句子；
2. 打印出每个单词及其重复的次数;

a=input(‘请输入英文句子(单词之间以空格作为分隔符，不能包含,和.)：’)
c=a.split(’ ')
b={}
for i in range(len©-1):

element=c[i]
time=c.count(element)
b.setdefault(element,time)

print(b)

结果展示：

3.字典的练习2

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

import random
box=[]
for i in range(1000):

element=random.randint(20,100)
box.append(element)

dic={}
box.sort()
for m in range(1000):

times=box.count(box[m])
dic.setdefault(box[m])=times

print(dic)

部分结果展示：

4.字典的练习3

1. 随机生成100个卡号；
   卡号以6102009开头， 后面3位依次是 （001， 002， 003， 100），
2. 生成关于银行卡号的字典， 默认每个卡号的初始密码为"redhat";
3. 输出卡号和密码信息， 格式如下:
   卡号 密码
   6102009001 000000
   “”"
   fromkeys第一个参数可以是 list/tuple/str/set
   将第一个参数的元素作为字典的key值
   并且所有key的value值一致,都为’00000000’
   “”"
   #print({}.fromkeys({‘1’,‘2’},‘0000000’))

box=[]
for i in range(1,101)

message=‘6102009001%.3d’ %(i)
box.append(message)

dict={}.fromkeys(box,‘redhat’)
print(‘卡号\t\t\t密码’)
for key in dict

print(’%s\t\t\t%s’ %(key,dict[key]))

结果展示：