day 07小结

1.元组类型内置方法（tuple）

什么是元组：只可取不可更改的列表

1.1 作用

元组一创建就被写死了

1.2 定义方式：

（）内用逗号隔开多个元素（可以为任意数据类型）

tup = tuple((1,2,3))
print(tup,type(tup))

# 如果元组只有一个元素，必须加逗号
tupe1 = (1,)
print(tupe1,type(tup1))

1.3 使用方法

1.3.1 索引取值

print(tup[0])

1.3.2 索引切片

print(tup[0:3])

1.3.3 for循环

for i in tup:
    print(i)

1.3.4 成员运算

print(0 in tup)

1.3.5 len长度

print(len(tup))

1.3.6 index获取元素索引

print(tup.index(1))

1.3.7 count计数

print(tup.count(2))

1.4 有序or无序

有序

1.5 可变or不可变

不存在这种说法

定义元组--》 元组占用内存小--》 写死了

2.字典数据类型内置方法

2.1 作用

储存多个数据，对每个数据具有描述

2.2 定义方式

{}内用逗号隔开多个键key（具有描述意义，不能为可变数据类型）：值value（任意数据类型

dic = {'name': 1}
print(dic)

dic = {0:'功能1'，1:'功能2'}
print(dic)

dic = {[1,2]: 'a'}  # 可变==不可哈希，不可变==可哈希
print(dic)

2.3 使用方法

优先掌握

2.3.1 按key取值/按key修改值

dic = {'a':1, 'b':2, 'c': 3}
print(dic['a'])

dic['b'] = 4
print(dic)

dic['d'] = 4
print(dic)

2.3.2 添加值，没有就添加，有就修改

dic['d'] = 4
print(dic)

2.3.3 for循环

for i in dic:
    print(i)

2.3.4 成员运算

print('a' in dic)

2.3.5 len长度

print(len(dic))

2.3.6 keys/values/items

print(dic.keys())  # 看成列表
print(dic.values())  # 获取所有值

print(dic.items())
for i in dic.items()
    print(i)
for key, values in dic.items()  # 解压缩
    print(key, values)

需要掌握

# 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)

# 有序or无序：无序

# 可变or不可变：可变
dic = {'a': 1}
print(id(dic))
dic['b'] = 2
print(id(dic))

3.散列表

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

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

为什么key是不可变数据类型

dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
# dic['a']

为什么key不能重名

dic = {'a': 1, 'a': 2}  # key不能重名
print(dic['a'])

3.字典为什么是乱序的

散列表（哈希表）解决了什么问题

4.集合内置方法

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

4.1 作用

​ 进行上述运算

​ 去重

​ 乱序 ---》基于列表实现的

4.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)

4.3 使用方法

pythoners = {'jason', 'nick', 'tank', 'seam'}
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.4 有序or无序：无序

4.5 可变or不可变：可变

set = {1,2,3}
print(id(set))
set.add(4)
print(id(set))

补充（了解）

lt = (1,2,3)  # --> 2
# lt - [1,2,3]  # --> 2
s = {lt,2,3,4}
# lt[0] = 2 # --> 3

5.数据类型总结

存值个数

存一个值：整型/浮点型/字符串

村多个值：列表/元组/字典/集合

有序or无序

有序：字符串/列表/元组（序列类型）

无序：字典/集合

可变or不可变

可变：列表/字典/集合

不可变：整型/浮点型/字符串/元组

6.深浅拷贝

6.1 可变or不可变

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

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

6.2 拷贝

# 当lt2为lt1的拷贝对象，lt1内部的不可变数据变化，lt2变；lt1内部的可变数据变化，lt2变
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']

6.3 浅拷贝

# 当lt2为lt1的浅拷贝对象时，lt1内部的不可变元素变化，lt2不变；lt1内部的可变元素变化，lt2变
import copy
l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
l2 = copy.copy(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']]

6.4 深拷贝

# 当lt2是lt1的深拷贝对象时，lt1内部的不可变类型变化，lt2不变；lt1内部的可变类型变化，lt2不变
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']]

主要内容

当lt2为lt1的拷贝对象，lt1内部的不可变数据变化，lt2变；lt1内部的可变数据变化，lt2变

当lt2为lt1的浅拷贝对象时，lt1内部的不可变元素变化，lt2不变；lt1内部的可变元素变化，lt2变

当lt2是lt1的深拷贝对象时，lt1内部的不可变类型变化，lt2不变；lt1内部的可变类型变化，lt2不变