字典的内置方法
定义方式
d = {'usernamne':"kevin"}
定义空字典：d = {}
1.key取值
dic = {'name': 'kevin', 'age': 18, 'hobbies': ['play game', 'basketball']}
print(dic['name']) # kevin
print(dic['hobbies']) # ['play game', 'basketball']
print(dic['hobbies'][1]) # basketball
2.赋值操作
{'name': 'jack', 'age': 18, 'hobbies': ['play game', 'basketball']}
dic['name'] = 'kevin' # {'name': 'kevin', 'age': 18, 'hobbies': ['play game', 'basketball']}
dic['gender'] = 'male' # 字典：当K存在的时候，就是修改操作，当k不存在的时候，就是增加一个key值 (重要)
# print(dic)
# dic1 = {'name': 'yyy'}
# dic1['name'] = 'xxx'
# dic1['age'] = 'aaaa'
# dic1['gender'] = 'xxx'
# print(dic1)
# print(len(dic1)) # 3
3. 成员运算符 in 和 not in
d = {'username':'kevin', 'age':18}
print('kevin' in d) # False
print('username' in d) # True
print('username' not in d) #False
4. 删除
d = {'username':'kevin', 'age':18}
d.pop('username') # {'age': 18} 字典删除k值必须写上要删除的key值，不能通过索引删除值
del d['username'] # {'age': 18}
print(d)
5. 键keys（），值values（），键值对items（）三剑客
d = {'username': 'kevin', 'age': 18}
print(d.keys()) # dict_keys(['username', 'age']) # 把它当成列表来记忆，把字典的所有key拿出来，组装成列表返回
print(d.values()) # dict_values(['kevin', 18]) # 把它当成列表来记忆，把字典的所有value值拿出来，组装成列表返回
# 返回的是列表套元组的形式，列表里面是一个个的小元组，元组里面是字典的k和v
print(d.items()) # dict_items([('username', 'kevin'), ('age', 18)])
6.循环
d = {'username': 'kevin', 'age': 18}
for i in d.keys():
print(i)
#
for j in d.values():
print(j)
d.items()----->dict_items([('username', 'kevin'), ('age', 18)])
for items in d.items():
# items是元组啊
print(items) # ('username', 'kevin')
print(items) # ('age', 18)
print(items[0], items[1])
for dic in d:
print(dic) # 暴露的是k值
字典的其他方法
1. get
d = {'username': 'jack', 'age': 18}
print(d['username'])
print(d['username1']) # 字典取值，如果key不存在，直接报错
print(d.get('username')) # jack
print(d.get('username1')) # None 如果使用get取值，key存在，则直接取出对应的值，如果key不存在，返回None
if d.get('username1'):
print('有值')
else:
print('无值')
'''以后字典取值最好使用get取值，不会直接报错'''
print(d.get('username', 'xxx')) # jack
print(d.get('username1', 'xxx')) # xxx, get可以传递第二个参数，意思是默认值，当取出的key不存在的时候，直接返回第二个参数的值
d = {'username': 'jack', 'age': 18, 'gender':'male'}
# popitem
print(d.popitem()) # ('age', 18) ('gender', 'male')
print(d) # {'username': 'jack'} {'username': 'jack', 'age': 18}
'''代表的是删除字典的元素。但是，删除的值末尾的k：v，并且把最后一个k：v弹出来了'''
2. update
d = {'username': 'jack', 'age': 18, 'gender': 'male'}
'''update的功能是：如果字典的k存在，则修改原来的k，如果不存在，则添加一个新值'''
d1 = {'username': 'tank', 'hobbys': ['read', 'music']}
d.update(d1)
print(d) # {'username': 'tank', 'age': 18, 'gender': 'male', 'hobbys': ['read', 'music']}
3. fromkeys(了解)
dic = dict.fromkeys(['k1','k2','k3', 'k4'],[]) # 相当于是给字典批量赋值
print(dic) # {'k1': [], 'k2': [], 'k3': []}
'''使用fromkeys初始化出来的值，占用的是一样的内存地址，有一个值改变了，其他值跟着改变'''
dic['k1'].append(666) # {'k1': [666], 'k2': [666], 'k3': [666], 'k4': [666]}
dic['k2'].append(999) # {'k1': [666, 999], 'k2': [666, 999], 'k3': [666, 999], 'k4': [666, 999]}
dic['k3'].append(888) # {'k1': [666, 999, 888], 'k2': [666, 999, 888], 'k3': [666, 999, 888], 'k4': [666, 999, 888]}
print(dic)
4. setdefault
dic = {'k1': 111, 'k2': 222}
res = dic.setdefault('k3', 333) # {'k1': 111, 'k2': 222, 'k3': 333}
res = dic.setdefault('k3', 333) # {'k1': 111, 'k2': 222, 'k3': 333}
print(dic)
print(res) # 333
# key不存在则新增键值对，并将新增的value返回
# key存在则不做任何修改，并返回已存在key对应的value值
元组的内置方法
定义
使用小括号括起来，内部存放多个元素，元素之间逗号个隔开，元素值不支持修改(索引对应的那个元素不能修),不可变的列表。
1. 类型转换
print(tuple('hello')) # ('h', 'e', 'l', 'l', 'o')
print(tuple((1, 2, 3, 4))) # (1, 2, 3, 4)
print(tuple([1, 2, 3, 4, 5])) # (1, 2, 3, 4, 5)
print(tuple({'a': 1, 'b': 2})) # ('a', 'b')
print(tuple({1, 2, 3, 4})) # (1, 2, 3, 4)
2. 索引取值
t = (1, 2, 3, 4) print(t[0]) print(t[1]) print(t[2]) # 索引取值，索引从0开始 print(t[-1]) print(t[-2]) # 负数代表的就是方向
3. 切片
t = (1, 2, 3, 4) print(t[0:2]) # (1, 2) print(t[0:]) # (1, 2) print(t[:2]) # (1, 2) print(t[0:3:2]) # (1, 2)
4. 求长度
t = (1, 2, 3, 4) print(len(t))
5. 成员运算 in 和 not in
tup = (1, 2, 3, 4, 5, 6, ) print(1 in tup) # True
6. 循环
tup = (1, 2, 3, 4, 5, 6, )
for i in tup:
print(i)
7. 单一元素元组
'''当元组内只有一个元素的时候，也要加上逗号结尾，否则不是元组类型！'''t = (123, )
'''建议：
只要是容器类型，当元素只有一个的时候，建议都加上逗号
容器类型：
只要是能够存放多个元素的数据类型都可以称之为是容器类型
'''
集合的内置方法
定义：
使用大括号括起来，内部存放多个元素，元素之间逗号隔开，不是k:v键值对的形式
s = {1, 2, 3, 4}
集合功能：
去重、集合运算、无序
1. 类型转换
# 空集合
set（）
print(set(123)) 不行
print(set(123.1)) 不行
print(set('hello')) # {'e', 'o', 'l', 'h'}
print(set([1, 2, 3, 4, 4, 3, 2, 1])) # {1, 2, 3, 4}
print(set((1, 2, 3, 4, 5))) # {1, 2, 3, 4, 5}
print(set({'username': 'kevin', 'age': 28})) # {'age', 'username'}
'''集合能够把支持for循环的数据类型都转为集合类型!'''
练习：
name_list = ['kevin', 'tank', 'tony', 'tony', 'jack', 'jack', 'jack', 'tony', 'ly',]
# 基本要求：去重
print(set(name_list)) # {'tank', 'jack', 'kevin'}
# 再次转为列表
print(list(set(name_list))) # ['kevin', 'tank', 'jack']
#### 拔高要求
# 去重，并且保留原来的顺序
new_list = [] # 用来存放取出之后的元素
for name in name_list:
# name----->列表的一个个元素
if name not in new_list:
new_list.append(name)
print(new_list) # ['kevin', 'tank', 'tony', 'jack', 'ly']
2. 集合的关系运算
friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们
friends2 = {"Jy","ricky","jason","egon"} # 用户2的好友们
1.合集/并集（|）：求两个用户所有的好友（重复好友只留一个）
print(friends1 | friends2) # {'zero', 'kevin', 'ricky', 'Jy', 'jason', 'egon'}
2. 交集（&）：求两个用户的共同好友
print(friends1 & friends2) # {'jason', 'egon'}
3. 差集（-）
print(friends1 - friends2) # {'kevin', 'zero'}
print(friends2 - friends1) # {'Jy', 'ricky'}
4. 对称差集（^）：求两个用户独有的好友们（即去掉共有的好友）
print(friends1 ^ friends2)
5. 值是否相等（==）
print(friends1 == friends2) # False
6. 父集（>=）:一个集合是否包含另外一个集合
print({1, 2, 3} >= {1, 2, 3}) # True
7. 子集（<）:一个集合是否被另外一个集合包含
print({1, 2, 3} < {1, 2}) # False
8.集合练习题
一.关系运算
有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
pythons={'ly','qq','kevin','ricky','gangdan','biubiu'}
linuxs={'kermit','tony','gangdan'}
1. 求出即报名python又报名linux课程的学员名字集合
2. 求出所有报名的学生名字集合
3. 求出只报名python课程的学员名字
4. 求出没有同时这两门课程的学员名字集合
"""
# 求出即报名python又报名linux课程的学员名字集合
>>> pythons & linuxs
# 求出所有报名的学生名字集合
>>> pythons | linuxs
# 求出只报名python课程的学员名字
>>> pythons - linuxs
# 求出没有同时这两门课程的学员名字集合
>>> pythons ^ linuxs
3. 内置方法
1. 长度（len）
s={'a','b','c'}
len(s)
2. 成员运算（in not in）
s = {1, 2, 3, 4, }
print(1 in s)
# True
3. 循环
for item in s:
print(item)
标签：username,day08,python,18,age,元组,print,dic,kevin From： https://www.cnblogs.com/zfq132/p/17421708.html