元组tuple，字典的数据类型，散列表(哈希表)，集合内置方法，数字类型总结（有序或无序，可变和不可变类型），浅拷贝-。

什么是元组tuple（了解）

元组;只可取 不可修改的列表，元素已创建就被写死了。

lt = [1,2,3]
lt[0] = 2
print(lt)  #[2, 2, 3]

1.作用：元素一创建就被写死了

2.定义方式：()内用逗号隔开多个元素。（可以为任意数据类型）

tup = tuple((1, 2, 3))
print(tup, type(tup))
#(1, 2, 3) <class 'tuple'>

如果元组只有一个元素，必须得加逗号.

count = (1,)
print(count.tepe(tup1))  #(1,) <class 'tuple'>

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 不可用：元组压根没这一说。

字典的数据类型

字符串/列表/字典 --》： 常用，他们三个就足够描述时间万物了# 其他的数据类型可以被替代 --》： 列表替代元组，redis数据库替代集合。

1.作用：储存多个元素，对每个数据具有描述。

2.2. 定义方式：{}内用逗号隔开多个键key(具有描述意义，不能为可变数据类型):值value（任意数据类型）对 #散列表（哈希表）

dic = {'name': 1}
print(dic)  #{'name': 1}
dic = {0: '功能1', 1: '功能2'}
print(dic)
#{0: '功能1', 1: '功能2'}

字典中：可变 ==不可哈希值，不可变 == 可哈希值。

**散列表(哈希表) **

散列表/哈希表存储数据 --》 相比较列表，插入/删除数据更快

1.首先对key做了哈希处理(能对所有数据类型都可以哈希处理)：梅森旋转算法（生成伪随机数）--> 通过哈希处理对于每个key他都可以生成一个序列（永不重复，相同的东西进入哈希处理，结果相同）

2.使用哈希函数对刚刚生成的序列（纯数字）,对纯数字除9取余（0，1，2，3，4，5，6，7，8）

假设：

''' 
key 哈希处理 纯数字序列 哈希函数  哈希值
'a' --》     12          --》     3
'b' --》     14          --》     5
'c' --》     24          --》     6
'd' --》     21          --》     3
'''

4.集合内置方法：

什么是集合：交集/差集/补集/并集

1.作用：1进行交叉并补运算。2.去重 3.乱序--》基于散列表实现的

2.定义方式：{}内以逗号隔开多个元素（不能可为变数据类型）

# s = {}  # 空字典
# print(type(s))  #<class 'dict'>
# s = set()  # 空集合  # 上面定义了一个相同的变量但是从未使用，你又定义了这个变量
# print(type(s))  #<class 'set'>

字符串比较，先比较第一位数字，然后再比较第二位数字

对于数字而言，不会乱序；但是对于其他，就乱序print(s):

count = {'a', 'a', 'a', 'a', 1, 'v', 2, 2, 'c', 3, 3, 4, 5, 6}  # 对于数字而言，不会乱序；但是对于其他，就乱序
print(count)#{1, 2, 3, 4, 5, 6, 'v', 'c', 'a'}

3.使用方法：

并集：

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
print(pythoners | linuxers) #{'kevin', 'jason', 'tank', 'egon', 'nick', 'sean'}   去掉重复的值。 符号：|

交集：

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'
print(pythoners & linuxers)  #{'nick'}  取相同的值 符号：&

差集：

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
print(pythoners - linuxers)  #{'jason', 'tank', 'sean'}
  # 两个值相减（取减数值，在被减数中没有出现的所有值）符号：-

补集：

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
print(pythoners ^ linuxers)  #{'jason', 'kevin', 'egon', 'tank', 'sean'} 符号：^ 除去交集的值 都取

add（任意在集合中找一个数更改值）

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
pythoners.add('oscar')
print(pythoners)  #{'jason', 'nick', 'oscar', 'tank', 'sean'}

remove和discard

pythoners.remove('oscar1')  # 没有报错
# print(pythoners)
# pythoners.discard('oscar1')  # 没有不报错
# print(pythoners)

pop(随机删除一个)

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
pythoners.pop()  # 随机删除一个
print(pythoners)
#{'jason', 'tank', 'nick'}

5.数字类型总结

# 存值个数

# 存一个值：整型/浮点型/字符串
# 存多个值：列表/元组/字典/集合


# 有序or无序
# 有序：字符串/列表/元组（序列类型）
# 无序：字典/集合


# 可变or不可变
# 可变：列表/字典/集合
# 不可变：整型/浮点型/字符串/元组


# 深浅拷贝（只针对可变数据类型） --. 用一定用不到，面试很大概率会问，这不是python独有的，而是一种语言独有的

6.深浅拷贝

1.可变 or 不可变

可变：值变id不变

不可变：值变id变化

id不变值可变，即在原值的基础上修改，则为可变数据类型；值变id也变，即重新申请一个空间放入新值，则为不可变数据类型。

age = 20
print(f'first:{id(age)}')
age = 23
print(f'second:{id(age)}')

# first:140725813474144
# second:140725813474240

2.拷贝(赋值)

如果l2是l1的拷贝对象，则l1内部的任何数据类型的元素变化，则l2内部的元素也会跟着改变，因为可变类型值变id不变。

l1 = ['a', 'b', 'c', ['d', 'e', 'f']]  #赋值
l2 = l1    #即是赋值又是拷贝
l1.append('g')
print(l1)
 #  ['a', 'b', 'c', ['d', 'e', 'f'], 'g']

print(l2)
  #  ['a', 'b', 'c', ['d', 'e', 'f'], 'g']

3.浅拷贝--> 表示的一种现象

如果l2是l1的浅拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，则l2会跟着改变。

import copy

l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
l2 = copy.copy(l1) #l2叫做l1的浅拷贝对象
l1.append('g')
print(l1)
  #  ['a', 'b', 'c', ['d', 'e', 'f'], 'g']
print(l2)
  #  ['a', 'b', 'c', ['d', 'e', 'f']]
l1[3].append('g')
print(l1)
##  ['a', 'b', 'c', ['d', 'e', 'f', 'g'], 'g']
print(l2)
  #  ['a', 'b', 'c', ['d', 'e', 'f', 'g']]

4.深拷贝

如果l2是l1的深拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，l2也不会变，即l2永远不会因为l1的变化而变化。

import copy
l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
l2 = copy.deepcopy(l1)
l1.append('g')
print(l1)
### ['a', 'b', 'c', ['d', 'e', 'f'], 'g']

print(l2)
### ['a', 'b', 'c', ['d', 'e', 'f']]

l1[3].append('g')
print(l1)
### ['a', 'b', 'c', ['d', 'e', 'f', 'g'], 'g']

print(l2)
### ['a', 'b', 'c', ['d', 'e', 'f']]

深浅拷贝的主要内容

# 主要内容

# 当l2为l1的拷贝对象，l1内部的不可变数据变化，l2变；l1内部的可变数据变化，l2变(*****)

# 当l2为l1的浅拷贝对象时，l1内部的不可变元素变化，l2不变；l1内部的可变元素变化，l2变(******)

# 当l2是l1的深拷贝对象时，l1内部的不可变类型变化，l2不变；l1内部的可变类型变化，l2不变(*****)



# 拷贝/浅拷贝/深拷贝 --> 只针对可变数据类型


s1 = 'Owen'
s2 = copy.copy(s1)  # 无论s2是指向s1指向的值Owen，还是自己新开辟内存空间


# 内置方法中的copy方法都是浅拷贝的copy，也就是说如果你的列表里面有可变数据类型，那就不要使用.copy方法
lt = [1,2,3,[1,]]
lt2 = copy.deepcopy(lt)