元组
#不可变数据类型,不可以增删改查
#可以存储任意数据类型
#如果元组里包含可变数据类型,可以修改该数据类型达到间接修改元组的目的
#当元组只有一个元素的时候记得在该元素后面加, 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,’~~’,max_score)’,*middle, '
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])=timesprint(dic)
部分结果展示:
4.字典的练习3
- 随机生成100个卡号;
卡号以6102009开头, 后面3位依次是 (001, 002, 003, 100), - 生成关于银行卡号的字典, 默认每个卡号的初始密码为"redhat";
- 输出卡号和密码信息, 格式如下:
卡号 密码
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 dictprint(’%s\t\t\t%s’ %(key,dict[key]))
结果展示: