元组、字典、集合的内置方法，散列表、深浅拷贝学习笔记

目录

• 元组内置方法（了解）
  • 元祖的方法
  • 有序or无序
  • 可变or不可变
    • 使用元组的目的
• 字典内置方法（*****）
  • 使用方法
  • 需要掌握（****）
    • 无序、不可变
• 散列表
• 集合的内置方法
  • 常用操作+内置方法
    • 优先掌握（*****）
    • 需要掌握
• 深浅拷贝
  • Python 直接赋值、浅拷贝和深度拷贝解析
    • 字典浅拷贝实例
  • 实例
  • 实例
    • 解析
    • 更多实例

元组内置方法（了解）

元组：只可取，不可更改的列表，元组一经创建就写死了

定义方式：（）内用逗号隔开多个元素，元素可以为任意数字类型

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

需要掌握（****）

1. get()

   dic = {'a':1,'b':'2'}
   print(f"dic.get('a'):{dic.get('a')}")
   print(f"dic.get('c'):{dic.get('c')}")
   

2. update()
   Python 字典(Dictionary) update() 函数把字典dict2的键/值对更新到dict里

   dic1 = {'a':1,'b':'2'}
   dic2 = {'c': 3}
   dic1.update(dic2)
   print(f"dic1: {dic1}")
   

3. fromkeys()

   Python 字典 fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。

   语法

   fromkeys()方法语法：

   dict.fromkeys(seq[, value])
   #seq -- 字典键值列表。
   #value -- 可选参数, 设置键序列（seq）的值。
   

4. setdefault()

   Python 字典 setdefault() 函数和 get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。

   语法

   setdefault() 方法语法：

   dict.setdefault(key, default=None)
   

   参数

   • key -- 查找的键值。

   • default -- 键不存在时，设置的默认键值。

     返回值

     如果字典中包含有给定键，则返回该键对应的值，否则返回为该键设置的值。

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

常用操作+内置方法

优先掌握（*****）

1. 长度len

2. 成员运算in和not in

3. |并集、union

4. &交集、intersection

5. -差集、difference

6. ^对称差集、symmetric_difference

7. ==

8. 父集：>、>= 、issuperset

9. 子集：<、<= 、issubset

   

需要掌握

1. add
2. remove
3. difference_update
4. discard
5. 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不变。