列表,字典,元组,集合内置方法

列表类型内置方法

1. 作用:多个女朋友/
2. 定义方式:[]内用逗号隔开多个任意数据类型的元素

friends_list = ['longzeluola'，'canglaoshi'，'qiaobenai'，'nick']
lis = list('abcd')

1. 方法:
   1. 优先掌握
      1. 索引取值(即可取又可改)
      2. 切片
      3. 长度
      4. append
      5. 成员运算
      6. for循环
   2. 需要掌握
      1. count
      2. remove
      3. reverse
      4. pop
      5. insert
      6. sort
      7. index
      8. del
      9. extend
      10. clear
2. 多个值or一个值:多个值
3. 有序or无序:有序
4. 可变or不可变:可变

元祖类型内置方法

1. 作用:类似于列表，可以取不可以存
2. 定义方式:

friends_tuple = ('longzeluola'，'canglaoshi'，'qiaobenai'，'nick')
tup = tuple('abcd')

1. 方法
   1. 优先掌握
      1. 索引取值(无法更改)
      2. 切片
      3. 长度
      4. 成员运算
      5. for循环
      6. count
      7. index
2. 多个值or一个值:多个值
3. 有序or无序:有序
4. 可变or不可变:无可变不可变这一说

字典类型内置方法

1. 作用:值太多列表存容易，取麻烦时使用字典
2. 定义方式:

nick_info_dict = {
'name':'nick'，
'height':180，
'weight':140，
'hobby_list':['read'，'run'，'music'，'fishing'，'programming'，'coding'，'debugging']
}

for k，v in nick_info_dict.items():
    print(k，v)

1. 方法
   1. 优先掌握
      1. 按键取值
      2. 长度
      3. keys/values/items
      4. for循环
      5. 成员运算
   2. 需要掌握
      1. pop
      2. fromkeys
      3. setdefault
      4. get
      5. update
      6. del
2. 多个值or一个值:多个值
3. 有序or无序:无序
4. 可变or不可变:可变

集合类型内置方法

1. 作用:存多个值，为了集合之间做运算
2. 定义方式:

s = set()

s = {1，2，3，4，5，1}

1. 方法:
   1. 优先掌握
      1. 去重
      2. 并集 |
      3. 交集 &
      4. 差集 -
      5. 对称差集 ^
      6. 父集 >&emsp；>=
      7. 子集 <&emsp；<=
      8. ==
   2. 需要掌握
      1. add
      2. difference_update
      3. isdisjoint
      4. remove # 值不存在会报错
      5. discard # 不会报错
2. 多个值or一个值:多个值
3. 有序or无序:无序
4. 可变or不可变:可变

布尔类型

1. 作用:一般用于判断，除了0/None/空/False自带布尔值为False，其他的数据类型自带布尔值为True

数据类型总结

拷贝

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

l1 = ['a'，'b'，'c'，['d'，'e'，'f']]
l2 = l1

l1.append('g')

print(l1)  # ['a'，'b'，'c'，['d'，'e'，'f']，'g']
print(l2)  # ['a'，'b'，'c'，['d'，'e'，'f']，'g']

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

浅拷贝

import copy

l1 = ['a'，'b'，'c'，['d'，'e'，'f']]
l2 = copy.copy(l1)

l1.append('g')

print(l1)  # ['a'，'b'，'c'，['d'，'e'，'f']，'g']
print(l2)  # ['a'，'b'，'c'，['d'，'e'，'f']]

l1[3].append('g')

print(l1)  # ['a'，'b'，'c'，['d'，'e'，'f'，'g']，'g']
print(l2)  # ['a'，'b'，'c'，['d'，'e'，'f'，'g']]

如果l2是l1的浅拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，则l2会跟着改变

深拷贝

import copy

l1 = ['a'，'b'，'c'，['d'，'e'，'f']]
l2 = copy.deepcopy(l1)

l1.append('g')

print(l1)  # ['a'，'b'，'c'，['d'，'e'，'f']，'g']
print(l2)  # ['a'，'b'，'c'，['d'，'e'，'f']]

l1[3].append('g')

print(l1)  # ['a'，'b'，'c'，['d'，'e'，'f'，'g']，'g']
print(l2)  # ['a'，'b'，'c'，['d'，'e'，'f']]

如果l2是l1的深拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，l2也不会变，即l2永远不会因为l1的变化而变化

原文地址：https://www.cnblogs.com/acate/p/10920670.html