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

目录

元组（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 无序 数据类型
有序 字符串、列表、元组
无序 数字、字典、集合

可变 or 不可变

可变 or 不可变 数据类型
可变 列表、字典、集合
不可变 数字、元组、字符串

访问类型

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

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

posted @ 2019-09-16 19:42  GeminiMp  阅读(128)  评论(0)  编辑  收藏  举报