元组、字典、集合的内置方法，散列表、深浅拷贝学习笔记
元组、字典、集合的内置方法，散列表、深浅拷贝学习笔记
目录
元组内置方法（了解）
元组：只可取，不可更改的列表，元组一经创建就写死了
定义方式：（）内用逗号隔开多个元素，元素可以为任意数字类型
tup1 = (1,2,3,4)
tup2 = (1,)#如果元组只有一个元素，必须加逗号隔开
lt = list((1,2,3))#将元组转化为列表
tup = tuple([1,2,3])#将列表转化为元组元祖的方法
元组的使用方法（与列表类似）：索引取值、索引切片、for循环、成员运算、index获取元素索引、count计数
有序or无序
有序
可变or不可变
不存在可变与不可变
使用元组的目的
元组已经写死，运行时占用内存小
字典内置方法（*****）
作用：存储多个数据，对每个数据进行描述
定义方式：{}内用逗号隔开多个键值对，key不能为可变数据类型，值可以为任意数据类型
使用方法
（优先掌握）1.按key取值、按key修改值
dic = {'a':1,'b':2,'c':3}
print(dic['a'])
dic = ['b'] = 4
print(dic)2.添加值，没有就添加，有就修改
dic = ['d']
print(dic)3.for循环
for i in dic:
print(i)#打印出所有的key
for k,v in dic.items():#items()可以换成keys()和values()
print(k,v)#打印出key和value(解压缩)4.成员运算、len长度
print('a' in dic)
print(let(dic))5.keys/values/items
print(dic.keys()) # 看成列表
print(dic.values()) # 获取所有值
print(type(dic.items()))
print(dic.items())
print(type(dic.keys()))
print(type(dic.values()))dict_keys(['a', 'b', 'c', 'd']) dict_values([1, 4, 3, 4]) <class 'dict_items'> dict_items([('a', 1), ('b', 4), ('c', 3), ('d', 4)]) <class 'dict_keys'> <class 'dict_values'>
需要掌握（****）
dict = {'runoob': '菜鸟教程', 'google': 'Google 搜索'} print "Value : %s" % dict.setdefault('runoob',None) print "Value : %s" % dict.setdefault('Taobao', '淘宝')Value : 菜鸟教程 Value : 淘宝
无序、不可变
散列表
散列表/哈希表存储数据 --》 相比较列表，插入/删除数据更快# 1. 首先对key做了哈希处理(能对所有数据类型都可以哈希处理)：梅森旋转算法（生成伪随机数）--> 通过哈希处理对于每个key他都可以生成一个序列（永不重复，相同的东西进入哈希处理，结果相同）'''import hashlib
2. 使用哈希函数对刚刚生成的序列（纯数字）,对纯数字除9取余（0，1，2，3，4，5，6，7，8）集合的内置方法
用途：集合可以去重，但是去重之后会打乱原来元素的顺序
定义：{}内用逗号隔开多个元素，每个元素必须是不可变数据类型
s = {1,2,1,'a'}
print(f"s:{s}")s: {1, 2, 'a'}
for循环
s = {1,2,1,'a','c'}
for i in s:
print(i)1 2 c a
常用操作+内置方法
优先掌握（*****）
- 长度len
- 成员运算in和not in
- |并集、union
- &交集、intersection
- -差集、difference
- ^对称差集、symmetric_difference
- ==
- 父集：>、>= 、issuperset
- 子集：<、<= 、issubset
需要掌握
- add
- remove
- difference_update
- discard
- isdisjoint
深浅拷贝
Python 直接赋值、浅拷贝和深度拷贝解析
- 直接赋值：其实就是对象的引用（别名）。
- 浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。
- 深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。
字典浅拷贝实例
实例
a = {1: [1,2,3]} b = a.copy() a, b ({1: [1, 2, 3]}, {1: [1, 2, 3]}) a[1].append(4) a, b ({1: [1, 2, 3, 4]}, {1: [1, 2, 3, 4]})
深度拷贝需要引入 copy 模块：
实例
import copy c = copy.deepcopy(a) a, c ({1: [1, 2, 3, 4]}, {1: [1, 2, 3, 4]}) a[1].append(5) a, c ({1: [1, 2, 3, 4, 5]}, {1: [1, 2, 3, 4]})
解析
1、b = a: 赋值引用，a 和 b 都指向同一个对象。
2、b = a.copy(): 浅拷贝, a 和 b 是一个独立的对象，但他们的子对象还是指向统一对象（是引用）。
b = copy.deepcopy(a): 深度拷贝, a 和 b 完全拷贝了父对象及其子对象，两者是完全独立的。
更多实例
以下实例是使用 copy 模块的 copy.copy（ 浅拷贝 ）和（copy.deepcopy ）:
#!/usr/bin/python # -*-coding:utf-8 -*-
import copy a = [1, 2, 3, 4, ['a', 'b']] #原始对象
b = a #赋值，传对象的引用
c = copy.copy(a) #对象拷贝，浅拷贝
d = copy.deepcopy(a) #对象拷贝，深拷贝
a.append(5) #修改对象a
a[4].append('c') #修改对象a中的['a', 'b']数组对象
print( 'a = ', a )
print( 'b = ', b )
print( 'c = ', c )
print( 'd = ', d )以上实例执行输出结果为：
('a = ', [1, 2, 3, 4, ['a', 'b', 'c'], 5]) ('b = ', [1, 2, 3, 4, ['a', 'b', 'c'], 5]) ('c = ', [1, 2, 3, 4, ['a', 'b', 'c']]) ('d = ', [1, 2, 3, 4, ['a', 'b']])
总结：当a为b的拷贝对象，a内部的不可变数据变化，b变；a内部的可变数据变化，b变；当b为a的浅拷贝对象时，a内部的不可变元素变化，b不变；a内部的可变元素变化，b变；当b是a的深拷贝对象时，a内部的不可变类型变化，b不变；a内部的可变类型变化，b不变。