数据类型之元组、字典、集合

元组（tuple）

元组与列表类似，都可以存多个值，但是不同的是元组本身不能被修改

用途：记录多个值，当多个值没有修改的需求，此时使用元组更为合适

定义方式：在()内用逗号分隔开多个任意类型的值

1、按索引方式取值

t=(1,1.3,'xx',('a','b'),[1,2])
print(t,type(t))

#打印结果  (1, 1.3, 'xx', ('a', 'b'), [1, 2]) <class 'tuple'>

t1 = tuple('hello')
print(t1)

#打印结果  ('h', 'e', 'l', 'l', 'o')

#按照索引取值，只能取，不能做别的操作
t=('zhangsan',123,['a','b'])
print(id(t[0]))
print(id(t[1]))
print(id(t[2][0]))
print(t[0])

#打印结果

1811845959608
1732284336
1811845815912
zhangsan

分割线的使用：

print('='*50)

虽然元组是不可变的，但是元组内的列表是可以改变的

#按照索引取值找到列表的位置，然后更改a位大写的A，由于字符串和数字类型为不可变类型，所以在元组中这些类型的数据也是不可变的
t=('egon',123,['a','b'])
t[2][0]='A'

#打印结果  ('egon', 123, ['A', 'b'])

2、切片

注意：顾头不顾尾，根据步长去实现切片操作，如果不写步长，那么步长默认为1（最后面写步长）

t=(1,2,3,4,5,6,7,8,9)
print(t[0:8:2])

#打印结果  (1, 3, 5, 7)

3、长度

#求t的长度
t=(1,2,3,4,5,6,7,8,9)
print(len(t))

#打印结果  9

4、循环

#循环打印
for item in ('a','b','c'):
    print(item)

#打印结果

a
b
c

5、元组的内置方法

#count：计数
t=('a','b','c','a')
print(t.count('a'))

#打印结果  2

#index：找出第一个匹配项的索引位置
t=('a','b','c','a')
print(t.index('a',1,10))

#打印结果  3

总结：

① 可以存放多个值

② 元组是有序的（可以被索引的都是有序的）

③ 不可变类型

字典（dict）

用途：记录多个值，每一个值对应的key都起到描述value的作用

定义方式：在{}内使用逗号分隔开多个key:value，其中value可以使任意类型，而key必须是不可变的类型，通常情况下应该是str类型

#定义一个字典，查看类型
dic = {'name':'zhangsan', 'age':18,'sex':'male'}
print(dic, type(dic))

#打印结果  {'name': 'zhangsan', 'age': 18, 'sex': 'male'} <class 'dict'>

定义字典的用法：

#用法一
dic = dict(x=1, y=2, z=3)
print(dic)

#打印结果  {'x': 1, 'y': 2, 'z': 3}

#用法二  使用解压赋值得到字典
userinfo=[
    ['name','zhangsan'],
    ['age',18],
    ['sex','male']
]
dic = {}
for k,v in userinfo:
    dic[k] = v
print(dic)

#打印结果  {'name': 'zhangsan', 'age': 18, 'sex': 'male'}

1、按key取值，可存可取

dic = {'name': 'zhangsan',  'sex': 'male'}
print(dic['name'])  #这种取值方式，如果key不存在的话会保存，继续向下看，会有防止报错的取值方式

#打印结果  zhangsan


#更改name的值
dic['name'] = 'lisi'
print(dic)

#打印结果  {'name': 'lisi', 'sex': 'male'}



#赋值
dic['age'] = 18
print(dic)

#打印结果  {'name': 'lisi', 'sex': 'male', 'age': 18}

2、长度（一个键值对长度为1）

dic = {'name': 'zhangsan', 'age': 18, 'sex': 'male'}
print(len(dic))

#打印结果  3

3、成员运算in和not  in ：字典成员运算判断的是key

dic = {'name': 'zhangsan', 'age': 18, 'sex': 'male'}
print('age' in dic)

#打印结果  True

dic = {'name': 'zhangsan', 'age': 18, 'sex': 'male'}
print('age' not in dic)

#打印结果  False

4、删除

#通用式删除，没有返回值（del），key如果不存在，会报错
dic = {'name': 'zhangsan', 'age': 18, 'sex': 'male'}
del dic['age']
print(dic)

打印结果  {'age': 18, 'sex': 'male'}

#pop 删除，有返回值，key如果不存在，会报错

dic = {'name': 'zhangsan', 'age': 18, 'sex': 'male'}
res = dic.pop('name')
print(res)

#打印结果  zhangsan

#popitem 默认删除字典中末尾的一个键值对，有返回值，以元组的形式返回
dic = {'name': 'zhangsan', 'age': 18, 'sex': 'male'}
res = dic.popitem()
print(res)

#打印结果  ('sex', 'male')

5、键keys()，值value()，键值对items()

#查看字典中所有的key、所有的value以及所有的键值对
dic = {'name': 'zhangsan', 'age': 18, 'sex': 'male'}
print(dic.keys())
print(dic.values())
print(dic.items())

#打印结果

dict_keys(['name', 'age', 'sex'])
dict_values(['zhangsan', 18, 'male'])
dict_items([('name', 'zhangsan'), ('age', 18), ('sex', 'male')])

6、循环打印字典

#循环打印字典中的key
dic = {'name': 'zhangsan', 'age': 18, 'sex': 'male'}
for k in dic.keys():
    print(k)

#打印结果

name
age 
sex

#循环打印字典中的value
dic = {'name': 'zhangsan', 'age': 18, 'sex': 'male'}
for v in dic.values():
    print(v)

#打印结果

zhangsan
18
male

#循环打印字典中的key、value
dic = {'name': 'zhangsan', 'age': 18, 'sex': 'male'}
for k,v in dic.items():
    print(k,v)

#打印结果

name zhangsan
age 18
sex male

8、get取值操作

dic = {'name': 'zhangsan', 'age': 18, 'sex': 'male'}
res = dic.get('name')
print(res)

#打印结果  zhangsan


res1 = dic.get('xxx')  #我们看到在字典中并没有xxx这个key，但是使用get取值并没有报错，而是返回了None
print(res1)

#打印结果  None

9、fromkeys的用法（快速创建字典）

l = ['name', 'age', 'sex']
dic = {}
dic = dic.fromkeys(l,None)
print(dic)

#打印结果  {'name': None, 'age': None, 'sex': None}

10、setdefault的用法（有则不动，返回原值。 无则添加，返回新值）

dic = {'name': 'zhangsan', 'age': 18}
res = dic.setdefault('name','lisi')
print(dic)
print(res)

#打印结果

{'name': 'zhangsan', 'age': 18}
zhangsan

dic = {'name': 'zhangsan', 'age': 18}
res = dic.setdefault('sex','male')
print(dic)
print(res)

#打印结果

{'name': 'zhangsan', 'age': 18, 'sex': 'male'}
male

总结：

① 可以存放多个值

② 字典是无序的，但是可以通过key取值

③ 字典是一个可变类型

集合（set）

用途：关系运算、去重

定义方式：在{}内用逗号分开的多个值

集合的三大特征：

　　每一个值都必须是不可变类型

　　元素不能重复

　　集合内元素无序

1、定义一个集合

s={1,3.1,'aa',(1,23),}
print(s, type(s))

#打印结果  {1, 3.1, 'aa', (1, 23)} <class 'set'>

2、集合去重

s={1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,3,4}
print(s)

#打印结果  {1, 2, 3, 4}

3、集合关系运算的使用（每个两种写法）

python={'李二丫','张金蛋','李银弹','赵铜蛋','张锡蛋','bob','kevin'}
linux={'lxx','jerry','张金蛋','张锡蛋','bob','陈独秀'}
#取报名python和linux课程的学员：并集
print(pythons & linuxs)
print(pythons.intersection(linuxs))

#打印结果  

{'张金蛋', 'alex', '张锡蛋'}
{'张金蛋', 'alex', '张锡蛋'}

# 取所有报名课程的学员:并集
print(pythons | linuxs)
print(pythons.union(linuxs))

#打印结果
{'bob', '陈独秀', '李银弹', '张金蛋', 'jerry', '李二丫', '赵铜蛋', 'lxx', 'kevin', '张锡蛋'}
{'bob', '陈独秀', '李银弹', '张金蛋', 'jerry', '李二丫', '赵铜蛋', 'lxx', 'kevin', '张锡蛋'}

　　

# 取只报名python课程的学员：差集
print(pythons - linuxs)
print(pythons.difference(linuxs))

#打印结果

{'李银弹', 'kevin', '李二丫', '赵铜蛋'}
{'李银弹', 'kevin', '李二丫', '赵铜蛋'}

# 取只报名linux课程的学员：差集
print(linuxs - pythons)
print(linuxs.difference(pythons))

#打印结果

{'jerry', 'lxx', '陈独秀'}
{'jerry', 'lxx', '陈独秀'}

# 取没有同时报名两门课程的学员：对称差集
print(pythons ^ linuxs)
print(pythons.symmetric_difference(linuxs))

#打印结果

{'陈独秀', '李二丫', 'jerry', '赵铜蛋', 'kevin', 'lxx', '李银弹'}
{'陈独秀', '李二丫', 'jerry', '赵铜蛋', 'kevin', 'lxx', '李银弹'}

4、判断两个集合是否相等

s1={1,2,3}
s2={3,1,2}
print(s1 == s2)

#打印结果  True      因为集合是无序的，所以改变写的顺序不会对集合产生影响

5、父集 

s1={1,2,3}
s2={1,2}
print(s1 >= s2)  # >=表示s1是否包含s2
print(s1.issuperset(s2))

#打印结果  True

6、子集

s1={1,2,3}
s2={1,2}
print(s2 <= s1)
print(s2.issubset(s1))

#打印结果  True

6、update的使用方法

s1={1,2,3}
s1.update({3,4,5})  # 把{3,4,5}更新到s1中，集合去重 print(s1)

#打印结果  {1, 2, 3, 4, 5}

7、pop使用方法

s1={1,2,3}
res=s1.pop()  
print(res)

#打印结果  1   #随机删除，因为集合是无序的

8、remove使用方法

s1={1,2,3}
res=s1.remove(3) #单纯的删除,返回值为None
print(s1)
print(res)

#打印结果

{1, 2}
None

9、add使用方法

s1={1,2,3}
s1.add(4)
print(s1)

#打印结果  {1, 2, 3, 4}

10、difference_update使用方法

s1={1,2,3}
s2={1,2}
s1.difference_update(s2) #s1=s1.difference(s2)
print(s1)

#打印结果  {3}
#difference_update() 方法用于移除两个集合中都存在的元素。
difference_update() 方法与 difference() 方法的区别在于 difference() 方法返回一个移除相同元素的新集合，
而 difference_update() 方法是直接在原来的集合中移除元素，没有返回值。

11、discard使用方法

s1={1,2,3}
res=s1.discard(3) ##单纯的删除,返回值为None
print(s1)
print(res)

#打印结果

{1, 2}
None

#s1.remove(4)  删除的元素不存在会报错

#s1.discard(4)  删除的元素不存在不会报错

12、isdisjoint使用方法（了解）

s1={1,2,3}
s2={1,2,4}
print(s1.isdisjoint(s2)) #如果两个集合没有交集则返回True

#打印结果  False



s1={1,2,3}
s2={4,5,6}
print(s1.isdisjoint(s2)) #如果两个集合没有交集则返回True

#打印结果  True

总结：

① 可以存放多个值

② 集合无序

③ set可变

注意：集合去重有一定的局限性：① 无法保证原数据类型的顺序  ② 当某一个数据中包含的多个值全部为不可变的类型时才能用集合去重