字典的内置方法(定义方式、按key存取值：可存可取、删除等)、字典的其它操作等、元组的内置方法、集合(类型转换和集合的功能、关系运算)

一、字典的内置方法

1.定义方式

'''
1.定义方式:在{}内用逗号分隔开多元素，
每一个元素都是key:value的形式，其中value可以是任意类型，
而key则必须是不可变类型，通常key应该是str类型，因为str类型会对value有描述性的功能
'''
d = {'username': 'kevin'}
print(d)  # {'username': 'kevin'}
# 定义空字典
d = {}
print(d)  # {}
# 2.也可以这么定义字典
info = dict(name='tony', age=18, sex='male')
print(info)  # {'name': 'tony', 'age': 18, 'sex': 'male'}

2.按key存取值：可存可取

dic = {
   'name': 'xxx',
   'age': 18,
   'hobbies': ['play game', 'basketball']
}
# 2.1 取
print(dic['name'])  # xxx
print(dic['hobbies'])  # ['play game', 'basketball']
print(dic['hobbies'][1])  # basketball
# 2.2 赋值操作：当K存在的时候，就是修改操作；当K不存在的时候，就是增加一个key值(重要)
dic['name'] = 'kevin'
print(dic)  # {'name': 'kevin', 'age': 18, 'hobbies': ['play game', 'basketball']}
dic['gender'] = 'male'
print(dic)  # {'name': 'kevin', 'age': 18, 'hobbies': ['play game', 'basketball'], 'gender': 'male'}
# 2.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

3.删除：字典删除K值，必须要写上要删除的key值，不能通过索引删除值

d = {'username': 'kevin', 'age': 18, 'gender': 'male'}
d.pop('username')
print(d)  # {'age': 18, 'gender': 'male'}
del d['gender']
print(d)  # {'age': 18}

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

# 键keys()，值values()，键值对items()
d = {'username': 'kevin', 'age': 18, 'gender': 'male'}
# 1.键keys() 把它当成列表记忆，把字典的key拿出来，组装成列表返回
print(d.keys())  # dict_keys(['username', 'age', 'gender'])
# 2.值values() 把它当成列表记忆，把字典的value拿出来，组装成列表返回
print(d.values())  # dict_values(['kevin', 18, 'male'])
# 3.键值对items() 返回的是列表套元组的形式，列表中是一个个小元组，元组中是字典的K的V
print(d.items())  # dict_items([('username', 'kevin'), ('age', 18), ('gender', 'male')])

# 循环取key值
for i in d.keys():
    print(i)
# 循环取value值
for i in d.values():
    print(i)
# # 注意：items是元组
for items in d.items():
    print(items)

5.字典的其它操作

5.1 get() 若使用get取值，key存在，直接取出对应的值，若key不存在，返回None

d = {'username': 'kevin', 'age': 18, 'gender': 'male'}

print(d['username'])  # kevin
# print(d['username1'])  # 字典取值，若key不存在，直接报错：KeyError: 'username1'
print(d.get('username'))  # kevin
print(d.get('username1'))  # None
if d.get('username'):
    print('有值')
else:
    print('无值')

'''
    以后字典取值最好使用get取值，不会直接报错
    注意：get取值可以传递第二个参数，意思是默认值，
        当取出的key不存在的时候，直接返回第二个参数的值
'''
print(d.get('username', 'xxx'))  # 
print(d.get('username1', 'xxx'))  # xxx

5.2 pop() 删除指定的key对应的键值对,并返回值

d = {'username': 'kevin', 'age': 18, 'gender': 'male'}
print(d.pop('username'))  # kevin
print(d)  # {'age': 18, 'gender': 'male'}

5.3 popitem() 随机删除一组键值对,并将删除的键值放到元组内返回

d = {'username': 'kevin', 'age': 18, 'gender': 'male'}
print(d.popitem())  # ('gender', 'male')
print(d)  # {'username': 'kevin', 'age': 18}

5.4 update() 若字典的K存在就修改原值，若K不存在则添加一个新的值

d = {'username': 'kevin', 'age': 18, 'gender': 'male'}
dic = {'username': 'tank', 'hobbies': ['read', 'music', 'write']}
d.update(dic)
print(d)  # {'username': 'tank', 'age': 18, 'gender': 'male', 'hobbies': ['read', 'music', 'write']}

5.5fromkeys() 和 setdefault()

'''
    使用fromkeys()初始化出来的值，
    占用的是一样的内存地址，有一个值改变了，其它的值跟着就改变
'''
# 5.5 fromkeys()
dic = dict.fromkeys(['k1', 'k2', 'k3', 'k4'], [])  # 相当于给字典批量赋值
print(dic)  # {'k1': [], 'k2': [], 'k3': [], 'k4': []}

dic['k1'].append(666)
print(dic)  # {'k1': [666], 'k2': [666], 'k3': [666], 'k4': [666]}
dic['k1'].append(999)
print(dic)  # {'k1': [666, 999], 'k2': [666, 999], 'k3': [666, 999], 'k4': [666, 999]}
dic['k1'].append(888)
print(dic)  # {'k1': [666, 999, 888], 'k2': [666, 999, 888], 'k3': [666, 999, 888], 'k4': [666, 999, 888]}


# 5.6 setdefault()
dic = {'k1': 111, 'k2': 222}
res = dic.setdefault('k3', 333)  # key不存在则新增键值对，并将新增的value返回
print(dic)  # {'k1': 111, 'k2': 222, 'k3': 333}
print(res)  # 333

二、元组的内置方法

1.定义

    使用小括号括起来，内部存放多个元素，元素之间逗号个隔开，
元素值不支持修改(索引对应的那个元素不能修),不可变的列表

2.类型转换

# 元组转换成字符串
print(tuple('hello'))  # # 转换成字符串
# 元组转换成元组
print(tuple((1, 2, 3, 4)))  # (1, 2, 3, 4)
# 列表转换成元组
print(tuple([1, 2, 3, 4]))  # (1, 2, 3, 4)
# 字典转换成元组
print(tuple({'username': 'kevin', 'age': 18}))  # ('username', 'age')
# 集合转换成元组
print(tuple({1, 2, 3, 4}))  # (1, 2, 3, 4)

3.取值与切片

# 取值
t = (1, 2, 3, 4)
print(t[0])
print(t[1])
print(t[-1])
print(t[-2])

# 切片
print(t[0:2])  # (1, 2)
print(t[0:])  # (1, 2, 3, 4)
print(t[:2])  # (1, 2)
print(t[::2])  # (1, 3)

4.长度、成员运算、循环

# 长度
t = ('jack', 'tony', 1, 2, [1, 2, 3])
print(len(t))  # 5

# 成员运算 in和not in
print('haha' in t)  # False
print('haha' not in t)  # True

# 循环
for line in t:
    print(line)

*************************************
t1 = (123)
t2 = (12.3)
t3 = (1)
t4 = (123,)
print(type(t1))  # <class 'int'>
print(type(t2))  # <class 'float'>
print(type(t3))  # <class 'int'>
print(type(t4))  # <class 'tuple'>

'''
    当元组内只有一个元素的时候，也要加上逗号结尾，否则不是元组类型
    建议：
        只要是容器类型，当元素只有一个的时候，建议都加上逗号
    容器类型：
        只要是能够存放多个元素的数据类型都可以称之为容器类型
'''
lst = [1, ]
print(type(lst))  # <class 'list'>

三、元组的内置方法

"""
定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：
     1：每个元素必须是不可变类型
     2：集合内没有重复的元素
     3：集合内元素无序
"""
s = {1,2,3,4}  # 本质 s = set({1,2,3,4})

# 注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，
# 而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，
# 而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。

# 注意2:{}既可以用于定义dict，也可以用于定义集合，
# 但是字典内的元素必须是key:value的格式，
# 现在我们想定义一个空字典和空集合，该如何准确去定义两者?
d = {} 		# 默认是空字典 
s = set()   # 这才是定义空集合

四、集合

1.类型转换和集合的功能：去重、集合运算、无序

# 集合的定义：
定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：
     1：每个元素必须是不可变类型
     2：集合内没有重复的元素
     3：集合内元素无序

# 集合能够把支持for循环的数据类型都转换为集合类型
print(set('123'))  # {'2', '3', '1'}
print(set('hello'))  # {'h', 'e', 'o', 'l'}
print(set([1, 2, 3, 4]))  # {1, 2, 3, 4}
print(set((1, 3, 5, 7)))  # {1, 3, 5, 7}
print(set({'username': 'kevin', 'age': 18, 'gender': 'male'}))  # {'username', 'gender', 'age'}


"""课堂练习1："""
s = {1, 2, 3, 4, 4, 3, 2, 23, 534, 65, 76, 78, 43, 324, }
print(s)

name_list = ['kevin', 'tank', 'tony', 'tony', 'jack', 'jack', 'jack', 'tony', 'ly', ]
# 基本要求：去重
print(set(name_list))  # {'tank', 'tony', 'jack', 'kevin', 'ly'}

# 再次转为列表
print(list(set(name_list)))  # ['ly', 'tank', 'jack', 'tony', 'kevin']

# 去重并且保留原来的顺序
new_list = []
for name in name_list:
    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)  # {'jason', 'egon', 'kevin', 'ricky', 'Jy', 'zero'}

# 2. 交集(&)：求两个用户的共同好友
print(friends1 & friends2)  # {'jason', 'egon'}

# 3.差集(-)：
print(friends1 - friends2)  # {'zero', 'kevin'}
print(friends2 - friends1)  # {'ricky', 'Jy'}

# 4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）
print(friends1 ^ friends2)  # {'Jy', 'zero', 'ricky', 'kevin'}

# 5.值是否相等(==)
print(friends1 == friends2)  # False

# 6.父集：一个集合是否包含另外一个集合
# 6.1 包含则返回True
print({1, 3, 2} >= {1, 2, 3})  # True

# 6.2 不存在包含关系，则返回False
print({1, 2, 3} < {1, 2})  # False

# 7.子集
print({1, 2} <= {1, 2, 3})  # True

集合运算练习题

# 练习题
l = ['a', 'b', 1, 'a', 'a']
s = set(l)
print(s)  # {1, 'a', 'b'}

# 针对不可变断类型，并且保证顺序则需要我们自己写代码实现，例如
l = [
    {'name': 'lili', 'age': 18, 'sex': 'male'},
    {'name': 'jack', 'age': 73, 'sex': 'male'},
    {'name': 'tom', 'age': 20, 'sex': 'female'},
    {'name': 'lili', 'age': 18, 'sex': 'male'},
    {'name': 'lili', 'age': 18, 'sex': 'male'},
]
new_l = []
for dic in l:
    if dic not in new_l:
        new_l.append(dic)
print(new_l)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
"""
[
    {'age': 18, 'sex': 'male', 'name': 'lili'},
    {'age': 73, 'sex': 'male', 'name': 'jack'},
    {'age': 20, 'sex': 'female', 'name': 'tom'}
]
"""

3.长度、成员运算、循环

s = {'a', 'b', 'c', 'd'}
# 3.1 长度
print(len(s))

# 3.2 成员运算
print('c' in s)

# 3.3 循环
for item in s:
    print(item)