一，一些小的知识点
1）注释
当行注释：# 被注释内容
多行注释：'''被注释内容'''，或者"""被注释内容"""
2）变量
变量是什么？ 变量：把程序运行的中间结果临时的存在内存里，以便后续的代码调用。
变量的作用：昵称，其代指内存里某个地址中保存的内容
变量定义的规则：
- 变量名只能是 字母、数字或下划线的任意组合
- 变量名的第一个字符不能是数字
- 以下关键字不能声明为变量名
- 变量的定义要具有可描述性
- 变量不能太长
- 变量要具有可读性
- 变量最好不用中文和拼音
推荐定义方式：
#驼峰体
NumberOfStudents = 80
#下划线
number_of_students = 80
3）常量
常量即指不变的量，或在程序运行过程中不会改变的量
在Python中没有一个专门的语法代表常量，程序员约定俗成用变量名全部大写代表常量
AGE_OF_OLDBOY = 56
什么是数据类型
4）什么是数据类型
我们人类可以很容易的分清数字与字符的区别，但是计算机并不能呀，计算机虽然很强大，但从某种角度上看又很傻，除非你明确的告诉它，1是数字，“汉”是文字，否则它是分不清1和‘汉’的区别的，因此，在每个编程语言里都会有一个叫数据类型的东东，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，就传字符串类型给他。
二，python运算知识汇总
1）占字符% :%d(代表的是数字)；%s(代表的是字符串) 如果在一句话中有正常使用的%，则%%代表的为正常%
格式化输出：
第一种格式
'%s ,%s' %(内容1，内容2)
第二种格式
dic = {'name':'老男孩','age':45}
'%(name)s,%(age)s'% dic
# 格式化输出 %占位符 s d name = input('请输入姓名：') age = int(input('请输入年龄：')) job = input('请输入工作：') hobby=input('请输入爱好：') msg = ''' ------------ info of %s ----------- Name : %s Age : %d job : %s Hobbie: %s ------------- end ----------------- ''' % (name, name, age, job, hobby) print(msg)
2)while 可以无限循环 终止循环可以有以下几种方法：
- 改变条件(根据上面的流程，只要改变条件，就会终止循环)。
- 关键字：break。(直接跳出while循环。)
- 调用系统命令：quit(),exit()
- 关键字：continue（只是终止本次循环，还在while循环体里面）
第一种改变条件终止循环举例：标志位的概念，就是前面设定一个‘flag’条件，在循环体中进行改变（主要是之前没留意这个标志位知识点）
flag = True while flag: print('小') print('旋) print('风') flag = False print('我是小旋风')
在python语言中
while else 当while循环被break打断，则不走else程序（注意break的位置，在写 代码时可以这样的写，条件放在：后面）。
count = 0 while count <= 5 : count += 1 if count == 3:break print("Loop",count) else: print("循环执行完毕") print("-----out of while loop ------")
这里补充个小知识点：三元运算
简单条件语句
if 条件成立:
val = 1
else:
val = 2
改成三元运算：
val = 1 if 条件成立 else 2
举例：
a = 2 b = 5 val = a if a > b else b print(val) # 5 val = a if a < 3 else b print(val) # 2
lambda函数的用法：
举例：
def sum(x,y):
return x+y
用lambda来实现
p= lambda x,y:x+y
print(p(4,6))
匿名函数lambda是指一类无需定义标识符（函数名）的函数或子程序。
lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值，也就是只能有一个表达式。
lambda匿名函数的格式：冒号前是参数，可以有多个，用逗号隔开，冒号右边的为表达式。其实lambda返回值是一个函数的地址，也就是函数对象。
3）算数运行符，比较运算符，布尔值，逻辑运算符这些很基础，要记死。
他们在计算过程中的逻辑运算优先顺序，需要注意：在没有()的情况下not 优先级高于 and，and优先级高于or，即优先级关系为( )>not>and>or，同一优先级从左往右计算。
成员运算：除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。
in:如果在指定的序列中值返回True，否则返回Flase；not in 就刚好相反
print('a' in 'abcd')
python运算符优先级：
|
4）数字与布尔值转 数值--->布尔值：非零为True ；零为False
布尔值--->数值：True为 1；False为 0
print(3 or 5) #返回值为3 而and的返回值和or刚好相反。
6）编码初识：0000 0001 8位 == 1个字符 一个字符表示一个字节 字节就是byte
8 bit = 1byte
1024byte = 1KB
ASCII码（American Standard Code for Information Interchange，美国标准信息交换代码）是基于拉丁字母的一套电脑编码系统ASCII码中只包含英文字母，数字以及特殊字符与二进制的对应关系，主要用于显示现代英语和其他西欧语言，其最多只能用 8 位来表示（一个字节），即：2**8 = 256，所以，ASCII码最多只能表示 256 个符号。
随着计算机的发展. 以及普及率的提高. 流⾏到欧洲和亚洲. 这时ASCII码就不合适了. 比如: 中⽂汉字有几万个. 而ASCII 多也就256个位置. 所以ASCII不行了. 怎么办呢? 这时, 不同的国家就提出了不同的编码用来适用于各自的语言环境（每个国家都有每个国家的GBK，每个国家的GBK都只包含ASCII码中内容以及本国自己的文字）. 比如, 中国的GBK, GB2312, BIG5, ISO-8859-1等等. 这时各个国家都可以使用计算机了.
GBK是采用单双字节变长编码，英文使用单字节编码，完全兼容ASCII字符编码，中文部分采用双字节编码。
对于ASCII码中的内容，GBK完全沿用的ASCII码，所以一个英文字母（数字,特殊字母）用一个字节表示，而对于中文来说，一个中文用两个字节表示。
但是GBK只包含中文，不能包含其他文字，言外之意，GBK编码是不能识别其他国家的文字的，举个例子：如果你购买了一个日本的游戏盘，在用中国的计算机去玩，那么此时中国的计算机只有gbk编码和ascii码，那么你在玩游戏的过程中，只要出现日本字，那就会出错或者出现乱码.......
但是，随着全球化的普及，由于网络的连通，以及互联网产品的共用（不同国家的游戏，软件，建立联系等），各个国家都需要产生各种交集，此时急需一个密码本：要包含全世界所有的文字与二进制0101010的对应关系，所以创建了万国码：
Unicode： 包含全世界所有的文字与二进制0101001的对应关系。
通用字符集（Universal Character Set, UCS）是由ISO制定的ISO 10646（或称ISO/IEC 10646）标准所定义的标准字符集。UCS-2用两个字节编码，UCS-4用4个字节编码。
起初：Unicode规定一个字符用两个字节表示：
英文: a b c 六个字节 一个英文2个字节
中文 中国 四个字节 一个中文用2个字节
但是这种也不行，这种最多有65535种可能，可是中国文字有9万多，所以改成一个字符用四个字节表示：.
a 01000001 01000010 01000011 00000001
b 01000001 01000010 01100011 00000001
中 01001001 01000010 01100011 00000001
这样虽然解决了问题，但是又引出一个新的问题就是原本a可以用1个字节表示，却必须用4个字节，这样非常浪费资源，所以对Uniocde进行升级
UTF-8:包含全世界所有的文字与二进制0101001的对应关系（最少用8位一个字节表示一个字符）。
UTF-8：是对Unicode编码的压缩和优化，他不再使用最少使用2个字节，而是将所有的字符和符号进行分类：ascii码中的内容用1个字节保存、欧洲的字符用2个字节保存，东亚的字符用3个字节保存...
UTF-8 ：最少用8位数,去表示一个字符.
英文: 8位,1个字节表示.
欧洲文字: 16位,两个字节表示一个字符.
中文,亚洲文字: 24位,三个字节表示.
三，数据类型知识
1）数据类型
int:数字
bit_length()就是帮助你快速的计算整数在内存中占用的二进制码的长度.
int--->bool:非零即True;零及False
str--->bool:非空即True；
bool：判断真假
str:简单少量的储存数据，并进行相应的操作
切片 索引：索引：步长：顾头不顾尾；-1是列表中最后一个元素的索引。
tuple:只读，不能更改
list:大量有序数据
dict:大量数据，且是关联性比较强的数据。
变量的命名规则：
1.必须是字母，数字，下划线的任意组合。
2.不能是数字开头
3.不能是python中的关键字
4.变量不能是中文
5.变量不能过长
6, 变量要具有可描述性
常量用全部的大写的字符串表示，通常放在文件的开头
字符串的常用方法
capitalize 首字母大写，其余小写
center 居中 可以在第二参数位置加入以什么填充如：print(str.center(20,'*'))
upper 全部大写 lower全部小写
startswith 判断以什么内容开头，返回布尔值，（可以切片，用逗号隔开）
endswith判断以什么内容结束
swapcase 大小写翻转
title 非字母隔开的每个单词的首字母大写
find 和 index 通过元素找索引，find找不到会返回-1 但是index会报错 均可以切片
strip 去除前后端的空格，换行符，制表符。lstrip去除左边的 rstrip去除 右边的
也可以去除字母 s.strip('a')
split str --->list 默认以空格分割 需要注意：
s = 'ttertdft33wett' li2 = s.split('t') print(li2) #['', '', 'er', 'df', '33we', '', '']，也就是说如果以什么为分割的元素，在字符串最前和最后，那么被分割后就会形成''空字符串，如果在中间，直接就分割掉了 #另要注意，以下两个得出的结果不一样，不是这样理解的，在开始从头分割时，t左侧是空，所以为“” s = ' er df 33we ' li2 = s.split(' ') #中间加有空格 print(li2) #['', '', 'er', 'df', '33we', '', ''] s = ' er df 33we ' li2 = s.split() #中间不加空格 print(li2) #['er', 'df', '33we', ]
join： list-->str 可以将列表，元组 字典转化为字符串 使用方法s = ''.join('如果是列表，里面不能是数字')【第一个空的‘’叫做分隔符，（）里面的可以是字符串，元组，字典，元素序列等，如果是字典，返回的只是键，键只能是字符串才行】
replace 替换 它有三个参数，str.repalce('','',n) n代表的是替换的个数。
公共方法：
len()返回总个数；count 计算某些元素出现的个数
format三种方法：
s='{}：{}：{}'.format('egon',18,'male') {}之间可以添加符号等
1）msg = '我叫{},今年{},爱好{}'.format('A','B','C')：{}相当于%占位符。{}中间不能有空格
2）msg = '我叫{0},今年{1},爱好{2}'.format('A','B','C') {}中的数字是format括号中的序列号，从零开始
3）msg = '我叫{name},今年{age},爱好{hobby}'.format(name = 'A',age = 'B',hobby ='C')
4)isalnum()字符串由字母或数字组成
isalpha()字符串只有字母组成
isdigit()字符串只有数字组成
isspace()字符串只有空格组成
for 变量 in 可迭代对象（含有多种元素）
*********************************
如果一串代码太长 可以用“”隔开再转下一行 无缝连接 输入input（).strip()后面一定跟个strip()去除空字符
**************列表的用法*************
列表
列表的索引切片 以及 增删改查
切片和字符串的切片用法一致
//增
append：给列表的最后面追加一个元素；
insert：插入在列表的任意位置，根据索引 但是实际插入位置应按照1,2 开始数 插入元素
l = [1, 2, 'a'] l.insert(1,'小旋风') print(l) # [1, '小旋风', 2, 'a']
extend 迭代这追加 在列表的最后面迭代这追加一组数据,在这里理解下什么叫做可迭代。
l = [1, 2, 'a'] l.iextend('小旋风') print(l) # [1, 2, 'a', '小','旋',风']
//删
pop 通过索引删除列表中对应的元素，该方法有返回值，返回值为删除的元素
remove按照元素删除
clear清除，
del 以下几种使用del删除的方法一定要记住 还可以在内存级别删除列表如 del l 这样直接将列表删除
#按照索引删除该元素 l = ['xiao', 'xuan', 'feng', '男神'] del l[2] print(l) # ['xiao', 'xuan', '男神'] # 切片删除该元素 l = ['xiao', 'xuan', 'feng', '男神'] del l[1:] print(l) # ['xiao'] # 切片(步长)删除该元素 l = ['xiao', 'xuan', 'feng', '男神'] del l[::2] print(l) # ['xuan', '男神']
//改
1，按照索引去改
2，按照切片去改 先将切片的区域内的内容全部删除，在迭代这添加内容。
# 按照索引改值 l = ['xiao', 'xuan', 'feng', '男神'] l[0] = '我是' print(l) # ['我是', 'xuan', 'feng', '男神'] # 按照切片改值(迭代着增加) l = ['xiao', 'xuan', 'feng', '男神'] l[1:3] = 'abcdefg' print(l) # ['xiao', 'a', 'b', 'c', 'd', 'e', 'f', 'g', '男神'] # 按照切片(步长)改值(必须一一对应) l =['xiao', 'xuan', 'feng', '男神'] l[::2] = '对应' print(l) # ['对', 'xuan','应', '男神'] 注意这个删除起始位置
//查
按照索引切片去查；for循环
//其他操作方法
len 计算元素个数
count 计算元素出现次数
列表里面只有index 没有find 这个index是用于从列表中找出某个值第一个匹配项的索引位置，可以用切片，但是切片范围内找不到会报错。
sort()排序 从小到大
sort(reverse=True)倒序
reverse 翻转
a = [2,1,3,4,5] a.sort()# 他没有返回值，所以只能打印a print(a) a.reverse()#他也没有返回值，所以只能打印a print(a)
//列表的套用 也就是嵌套 很简单
元组
只读列表 不能增删改 只能查询 儿子不能改 但是孙子可以改
索引 切换 步长 例如tu1 = ('xiao','xuan',[22,44,'feng']) 可以对元组中的列表进行增删改查。
元组可以使用公共参数index len count
range是一个自定义的数字范围 顾头不顾腚 可以加步长 和for循环结合使用
1，元组中里面如果只有一个元素，且没有逗号，则该数据类型与里面的元素相同
1）例子
tu1 = ('lannanhai')
tu2 = ('laonanhai',)
print(tu1,type(tu1)) #字符串
print(tu2,type(tu2)) #元组
2）例子
tu1 = (1)
tu2 = (1,)
print(tu1,type(tu1)) #整数
print(tu2,type(tu2))#元组
字典
基础数据类型之一，{}以键值对的形式存储数据
以Key:value形式，映射。
字典的Key必须是不可变的数据类型，是唯一的
hash算法：
字典的键通过hash表转换成数字，采用二分查找查询s数值。
字典的value可以是任意数据类型。
字典的查询速度非常快，存储的大量的关系型数据。
字典在Python3.5以及之前都是无序的，但3.6后是有序的。
数据类型的分类：
可变：list dict set
不可变：str tuple int bool
容器类的数据类型:list tuple dict
非容器类的数据 类型:str,int,bool
//增
dic['sex'] = 'laddy_boy':有则覆盖，无则添加
dic.setdefault('sex','laddy_boy') 有则不变，无则添加。需要注意这个参数setdefault是有返回值的。
dic = {'name': '我是小旋风', 'age': 18}
ret = dic.setdefault('name')
print(ret) # 我是小旋风
//删
dic.pop()根据键去删除 键值对；有返回值，返回的是键对应的值。
如果删除的键没有在字典里 为了不报错 可以 dic.pop('age1',None) 返回None，None可以用其他代替。
dic.clear() 清空字典。
dic.popitem() 删除最后一个 叫做随机删除，有返回值，返回的是元组，元组里面是键值对。
del dic 可以删除整个字典；按照键删除键值对。
//改
dic['name'] = '我是小旋风'
update:可以增加字典的键值对，或者列表，也可以针对两个字典的更新 将dic2里面的所有键对值，有的不变 无则添加添加到dic1中，dic2不变
dic = {'name': '我是小旋风', 'age': 18}
dic.update(sex='男', height=175)#前面的键不能加上‘’
print(dic) # {'name': '我是小旋风', 'age': 18, 'sex': '男', 'height': 175}
dic = {'name': '我是小旋风', 'age': 18}
dic.update([(1, 'a'),(2, 'b'),(3, 'c'),(4, 'd')])
print(dic) # {'name': '我是小旋风', 'age': 18, 1: 'a', 2: 'b', 3: 'c', 4: 'd'}
dic1 = {"name":'我是小旋风',,"age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic1.update(dic2)
print(dic1) # {'name': '我是小旋风',, 'age': 18, 'sex': 'male', 'weight': 75}
print(dic2) # {'name': '我是小旋风',, 'weight': 75}
//查
dic['name']:根据键查值，如果字典中没有这个name键 就会报错
dic.get('name') ：如果 没有不会报错，可以设置返回值。
dic.get('name','没有此键')
for循环查询
dic.keys();dic.values();dic.items()：类似于list 但不是list的类型
l_key = list(dic.keys()) 将dic.keys 转化成list
分别赋值概念：
a,b = 1,2
print(a,b)
for i in dic.items():返回的元组
for k,v in dic.items()：分别赋值得到变量
字典添加的一个函数：fromkeys 它的功能是创建
dic = dict.fromkeys('ab','小旋风') {'a':'小旋风','b':'小旋风'}
**************列表转化为字典 使用zip()函数以及dict函数*******************
dic = {'k1':'123','k2':'4334','k3':'adettg',True:['123']}
l1=[]
l2= []
for i in dic.keys():
l1.append(i)
print(l1)
for i in dic.values():
l2.append(i)
print(l2)
dic1 = dict(zip(l1,l2))
print(dic1)
*******************将字典转化为列表**************************************
for key in dic:
l1.append("{}:{}".format(key, dic[key]))
print(l1)
*************************************************************************
集合set
和字典相比 只是没有了键 但是里面的值必须的是不可变数据类型，里面的数据是无序的
增
set.add() 增加一个元素
set.update() 迭代这增加
删
set1.remove('')删除一个元素
set1.pop()随机删除一个元素
set1.clear() 清空集合
del set1 删除集合
集合的交集 & 或者 intersection
并集 | 或者union
差集 - 或者different
反交集 ^或者 symmertric_difference
*****************************一个很好用的参数*******************************
enumerate：枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。
li = ['小旋风','空气,'吃货','电脑','计算机'] for i in enumerate(li): print(i) (0, '小旋风') (1, '空气') (2, '吃货') (3, '电脑') (4, '计算机') for index,name in enumerate(li,1): print(index,name) (1, '小旋风') (2, '空气') (3, '吃货') (4, '电脑') (5, '计算机') for index, name in enumerate(li, 100): # 起始位置默认是0，可更改 print(index, name) (100, '小旋风') (101, '空气') (102, '吃货') (103, '电脑') (104, '计算机')
********************* for 循环深入理解*********************
for i in [1,2,3,4,4]: #for循环的是次数，while是无限循环
print('abc') #循环四次
'abc'
'abc'
'abc'
'abc'
五，小数据池
1）在Python中，id是什么？id是内存地址，那就有人问了，什么是内存地址呢？ 你只要创建一个数据（对象）那么都会在内存中开辟一个空间，将这个数据临时加在到内存中，那么这个空间是有一个唯一标识的，就好比是身份证号，标识这个空间的叫做内存地址，也就是这个数据（对象）的id，那么你可以利用id（）去获取这个数据的内存地址：
而 is 是比较的两边的内存地址是否相等。 如果内存地址相等，那么这两边其实是指向同一个内存地址。
is 判断内存id是否相同
== 判断的是数值是否相同
id 测试他的内存地址
name = 'adc'
print(id(name)) #输出的是虚拟内存号
小数据池 int str 在一定范围内，如果两个数值相同，为了节省内存，共用一个内存地址
小数据池是针对不同代码块之间的缓存机制！！！
代码块：一个模块，一个函数，一个类，一个文件等都是一个代码块
而作为交互方式输入的每行命令都是一个代码块
>>> i1 = 1000
>>> i2 = 1000 这两行代码就分别是两个代码块
代码块的缓存机制：
执行同一个代码块时，遇到初始化对象的命令时，他会将初始化的这个变量与值存储在一个字典中，在遇到新的变量时，会先在字典中查询记录，如果有同样的记录那么它会重复使用这个字典中的之前的这个值。所以在你给出的例子中，文件执行时（同一个代码块）会把i1、i2两个变量指向同一个对象，满足缓存机制则他们在内存中只存在一个，即：id相同。
代码块的缓存机制的适用范围：
int（float），str，bool。
int(float):任何数字在同一代码块下都会复用。
bool:True和False在字典中会以1，0方式存在，并且复用。
str：几乎所有的字符串都会符合缓存机制（但有得不可以，这个知识只需了解）
小数据池的适用范围：
int 范围 -5 - 256
str 范围 1，只包含数字或者字母的可以做小数据池（这个还有其他情况，只做了解）
bool（bool值就是True，False，无论你创建多少个变量指向True，False，那么他在内存中只存在一个）.
2，单个字符*int(21)内 存在小数据池 （现在范围变大了，需要核查）
剩下的数据类型都不存在小数据池
理解：Python自动将-5~256的整数进行了缓存，当你将这些整数赋值给变量时，并不会重新创建对象，而是使用已经创建好的缓存对象。python会将一定规则的字符串在字符串驻留池中，创建一份，当你将这些字符串赋值给变量时，并不会重新创建对象， 而是使用在字符串驻留池中创建好的对象。其实，无论是缓存还是字符串驻留池，都是python做的一个优化，就是将~5-256的整数，和一定规则的字符串，放在一个‘池’（容器，或者字典）中，无论程序中那些变量指向这些范围内的整数或者字符串，那么他直接在这个‘池’中引用，言外之意，就是内存中之创建一个。优点：能够提高一些字符串，整数处理人物在时间和空间上的性能；需要值相同的字符串，整数的时候，直接从‘池’里拿来用，避免频繁的创建和销毁，提升效率，节约内存
指定驻留
from sys import intern
a = intern('hello!@'*20)
b = intern('hello!@'*20)
print(a is b) #指定驻留是你可以指定任意的字符串加入到小数据池中，让其只在内存中创建一个对象，多个变量都是指向这一个字符串。
如果在同一代码块下，则采用同一代码块下的缓存机制。
如果是不同代码块，则采用小数据池的驻留机制。
pycharm 通过运行文件的方式执行下列代码： 这是在同一个文件下也就是同一代码块下，采用同一代码块下的缓存机制。
i1 = 1000
i2 = 1000
print(i1 is i2) # 结果为True 因为代码块下的缓存机制适用于所有数字
通过交互方式中执行下面代码： # 这是不同代码块下，则采用小数据池的驻留机制。
>>> i1 = 1000
>>> i2 = 1000
>>> print(i1 is i2)
False # 不同代码块下的小数据池驻留机制 数字的范围只是-5~256.
举例验证：
# 虽然在同一个文件中，但是函数本身就是代码块，所以这是在两个不同的代码块下，不满足小数据池（驻存机制），则指向两个不同的地址。
def func():
i1 = 1000
print(id(i1)) # 2288555806672
def func2():
i1 = 1000
print(id(i1)) # 2288557317392
func()
func2()
*************************编码二********************************
ASCII ：一个字符 1个字节表示8位 ：数字 字母 特殊字符。
Unicode：万国码
一个字符用4个字节表示
utf-8:最少用8位表示一个字符：
a : 0000 0001
欧洲： 0000 0001 0100 0001
亚洲： 0000 0001 0000 0001 1100 0001
gbk:国标 只包含数字 字母 特殊字符 和中文 8位一个字节
一个英文用一个字节 一个中文用两个字节
a:0001 0001
中：0000 0001 0000 0001
1，不同的密码本之间的二进制是不能互相识别的，容易报错或者产生乱码
2，计算的文件存储和传输都是01010101（gbk,utf-8,ascli,gb2312等）不能是万国码
在计算机内存中，统一使用Unicode编码，当需要将数据保存到硬盘或者需要网络传输的时候，就转换为非Unicode编码比如：UTF-8编码。
大前提： Python3X，编码
数据类型：
int str bytes:str拥有的所有方法，bytes都有
bool list tuple
dict set
str：Python3X 内存中的编码方式是unicode 所以str不能直接传输 需要通过bytes转化
bytes:内部编码方式是：utf-8,gbk,gb2313....非Unicode
英文：
str：表现形式 name = 'abc'
内部编码：Unicode
bytes：表现形式 name1 = b'abc'
内部编码：非unicode
中文：
str：表现形式 name = '中国'# 中国
内部编码：Unicode
bytes：表现形式 name1 = 中国.encode('utf-8') #b'xe4xb8xadxe5x9bxbd'
内部编码：非unicod
所以str bytes 都存在 只有bytes那么中文就无法显示。
**************将str转化为bytes类型************
s1 = '中国'
str--->bytes bytes数据类型生成方法 b = b'werggge' #前面加个b 为bytes
b1 = s1.encode('utf-8') encode编码
bytes--->str
s2 = b1.decode('utf-8') decode解码
***************** utf-8----->gbk ****************
unicode--encode('utf-8')-->utf-8
utf-8--decode('utf-8')-->unicode
unicode--encode('gbk')-->gbk
gbk--decode('gbk')-->unicode
所以utf-8到gbk之间需要转化到unicode 之后再转化。