用python怎么拷贝元组_元组、字典、集合内置方法， 深浅拷贝

这里将告诉您元组、字典、集合内置方法， 深浅拷贝,具体实现方法:

目录

元组内置方法

作用

定义方式

使用方法

有序or无序

可变or不可变

字典内置方法

作用

定义方式

使用方法

有序or无序

可变or不可变

集合内置方法

作用

定义方式

使用方法

有序or无序

可变or不可变

数据类型总结

存值个数

有序or无序

可变or不可变

深浅拷贝

可变or不可变

拷贝

浅拷贝

深拷贝对象

元组内置方法

作用

元组可以看成只可取不可修改的列表，元组一创建就被写死了

定义方式

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

tup = tuple((1, 2, 3))

print(tup, type(tup))

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

tup1 = (1,)

print(tup1, type(tup1))

使用方法

tup = (1,2,3,4,5,)

# 1.索引取值

print(tup[1]) # 2

# 2.切片

print(tup[1:4]) # (2, 3, 4)

# 3.for循环

for i in tup:

print(tup)

# 4.len长度

print(len(tup)) # 5

# 5.in / not in

print(0 in tup) # False

# 6.index获取索引

print(tup.index(1)) # 0

# 7.count计数

print(tup.count(1)) # 1

有序or无序

元组能索引取值，是有序的

可变or不可变

算是不可变吧

字典内置方法

作用

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

定义方式

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

使用方法

dic = {'a':1, 'b':2}

# 1.按key取值

print(dic['a']) # 1

# 2.按key修改值

dic['a'] = 666

print(dic) # {'a': 666, 'b': 2}

dic['c'] = 3 # 没有就加值

print(dic) # {'a': 666, 'b': 2, 'c': 3}

# 3.for循环

for i in dic:

print(i) # 只能取到key值

# 4.in / not in

print('a' in dic) # True

# 5.len

print(len(dic)) # 3

# 6.keys/values/items

print(dic.keys()) # dict_keys(['a', 'b', 'c'])

print(dic.values()) # dict_values([666, 2, 3])

print(dic.items()) # dict_items([('a', 666), ('b', 2), ('c', 3)])

# 7.get

print(dic.get('a')) # get取值，如果没有返回None

# 8.update

dic1 = {'a': 1, 'c': 2}

dic2 = {'b': 1, 'd': 2}

dic1.update(dic2)

print(dic1) # {'a': 1, 'c': 2, 'b': 1, 'd': 2}

# 9.fromkeys 创建一个新字典，如没有value值，默认None

print(dic.fromkeys(['a','b','c'], 1)) # {'a': 1, 'b': 1, 'c': 1}

# 10.# setdefault # 字典有这个key，就不修改，没有则增加

dic.setdefault('j', 2)

dic.setdefault('a', 2)

print(dic)

有序or无序

字典无序

可变or不可变

字典可变

集合内置方法

作用

进行 交集 / 并集 / 补集等运算，可以去重，但是集合内元素是乱序的

定义方式

{}内以逗号隔开多个元素(不能可为变数据类型)

s = {'a', 'a', 'a', 'a', 1, 'v', 2, 2, 'c', 3, 3, 4, 5, 6} # 对于数字而言，不会乱序；但是对于其他，就乱序

print(s)

# {1, 2, 'a', 3, 4, 5, 6, 'v', 'c'}

使用方法

se1 = {'cwz', 'neo', 'woods'}

se2 = {'reese', 'chars', 'cwz'}

# 1.并集

print(se1 | se2) # {'neo', 'reese', 'cwz', 'woods', 'chars'}

# 2.交集

print(se1 & se2) # {'cwz'}

# 3. 差集

print(se1 - se2) # {'neo', 'woods'}

# 4.补集

print(se1 ^ se2) # {'reese', 'chars', 'neo', 'woods'}

# 5.add

se1.add('sad')

print(se1) # {'neo', 'sad', 'woods', 'cwz'}

# 6.remove / discard

se1.remove('neo') # 没有的，删除用remove会报错

print(se1) # {'sad', 'woods', 'cwz'}

se2.discard('chars') # 没有的，删除用discard不会报错

print(se2) # {'cwz', 'reese'}

# 7.pop

se1.pop() # 随机删除值

print(se1) # {'woods', 'cwz'}

有序or无序

无序

可变or不可变

可变

数据类型总结

存值个数

存一个值：整型 / 浮点型 / 字符串

存多个值：列表 / 元组 / 字典 / 集合

有序or无序

有序：字符串 / 列表 / 元组

无序：字典 / 集合

可变or不可变

可变：列表 / 字典 / 集合

不可变：整型 / 浮点型 / 字符串 / 元组

深浅拷贝

可变or不可变

id值不可变，就是在原值基础上修改，为可变数据类型；

id值变化，就是重新申请一块内存空间放入新值，为不可变数据类型。

拷贝

如果lt2是lt1的拷贝对象，则lt1内任何数据类型的元素变化，lt2也跟着变化。

lt1 = [1,2,3,4,'a',[1,23,5]]

lt2 = lt1

print(lt1)

print('lt1_id: ', id(lt1))

lt1.append('b')

print('*'*50)

print(lt1)

print('lt1_id: ', id(lt1))

print(lt2)

print('lt2_id: ', id(lt2))

# 打印结果：

[1, 2, 3, 4, 'a', [1, 23, 5]]

lt1_id: 1990616507080

**************************************************

[1, 2, 3, 4, 'a', [1, 23, 5], 'b']

lt1_id: 1990616507080

[1, 2, 3, 4, 'a', [1, 23, 5], 'b']

lt2_id: 1990616507080

浅拷贝

如果lt2是lt1的浅拷贝对象，则lt1内的不可变元素发生了变化，lt2不变；

如果lt1内的可变元素发生了改变，则lt2跟着改变

import copy

lt1 = [1, 2, 3, 4, 'a', [1, 23, 5]]

lt2 = copy.copy(lt1)

lt1.append(99)

print('lt1: ', lt1)

print('lt1_id: ', id(lt1))

print('lt2: ', lt2)

print('lt2_id: ', id(lt2))

print('*'*50)

lt1[5].append('qq')

print('lt1[5]: ', lt1)

print('lt1[5]_id: ', id(lt1))

print('lt2: ', lt2)

print('lt2_id: ', id(lt2))

# 打印结果：

lt1: [1, 2, 3, 4, 'a', [1, 23, 5], 99]

lt1_id: 2049177903816

lt2: [1, 2, 3, 4, 'a', [1, 23, 5]]

lt2_id: 2049299510728

**************************************************

lt1[5]: [1, 2, 3, 4, 'a', [1, 23, 5, 'qq'], 99]

lt1[5]_id: 2049177903816

lt2: [1, 2, 3, 4, 'a', [1, 23, 5, 'qq']]

lt2_id: 2049299510728

深拷贝对象

如果lt2是lt1的深拷贝对象，则lt1内的不可变数据类型元素改变，lt2不变；

如果lt1内的可变数据类型元素改变，lt2不变

import copy

lt1 = [1, 2, 3, [4, 5, 6]]

lt2 = copy.deepcopy(lt1)

print('id(lt1)', id(lt1))

print(id(lt1[0]))

print(id(lt1[1]))

print(id(lt1[2]))

print(id(lt1[3]))

print(id(lt1[3][0]))

print(id(lt1[3][1]))

print(id(lt1[3][2]))

print('*' * 50)

print('id(lt2)', id(lt2))

print(id(lt2[0]))

print(id(lt2[1]))

print(id(lt2[2]))

print(id(lt2[3]))

print(id(lt2[3][0]))

print(id(lt2[3][1]))

print(id(lt2[3][2]))

# 打印结果：

id(lt1) 2156612313800

140728121221968

140728121222000

140728121222032

2156612313736

140728121222064

140728121222096

140728121222128

**************************************************

id(lt2) 2156760304520

140728121221968

140728121222000

140728121222032

2156642018504

140728121222064

140728121222096

140728121222128元组、字典、集合内置方法， 深浅拷贝就为您介绍到这里，感谢您关注懒咪学编程c.lanmit.com.

本文地址：https://c.lanmit.com/bianchengkaifa/Python/15424.html