day 07

目录

• 元组内置方法
  • 作用
  • 定义方式
  • 使用方法
    • 索引取值
    • 索引切片
    • for循环
    • 成员运算
    • len长度
    • index获取元素索引
    • count 计数
  • 有序or无序
  • 可变or不可变
• 字典数据类型
  • 作用
  • 定义方式
  • 使用方法
• 散列表(哈希表)
• 集合类型内置方法(set)
  • 作用
  • 定义方式
  • 使用方法
    • 优先掌握
      • 长度len
      • 成员运算in和not in
      • |并集、union
      • &交集、intersection
      • -差集、difference
      • ^对称差集、symmetric_difference
      • ==
      • 父集：>、>= 、issuperset
      • 子集：<、<=、issubset
    • 需要掌握
      • add
      • remove
      • difference_update
      • discard
      • isdisjoint
• 数据类型总结
  • 按存值个数区分
  • 按可变不可变区分
  • 有序无序区分
  • 按访问类型区分
• 深浅拷贝
  • 可变or不可变
  • 拷贝(赋值)
  • 浅拷贝
  • 深拷贝

元组内置方法

作用

只可取，不可更改的列表。当创建的时候就被写死了。

定义方式

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

lt = list([1,2,3])
tup = tuple((1,2,3))
print(tup,type(tup))

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

tup1 = (1,)
print(tup1,type(tup1))

使用方法

索引取值

print(tup[0])

索引切片

print(tup[0:3])

for循环

for i in tup:
    print(i)

成员运算

print(0 in tup)

len长度

print(len(tup))

index获取元素索引

print(tup.index(1))

count 计数

print(tup.count(2))

有序or无序

有序

可变or不可变

压根不存在

字典数据类型

作用

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

定义方式

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

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

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

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

dic = {(1,2):'a'}
print(dic)

使用方法

优先掌握

# 1.按key取值/按key修改值
dic = {'a':1,'b':2,'c':3}

print(dic['a'])

# 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.key())  # 看成列表
print(dic.value())  # 获取所有值

print(dic.item())
for i in dic.items():
    print(i)
for sksskkk,asasa in dic.items():  # 解压缩
   print(sksskkk,asasa)

需要掌握

# 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不可变：可变
dic = {'a': 1}
print(id(dic))
dic['b'] = 2
print(id(dic))

散列表(哈希表)

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

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

集合类型内置方法(set)

集合可以理解成一个集合体

作用

用于关系运算的集合体，由于集合内的元素无序且集合元素不可重复，因此集合可以去重，但是去重后的集合回打乱原来元素的顺序。

定义方式

{}内用逗号隔开多个元素，每个元素必须是不可变类型。

s = {1, 2, 1, 'a'}  # s = set({1,2,'a'})
print(f"s: {s}")

s: {1,2,'a'}
    
    
s = {1, 2, 1, 'a', 'c'}
for i in s:
    print(i)   
    
1
2
c
a

s = set('hello')
print(f"s: {s}")

s: {'e','c','h','l'}

使用方法

优先掌握

长度len

s = {1,2,'a'}
print(f'len(s):{len(s)}')

len(s):3

成员运算in和not in

s = {1,2,'a'}
print(f'l in s: {i in s}')

l in s: True

|并集、union

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners|linuxers: {pythoners|linuxers}")
print(f"pythoners.union(linuxers): {pythoners.union(linuxers)}")

pythoners|linuxers: {'egon', 'tank', 'kevin', 'jason', 'nick', 'sean'}
pythoners.union(linuxers): {'egon', 'tank', 'kevin', 'jason', 'nick', 'sean'}

&交集、intersection

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners&linuxers: {pythoners&linuxers}")
print(f"pythoners.intersection(linuxers): {pythoners.intersection(linuxers)}")

pythoners&linuxers: {'nick'}
pythoners.intersection(linuxers): {'nick'}

-差集、difference

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners-linuxers: {pythoners-linuxers}")
print(f"pythoners.difference(linuxers): {pythoners.difference(linuxers)}")

pythoners-linuxers: {'tank', 'jason', 'sean'}
pythoners.difference(linuxers): {'tank', 'jason', 'sean'}

^对称差集、symmetric_difference

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners^linuxers: {pythoners^linuxers}")
print(
    f"pythoners.symmetric_difference(linuxers): {pythoners.symmetric_difference(linuxers)}")

pythoners^linuxers: {'egon', 'tank', 'kevin', 'jason', 'sean'}
pythoners.symmetric_difference(linuxers): {'egon', 'tank', 'kevin', 'jason', 'sean'}

==

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
javers = {'nick', 'egon', 'kevin'}

print(f"pythoners==linuxers: {pythoners==linuxers}")
print(f"javers==linuxers: {javers==linuxers}")

pythoners==linuxers: False
javers==linuxers: True

父集：>、>= 、issuperset

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
javaers = {'jason', 'nick'}

print(f"pythoners>linuxers: {pythoners>linuxers}")
print(f"pythoners>=linuxers: {pythoners>=linuxers}")
print(f"pythoners>=javaers: {pythoners>=javaers}")
print(f"pythoners.issuperset(javaers): {pythoners.issuperset(javaers)}")


pythoners>linuxers: False
pythoners>=linuxers: False
pythoners>=javaers: True
pythoners.issuperset(javaers): True

子集：<、<=、issubset

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
javaers = {'jason', 'nick'}

print(f"pythoners<linuxers: {pythoners<linuxers}")
print(f"pythoners<=linuxers: {pythoners<=linuxers}")
print(f"javaers.issubset(javaers): {javaers.issubset(javaers)}")


pythoners<linuxers: False
pythoners<=linuxers: False
javaers.issubset(javaers): True

需要掌握

add

s = {1,2.,'a'}
s.add(3)

print(s)

{1,2,3,'a'}

remove

s = {1,2,'a'}
s.remove(1)

print(s)

{2,'a'}

difference_update

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
pythoners.difference_update(linuxers)

print(f"pythoners.difference_update(linuxers): {pythoners}")

pythoners.difference_update(linuxers): {'tank', 'jason', 'sean'}

discard

s = {1, 2, 'a'}
# s.remove(3)  # 报错
s.discard(3)

print(s)

{1, 2, 'a'}

isdisjoint

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
pythoners.isdisjoint(linuxers)

print(f"pythoners.isdisjoint(linuxers): {pythoners.isdisjoint(linuxers)}")

pythoners.isdisjoint(linuxers): False

数据类型总结

按存值个数区分

存值个数	数据类型
单个值	数字、字符串
多个值(容器)	列表、元组、字典、集合

按可变不可变区分

可变or不可变	数据类型
可变	列表、字典、集合
不可变	数字、字符串、元组

有序无序区分

有序or无序	数据类型
有序(可按索引取值)	字符串、列表、元组
无序	字典、集合

按访问类型区分

直接访问	数字
顺序访问(序列类型)	字符串、列表、元组
key值访问(映射类型)	字典

深浅拷贝

拷贝/浅拷贝/深拷贝都是针对可变类型数据而言的

可变or不可变

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

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

拷贝(赋值)

如果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']

浅拷贝

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

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']]

深拷贝

如果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']]

内置方法中的copy方法都是浅拷贝的copy，也就是说如果你的列表里面有可变数据类型，那就不要使用.copy方法。