元组、字典、散列表、集合、深浅拷贝

目录

• 1. 元组（tuple）
  • 1. 作用
  • 2. 定义方式
  • 3. 使用方法
  • 4. 有序or无序
  • 5. 可变or不可变
• 2. 字典（基于散列表（哈希）实现存储）
  • 1. 作用
  • 2. 定义方式
  • 3. 使用方法
  • 4. 有序or无序
  • 5. 可变or不可变
• 3. 散列表（哈希表）
• 4. 集合（基于散列表（哈希）实现存储）
  • 1. 作用
  • 2. 定义方式 （set）
  • 3. 使用方法
  • 4. 有序or无序
  • 5. 可变or不可变
• 5. Pycharm中代码变黄的原因
• 6.数据类型总结
• 7. 深浅拷贝
  • （1） 拷贝
  • （2）浅拷贝
  • （3）深拷贝

1|01. 元组（tuple）

• 元组和列表用法相同，只是元组只可取，不可修改，元组一创建就被写死

• 元组相对于列表的优点在于：占用内存小。不用判断是否增加元组的内存分配，少了这个判断增加内存。

1|11. 作用

存储多个元素

1|22. 定义方式

tup = tuple((1, 2, 3))
print(tup, type(tup))
# 如果元组只有一个元素，必须得加逗号，否则括号只是被当做一个运算符的优先级的作用
tup1 = (1,)
print(tup1, type(tup1))

1|33. 使用方法

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

1|44. 有序or无序

有序

1|55. 可变or不可变

没有这一说

2|02. 字典（基于散列表（哈希）实现存储）

字典的key不能用可变的数据类型

2|11. 作用

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

可变==不可哈希，不可变==可哈希

2|22. 定义方式

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

2|33. 使用方法

# 优先掌握
# 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)

    
# 需要掌握

# pop(k):抽取，作用和删除类似，只不过pop有个返回值，是key对应的值。pop括号内必须有参数，且key必须是存在的key值。若key值不存在，则必须给其指定一个默认值，这样返回的就是指定的默认值，不指定默认值则会报错。

dic.pop(键名1)  # 抽出key为键名1的键值对中的值

# popitem() 抽取字典中的最后一个键值对，并以元组形式返回这个键值对。popitem括号内没有参数

例子：
dict1 = {1: "a", 2: [1, 2],3:'df',4:'uoi'}

print(dict1.popitem())  # (4, 'uoi')
print(dict1)  # {1: 'a', 2: [1, 2], 3: 'df'}
print(dict1.pop(3,'jdgfjadsgf'))  # df
print(dic1)  # {1: 'a', 2: [1, 2]}
print(dict1.pop(4,'jhjk'))  # jhjk

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

2|44. 有序or无序

在3.7版本之前是无序的，但是在之后的版本都是有序的，即按照插入顺序排列键值对

2|55. 可变or不可变

可变

3|03. 散列表（哈希表）

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

'a':1
'b':2
'c':3   #散列表
'd':4

# 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   （除9取余）        --》     3
'b' --》     14                    --》     5
'c' --》     24                    --》     6
'd' --》     21                    --》     3
然后根据哈希值存储键值对
对于哈希值相同的键值对，对后面的键值对有两种处理方法：
1. 存储到哈希值的下面，即存储到'a':1 的下面  
2. 往该哈希值左右分别寻找最近的空的位置，然后存储下去
'''

# 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. 字典为什么是乱序的
因为字典是基于哈希存储的，字典存储时，索引是对key做哈希处理，生成的哈希值作为索引（这样的索引没有规律）来存储键值对。

4|04. 集合（基于散列表（哈希）实现存储）

4|11. 作用

1. 进行交集、并集、补集、差集运算
2. 去重
3. 乱序

4|22. 定义方式 （set）

{}内以逗号隔开多个元素（不能可为变数据类型）
# s = {}  # 空字典
# print(type(s))
# s = set()  # 空集合  
# print(type(s))

4|33. 使用方法

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 = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

pythoners.remove('oscar1')  # 没有要删除的这个元素就报错
# print(pythoners)
# pythoners.discard('oscar1')  # 没有要删除的这个元素，但不报错，会返回None
# print(pythoners)

pythoners.pop()  # 随机删除一个
print(pythoners)

4|44. 有序or无序

无序

4|55. 可变or不可变

可变

5|05. Pycharm中代码变黄的原因

• 上面定义了一个相同的变量但是从未使用，你又定义了一次这个变量

6|06.数据类型总结

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


# 有序or无序   （数字类型没有可变不可变一说）
# 有序：字符串/列表/元组（序列类型）
# 无序：字典/集合


# 可变or不可变   （元组没有可变不可变一说）
# 可变：列表/字典/集合
# 不可变：整型/浮点型/字符串。  

7|07. 深浅拷贝

• 使用深浅拷贝时要导入copy库

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

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

7|1（1） 拷贝

• 拷贝就是直接赋值

• 当y为x的拷贝对象，如果x为不可变类型，x变化y不变；如果x为可变类型，x变化y也变

x = 10 # 赋值
y = x  # 即是赋值又是拷贝
x += 1
print(y) #打印结果  y=10

• lt1 和 lt2 都为列表
  当lt2为lt1的拷贝对象，lt1内部的不可变数据变化，lt2变；lt1内部的可变数据变化，lt2变(*****)
  

7|2（2）浅拷贝

import copy
lt1 = [1, 2, 3]
lt2 = copy.copy(lt1)  # lt2叫做lt1的浅拷贝对象

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

7|3（3）深拷贝

import copy
lt1 = [1, 2, 3, [4, 5, 6]]
lt2 = copy.deepcopy(lt1)

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

__EOF__

本文作者：BigSun丶
本文链接：https://www.cnblogs.com/Mcoming/p/11528394.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！