first ：深浅拷贝&嵌套拷贝
# 列表里面嵌套列表
"""
li = [['a', 'b'], 2, 3, 4]
li2 = li[:]
li3 = li.copy()
id(li), id(li1), id(li2)
(140198666531528, 140198653810888, 140198653810824) ******* 存储地址不同
id(li), id(li1), id(li2), id(li3)
(140198666531528, 140198653810888, 140198653810824, 140198653949512)
li.append(5)
li, li2, li3
([['a', 'b'], 2, 3, 4, 5], [['a', 'b'], 2, 3, 4], [['a', 'b'], 2, 3, 4])
li[0].append('c') *********在嵌套集合内添加元素
li, li2, li3
([['a', 'b', 'c'], 2, 3, 4, 5], [['a', 'b', 'c'], 2, 3, 4], [['a', 'b', 'c'], 2, 3, 4])
li = [['a', 'b'], 1,2]
li2 = li.copy()
li
[['a', 'b'], 1, 2]
li2
[['a', 'b'], 1, 2]
id(li[0])
140198666473736 **********嵌套的列表存储地址相同（浅拷贝）
id(li2[0])
140198666473736
import copy
li
[['a', 'b'], 1, 2]
li2
[['a', 'b'], 1, 2]
li3 = copy.copy(li)
li4 = copy.deepcopy(li)
li
[['a', 'b'], 1, 2]
li4
[['a', 'b'], 1, 2]
id(li[0])
140198666473736
id(li4[0])
140198658766920 ***********嵌套的列表存储地址不同（神拷贝）
"""
# 所有的数值类型和布尔类型, str是不可变数据类型,
# list是可变数据类型;
# 浅拷贝的实现:
# - li.copy()
# - li[:]
# - copy.copy(li)
# 实现深拷贝:
# - copy.deepcopy(li)
1.元组
1. 定义元组
t = (1, 2.1, 2e+10, True, 2j+3, [1,2,3],(1,2,3) )
print( type(t))
输出为class tuple，tuple代表元组
如果元组里面包含可变数据类型， 可以间接修改元组内容;
t1 = ([1,2,3], 4)
t1[0].append(4)
print(t1)
结果为：([1,2,3,4],4)
t2 = ()
t3 = tuple([])
# 元组如果只有一个元素， 后面一定要加逗号, 否则数据类型不确定；
t4 = ('hello')
t5 = ('hello',)
print(type(t2), type(t3), type(t4), type(t5))
结果为：’str‘ ‘tuple’ ‘str’ ‘tuple’
2.元组的特性
元组支持连接，索引，切片，重复，成员操作符。
重点：
for循环
print("显示".center(50, '*')) 结果：******************************显示*******************************
# # for循环并且求索引(枚举)
for index,user in enumerate(allowUsers):
print("第%d个白名单用户: %s" %(index+1, user)) 结果为：第一个白名单用户：root 第二个白名单用户：westos 等等
# zip: 集和用户名和密码两个元组， 元素之间一一对应
for user, passwd in zip(allowUsers, allowPasswd):
print(user,':', passwd) 例：root：123 westos：456 等等
3.元组的应用场景
变量交换数值 a=1 b=2 a,b=b,a a=2 b=1
元组的赋值: 有多少个元素， 就用多少个变量接收
t = ('westos', 10, 100)
name, age,score = t
print(name, age, score) 结果为：‘westos’ 10 100
如果数量不对等，会报错
scores = (100, 89, 45, 78, 65)
先对元组进行排序
scoresLi = list(scores) 转化为列表
scoresLi.sort() 作为列表排序
print(scoresLi) 结果是列表，[45,65,78,89,100]
scores = sorted(scores) 元组内置排序的函数
python3中
minScore, *middleScore, maxScore = scores
print(minScore, middleScore, maxScore)
print("最终成绩为: %.2f" %(sum(middleScore)/len(middleScore))) 求的是平均成绩
2.集合
1.集合定义
集合里面的元素是不可重复的;
s = {1, 2, 3, 4, 1, 2, 3}
print( type(s)) 结果为：class ‘set’ ！！！！！有重复的会自动去除！！！！！！！
s1 = {1}
print(s1, type(s1)) 结果为：{1} class ‘set’
*******如何定义一个空集合?
s2 = {} # 默认情况是dict， 称为字典
print(s2, type(s2) 结果为：{} class‘dict’
定义一个空集合.
s3 = set([ ]) ！！！！！！！！！！！！！集合定义方式！！！！！！！！！！！
集合应用1： 列表去重
li = [1,2,3,1,2,3]
print(list(set(li))) 结果为：[1,2,3]
2.集合特性
集合只支持成员操作符
print(1 in {1,2,3}) 返回Ture
print(1 not in {1,2,3}) 返回False
3.集合的常用方法
s={2，3，4}
增加:
s.add(1) 输出s为{1，2，3，4}
s.update({7,8,5}) 增加多个元素 返回s为{1，2，3，4，7，8，5}
删除：
s.pop() 删除集合里的所有元素
s.remove(3) 删除特定元素 返回s为{1，2，4，7，8，5}
交集， 并集， 差集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
并集
print("并集：", s1.union(s2)) 结果为：并集：{1，2，3，4}
print("并集：", s1 | s2）
交集
print("交集:", s1.intersection(s2))
print("交集:", s1 & s2) 结果为：交集：{2，3}
差集
print("差集:", s1.difference(s2)) # s1- (s1&s2) 结果为：{1}
print("差集:", s2.difference(s1)) # s2- (s1&s2) 结果为：{4}
print("差集:",s1-s2)
print("差集:",s2-s1)
对等差分: 并集-交集
print("对等差分:", s1.symmetric_difference((s2)))
print("对等差分:", s1^s2) 结果为：{1，4}
集合的例题：import random
先 生成n个随机数
列表， 集合也可以， 优先选择集合,
s = set([]) 生成一个集合
for i in range(int(input('N:'))): 循环N次，N为输入值
num = random.randint(1,1000) 随机数赋值
s.add(num) 随机数叠加
print(sorted(s)) 打印排序后的随机数
3.字典（重点 难点）
1.字典的定义
总结: 定义字典:
- 定义空字典, {}, dict()
- 赋值: d = {'key':'value', 'key1':'value1'}
- 初始化所有value值: fromkeys()
- 根据已有的数据创建字典:
users = ['user1', 'user2']
passwds = ['123', '456']
zip(users, passwds)
<zip object at 0x7f764d2c3908>
list(zip(users, passwds))
结果： [('user1', '123'), ('user2', '456')]
userinfo = dict(zip(users, passwds))
userinfo
{'user1': '123', 'user2': '456'}
s = {}
print(type(s)) 结果为：class ‘dict’
s = {
'fentiao':[100, 80, 90],
'westos':[100,100,100]
}
print(s, type(s)) 结果为：class ‘dict’
d = dict(a=1, b=2)
print(d) 结果为：{'a':1,'b':2}
cardinfo = {
'001':'000000',
'002':'000000',
}
# 随机生成100张卡号， 卡号的格式为610 334455 001 ---610 334455 100
cards = []
for cardId in range(100):
card = "610334455 %.3d" %(cardId+1)
cards.append(card)
print(cards) 结果为['610334455001','610334455002',........'610334455100']
print({}.fromkeys(cards)) 结果为：{'610334455001':None,'610121334455002':None,.............}
print({}.fromkeys(cards, '666666')) 结果为：{'610334455001':'666666','610334455002':'666666'，................}
"""
定义空集合， 必须set(),
{}默认的类型为字典;
d = {}
字典: key-value值, 键值对；
value值可以是任意数据类型: int,float,long, complex, list, tuple,set, dict
d = {
'王旭': [18, '男', "请假"],
'张龙': [18, '男', '俯卧撑']
}
print(d['张龙']) 结果为： [18,男，俯卧撑]
d3 = {
'a': {1, 2, 3},
'b': {2, 3, 4}
}
print(d3) 结果为：{'a':{1,2,3},'b':{2,3,4}}
字典的嵌套;
students = {
'13021001': {
'name':'张龙',
'age':18,
'score':100
},
'13021003': {
'name': '张',
'age': 18,
'score': 90
}
}
print(students['13021003']['name']) 结果为：张
工厂函数;
l = list([1,2,3])
print(l) 结果为：[1,2,3]
# fromkeys第一个参数可以列表/tuple/str/set， 将列表的每一个元素作为字典的key值，
# 并且所有key的value值一致， 都为'000000';
print({}.fromkeys({'1', '2'}, '000000'))
结果为：{'1':'0000000','2':000000}
# 字典必须是不可变数据类型;d = {[1,2,3]:1}(x)
# 可变数据类型:list, set, dict
# 不可变: 数值类型， str, tuple
2.字典的特性
字典不支持重复，索引，切片，支持成员操作符
成员操作符，判断key值是否存在
d={'a':1,'c':2}
print('a' in d) 结果为：Ture
print(2 in d) 结果为：False
for循环便利 ！！！！！！！！！！！！！！！判断的依旧是key值！！！！！！！！！！！！！
for i in d:
print(i) 结果为：a c