Day - 04

元组的创建

列表：打了激素的数组 元组:带了紧箍咒的列表
不可变数据类型，没有增删改查
可以存储任意数据类型

#定义元组
t = (1,1.2,True,‘westos’)
print(t,type(t))

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

t2 = ()
print(t2)
t3 = tuple([])
print(t3)
l4 = list(())
print(l4)

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

元组的特性

tuple = (1,1.0,True,‘westos’)
#索引
print(tuple[0])
print(tuple[-1])

#切片
print(tuple[1:])
print(tuple[:-1])
print(tuple[::-1])

#连接
#不同的数据类型可以连接麼(除了数值类型之外，不同的数据类型之间不可以连接)
print(tuple + (1,2,3))
print(tuple + [4,5,6])
print(tuple + ‘westos’)

#重复
print(tuple * 5)

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

#成员操作符
print(1 in tuple)
print(i not in tuple)

元组的常用方法

t = (1,2,‘a’,‘c’,‘a’)
#查看元素的索引值
print(t.index(‘c’))
#查看元素在元组中出现的次数
print(t.count(‘a’))

元组的应用场景

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)

打印变量值
name = ‘westos’
age = 11
t = (name,age)
print(‘name:%s,age:%d’ %(name,age))
print(‘name:%s,age:%d’ %t)

元组的赋值：有多少个元素，就用多少个变量接收
t = (‘Westos’,10,100)
name,age,score = t
print(name,age,score)

scores = (100,89,45,78,65)
先对元组进行转换
scoreli = list(scores)
scoreli.sort()
print(scoreli)
scores_sort = sorted(scores)
print(scores_sort)

比赛计分器

scores = (100,89,98,60,90,67)
#scores.sort()
scores = sorted(scores)
#python2中*middle不能使用的
min_score,*middle,max_score = scores
print(min_score,'~~~~',*middle, '~~~~~~',max_score)
print('最终成绩为:%s' %(sum(middle)/4))

深拷贝和浅拷贝

当一个变量=xxx的时候,约定为: 指向地址的过程
浅拷贝:copy.copy()
深拷贝:copy.deepcopy()

In [38]: import copy

In [39]: a = [11,22]

In [40]: b = [33,44]

In [41]: c = [a,b]

In [42]: c
Out[42]: [[11, 22], [33, 44]]

In [43]: d = copy.copy©

In [44]: id©
Out[44]: 140233732341960

In [45]: id(d)
Out[45]: 140233713050888

In [46]: id(c[0])
Out[46]: 140233732292488

In [47]: id(d[0])
Out[47]: 140233732292488

In [48]: id(a)
Out[48]: 140233732292488

In [49]: e = copy.deepcopy©

In [50]: id(e)
Out[50]: 140233732321800

In [51]: id©
Out[51]: 140233732341960

In [52]: id(c[1])
Out[52]: 140233731307720

In [53]: id(e[1])
Out[53]: 140233713173832

In [54]: id(d[1])
Out[54]: 140233731307720

“”"

“”"

In [55]: a = [11,22]

In [56]: b = [33,44]

In [57]: c = [a,b]

In [58]: d = copy.copy©

In [59]: e = copy.deepcopy©

In [60]: id©
Out[60]: 140233732324104

In [61]: id(d)
Out[61]: 140233740633608

In [62]: id(e)
Out[62]: 140233732090888

In [63]: c.append([55,66])

In [64]: c
Out[64]: [[11, 22], [33, 44], [55, 66]]

In [65]: d
Out[65]: [[11, 22], [33, 44]]

In [66]: e
Out[66]: [[11, 22], [33, 44]]

“”"
“”"

如果copy.copy()拷贝的是元组,那么它不会进行浅拷贝,仅仅是指向
因为元组是不可变数据类型,那么意味着数据一定不能修改,因此用copy.copy的 时候它会自动判断,是指向

如果,用copy.copy() copy.deepcopy()对一个全部是不可变类型的数据进行 数据拷贝,那么它们的结果相同,都是引用
如果拷贝的是一个拥有可变类型的数据,那么deepcopy依然是深拷贝,而copy.copy 还是指向

总结：
1，深浅拷贝都是对源对象的复制，占用不同的内存空间。

2，不可变类型的对象，对于深浅拷贝毫无影响，最终的地址值和值都是相等的。

3，可变类型：
=浅拷贝： 值相等，地址相等 copy浅拷贝：值相等，地址不相等

In [73]: a = [11,22]

In [74]: b = [33,44]

In [75]: c = (a,b)

In [76]: c
Out[76]: ([11, 22], [33, 44])

In [77]: d = copy.copy©

In [78]: id©
Out[78]: 140233732322440

In [79]: id(d)
Out[79]: 140233732322440

In [80]: e = copy.deepcopy©

In [81]: id(e)
Out[81]: 140233713145672

In [82]: id©
Out[82]: 140233732322440

In [83]: id(c[1])
Out[83]: 140233713122504

In [84]: id(e[1])
Out[84]: 140233731173640

In [85]: id(d[1])
Out[85]: 140233713122504

In [86]: a.append(55)

In [87]: c
Out[87]: ([11, 22, 55], [33, 44])

In [88]: e
Out[88]: ([11, 22], [33, 44])

集和的定义

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

#如何定义一个空集和
s2 = {} #默认情况是dict,称为字典
print(s2,type(s2))

#定义一个空集和
s3 = set([])
print(s3,type(s3))

#集和应用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=' ')
print()
print('~~~~~~')

#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})
print(s)

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

#删除指定元素(元素要存在)
s.remove(3)
print(s)

交集 并集 差集
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)
可以理解为s2中有哪些s1中没有的元素
print(‘差集:’,s2.difference(s1)) # s2 - (s1&s2)
print(‘差集:’,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的超集
#什么是超集?
print(s3.issuperset(s4))
#两个集和是不是不相交
print(s3.isdisjoint(s4))

华为笔试编程

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

错误：

原因：

改：

代码：

import random
# 先 生成n个随机数
# 有先选择集和
s = set([])
for i in range(int(input('N:'))):
    s.add(random.randint(1,1000))
print(sorted(s))

字典的创建

字典:key-value 键值对存储的一种数据结构
value值可以是任意数据类型:int float long list tuple set dict

d = {
‘王超’:[18,‘男’,‘玩手机’],
‘王凯’:[18,‘男’,‘修手机’]
}
print(d)
print(d[‘王凯’])

d2 = {
‘a’:1,
‘b’:2
}
print(d2)

d3 = {

'a':{1,2,3},
'b':{2,3,4}

}

print(d3)

字典的嵌套

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

print(students[‘03162003’][‘name’])

#工厂函数
d5 = dict(a=1,b=2)
print(d5)

字典的特性

d = {
‘1’:‘a’,
‘8’:‘b’,
‘2’:‘a’
}
print(d[‘1’])
#字典不支持索引
#print(d[0])
#字典不支持切片
#print(d[::-1])

#字典的重复和连接是无意义的，字典的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])

services = {

'http': 80,
'ftp': 21,
'ssh': 22

}
“”"
1.增加一个元素
1).如果key值存在，则更新对应的value值
2).如果key值不存在，则添加对应的key-value值
“”"
services[‘mysql’] = 3306
print(services)
services[‘http’] = 443
print(services)

“”"
2.添加多个key-value值
1).如果key值存在，则更新对应的value值
2).如果key值不存在，则添加对应的key-value值
“”"
service_backup = {
‘tomcat’:8080,
‘https’:443,
‘http’:8888
}

services.update(service_backup)
print(services)
services.update(flask=9000,http=999)
print(services)

“”"
3.setdefault添加key值:
1).如果key值存在,则不做修改
2).如果key值不存在,则添加对应的key-value值
“”"
services.setdefault(‘http’,9000)
print(services)
services.setdefault(‘oracle’,44575)
print(services)

字典的删除

#1.del关键字
del services[‘http’]
print(services)

“”"
2.pop删除指定的key的key-value值
1.)如果key存在,删除,并且返回删除key对应的value值
2.)如果key不存在,直接报错
“”"
item = services.pop(‘http’)
print(item)
print(services)

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

item = services.popitem()
print(‘删除的key-value对应的是:’,item)
print(services)

“”"
4.清空字典内容
“”"
services.clear()
print(services)

字典的修改与查看

service = {
‘http’:80,
‘mysql’:3306
}

#查看字典里面的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’])
print(service[‘https’])

“”"
get 方法获取指定key对应的value值
如果key值存在,返回对应的value值
如果key值不存在,默认返回None,如果需要指定返回的值,传值即可
“”"
print(service.get(‘https’))

字典的练习

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

s = input('str:')
s1 = s.split(' ')
words_dict = {}
for i in s1:
    if i in words_dict:
        words_dict[i] += 1
    else:
        words_dict[i] = 1
print(words_dict)

字典的练习02

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

import random
li =[random.randint(20,100) for i in range(1000)]
print(li)
sorted_num = sorted(li)
nums_dict = {}
for i in li:
    if i in nums_dict:
        nums_dict[i] += 1
    else:
        nums_dict[i] = 1
print(nums_dict)

字典的练习03

1. 随机生成100个卡号；
   卡号以6102009开头， 后面3位依次是 （001， 002， 003， 100），

2. 生成关于银行卡号的字典， 默认每个卡号的初始密码为"redhat";

3. 输出卡号和密码信息， 格式如下:
   卡号 密码
   6102009001 000000

fromkeys第一个参数可以是 list/tuple/str/set
将第一个参数的元素作为字典的key值
并且所有key的value值一致,都为’00000000’

card_ids = []
for i in range(100):
    s = '6102009001%.3d' %(i+1)
    card_ids.append(s)
card_ids_dict = {}.fromkeys(card_ids,'redhat')
print(card_ids_dict)

print('卡号\t\t\t\t\t\t密码')
for key in card_ids_dict:
    print('%s\t\t\t%s' %(key,card_ids_dict[key]))