自我总结06
1.元组
只可取不佳而更改的列表
1.作用
# 元组一创建就被写死了， 定义元组--》占用内存小 --》 写死了
2.定义方法
（）内用逗号隔开多个元素
# lt =list([1,2,3])
tup = tuple((1, 2, 3))
print(tup, type(tup))
# 如果元组只有一个元素，必须得加逗号
tup1 = (1,)
print(tup1, type(tup1))
3.使用方法
# 1. 索引取值
print(tup[0])
# 2. 索引切片
print(tup[0:3])
# 3. for循环
for i in tup:
print(i)
# 4. 成员运算
print(0 in tup)
# 5. len长度
print(len(tup))
# 6. index获取元素索引
print(tup.index(1))
# 7. count 计数
print(tup.count(2))
4. 有序or无序
有序
5. 可变or不可变
压根不存这一说
2.字典的内置方法
1.作用
存储多个数据，对每个数据具有描述
2.定义方法
{}内用逗号隔开多个键key(具有描述意义，不能为可变数据类型):值value（任意数据类型）对 # 散列表（哈希表）
dic = {'name': 1}
print(dic)
# 0001
dic = {0: '功能1', 1: '功能2'}
print(dic)
dic = {[1, 2]: 'a'} # 可变==不可哈希，不可变==可哈希
print(dic)
3.使用方法
# 优先掌握
# 1. 按key取值/按key修改值
dic = {'a': 1, 'b': 2, 'c': 3}
print(dic['a'])
dic['b'] = 4
print(dic)
# 2. 添加值,没有就添加，有就修改
dic['d'] = 4
print(dic)
# 3. for循环
for i in dic:
print(i)
# 4. 成员运算
print('a' in dic)
# 5. len长度
print(len(dic))
# 6. keys/values/items
print(dic.keys()) # 看成列表
print(dic.values()) # 获取所有值
print(dic.items())
for i in dic.items():
print(i)
for kasdfsad, vsdfsdf in dic.items(): # 解压缩
print(kasdfsad, vsdfsdf)
# 需要掌握
# get:获取
s = 'e'
# print(dic[s]) # KeyError: Nonetype --> s是None，并不是你想象的e
print(dic.get('b', 1)) # 字典中没有返回None,可以给定一个默认值
# update : 更新，等同于list里的extend
dic1 = {'a': 1, 'c': 2}
dic2 = {'b': 1, 'd': 2}
dic1.update(dic2)
print(dic1)
# fromkeys
print(dict.fromkeys(dict.fromkeys([1, 2, 3, 4]))) # 默认给None
# setdefault # 字典有这个key，就不修改，没有则增加
dic.setdefault('j', 2)
dic.setdefault('a', 2)
print(dic)
4. 有序or无序
无序
5. 可变or不可变
可变
3.散列表（哈希表）
# 散列表/哈希表存储数据 --》 相比较列表，插入/删除数据更快
# 1. 首先对key做了哈希处理(能对所有数据类型都可以哈希处理)：梅森旋转算法（生成伪随机数）--> 通过哈希处理对于每个key他都可以生成一个序列（永不重复，相同的东西进入哈希处理，结果相同）
import hashlib
m = hashlib.md5()
# m.update(b'a') # 0cc175b9c0f1b6a831c399e269772661
# m.update(b'b') # 92eb5ffee6ae2fec3ad71c777531578f
# m.update(b'c') # 4a8a08f09d37b73795649038408b5f33
# m.update(b'd') # 8277e0910d750195b448797616e091ad
m.update(b'a') # 0cc175b9c0f1b6a831c399e269772661
print(m.hexdigest())
# 2. 使用哈希函数对刚刚生成的序列（纯数字）,对纯数字除9取余（0，1，2，3，4，5，6，7，8）
'''
key 哈希处理 纯数字序列 哈希函数 哈希值
'a' --》 12 --》 3
'b' --》 14 --》 5
'c' --》 24 --》 6
'd' --》 21 --》 3
'''
# 1. 为什么key是不可变数据类型
dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
# dic['a']
# 2. 为什么key不能重名
dic = {'a':1, 'a':2} # key不能重名
print(dic['a'])
# 3. 字典为什么是乱序的
# 4. 散列表（哈希表）解决了什么问题
4.集合
交集/并集/补集/差集
∩ ∪
1.作用
1。进行上述运算 2. 去重 3.乱序 ---》基于散列表实现的
2.定义方法
{}内以逗号隔开多个元素（不能可为变数据类型）
# s = {} # 空字典
print(type(s))
# s = set() # 空集合 # 上面定义了一个相同的变量但是从未使用，你又定义了这个变量
print(type(s))
# inp = input('enter')
# s = {}
# if inp > '11': # 字符串比较，先比较第一位数字，然后再比较第二位数字
# s +=1
# else:
# print(s)
s = {'a', 'a', 'a', 'a', 1, 'v', 2, 2, 'c', 3, 3, 4, 5, 6} # 对于数字而言，不会乱序；但是对于其他，就乱序
print(s)
3.使用方法
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
# 并集
print(pythoners | linuxers)
# 交集
print(pythoners & linuxers)
# 差集
print(pythoners - linuxers)
# 补集
print(pythoners ^ linuxers)
# add（*******）
pythoners.add('oscar')
print(pythoners)
#
# pythoners.remove('oscar1') # 没有报错
# print(pythoners)
# pythoners.discard('oscar1') # 没有不报错
# print(pythoners)
pythoners.pop() # 随机删除一个
print(pythoners)
4. 有序or无序
无序
5. 可变or不可变
可变
set = {1, 2, 3}
print(id(set))
set.add(4)
print(id(set))
5.数据类型总结
存值个数
# 存一个值：整型/浮点型/字符串
# 存多个值：列表/元组/字典/集合
有序和无序
# 有序：字符串/列表/元组（序列类型）
# 无序：字典/集合
可变or不可变
# 可变：列表/字典/集合
# 不可变：整型/浮点型/字符串/元组
6.深浅拷贝
# 主要内容
# 当lt2为lt1的拷贝对象，lt1内部的不可变数据变化，lt2变；lt1内部的可变数据变化，lt2变(*****)
# 当lt2为lt1的浅拷贝对象时，lt1内部的不可变元素变化，lt2不变；lt1内部的可变元素变化，lt2变(******)
# 当lt2是lt1的深拷贝对象时，lt1内部的不可变类型变化，lt2不变；lt1内部的可变类型变化，lt2不变(*****)
# 拷贝/浅拷贝/深拷贝 --> 只针对可变数据类型
s1 = 'nick'
s2 = copy.copy(s1) # 无论s2是指向s1指向的值nick，还是自己新开辟内存空间
# 内置方法中的copy方法都是浅拷贝的copy，也就是说如果你的列表里面有可变数据类型，那就不要使用.copy方法
lt = [1,2,3,[1,]]
lt2 = copy.deepcopy(lt)
