元组字典集合

一、元组 tuple 不可变

 

 

1.#作用：能够存储多个元素，元素与元素之间逗号隔开  元素可以是任意类型,元组不能被修改

2.#定义：与列表类型比，只不过[]换成()
age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55))

# t1 = tuple(1)  # 报错  必须传容器类型
# n = ('a')
# n1 = (1)
# print(type(n),type(n1))  # <class 'str'>  <class 'int'>
# 在定义容器类型的时候，哪怕内部只有一个元素，你也要用逗号隔开 区分一下（******）

#优先掌握的操作：

#1、按索引取值(正向取+反向取)：只能取
#2、切片(顾头不顾尾，步长)
#3、长度
#4、成员运算in和not in
#5、循环

1、按索引取值(正向取+反向取)：只能取，不能改不能删

t = (1, 2, 3, 'a', 'b', [1, 2, 3])
print(t[0])
# t[1] = 'hahah'  #报错 不能修改
# t[-1] = 'hahaha'  #报错 不能修改
t[-1][0] = '我改了'  # (1, 2, 3, 'a', 'b', ['我改了', 2, 3])  元组不能改但是内部的可变数据的值可以改
print(t)

# del t[0]  #报错 不能删除

t2 = (1,2,3,4,[1,2])
print(id(t2))  #5308928
t2[-1].append(666)
print(t2)   #(1, 2, 3, 4, [1, 2, 666])
print(id(t2))  #5308928  列表为可变类型，即使值改变，id也可能不改变，赋值情况下id不变，因此元组id也不改变

2、切片(顾头不顾尾，步长)

print(t[0:4:2]) #索引+步长

3、长度

 print(len(t))

4、成员运算in和not in

 print('a' in t)

5、循环

 for i in t:
     print(i)

二、字典  可变类型

 

 

1.作用：能存存储多组 key:value键值对  key是对value的描述  key通常情况下都是字符串
2. 其实这个key只能是不可变类型一般都是字符串,value可以是任意数据类型

3.强调:字典的key是不能重复的 要唯一标识一条数据， 如果重复了 只会按照最后一组重复的键值对存储
4.定义：
 d = {'name':'jason','password':123}  # d = dict( {'name':'jason','password':123})

#定义字典的三种方式

1.第一种：
#d1 = {'name':'jason','password':123}
2.第二种：
#d2 = dict(name='jason',password=123,age=18)  # (******)
print(d2,type(d2))
 

第三种：（了解）
l = [
    ['name','jason'],
    ['age',18],
    ['hobby','read']
]
d = {}
for i in l:  # ['name','jason'],['age',18]...
    d[i[0]] = i[1]
print(d)

for k,v in l:  # ['name','jason'],['age',18]...
    d[k] = v 
print(d)

d3 = dict(l)
print(d3)

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

 # 赋值语句当key不存在的情况下，会自动新增一个键值对(******)

#取
d3 = {'name':'jason','password':'123'}
print(id(d3))  #jason
print(d3['name'])  #31175592  但是此方法key不存在会报错，一般不用，统一使用下面的.get（key，提示信息）

#存
d3['age'] = 18  # 赋值语句当key不存在的情况下，会自动新增一个键值对(******)
print(d3,id(d3))  #{'name': 'jason', 'password': '123', 'age': 18}   #31175592  字典为可变类型，重新赋值后id不变

for循环取值

 

2、长度len

 统计的键值对的个数

3、成员运算in和not in 对于字典来说只能判断key值

4、删除

d3 = {'name':'jason','password':'123'}
del d3['name']
print(d3)  #{'password': '123'}

res = d3.pop('name')  #   jason 弹出仅仅是value
res = d3.pop('age')  # 当键不存在的时候直接报错
print(res)
print(d3)

d3.clear()
print(d3)  #{}

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

d1 = {'name':'jason','password':123}
print(d1.keys())  # dict_keys(['name', 'password'])  老母猪
for k in d1.keys():
    print(k)  #name   password
print(d1.values())  # dict_values(['jason', 123])  老母猪  现在就把它当成一个列表来看即可

print(d1.items())  # dict_items([('name', 'jason'), ('password', 123)])
# 就把它看成是列表套元组，元组的第一个元素是字典的key 第二个元素是字典的value
#python2中都是直接输出一个列表，比较占用内存

6.get()根据key获取value（******）推荐使用d.get('key',提示信息')，不要用常规d['key']

# get可以传第二个参数。当你的key不存在的情况下，返回第二个你写好的参数信息
# 第二个参数不写的话 当key不存在的情况下返回None，写了就返回写了内容

1.常规Key取值 找不到会报错
1 = {'name':'jason','pwd':123}
print(d1['name'])  # 正常取值
print(d1['age'])  #会报错
2.get 取值  不会报错还能返回提示信息  
print(d1.get('name','你给我的name在字典的key中'))  #jason
res = d1.get('age')  #  None  当字典的key不存在的情况 不报错 返回None
res1 = d1.get('xxx','找不到')  #找不到

7.dict.fromkeys() 快速的创建一个字典

l1 = ['name','password','age','hobby']
print(dict.fromkeys(l1,123))  #{'name': 123, 'password': 123, 'age': 123, 'hobby': 123}

面试题(******)  指定的多个key指向同一块内存同一个值，想给key赋不同的值必须一个一个赋值
res = {}.fromkeys(['name','password','age'],[])
print(res)  # {'name': [], 'password': []}

res['name'].append('jason')  #三个key都指向一个内存即定义的那个空列表，append在空列表中添加值后其他key也指向该内存空间
print(res)  #{'name': ['jason'], 'password': ['jason'], 'age': ['jason']}

print(id(res['name']),id(res['password'])) #  31912392 31912392  id一模一样 

res['name'] = 666  #赋值相当于另外开辟一片内存空间，与其他两个key不再公用一个和空间一个值
print(res)  #{'name': 666, 'password': ['jason'], 'age': ['jason']}

 

8.dict.popitem() 尾部以元组的形式弹出键值对（类似列表的pop尾部弹出整个键值对，字典的pop可以指定key弹出）

d1 = {'name': 'jason', 'pwd': 123}
print(d1.popitem())  # ('pwd', 123)  

9.setdefault() 取出K的值或者添加一个k-v键值对（key有重复的不修改原值，没有就添加新的键值对）

d1 = {'name':'jason','pwd':123}
res1 = d1.setdefault('name','xxoo')  #   当键存在的情况下 不修改值 并且将原先key对应值返回给你
print(d1,res1)   #{'name': 'jason', 'pwd': 123} jason
res2 = d1.setdefault('age',18)  # 当键不存在的情况下 新增一个键值对 并且将新增的键值对的值返回给你
print(d1)  #{'name': 'jason', 'pwd': 123, 'age': 18}

10.dict.update()往字典中添加k-v键值对（key有重复的重新赋值，没有就添加新的键值对（通常哪里都是这尿性除了上面的setdefault））

d1 = {'name':'jason','pwd':123}
d2 = {"age":18，'name':'我变了'}

第一种  直接添加单个 d1['age'] = 18   #{'name': 'jason', 'pwd': 123, 'age': 18} 直接添加

第二种 方法添加单个或多个 d1.update(age=666)  #{'name': 'jason', 'pwd': 123, 'age': 666}  调用方法直接添加一个或者多个 

第三种 方法添加整个字典 d1.update(d2) #{'name': '我变了', 'pwd': 123, 'age': 18} 合并字典，有重复的重新赋值，没有就添加新的键值对

 print(d1)

三、集合 set

 

 

1.作用：去重，关系运算(共同好友，好友点赞) 

2.定义：可以包含多个元素，用逗号分割，加{}
# s = {1,2,3,4,5,6}  # <class 'set'>  # s = set()

3.注意在定义空集合的只能用关键字set， 如果你仅仅只写了一个大括号 那么python默认将它当做字典类型
 s1 = set()
 print(type(s1))  #<class 'set'> 
 x = {}   
# print(type(x))  # <class 'dict'> 

1.集合的元素遵循三个原则：

1：每个元素必须是不可变类型
   
ps:# 可变:不可hash
   # 不可变:可hash
s = {1,2,3,4,5,6,'a',(1,2),[1,2]}  #  unhashable type: 'list' 报错
s = {1,2,3,4,5,6,'a',(1,2),{"name":'jason'}}  #   unhashable type: 'dict' 报错

2: 没有重复的元素
s = {1,2,2,2,2,2,2,2,2,2,3,4,4,4,4,4,5}
 print(s)  # 自动将重复的元素 去除

3：无序

# 注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值

2.优先掌握的方法

1、长度len
2、成员运算in和not in
3、| 合集
4、& 交集
5、- 差集
6、^ 对称差集
7、==
8、父集：>,>=

9、子集：<,<=

pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}
# 既报名python也报名linux的学生姓名
print(pythons & linux)  # 交集

# 只报名python的学生姓名
print(pythons - linux)

# 只报名linux的学生姓名
print(linux - pythons)

# 没有同时报名两门课程,只报了一门的学生姓名
print(pythons ^ linux)  # 对称差集

# 取出所有报了名的学生姓名
print(pythons | linux)

3.需要了解的方法

s.clear()  #全部清除
s.remove()# 指定要删除的值，返回是None
s.update()   #添加元素
s.add()  #添加元素或者容器类型整体

四、总结

可变：list dict set集合
不可变 int float str tuple元组 bool

 

转载于:https://www.cnblogs.com/xp1315458571/p/11134153.html