目录
1. 元组(tuple)
-
元组和列表用法相同,只是元组只可取,不可修改,元组一创建就被写死
-
元组相对于列表的优点在于:占用内存小。不用判断是否增加元组的内存分配,少了这个判断增加内存。
1. 作用
存储多个元素
2. 定义方式
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. 字典(基于散列表(哈希)实现存储)
字典的key不能用可变的数据类型
1. 作用
存储多个数据,对每个数据都具有描述意义
可变==不可哈希,不可变==可哈希
2. 定义方式
dic = {'name': 1}
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)
# 需要掌握
# 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)
4. 有序or无序
无序
5. 可变or不可变
可变
3. 散列表(哈希表)
散列表/哈希表存储数据 --》 相比较列表,插入/删除数据更快
'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. 集合(基于散列表(哈希)实现存储)
1. 作用
- 进行交集、并集、补集、差集运算
- 去重
- 乱序
2. 定义方式 (set)
{}内以逗号隔开多个元素(不能可为变数据类型)
# s = {} # 空字典
# print(type(s))
# s = set() # 空集合
# print(type(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 = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
pythoners.remove('oscar1') # 没有要删除的这个元素就报错
# print(pythoners)
# pythoners.discard('oscar1') # 没有要删除的这个元素,但不报错,会返回None
# print(pythoners)
pythoners.pop() # 随机删除一个
print(pythoners)
4. 有序or无序
无序
5. 可变or不可变
可变
5. Pycharm中代码变黄的原因
- 上面定义了一个相同的变量但是从未使用,你又定义了一次这个变量
6.数据类型总结
# 存值个数
# 存一个值:整型/浮点型/字符串
# 存多个值:列表/元组/字典/集合
# 有序or无序 (数字类型没有可变不可变一说)
# 有序:字符串/列表/元组(序列类型)
# 无序:字典/集合
# 可变or不可变 (元组没有可变不可变一说)
# 可变:列表/字典/集合
# 不可变:整型/浮点型/字符串。
7. 深浅拷贝
-
使用深浅拷贝时要导入copy库
-
深浅拷贝(只针对可变数据类型) --. 用一定用不到,面试很大概率会问,这不是python独有的,而是一种语言独有的
-
内置方法中的copy方法都是浅拷贝的copy,也就是说如果你的列表里面有可变数据类型,那就不要使用.copy方法
(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变(*****)
(2)浅拷贝
import copy
lt1 = [1, 2, 3]
lt2 = copy.copy(lt1) # lt2叫做lt1的浅拷贝对象
当lt2为lt1的浅拷贝对象时,lt1内部的不可变元素变化,lt2不变;lt1内部的可变元素变化,lt2变(******)
(3)深拷贝
import copy
lt1 = [1, 2, 3, [4, 5, 6]]
lt2 = copy.deepcopy(lt1)
当lt2是lt1的深拷贝对象时,lt1内部的不可变类型变化,lt2不变;lt1内部的可变类型变化,lt2不变(*****)