数据类型内置方法总结

目录

• 元组: (tuple)
  • --元组是不可变的列表，即元组的值不可更改
  • --用途：元组进行元素存储
  • --定义： 在()内可以有多个任意类型的值，逗号分隔元素
  • 内置方法：
    • 索引取值
    • 切片
    • 长度len
    • 成员运算
    • for循环
    • count
    • index
    • 有序 or 无序 ： 有序（有索引）
    • 可变 or 不可变： 不可变数据类型--》数据更新--》开辟新空间
  • 元祖 和 列表 的区别：
    • 1.列表可变：索引所对应的值的内存地址是可以改变
    • 2.元组不可变：索引所对应的值的内存地址不可改变
• 字典:(dict)
  • ----列表的扩展（描述值）
  • 用途：存多个值，但每一个值都有一个key与之对应，key对值有描述功能
    • 定义： ：{}内用逗号分隔开多个元素，每一个元素都是key：value的形式，value可以是任意数据类型，，但是key必须为不可变类型。
  • 内置方法：
  • 按key存取值：可存可取
  • 长度len
  • 成员运算in和not in
  • 删除del
  • 键keys()、值values()、键值对items()
  • 循环
  • get-->get(key)----->没有则None
  • update ===列表中的extend
  • fromkeys --->多个键，给一个值
  • setdefult() --->有指定key不会改变值；无指定key则改变值
  • 有序 or 无序 ：无序
  • 可变or不可变：可变数据类型
• 集合：（set）
  • ----集合可以理解成一个集合体
  • 用途：用于关系运算的集合体，由于集合内的元素无序且集合元素不可重复，因此集合可以去重，但是去重后的集合会打乱原来元素的顺序。
  • 定义：{}内用逗号分隔开多个元素，每个元素必须是不可变类型。
  • 内置方法：
    • 长度len
    • 成员运算in和not in
    • |并集、union
    • &交集、intersection
    • -差集、difference
    • ^对称差集、symmetric_difference
    • ==
    • 父集：>、>= 、issuperset
    • 子集：<、<= 、issubset
    • add
    • remove
    • difference_update
    • discard
    • isdisjoint ---->集合没有共同的部分返回True，否则返回False
• 深浅拷贝：---值变化后
  • 赋值(拷贝)：对象赋值实际上是对象的引用。当创建一个对象，然后把它赋给另一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用
  • 可变 or 不可变：id不变值可变，即在原值的基础上修改，则为可变数据类型；值变id也变，即重新申请一个空间放入新值，则为不可变数据类型。
  • 拷贝：--创建一一个新变量。并用引用计数指向内存空间
  • --B是A的拷贝对象，则A内部的任何数据类型的元素变化，则B内部的元素也会跟着改变，因为可变类型值变id不变
  • 浅拷贝： ---只拷贝变化后可变类型元素，不在乎不可变类型元素
  • B是A的浅拷贝对象，则A内的不可变元素发生了改变，B不变；如果A内的可变元素发生了改变，则B会跟着改变
  • 深拷贝： ---不管如何变化，都不拷贝
  • B是A的深拷贝对象，则A内的不可变元素发生了改变，B不变；如果A内的可变元素发生了改变，B也不会变，即l2永远不会因为l1的变化而变化。
• 数据类型总结:
  • 一，按存值个数：
  • 二、按可变不可变区分
  • 三、有序无序区分
  • 四、按访问类型区分

元组: (tuple)

--元组是不可变的列表，即元组的值不可更改

--用途：元组进行元素存储

--定义： 在()内可以有多个任意类型的值，逗号分隔元素

内置方法：

索引取值

切片

长度len

成员运算

for循环

count

index

有序 or 无序 ： 有序（有索引）

可变 or 不可变： 不可变数据类型--》数据更新--》开辟新空间

元祖 和 列表 的区别：

1.列表可变：索引所对应的值的内存地址是可以改变

2.元组不可变：索引所对应的值的内存地址不可改变

l = ['a', 'b', 'c']
print(f"id(l[0]): {id(l[0])}")
l[0] = 'A'
print(f"id(l[0]): {id(l[0])}")

id(l[0]): 4357367208
id(l[0]): 4357775176

字典:(dict)

----列表的扩展（描述值）

用途：存多个值，但每一个值都有一个key与之对应，key对值有描述功能

定义： ：{}内用逗号分隔开多个元素，每一个元素都是key：value的形式，value可以是任意数据类型，，但是key必须为不可变类型。

内置方法：

1. 按key存取值：可存可取

2. 长度len

3. 成员运算in和not in

4. 删除del

5. 键keys()、值values()、键值对items()

6. 循环

7. get-->get(key)----->没有则None

8. update ===列表中的extend

9. fromkeys --->多个键，给一个值

10. setdefult() --->有指定key不会改变值；无指定key则改变值

统计s='hello tank tank say hello sb sb'中每个单词的个数

结果如：{'hello': 2, 'tank': 2, 'say': 1, 'sb': 2}

s='hello tank tank say hello sb sb'

l=s.split()

dic={}
for item in l:
    if item in dic:
        dic[item]+=1
    else:
        dic[item]=1
print(dic)
{'hello': 2, 'tank': 2, 'say': 1, 'sb': 2}

有序 or 无序 ：无序

可变or不可变：可变数据类型

集合：（set）

----集合可以理解成一个集合体

用途：用于关系运算的集合体，由于集合内的元素无序且集合元素不可重复，因此集合可以去重，但是去重后的集合会打乱原来元素的顺序。

定义：{}内用逗号分隔开多个元素，每个元素必须是不可变类型。

内置方法：

1. 长度len

2. 成员运算in和not in

3. |并集、union

4. &交集、intersection

5. -差集、difference

6. ^对称差集、symmetric_difference

7. ==

8. 父集：>、>= 、issuperset

9. 子集：<、<= 、issubset

10. add

11. remove

12. difference_update

13. discard

14. isdisjoint ---->集合没有共同的部分返回True，否则返回False

如下列表，列表元素为不可hash类型，去重，得到新列表，且新列表一定要保持列表原来的顺序

stu_info_list = [
    {'name':'nick','age':19,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'tank','age':20,'sex':'female'},
    {'name':'tank','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
]
stu_info_list = [
    {'name': 'nick', 'age': 19, 'sex': 'male'},
    {'name': 'egon', 'age': 18, 'sex': 'male'},
    {'name': 'tank', 'age': 20, 'sex': 'female'},
    {'name': 'tank', 'age': 20, 'sex': 'female'},
    {'name': 'egon', 'age': 18, 'sex': 'male'},
]

new_stu_info_list = []
for stu_info in stu_info_list:
    if stu_info not in new_stu_info_list:
        new_stu_info_list.append(stu_info)

for new_stu_info in new_stu_info_list:
    print(new_stu_info)
{'name': 'nick', 'age': 19, 'sex': 'male'}
{'name': 'egon', 'age': 18, 'sex': 'male'}
{'name': 'tank', 'age': 20, 'sex': 'female'}

深浅拷贝：---值变化后

赋值(拷贝)：对象赋值实际上是对象的引用。当创建一个对象，然后把它赋给另一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用

可变 or 不可变：id不变值可变，即在原值的基础上修改，则为可变数据类型；值变id也变，即重新申请一个空间放入新值，则为不可变数据类型。

拷贝：--创建一一个新变量。并用引用计数指向内存空间

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

浅拷贝： ---只拷贝变化后可变类型元素，不在乎不可变类型元素

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

port copy

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

l1.append('g')
print(id(l1))
print(id(l2)

深拷贝： ---不管如何变化，都不拷贝

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

import copy

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

l1.append('g')

print(id(l1))
print(id(l2))

数据类型总结:

一，按存值个数：

存值个数	数据类型
单个值	数字，字符串
多个值(容器)	列表，元组，字典，集合

二、按可变不可变区分

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

三、有序无序区分

有序or无序	数据类型
有序(可按索引取值)	字符串，列表，元组
不可变	字典，集合

四、按访问类型区分

访问类型	数据类型
直接访问	数字
顺序访问(序列类型)	字符串，列表，元组
key值访问(映射类型)	字典