python中字典copy_python中字典、元祖、浅拷贝、深拷贝

# -*- coding:utf-8 -*-

#yys

#python 3.7.2

#1. 什么是元祖

# Python的元组与列表类似，不同之处在于元组的元素不能修改。#

# 元组使用小括号，列表使用方括号。#

# 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

# 1> 可以用元祖告诉读代码的人，你不打算改变这个序列的值。

# 2> 因为元祖的不可变性，python可以实现一些优化

importtime

T1=time.time()

fori intuple(range(1000)):

pass

T2=time.time()

print("%.1f"%((T2-T1)*1000),"毫秒") #500.0 毫秒

T3=time.time()

fori inlist(range(1000)):

pass

T4=time.time()

print("%.1f"%((T4-T3)*1000),"毫秒") #500.0 毫秒

# 元祖创建语法

# 元祖名=(元素1,元素2,元素n…….)

tuple0=()

print(tuple0) #('早餐',)

print(type(tuple0)) #

tuple1="早餐",

print(tuple1) #('早餐',)

print(type(tuple1)) #

tuple2=("早餐",)

print(tuple2) #('早餐',)

print(type(tuple2)) #

tuple3="早餐","午餐"

print(tuple3) #('早餐', '午餐')

print(type(tuple3)) #

tuple4=("早餐","午餐")

print(tuple4) #('早餐', '午餐')

print(type(tuple4)) #

# 2.操作元祖

#2.1 要访问元祖中的tom,与访问列表、字符的方法一致

#索引从0开始

tuple5=("耶鲁","楼梯","道路","棕榈树")

print(tuple5[1]) #楼梯

#2.2 删除元祖

# 元祖和列表不一样，元祖中的元素值是不允许被单独修改和删除的，但是我们可以使用del语句来删除整个元祖

#不可删除元祖中单个元素

tuple6=("高楼","楼梯","道路","雕像")

deltuple6

try:

print(tuple6)

exceptException ase:

print(e)

# name 'tuple6' is not defined

# 2.3 元组截取，与字符串/列表表的截取一致

tuple7=("高楼","楼梯","道路","雕像","飞盘","美术馆")

print("截取元素0:3",tuple7[0:3]) #截取元素0:3 ('高楼', '楼梯', '道路')

#2.4 元祖嵌套，与字典，列表一样

tuple8=("高楼",("楼梯","道路","雕像"),("飞盘"),"美术馆")

print(tuple8) #('高楼', ('楼梯', '道路', '雕像'), '飞盘', '美术馆')

print(type(tuple8)) #

tuple9=("高楼",("楼梯","道路","雕像"),("飞盘",),"美术馆")

print(tuple9) #('高楼', ('楼梯', '道路', '雕像'), ('飞盘',), '美术馆')

print(tuple9[1][2]) #雕像

print(type(tuple9)) #

#3 元祖函数

# len(tuple) 计算元祖中元素的个数

tuple10=(1,2,3,4,"早上",("早餐","午餐"))

print(len(tuple10)) #6

# max(tuple) 返回列表元素中的最大值。

tuple10=(1,-2,3,40)

print(max(tuple10)) #40

# min(tuple) 返回列表元素中的最小值。

print(min(tuple10)) #-2

# 4.tuple(list) 将列表转换为元祖

list1=["雷诺"]

print(tuple(list1)) #('雷诺',)

print(type(tuple(list1))) #

# 5.什么是字典

# 字典是另外一种可变容器类型，且可以存储任意类型对象。

# 列表元素进行修改的话，通过索引进行修改;

# 而字典通过键去修改值。

# 字典创建语法：字典的创建使用{}，每个键值(key=>value)对用冒号(：)分割，每对之间用逗号(,)分割。

# 字典名={key1:value1,key2:value2}

students={'name':'厨房','age':28,'sex':'女',28:19}

print(students) #{'name': '厨房', 'age': 28, 'sex': '女', 28: 19}

print(type(students)) #

#6. 操作字典

#6.1 字典中根据键访问值，放在方括号内的键。

print(students['name']) #厨房

#6.2添加元素 动态的向字典中添加元素的时候，只要添加的键在字典中不存在，就会新增这个元素。

students['美食']="蛋糕"

print(students) #{'name': '厨房', 'age': 28, 'sex': '女', 28: 19, '美食': '蛋糕'}

#6.3 删除字典元素

# 使用del语句删除元素：del既可以删除指定的字典元素(列表也可以指定)，也可以删除整个字典，

# 如果不指定key，代表删除整个字典。语法如下：

# del 字典名[key]

dict1={'name':'厨房','age':28,'sex':'女'}

deldict1['age']

print(dict1) #{'name': '厨房', 'sex': '女'}

deldict1

try:

print(dict1)

exceptException ase:

print(e)

# 'dict1' is not defined

# 使用clear()方法清空整个字典：

# 被清空的字典最后会剩下一个空的字典在，而用del删除的字典在程序当中就不存在了。

dict2={'name':'厨房','age':28,'sex':'女'}

dict2.clear()

print(dict2) #{}

# 按键名删除 字典名.pop(‘键名’)

dict3={'name':'厨房','age':28,'sex':'女','形状':'球',28:19,"美食":"蛋糕"}

dict3.pop('name')

print(dict3) #{'age': 28, 'sex': '女', '形状': '球', 28: 19, '美食': '蛋糕'}

# Python 字典 popitem() 方法随机返回并删除字典中的一对键和值(一般删除末尾对)。

# 如果字典已经为空，却调用了此方法，就报出KeyError异常。

print(dict3.popitem())#('美食', '蛋糕')

print(dict3) #{'age': 28, 'sex': '女', '形状': '球', 28: 19}

# 7.字典函数&方法

# len(dict) 计算字典中元素的个数

dict4={'name':'Tom','age':18}

print(len(dict4)) #2

# str(dict) 输出字典，以可打印的字符串表示

dict5={'name':'Tom','age':18,'sex':'男',18:19}

str1=str(dict5)

print(str1) #{'name': 'Tom', 'age': 18, 'sex': '男', 18: 19}

print(type(str1)) #判断str1的数据类型

# type(variable) 返回输入变量的数据类型，如果变量是字典就返回

dict6={'name':'Tom'}

print(type(dict6)) #

# dict.keys() 以字典键的形式返回一个字典所有的键

dict7={'name':'Tom','age':18,'sex':'男',18:19}

print(dict7.keys()) #dict_keys(['name', 'age', 'sex', 18])

print(type(dict7.keys())) #

# key in dict 如果键在字典dict里返回true,否则返回false

print('name'indict7) #True

# dict.values() 以字典值得形式返回一个字典中的所有值

print(dict7.values()) #dict_values(['Tom', 18, '男', 19])

print(type(dict7.values())) #

# dict.get(key,default=None) 返回指定键的值，如果值不在字典中返回default值(default不传参则为None)

print(dict7.get('name')) #Tom

print(dict7.get('name1')) #None

# dict.fromkeys(seq[,value]) 创建一个新字典，以序列seq中元素做字典的值，value为字典所有键对应的初始值([],[])

seq=('name','age','sex')

dict8=dict.fromkeys(seq)

print(dict8) #{'name': None, 'age': None, 'sex': None}

dict9=dict.fromkeys(seq,'jack')

print(dict9)#{'name': 'jack', 'age': 'jack', 'sex': 'jack'}

seq2=('TOM','18','男')

dict10=dict.fromkeys(seq,seq2)

print(dict10)#{'name': ('TOM', '18', '男'), 'age': ('TOM', '18', '男'), 'sex': ('TOM', '18', '男')}

# 构建字典的 2 个列表/元祖中的元素相同

dict11=dict(zip(seq,seq2))

print(dict11) #{'name': 'TOM', 'age': '18', 'sex': '男'}

#构建字典的 2 个列表/元祖中的元素不同(key比value多)

a1 = [1, 2, 3, 4]

c1 = ['aa', 'ss']

print(dict(zip(a1,c1)))#{1: 'aa', 2: 'ss'}

# 构建字典的2个列表/元祖中的元素不同(key比value少)

a2 = [1, 2, 3, 4]

d2 = ['fa','fb','fc','fd','fe']

print( dict(zip(a2,d2)))#{1: 'fa', 2: 'fb', 3: 'fc', 4: 'fd'}

# dict.setdefault(key,default=None) 和get类似，但如果键不存在于字典中，将会添加键并将值设为default

dict12={'name':'Tom','age':18,'sex':'男',18:19}

print(dict12.setdefault("name"))#Tom

print(dict12)#{'name': 'Tom', 'age': 18, 'sex': '男', 18: 19}

print(dict12.setdefault("name1"))#None

print(dict12)#{'name': 'Tom', 'age': 18, 'sex': '男', 18: 19, 'name1': None}

# 8.什么是集合

# 集合是基本的数学概念，它是集合论的研究对象，指具有某种特定性质的事物的总体，

# (在最原始的集合论─朴素集合论─中的定义，集合就是“一堆东西”。)集合里的事物(“东西”)，叫作元素。

#相当于把字典丢弃掉(value)值， 只有key(不可变，不可重复)

# 集合： s1={'a','b','c'}

# set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

# 可以使用set方法传入一个字符串，形成一个集合

# 可以使用for in访问集合中的元素

# 也能转换为l列表形式，执行访问操作

# 增加元素add 删除元素remove

# 集合具有交集 ，并集， 差集

x = set('runoob')

y = set('google')

## 重复的被删除

print(x,y)#{'r', 'u', 'o', 'b', 'n'} {'e', 'o', 'l', 'g'}

# 交集

print(x & y )#{'o'}

# 并集

print(x | y )#{'r', 'l', 'g', 'u', 'o', 'b', 'e', 'n'}

# 差集

print(x - y )#{'n', 'r', 'b', 'u'}

# 浅拷贝与深拷贝

# Python中string、tuple和number是不可变对象，而dict、list等是可变对象

# 不可变对象在进行重新赋值的时候，实际上是将原始值丢弃，将变量指向一个新值；

# 可变对象的可变性实质上是指更改可变对象中的子对象，比如list中的item元素的更改。

# 直接赋值：其实就是对象的引用(起个 别名)

a3 = [1,2,3]

b3 = [11,22,33]

c3 = [111,222,333]

var01 = [a3,b3,c3]

var02 = var01 #起别名

print(var01)

print(var02)

#id 获取变量在内存中的地址

print(id(var01)) #2869237497224

print(id(var02))#2869237497224

print('-------------------------')

a3.append(4) # a插入一个新元素

print(var01)

print(var02)

#id 获取变量在内存中的地址

print(id(var01))#2573024608072

print(id(var02))#2573024608072

print('-'*30)

a4 = (1,2,3)

b4 = (11,22,33)

c4 = (111,222,333)

var03 = (a4,b4,c4)

var04 = var03 #起别名

print(var03)

print(var04)

#id 获取变量在内存中的地址

print(id(var03))#2417112784760

print(id(var04))#2417112784760

# 浅拷贝：不拷贝子对象(针对子对象中的item)，当子对象进行更改的时候，原始对象也会改变。

# 常见操作：列表的切片[:]操作、list()操作，

# 字典的copy()函数、copy模块的copy()函数(两个一模一样的双胞胎)

# 深拷贝：会拷贝子对象，当对原始对象子对象进行更改的时候，原始对象不会改变。

# 常见操作：copy模块的deepcopy()函数

# 浅拷贝，只是拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。

# 深拷贝，外围和内部元素都进行了拷贝对象本身，而不是引用。

# 但是对于数字，字符串和元组类型对象，没有被拷贝的说法，即便是用深拷贝，查看id的话也是一样的，

# 如果对其重新赋值，也只是新创建一个对象，替换掉旧的而已。

#

importcopy

a = [1, 2, 3, 4, ['a', 'b']]

b = a

c = copy.copy(a) #浅拷贝

d = copy.deepcopy(a)#深拷贝

a.append(5)

a[4].append('c')

print("*"*20)#********************

print (a) #[1, 2, 3, 4, ['a', 'b', 'c'], 5]

print(id(a[4]))#2045327748488

print(id(b[4]))#2045327748488

print(id(c[4]))#2045327748488

print(id(d[4]))#2045327829960

print('a = ', a) #a = [1, 2, 3, 4, ['a', 'b', 'c'], 5]

print('b = ', b) #b = [1, 2, 3, 4, ['a', 'b', 'c'], 5]

print('c = ', c) #c = [1, 2, 3, 4, ['a', 'b', 'c']]

print('d = ', d) #d = [1, 2, 3, 4, ['a', 'b']]