Python 之元组、字典、浅复制

 

元组

• 元组基本介绍
• 元组表现形式tuple
• 元组是⼀个不可变序列(⼀般当我们希望数据不改变时，我们使⽤元组，其他
• 情况下基本都⽤列表)
• 使⽤()创建元素
• 元组不是空元组⾄少有⼀个 逗号(,) 当元组不是空元组时括号可以省略
• 元组解包指将元组当中的每⼀个元素都赋值给⼀个变量

作用 ：

元组与列表类似，也是可以存多个任意类型的元素，不同之处在于元组的元素不能修改，即元组相当于不可变的列表，用于记录多个固定不允许修改的值，单纯用于取。

 定义方式

# 在()内用逗号分隔开多个任意类型的值
>>> countries = ("中国"，"美国"，"澳大利亚")  # 本质:countries = tuple("中国"，"美国"，"澳大利亚")
# 强调：如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组
>>> countries = ("中国"，)  # 本质:countries = tuple("中国")

类型转换

# 但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型
>>> tuple('wdad') # 结果：('w', 'd', 'a', 'd') 
>>> tuple([1,2,3]) # 结果：(1, 2, 3)
>>> tuple({"name":"jason","age":18}) # 结果：('name', 'age')
>>> tuple((1,2,3)) # 结果：(1, 2, 3)
>>> tuple({1,2,3,4}) # 结果：(1, 2, 3, 4)
# tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中

   元祖的解包

   案列：

# 解包指的是将元祖当中的元素都赋值给一个变量
my_tuple = 10,20,30,40,60
# a,b,c,d = my_tuple
# a,b = my_tuple  # ValueError: too many values to unpack (expected 2)
# a,b,*c = my_tuple
# a,*b,c = my_tuple
*a,b,c = my_tuple

  上述结果如下：

 

print('a =',a)
print('b =',b)
print('c =',c)
# print('d =',d)

案列：

 

 tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33) 
# 1、按索引取值(正向取+反向取)：只能取，不能改否则报错！  
>>> tuple1[0]
1
>>> tuple1[-2]
22
>>> tuple1[0] = 'hehe'  # 报错：TypeError:

 2、切片(顾头不顾尾，步长)
>>> tuple1[0:6:2] 
(1, 15000.0, 22)

 3、长度
>>> len(tuple1)  
6

 4、成员运算 in 和 not in
>>> 'hhaha' in tuple1 
True
>>> 'hhaha' not in tuple1  
False 

5、循环
>>> for line in tuple1:
...     print(line)
1
hhaha
15000.0
11
22
33

 

字典的基本介绍

• 字典属于⼀种新的数据结构称为映射(mapping)
• 字典的作⽤和列表类似，都是⽤来存储对象的容器列表存储数据的性能好，但是查询数据的性能差，
• 字典正好与之相反在字典中每⼀个元素都有唯⼀的名字，通过这个唯⼀的名字可以找到指定的元素
• 这个唯⼀的名字我们称之为key 通过key可以快速查询value 也可以称之为值
• 字典我们也称之为键值对(key-value)结构
• 每个字典中都可以有多个键值对，⽽每⼀个键值对我们称其为⼀项(item)
• 创建⼀个有数据的字典 语法 {key:value}
• 字典的值可以是任意对象 字典的键可以是任意的不可变对象(int str bool
• tuple....)
• 字典的键是不能重复的，如果出现重复的后⾯的会替换前⾯的

  字典的使⽤

* 使用dict()来创建字典
  d=dict(name='葫芦娃',age=7,gender='男')

* 也可以将一个包含有双值子序列的序列转换为字典
  双值序列，序列当中有2个值[4,5],(1,2),'ab'

* 子序列，如果序列当中的元素也是序列，我们就称这个元素为子序列[(1,2,4),[4,5]]

  d = dict([('name','葫芦娃'),('age',7)])
  print(d,type(d))

* len() 字典中键值对的个数
  print(len(d))


in  检查字典中是否包含有指定的键
not in  检查字典中是否包不含有指定的键

print('葫芦娃' not in d)
print(d['age'])

   n = 'name'
   print(d['n']) # KeyError: 'n'
   get(key,default)通过get也可以获得字典当中的值
   print(d.get('name','我也不知道'))
   print(d.get('n'))

   d =  {'name':'葫芦娃','age':7,'gender':'男'}

 

可以通过get方法获取，get(key,default)
get方法是通过键来获取字典当中的值，若是没有，则返回None，或者通过设置第二个参数（默认值）来返回默认值内容
比如：

dct = dict(name='tom',age=18,job='teacher',home_add='beijing')
print(dct.get('name'))
print(dct.get('jack'))
print(dct.get('jack'),'Sorry, the key is  not in the dictionary')

上述结果如下：

tom
None
None Sorry, the key is  not in the dictionary

 

修改字典

直接修改或添加

字典中的键不能重复
可以直接用获取key改变value
如果没有这个键，则可以增加字典中的键值对
比如：

dct = dict(name='tom',age=18,job='teacher',home_add='beijing')
print('修改前',dct)
fan = dct.pop('name')
print('返回值：',fan)
print('修改后',dct)

修改前 {'name': 'tom', 'age': 18, 'job': 'teacher', 'home_add': 'beijing'}
返回值： tom
修改后 {'age': 18, 'job': 'teacher', 'home_add': 'beijing'}

删除 

del:

删除字典中的key:value

dct = dict(name='tom',age=18,job='teacher',home_add='beijing')
print('修改前',dct)
del dct['name']
print('修改后',dct)

修改前 {'name': 'tom', 'age': 18, 'job': 'teacher', 'home_add': 'beijing'}
修改后 {'age': 18, 'job': 'teacher', 'home_add': 'beijing'}

 

pop:

 dic.pop('name')  # 通过指定字典的key来删除字典的键值对

dct = dict(name='tom',age=18,job='teacher',hone_add='beijing')
print('修改前',dct)
fan = dct.pop('name')
print('返回值：',fan)
print('修改后',dct)

 

修改前 {'name': 'tom', 'age': 18, 'job': 'teacher', 'home_add': 'beijing'}
返回值： tom
修改后 {'age': 18, 'job': 'teacher', 'hone_add': 'beijing'}

popitem

随机删除字典中的一个键值对，一般删除最后一个
删除后会将删除的值作为返回值返回(元组形式)

dct = dict(name='tom',age=18,job='teacher',home_add='beijing')
print('修改前',dct)
dct.popitem()
print('修改后',dct)

修改前 {'name': 'tom', 'age': 18, 'job': 'teacher', 'home_add': 'beijing'}
修改后 {'name': 'tom', 'age': 18, 'job': 'teacher'}

 

通过setdefault(key,default)方法添加key:value

如果这个key已经存在，则返回key值，对字典没有任何影响
如果key不存在，向字典添加这个key并设置value，返回value
比如：

dct = dict(name='tom',age=18,job='teacher',home_add='beijing')
print('修改前',dct)
dct.setdefault('name','jack')
dct.setdefault('sex','male')
print('修改后',dct)

 

修改前 {'name': 'tom', 'age': 18, 'job': 'teacher', 'home_add': 'beijing'}
修改后 {'name': 'tom', 'age': 18, 'job': 'teacher', 'home_add': 'beijing', 'sex': 'male'}

update方法添加字典

update方法将其他字典添加到当前字典中
比如：

dct = dict(name='tom',age=18,job='teacher',home_add='beijing')
dct1 = dict(sex='male')
print('修改前',dct)
dct.update(dct1)
print('修改后',dct)

修改前 {'name': 'tom', 'age': 18, 'job': 'teacher', 'home_add': 'beijing'}
修改后 {'name': 'tom', 'age': 18, 'job': 'teacher', 'home_add': 'beijing', 'sex': 'male'}

clear()

清空字典

dct = dict(name='tom',age=18,job='teacher',home_add='beijing')
print('修改前',dct)
dct.clear()
print('修改后',dct)

上诉结果如下：

修改前 {'name': 'tom', 'age': 18, 'job': 'teacher', 'home_add': 'beijing'}
修改后 {}

 

浅复制

浅复制复制以后与原对象之间是独立的，修改一个并不会影响另一个
普通复制：

dct = dict(name='tom',age=18,job='teacher',home_add='beijing')
#普通复制
dct1 = dct
dct['name'] = 'jack'
print('dct:',dct,id(dct))
print('dct1:',dct1,id(dct1))

上述结果如下：

dct: {'name': 'jack', 'age': 18, 'job': 'teacher', 'home_add': 'beijing'} 63744392
dct1: {'name': 'jack', 'age': 18, 'job': 'teacher', 'home_add': 'beijing'} 63744392

普通复制两个id相同，一方修改另一个也会改变
浅复制：

dct = dict(name='tom',age=18,job='teacher',home_add='beijing')
#浅复制
dct1 = dct.copy()
dct['name'] = 'jack'
print('dct:',dct,id(dct))
print('dct1:',dct1,id(dct1))

上述结果如下：

dct: {'name': 'jack', 'age': 18, 'job': 'teacher', 'home_add': 'beijing'} 61123032
dct1: {'name': 'tom', 'age': 18, 'job': 'teacher', 'home_add': 'beijing'} 61103112

浅复制双方id不同，一方修改另一方不会改变
但是，如果嵌套字典，则会只复制第一层字典内容
比如：

dct = {'n':{'name':'tom','age':'18'},'job':'teacher'}
#浅复制
dct1 = dct.copy()
dct['n']['name'] = 'jack'
print('dct:',dct,id(dct))
print('dct1:',dct1,id(dct1))

上述结果如下：字典内的嵌套字典会随一方改变而改变

dct: {'n': {'name': 'jack', 'age': '18'}, 'job': 'teacher'} 66870360
dct1: {'n': {'name': 'jack', 'age': '18'}, 'job': 'teacher'} 66870640