week2 day3 基本数据类型及其内置方法（tuple,dict,set）|||所有数据类型基本操作汇总

补充知识点：可变类型与不可变类型
1.可变类型：值改变，id不发生改变（主要包括容器数据类型，list，dict，set）
2.不可变类型：值改变，id发生改变（主要包括int，float，str，tuple）

一. 元组类型（tuple）

1.1 基本情况

数据类型名称	作用	定义方式	数据类型转换	常用操作	存一个值or多个值	可变or不可变
元组 tuple	不可变的列表	t=(1,2,(3,4,))	tuple(可迭代元素)	见1.2	存多个值，如果值是不可变类型，则不可更改。如果值是可变类型，可通过嵌套索引改变	不可变

1.2 tuple常用操作

1.2.1 索引和切片（*****）

跟字符串索引切片操作相同。

1.2.2 计算长度(*****)

跟字符串索引切片操作相同。

1.2.3 成员运算 in 和 not in（*****）

跟字符串索引切片操作相同。

1.2.4 循环(****)

跟字符串索引切片操作相同。

1.2.5 需要了解的元组内置方法

1.index
t=(1,2,3,(4,5))
print(t.index(2))----->1

2.count
t=(1,2,3,(4,5))
print(t.count(3))----->1

二. 字典类型

2.1 基本情况

数据类型名称	作用	定义方式	数据类型转换	常用操作	存一个值or多个值	可变or不可变
字典 dict	记录不同属性的多个值，key对value具有描述性作用	{}内存放多个元素，每个元素由key和value组成，key：value。用逗号隔开	dict（一个可迭代数据），每个数据必须由两部分组成，可以分别提供给key和value	见2.2	存多个值，可通过key取value	可变

2.2 基本操作

2.2.1 造字典的三种方式（***）

1.通过dict
dictionary=dict((['name','wth],('age',18)))
print(dictionary)----->{'name':'wth','age':18}

2.通过直接赋值
dict1=dict(a=1,b=2,c=3)
print(dict1)----->{'a':1,'b':2,'c':3}

3.通过空字典调用的fromkeys
dict1={}.fromkeys(('age','name','salary'),None)
print(dict1)----->{'age':None,'name':None,'salary':None}

2.2.2 计算长度（*****）

与字符串相同用法，不再详述。

2.2.3 成员运算 in和 not in（*****）

只能检查key在不在字典中。

2.2.4 按照key存取值（*****）

dict1={'name':'wth,'age':18,'salary':3000}
dict1['k3'] # ----->报错
print(dict1['name']) # ----->'wth'
dict1['k3']=123
print(dict1) # ----->{'name':'wth,'age':18,'salary':3000,'k3':123}

2.2.5 删除（*****）

1.pop
dict1={'name':'wth,'age':18,'salary':3000}
res=dict1.pop('name')
print(res)----->'wth'
pop删除方法填入的内容是key，返回值是value

2.popitem
v=dict1.popitem()
print(v)----->('name','wth')
popitem删除方法随机删除一组元素，返回一个元组，第一个元素是key，第二个元素是value

2.2.6 取键，取值，取键值对（*****）

dict1={'name':'wth','age':18,'salary':3000}
print(dict1.keys()) # ----->dict_keys(['name', 'age', 'salary'])
print(dict1.values()) # ----->dict_values(['wth', 18, 0])
print(dict1.items()) # ----->dict_items([('name', 'wth'), ('age', 18), ('salary', 0)])

我们可以将所有上面显示的内容转换成列表显示。
print(list(d.keys())) # ----->['name', 'age', 'salary']
print(list(d.values())) # ---->['wth', 18, 0]
print(list(d.items())) # ----->[('name', 'wth'), ('age', 18), ('salary', 0)]

2.2.7 get（*****）更常用，因为用get取值取不到不会报错，会返回None

dict1={'name':'wth,'age':18,'salary':3000}
print(dict1.get('name')) # ----->'wth'
print(dict1.get('xxx')) # ----->None
对于get（不存在的key），返回值为None

2.2.8 update（*****）

dict1={'name':'wth,'age':18,'salary':3000}
dict1.update({'k1':123,'k2':234,'name':'xxxx'})
print(dict1) # ----->{'name':'xxxx','age':18,'salary':3000,'k1':123,'k2':234}
update的用法是，对于update括号里面的内容，如果原字典有对应的key：value，则覆盖value。如果不存在key：value则添加到原字典中。

三. 集合类型（实际使用中很少出现）

3.1 集合基本情况

数据类型名称	作用	定义方式	数据类型转换	常用操作	存一个值or多个值	可变or不可变
集合 set	去重和关系运算	{}内存放多个元素，每个元素由用逗号隔开。集合内元素的特点①必须是不可变类型（数字，字符串，元组） s={11.3,1,‘srt’,(1,2,3)} ②元素无序③元素不可重复	set（一个可迭代数据）	见3.2	存多个值	可变

3.2 集合基本操作

3.2.1 集合的去重操作

s=set('hello')
print(s)----->{'l','o','h','e'}
其实集合的去重有些鸡肋，因为它去重后产生的集合里面元素是随机排放的。

如果想要对于某个容器型数据进行去重且有序出现，可以用以下代码实现。

new_l=[]
s=[{'name':'wth','age':18,'sex':'male'},
	{'name':'egon','age':20,'sex':'male'},
	{'name':'john','age':19,'sex':'female'},
	{'name':'wth','age':18,'sex':'male'}]
for i in s:
	if i not in s:
		new_l.append(i)
print(new_l)


[{'name':'wth','age':18,'sex':'male'},
	{'name':'egon','age':20,'sex':'male'},
	{'name':'john','age':19,'sex':'female'}]

3.2.2 集合的内置操作

pythons={1,2,3,4,5,6}
linuxs={5,6,7,8,9,10}

1.取交集（既在pythons也在linuxs）
print(pythons & linuxs) # ----->{5,6}
print( pythons.intersection(linuxs) ) # ----->{5,6}

2.取补集（在pythons或者在linuxs）
print(pythons | linuxs) # ----->{1,2,3,4,5,6,7,8,9,10}
print( pythons.union(linuxs) ) # ----->{1,2,3,4,5,6,7,8,9,10}

3.取差集（在pythons不在linuxs或者在linuxs不在pythons）
print(pythons - linuxs) # ----->{1,2,3,4}
print(pythons.difference(linuxs)) # ----->{1,2,3,4}
print(linuxs - pythons) # ----->{7,8,9,10}
print(linuxs.difference(pythons)) # ----->{7,8,9,10}

4.取对称差集（只在pythons以及只在linuxs）
print( (pythons - linuxs) | (linuxs - pythons) )
print(pythons ^ linuxs) # ----->{1,2,3,4,7,8,9,10}
print(pythons.symmetric_difference(linuxs)) # ----->{1,2,3,4,7,8,9,10}

5.父子集合（包含关系）
print(pythons >= linuxs) # ----->False
print(pythons.superset(linuxs)) # ----->False
print(linuxs <= pythons) # ----->False
print(linuxs.issubset(pythons)) # ----->False

3.2.3 集合的其他操作

res={7,8,9,12,13}
res.update({1,2,3,4,5}) # 取两个集合的合集
res.add(67)
res.remove(1) # 找不到则报错
print(res) # ----->{1,2,3,4,5,7,8,9,12,13,67}
res.pop() # 随即删除一个值
print(res)
s1=res.discard(33333) # 找不到返回None
res.clear()
res.isdisjoint()

四. 基本数据类型基本操作（增删改查）整理

数据类型名称	增	删	改	查	该数据类型其他独有操作	可变or不可变	一个值or多个值	有序or无序
int/float	-	-	-	-	-	不可变	一个值	-
str	-	-	-	-	切片索引，len，strip，split，成员运算in/not in，循环，replace(被替换，替换)，find（找不到返回-1）/index（找不到报错），startswith/endswith，upper/lower，join，isdigit/isalpha，center/ljust/rjust，format	不可变	一个值	有序
list	append追加，extend（可迭代），insert（索引，元素）	pop（索引），remove（元素）	索引改	索引查	index，count，sort，reverse	可变	多个值（相同属性）	有序
tuple	-	-	可变类型元素嵌套索引改	索引查	index，count	不可变（不可变类型不可变，可变类型可变）	多个值	有序
dict	dict[key]=value，update（{原字典存在则覆盖，不存在则添加}）	pop(key，返回key对应值)，popitem（随机删除键值对，组成元组返回）	dict[key]=value，update（{原字典存在则覆盖，不存在则添加}）	dict[key，不存在则报错]，dict.get(不存在则返回None)	dict.keys(),dict.values(),dict.items()，创建字典的三个方法（dict（两种），{}.fromkeys(一种)）	可变	多个值（不同属性）	无序