目录
一、字典的内置方法
1、类型转换（把其他类型转换成自己的类型）
与之前的数据类型相同，字典的转换方法就是dict()。但是字典的转换条件很苛刻，只有以下两种情况下的字符串可以用于转换，所以通常我们都是自己定义。
两种转换形式：
# 转换方法一：
nfo = dict([['name', 'tony'], ('age', 18)])
# 如果我们想用dict方法转换字典，需要在括号内建立一个列表并在列表内建立两个列表分别放入键（key）和值（value），否则就报错。
print(nfo) # 输出结果：{'name': 'tony', 'age': 18}
# 转换方法二：fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中
nfo1 = {}.fromkeys(('name', 'age', 'sex'), None)
print(nfo1) # 输出结果：{'name': None, 'age': None, 'sex': None}
2、取值
第一种方法：
我们可以通过键（key）取值，但是我们需要注意，如果没有这个键（key），就会直接报错。
user_dict = {
'username': 'jason',
'password': 123,
'hobby': ['read', 'music', 'run']
}
print(user_dict['username']) # jason
print(user_dict['phone']) # k不存在会直接报错
第二种方法：
我们也可以通过使用.get方法来取值，如果没有这个键，默认会返回None，也可以自己定义返回值，不会报错。
user_dict = {
'username': 'jason',
'password': 123,
'hobby': ['read', 'music', 'run']
}
print(user_dict.get('username')) # jason
print(user_dict.get('age')) # None
# get方法可以有两个参数，第一个参数用于查找键（key），第二个参数用于在找不到的情况下给出提示
print(user_dict.get('username', '没有哟 嘿嘿嘿')) # jason 键存在的情况下获取对应的值
print(user_dict.get('phone', '没有哟 嘿嘿嘿')) # 键不存在默认返回None 可以通过第二个参数自定义
3、修改数据值
由于字典是无序的，我们要通过键来修改值。
user_dict = {
'username': 'jason',
'password': 123,
'hobby': ['read', 'music', 'run']
}
user_dict['username'] = 'java'
print(user_dict)
# 结果如下：{'username': 'java', 'password': 123, 'hobby': ['read', 'music', 'run']}
4、增加数据值
字典中增加新的值不需要使用方法，依旧是输入键和值，如果键存在的时候，就是修改值，如果键不存在，就是新增值。
user_dict = {
'username': 'jason',
'password': 123,
'hobby': ['read', 'music', 'run']
}
user_dict['language'] = 'java'
print(user_dict)
# 结果如下：{'username': 'jason', 'password': 123, 'hobby': ['read', 'music', 'run'], 'language': 'java'}
append方法
需要字典的值都是列表才能使用
# 这里的append方法其实和根据键增加值是一样的效果
user_test = {'name':[1],'pwd':[1],'hobby':[1]}
user_test['name'].append('jason')
user_test['pwd'].append(123)
user_test['hobby'].append('study')
print(user_test)
# 结果如下：{'name': [1, 'jason'], 'pwd': [1, 123], 'hobby': [1, 'study']}
从代码中我们可以得出结论，当字典的值是可变类型的时候，可以使用append方法加入值，当值为列表的时候会加在列表末尾。
5、删除数据值
1.del 方法
del是删除的通用方法，在del后方跟上删除的键就能把键和值一起删了
user_dict = {
'username': 'jason',
'password': 123,
'hobby': ['read', 'music', 'run']
}
del user_dict['username']
print(user_dict)
# 结果：{'password': 123, 'hobby': ['read', 'music', 'run']}
2.pop方法
跟其他方法中的用法相同，在删除的同时，可以取得删除对象的值（键行）
user_dict = {
'username': 'jason',
'password': 123,
'hobby': ['read', 'music', 'run']
}
res = user_dict.pop('password')
print(user_dict)
# 结果：{'hobby': ['read', 'music', 'run']}
print(res) # 123
6、统计字典中键值对的个数
len方法可以统计字典中的数据个数。
user_dict = {
'username': 'jason',
'password': 123,
'hobby': ['read', 'music', 'run']
}
print(len(user_dict)) # 3
7、字典三剑客
1.keys方法
可以打印出所有的键
user_dict = {
'username': 'jason',
'password': 123,
'hobby': ['read', 'music', 'run']
}
print(user_dict.keys())
# 一次性获取字典所有的键 dict_keys(['username', 'password', 'hobby'])
2.values方法
可以打印出所有的值
user_dict = {
'username': 'jason',
'password': 123,
'hobby': ['read', 'music', 'run']
}
print(user_dict.values())
# 一次性获取字典所有的值 dict_values(['jason', 123, ['read', 'music', 'run']])
3.items方法
可以把所有键值对都打印出来
user_dict = {
'username': 'jason',
'password': 123,
'hobby': ['read', 'music', 'run']
}
print(user_dict.items())
# 一次性获取字典的键值对数据 dict_items([('username', 'jason'), ('password', 123), ('hobby', ['read', 'music', 'run'])])
这里拓展一种更加方便的输出方式
user_dict = {
'username': 'jason',
'password': 123,
'hobby': ['read', 'music', 'run']
}
for i in user_dict.items():
k, v = i
print(k)
# k会单独打印所有的键
# 结果：
'''
username
jason
password
'''
print(v)
# v会单独打印所有的值
# 结果
'''
123
hobby
['read', 'music', 'run']
'''
# 当然我们可以把两者放在一起打印出一个个的键值对
print(k, v)
# 结果
'''
username jason
password 123
hobby ['read', 'music', 'run']
'''
8、补充说明
fromkeys方法
多用于快速生成值相同的字典
user_dict = {
'username': 'jason',
'password': 123,
'hobby': ['read', 'music', 'run']
}
res = dict.fromkeys(['name', 'pwd', 'hobby'], [])
print(res)
# 结果：{'name': [], 'pwd': [], 'hobby': []}
使用formkeys方法创建的列表在使用append方法加入值的时候是同时往所有的键中加入值
res = dict.fromkeys(['name', 'pwd', 'hobby'], [])
res['name'].append('jason')
res['pwd'].append(123)
res['hobby'].append('study')
print(res)
# 结果如下：{'name': ['jason', 123, 'study'], 'pwd': ['jason', 123, 'study'], 'hobby': ['jason', 123, 'study']}
setdefault方法
setdefault方法有两个参数，第一个参数是键，第二个参数是想要插入的值。
当key存在时则不做任何修改，并返回已存在key对应的value值
user_dict = {
'username': 'jason',
'password': 123,
'hobby': ['read', 'music', 'run']
}
res = user_dict.setdefault('username','tony')
print(user_dict, res) # 键存在则不修改 结果是键对应的值
# {'username': 'jason', 'password': 123, 'hobby': ['read', 'music', 'run']} jason
当key不存在则新增键值对，并将新增的value返回
user_dict = {
'username': 'jason',
'password': 123,
'hobby': ['read', 'music', 'run']
}
res = user_dict.setdefault('age',123)
print(user_dict, res) # 键不存在则新增键值对 结果是新增的值
{'username': 'jason', 'password': 123, 'hobby': ['read', 'music', 'run'], 'age': 123} 123
popitem方法
跟pop方法的用法相似，默认情况下会先删除最后一个插入的键值对，同样我们也可以用变量名绑定这个键值对。
user_dict = {
'username': 'jason',
'password': 123,
'hobby': ['read', 'music', 'run']
}
res1 = user_dict.popitem() # 弹出键值对 后进先出
print(res1)
# 结果：('age', 123)
二、元组的内置方法
1、类型转换（把其他类型转换成自己的类型）
tuple()方法，可以for循环的数据类型都是可以转换成元组类型的
2、索引取值
元组的索引取值跟列表的相似，根据索引位置就可以得到对应的值
a = (1, 2, 3, 4, 5)
print(a[3]) # 结果是4
切片取值
元组的切片取值也跟列表相似，它的顺序、步幅也是一样设置的。
a = (1, 2, 3, 4, 5)
print(a[0:3]) # (1, 2, 3)
print(a[2:3]) # (3,)
print(a[::-1]) # (5, 4, 3, 2, 1)
print(a[::]) # (1, 2, 3, 4, 5)
3、统计元组内数据个数——len()
a = (1, 2, 3, 4, 5)
print(len(a)) # 值为5
4、统计某一数据值出现的次数——count
b = (1,1,1,2,2,3,3,)
print(b.count(1)) # 结果为为3
5、查找指定数据值的索引——index
a = (1, 2, 3, 4, 5)
print(a.index(3)) # 结果为2
6、一些注意事项
1.元组的内部如果只有一个数据值，后面需要跟上逗号，否则就会变成数据值对应的类型。
2.元组是不可变类型，但是当元组内绑定上可变类型的时候，绑定的那个可变类型中的数据时可以修改的。
三、集合的内置方法
1、类型转换（把其他类型转换成自己的类型）
这里需要注意，只能把不可变类型的数据值转换成集合
注：集合内部也是无序的，没有索引
s = set([1,2,3,4])
s1 = set((1,2,3,4))
s2 = set({'name':'jason',})
s3 = set('oscar')
print(s)
print(s1)
print(s2)
# 只能取到键
print(s3)
# 结果如下：
'''
{1, 2, 3, 4}
{1, 2, 3, 4}
{'name'}
{'s', 'a', 'r', 'c', 'o'}
'''
2、需要掌握的方法
1.去重
当我们对其他类型数据使用set()方法转换成集合的时候，会自动把其中重复部分删除，但是因为集合是无序的，并不能保持之前的排列顺序。
s1 = {11, 22, 11, 22, 22, 11, 222, 11, 22, 33, 22}
l1 = [11, 22, 33, 22, 11, 22, 33, 22, 11, 22, 33, 22]
s1 = set(l1)
l1 = list(s1)
print(s1)
print(l1)
# 结果如下：
'''
{33, 11, 22}
[33, 11, 22]
'''
2.关系运算
我们可以使用一些符号对集合进行关系运算，这些符号就是一些集合内置方法的化简。
# 假设这是两个人的好友列表
f1 = {'jason', 'tony', 'jerry', 'oscar'} # 用户1的好友列表
f2 = {'jack', 'jason', 'tom', 'tony'} # 用户2的好友列表
# 1.求两个人的共同好友
print(f1 & f2) # {'jason', 'tony'}
# .intersection()方法也是这个效果：得到集合a与集合b共有的元素。
# 2.求用户1独有的好友
print(f1 - f2) # {'jerry', 'oscar'}
# difference()方法也是这个效果：得到集合a中包含，但集合b中不包含的元素。
# 3.求两个人所有的好友
print(f1 | f2) # {'jason', 'jack', 'tom', 'tony', 'oscar', 'jerry'}
# a.union(b) 得到集合a和集合b中，包含的所有元素。
# 4.求两个人各自独有的好友
print(f1 ^ f2) # {'oscar', 'tom', 'jack', 'jerry'}
# symmetric_difference()方法也是这个效果
# 5.父集：一个集合是否包含另外一个集合
# 包含则返回True
print({1, 2, 3} > {1, 2})
# True
print({1, 2, 3} >= {1, 2})
# True
# 不存在包含关系，则返回False
print({1, 2, 3} > {1, 3, 4, 5})
# False
print({1, 2, 3} >= {1, 3, 4, 5})
# False
# 6.子集
print({1, 2} < {1, 2, 3})
# True
print({1, 2} <= {1, 2, 3})
# True
# a.issuperset(b) 判断集合b是否为集合a的子集，即集合b中的元素是否全部包含在集合a中。是为True，否为False。
# a.issubset(b) 判断集合a是否为集合b的子集，即集合a中的元素是否全部包含在集合b中。是为True，否为False。
3、需要了解的方法
1.计算集合中的数据值个数——len()
#长度len()
a = {"11111", 666}
print(len(a)) # 结果为2
2.添加
add
#添加操作.add()
a = {"11111", 666}
a.add("yyds")
print(a) # 结果：{"11111", 666, "yyds"}
update(x)
向集合中，添加x中的每一个元素。x可以是字符串、列表、元组、集合类型。
#添加操作.update()
a = {"11111", 666}
a.update("yyds", "关注了")
print(a) # 结果：{"11111", 666, "yyds", "关注了"}
3.删除操作
.remove(x) 删除集合中的元素x。
#删除操作.remove()
a = {"编程八点档", 666}
a.remove(666)
print(a) # {"编程八点档"}
.discard(x) 删除集合中的元素x。
#删除操作.discard()
a = {"编程八点档", 666}
a.discard(666)
print(a) # {"编程八点档"}
.pop() 随机删除集合中的某个元素。
#删除操作.pop()
a = {"编程八点档", 666}
a.pop()
print(a) # {666}
.clear() 清空集合。
#删除操作.clear()
a = {"编程八点档", 666}
a.clear()
print(a) # set()
四、字符编码
概念讲解：
对于文本文件，因为计算机只认识二进制，所以需要一个翻译本来充当媒介让计算机能读懂我们的语言，这个翻译本叫做字符编码表。
发展历史：
1、首先由美国人发明计算机并开发出了ASCII码表
2、当计算机逐渐在世界普及之后，各个国家都创建了各自的字符编码表：中国的GBK等
3、当各个国家交流的时候，会因为各自使用的字符编码表不同，出现乱码的情况，所有开发了unicode万国码，兼容所有国家语言字符，起步就是两个字节来表示字符 。并在后期的优化中发展了其他版本如果utf系列:utf8 utf16 ...。专门用于优化unocide存储问题，英文还是采用一个字节，中文三个字节。通常我们使用的是utf8.
使用讲解：
编码及解码
我们可以在python中编码或是解码
编码：
字符串.encode(内部可以跟上你想使用的字符编码表名称来编码)
解码：
字符串.decode(这里的话需要使用跟编码相同的字符编码表，否则会报错)
python2和python3中的区别
由于python2开发的年代早于unicode万国码，所以python不能识别unicode万国码，因此我们需要在文件的顶端加上# encoding:utf8，并在字符串的前面加上一个u，python3中的默认字符编码是utf8.
python2默认的编码是ASCII
1.文件头
# encoding:utf8
2.字符串前面加u
u'你好啊'