Python-数据类型内置方法(2)

目录

• 元组（tuple）
  • 内置方法：
• 字典（dict）
  • 内置方法：
  • 优先掌握：
  • 需要掌握
• 集合（set）
  • 优先掌握
• 深浅拷贝
  • 拷贝（赋值）
  • 浅拷贝
  • 深拷贝
  • 拷贝
  • 浅拷贝
  • 深拷贝
• 总结
  • 存值个数
  • 有序 or 无序
  • 可变 or 不可变
  • 访问类型

元组（tuple）

元组是不可变的列表，只可以存不可以修改，早起元组类型占用内存小

定义：tup = tuple((1,2,3))

内置方法：

• 索引取值

  name_tuple = ("qinyj","age",18)
  
  print(name_tuple[0])
  
  

• 索引切片

  name_tuple = ("qinyj","age",18)
  
  print(name_tuple[0:2])
  
  

• 长度len

  name_tuple = ("qinyj","age",18)
  
  print(len(name_tuple))
  
  

• 循环

  name_tuple = ("qinyj","age",18)
  
  for i in name_tuple:
  
      print(i)
  
  

• count

  name_tuple = ("qinyj","age",18)
  
  print(name_tuple.count("qinyj"))
  
  

• index

  name_tuple = ("qinyj","age",18)
  
  print(name_tuple.index("qinyj"))
  
  

有序但不可变类型。

字典（dict）

定义：dic = dict()

内置方法：

优先掌握：

• 按key存取值：可存可取（可查可修改）

  dic = {'a': 1, 'b': 2}
  
  print(f"first dic['a']: {dic['a']}")
  
  dic['a'] = 3
  
  print(f"second dic['a']: {dic['a']}")
  
  

• 长度len

  dic = {'a': 1, 'b': 2}
  
  print(len(dic))
  
  

• 成员运算

  dic = {'a': 1, 'b': 2}
  
  print("a" in dic)
  
  

• 删除del、pop指定元素

  dic = {'a': 1, 'b': 2}
  
  del dic["a"]
  
  print(dic)
  
  

• keys/values/items

  dic = {'a': 1, 'b': 2}
  
  print(dic.keys())
  
  print(dic.values())
  
  print(dic.items())
  
  for i,k in dic.items:
  
      print(i,k)
  
  

• fo 循环：循环的是key

• get：查指定元素，如果没有返回None，可设默认值

需要掌握

• get
• pop删除
• popitem删除末尾键值对
• update 扩展字典。类似list 中extend方法
• formkeys
• setdefault 有指定key不会改变值；无指定key则改变值

集合（set）

优先掌握

1. 长度len
2. 成员运算in和not in
3. |并集、union
4. &交集、intersection
5. -差集、difference
6. ^对称差集、symmetric_difference
7. ==
8. 父集：>、>= 、issuperset
9. 子集：<、<= 、issubset

深浅拷贝

拷贝（赋值）

>>> lt1 = ["a","b","c"]

>>> print(id(lt1))

43366216

>>> lt2 = lt1

>>> print(id(lt2))

43366216

>>> lt1.append("d")

>>> print(lt1)

["a","b","c","d"]

>>> print(lt2)

["a","b","c","d"]

# 43366216  内存地址一样。两个变量指向同一个内存地址，一个变，另一个也改变

如果lt2 是lt1的拷贝对象，lt1 内部的任何数据类型的元素变化，lt2内部的元素也会跟着变化。因为可变类型值变id不变。

浅拷贝

>>> import copy

>>> lt1 = ["a","b","c",["d","e"]]

>>> print(id(lt1))

43434056

>>>

>>> lt2 = copy.copy(lt1)

>>> print(id(lt2))

43449224

>>> lt1[-1].append("f")

>>> print(lt1)

['a', 'b', 'c', ['d', 'e', 'f']]

>>> print(lt2)

['a', 'b', 'c', ['d', 'e', 'f']]

>>>

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

如果lt1内部的可变元素发生了变化，lt2也跟着改变。

深拷贝

>>> import copy

>>> lt1 = ["a","b","c",["d","e"]]

>>> print(id(lt1))

43434440

>>> lt2 = copy.deepcopy(lt1)

>>> print(id(lt2))

43447368

>>> lt1[-1].append("f")

>>> print(lt1)

['a', 'b', 'c', ['d', 'e', 'f']]

>>> print(lt2)

['a', 'b', 'c', ['d', 'e']]

>>>

如果lt2是lt1的深拷贝对象，lt1内部的任何元素发生了变化，lt2不会跟着改变。

• 拷贝

  如果lt2 是lt1的拷贝对象，lt1 内部的任何数据类型的元素变化，lt2内部的元素也会跟着变化。因为可变类型值变id不变。

• 浅拷贝

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

  如果lt1内部的可变元素发生了变化，lt2也跟着改变。

• 深拷贝

  如果lt2是lt1的深拷贝对象，lt1内部的任何元素发生了变化，lt2不会跟着改变。

总结

存值个数

单个值	数字、字符串
多个值	列表、元组、字典、集合

有序 or 无序

有序	字符串、列表、元组
无序	数字、字典、集合

可变 or 不可变

可变	列表、字典、集合
不可变	数字、元组、字符串

访问类型

直接访问	数字
顺序访问	字符串、列表、元组
key值访问	字典

拷贝/浅拷贝/深拷贝 都是针对可变类型数据而言。