元组(tuple)
元组跟列表类似，只不过[ ]换成了( )，可以存多个值，但是不同的是元组本身不能被修改。(有序，不能变)
1.基本使用 tuple
作用：能存储多个元素，元素与元素之间逗号隔开，元素可以是任何类型，不过元素不能被修改
2.定义方式
在（）内用逗号分隔开多个任意类型的值
t = (1,2,3,\'xx\',(a,b,c),[1,2]) #t = tuple (1,2,3,\'xx\',(a,b,c),[1,2]) print (t,type(t)) t1 = tuple(\'hello\') #相当于直接将 hello加入到元组里 print (t1) #输出结果是(1,2,3,\'xx\',(a,b,c),[1,2],\'hello\')
3.优先要掌握的操作
1).按索引取值（正向取+反向取）：只能取
tuple = (1, \'hehe\', 15.00 ,666) >>> tuple[0] # 取第一个 1 >>> tuple[-1] # 取倒数第一个 666
2).切片（顾头不顾尾，步长）
t=(1,2,3,4,5) print(t[0:3]) #（1,2,3） print(t) #（1,2,3,4,5）
3).长度 len()
print(len(t))
4).成员运算 in 和 not in
>>> tuple = (1, \'hehe\', 15.00 ,666) >>> \'hehe\' in tuple True >>> \'hehe\' not in tuple Flase
5).循环
for item in (\'a\',\'b\',\'c\') print(item) #依次输出a b c
n = (\'a\')
n1 = (1)
print(type(n),type(n1)) #<class \'str\'> <class \'int\'>
#在定义容器类型的时候，哪怕内部只有一个元素，也要用逗号隔开以便区分
字典（dict）
1.用途：
记录多个值，每一个值都是对应的key来描述value的作用
2.定义方式
在{ }内用逗号隔开多个key：value值。其中value可以是任意类型，而key必须要是不可变类型。通常情况下是字符串（str).
name = {0:\'aa\',1:\'bb\',2:\'cc\'} #name = dict{0:\'aa\',1:\'bb\',2:\'cc\'}
print(type(name)) # <class.dict>
print(name[0]) # aaa
用法一： dic = dict(x=1,y=2,z=3) print(dic) #{\'x\': 1, \'y\': 2, \'z\': 3} 用法二 userinfo=[ [\'name\',\'egon\'], [\'age\',18], [\'sex\',\'male\'] ] d={ } for k,v in username: #k,v = [\'name\',\'egon\'] d[k]=v print(d)
3、需要优先掌握的操作
1).按key存取值：可存可取
dic={\'name\':\'li \'}
print(dic[\'name\']) # li
dic[\'name\']=\'LI\' #把LI赋值给name，将name中原先的值li挤了出来
print(dic) # {\'name\': \'LI\'},
dic[\'age\']=18 #赋值语句当key不存在是的情况下，会自动新增一个键值对
print(dic) # {\'name\': \'LI\', \'age\': 18}
2).长度len #统计的键值对的个数
dic={\'name\':\'egon\',\'age\':18,\'name\':\'EGON\',\'name\':\'XXXX\'}
print(dic) #{\'name\': \'XXXX\', \'age\': 18}
print(len(dic)) #2
注意：字典的key是不能重复的，要唯一标识的一条数据。如果重复了，只能按照最后一组重复的键值进行存储。
3).成员运算in和 not in 。对于字典来说只能判断key值
dic={\'name\':\'egon\',\'age\':18,}
print(18 in dic) #false
print(\'age\' in dic) #true 字典暴露给用户的只有key，其中value是隐藏的
4).删除
dic = {‘name’:\'li\',\'age\':18}
del:
del dic[\'name\']
print(dic) #{\'age\': 18}
del dic[\'xxx\'] #如果key不存在，则显示报错
.pop:#用于移除列表中的一个元素（如果不写就默认为最后一个元素），并且返回该元素的值value。
res=dic.pop(\'age\') #删除key对应的value后,并弹出所删的value
print(dic)#{\'name\': \'li\'}
print(res)#18
dic.pop(\'xxx\') #如果key不存在，则显示报错
.popitem()# 随机返回并删除字典中的最后一对键和值。
dic = {\'name\': \'li\', \'age\': 18, \'password\': 55}
res = dic.popitem()
print(dic)#{\'name\': \'li\', \'age\': 18}
print(res)#(\'password\', 55)
#如果字典已经为空，却调用了此方法，就会报出KeyError异常。
clear 清空列表，该方法没有返回值
5).键keys(),值values(),键值对items()
d1 = {\'name\':\'jason\',\'password\':123}
print(d1.keys()) # dict_keys([\'name\', \'password\'])#取出key值
for k in d1.keys():
print(k)
print(d1.values()) # dict_values([\'jason\', 123]) 现在就把它当成一个列表来看即可 ，取出value值
print(d1.items()) # dict_items([(\'name\', \'jason\'), (\'password\', 123)])
#把它看成是列表套元组，元组的第一个元素是字典的key 第二个元素是字典的value。
6).get() 根据key获取value
d = {\'name\':\'li\' , \'pwd\':123}
print(d(name))
print((age))
res = d.get(\'age\') # 当字典的key不存在的情况 不报错 返回None
res1 = d.get(\'xxx\',\'你给我的age在字典的key中\') # 当字典的key不存在的情况 不报错 返回None
#get可以传第二个参数。当你的key不存在的情况下，返回第二个你写好的参数信息
print(resl)
print(d1.get(\'xxx\',\'asdsad\'))
#第二个参数不写的话 当key不存在的情况下返回None，写了就返回写了内容
7).fromkeys() 快速创建一个字典
语法为dict.fromkeys(seq[,value]) ，其中序列seq中的元素做字典的键，value为字典所有键对应的初始值。
l1 = [\'name\',\'password\',\'age\',\'hobby\'] print(dict.fromkeys(l1,123)) #{\'name\': 123, \'password\': 123, \'age\': 123, \'hobby\': 123}
8).setdefault
d1 = {\'name\':\'li\',\'pwd\':123}
res1 = d1.setdefault(\'name\',\'xxoo\') # 当键存在的情况下 不修改值 并且将原先key对应值返回给你
print(d1,res1) #{\'name\': \'li\', \'pwd\': 123} li
res2 = d1.setdefault(\'age\',18) # 当键不存在的情况下 新增一个键值对 并且将新增的键值对的值返回给你
print(d1,res2) #{\'name\': \'li\', \'pwd\': 123, \'age\': 18} 18
9).update 可以更新字典中的键/值对，可以修改存在的键对应的值，也可以添加新的键/值对到字典中
d1 = {\'name\':\'li\',\'pwd\':123}
d2 = {"age":18} #添加
d1.update(d2)
d1[\'age\'] = 18
d1.update(age=666) #字典更新
print(d1) #{\'name\': \'jason\', \'pwd\': 123, \'age\': 666}
集合（set）
1.定义
可以包含多个元素，用逗号分开.
2.作用
集合、列表、字典、字符串一样都可以存放多个值，但是集合的主要作用：去重，关系运算。
3.定义
在{ }内用逗号分隔开多个元素，集合具备以下三个特点：
1）.每个元素必须是不可变类型
2）.没有重复的元素，因为在集合中，print会自动将重复的数去掉
3）.集合内的元素无序
s = {1,2,3,4,5} #s = {1,2,3,4,5} print(type(s)) #<class \'set\'> s1 = set() print(type(s1)） #在定义空集合是只能用关键字set x = {} #如果输入的仅仅是一个大括号，那么python默认将它当做字典类型 print(type(x)) # # <class\'dict\'> t = 0 #如果输入的仅仅是一个大括号，那么python默认将它当做元组类型 print(type(t)) #<class\'tuple\'>
注意：集合的目的是讲不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值。
4.集合的使用
1）.关系运算
friends1 = {"a","b","c","f"}
friends2 = {"a","b","c","d","e"}
# 1.合集(|)：求两个用户所有的好友（重复好友只留一个）
>>> friends1 | friends2
# 2.交集(&)：求两个用户的共同好友
>>> friends1 & friends2
# 3.差集(-)：
>>> friends1 - friends2 # 求用户1独有的好友
>>> friends2 - friends1 # 求用户2独有的好友
# 4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）
>>> friends1 ^ friends2
# 5.值是否相等(==)
>>> friends1 == friends2
# 6.父集：一个集合是否包含另外一个集合
# 6.1 包含则返回True
>>> {1,2,3} > {1,2}
True
>>> {1,2,3} >= {1,2}
True
# 6.2 不存在包含关系，则返回True
>>> {1,2,3} > {1,3,4,5}
False
>>> {1,2,3} >= {1,3,4,5}
False
# 7.子集
>>> {1,2} < {1,2,3}
True
>>> {1,2} <= {1,2,3}
True
2）.去重
集合去重复具有局限性。
#1.只能针对不可变类型 #2.集合本身就是无序的，去重之后无法保留原来的顺序
可变类型与不可变类型
可变数据类型：值发生改变时，内存地址不变，即id不变，证明在改变原值。
不可变类型：值发生改变时，内存地址也发生改变，即id也变, 证明是没有在改变原值，而是产生了新的值。