编码说明：

　　　常用编码介绍：

　　　　ascii 数字，字母 特殊字符。
　　　　字节：8位表示一个字节。
　　　　字符：是你看到的内容的最小组成单位。
　　　　abc ： a 一个字符。
　　　　中国：中 一个字符。
　　　　a : 0000 1011

　　　　unicode: 万国码
　　　　起初： a : 0000 1011 0000 1011
　　　　中: 0000 1011 0000 1111
　　　　升级： a : 0000 1011 0000 1011 0000 1011 0000 1011
　　　　中: 0000 1011 0000 1111 0000 1011 0000 1011

　　　　utf-8：最少用8位表示一个字符。
　　　　a: 0000 1011
　　　　欧洲： 0000 1011 0000 1011
　　　　亚洲中：0000 1011 0000 1011 0000 1011

　　　　gbk：国标
　　　　a: 0000 1011
　　　　中：0000 1011 0000 1011 两个字节。

　　　 1，不同编码之间的二进制是不能互相识别的。
　　　 2，对于文件的存储，及传输 不能是unicode的编码。
　　　　python3x
　　　　　　int
　　　　　　bool
　　　　　　bytes:内部编码方式：(非unicode，utf-8,gbk.gb2312...)
　　　　　　str : 内部编码方式unicode
　　　　　　list
　　　　　　dict
　　　　　　tuple

　　　　　　bytes:内部编码方式：(非unicode，utf-8,gbk.gb2312...)
　　　　　　str : 内部编码方式unicode
　　　   字母：
　　　　　　str：表现形式：s1 = 'alex'
　　　　　　内部编码：unicode

　　　　　　bytes：表现形式：s2 = b'alex'
　　　　　　内部编码：非unicode

　　　　中文：
　　　　　　str：表现形式：s1 = '中国'
　　　　　　内部编码：unicode

　　　　bytes：

　　　　　　表现形式：b1 = b'\xe4\xb8\xad\xe5\x9b\xbd'
　　　　　　内部编码：非unicod

　　说明：
　　　　不同编码之间的二进制是不能互相识别的。
　　　　对于文件的存储，及传输 不能是unicode的编码
　　　　在python3中默认字符串编码方式是unicode，所以字符串不能直接发送和写入文件，所以需要转化。
　　　　Bytes默认字符编码是可变得但不是unicode编码方式，但bytes与str的所有操作方式都是一样的。
　　　　所以str想直接存储或者传输，需要将str转化成bytes再存储。

　　字符间转换方式：

　　　　存在str和bytes原因，是因为两者英文显示都是一样可以使用，但在表示中文的时候bytes可读性很差。
　　　　所以向str转化成bytes类型使用encode（‘字符编码’）

　　　　str转byts方法：——encode（‘字符编码’）

　　　　bytes转回str类型（解码）：——decode（‘默认可以不写’）

　　　　bytes中文转化为其他编码方式是先转化为str后再转化为其他字符：
　　　　str可以转化为其他编码格式，存储时候使用bytes存储，所以其他格式的字符编码想转化为其他字符，就需要先dicode转化为str然后再通过enco的将str转化为其他。

　　　　举例：

　　　　　　s1 = 'alex'
　　　　　　# str ---> bytes encode 编码
　　　　　　b1 = s1.encode('utf-8')
　　　　　　print(b1)
　　　　　　#bytes---> str decode 解码
　　　　　　s2 = b1.decode('utf-8')
　　　　　　print(s2)

　　　　　　s4 = '中国'
　　　　　　b4 = s4.encode('utf-8') # utf-8 bytes
　　　　　　print(b4) ###b'\xe4\xb8\xad\xe5\x9b\xbd'

　　　　　　b6 = b4.decode('utf-8').encode('gbk')

　　　　　　print(b6) ###b'\xd6\xd0\xb9\xfa'

深 浅 cop说明

　　.Copy（）

　　对赋值运算来说，就是公用一个内存地址，两个值都是公用一个内存地址，一个变另一个也跟着变。
　　.copy（）复制的内容，浅copy是第一层级是相对独立，从第二层级后公用一个内存地址。
　　对于深copy需要引用copy模块，inmport copy不论嵌套多少层都是使用独立的内存地址，即别人变我不变。

　　浅copy：
　　　　对于层级比较多的列表或字典的时候，第一层（最外层）是相对独立的内存地址，从第二层开始，就开始共公用一个内存地址

　　深copy ：
　　　　Import copy ——引用一个copy模块

　　　　深copy是表示不论你列表中嵌套了多少层，内存地址都是独立的。互补影响。

　　举例：
　　　　#赋值运算
　　　　# s1 = [1, 2, 3] ####赋值运算公用一个地址
　　　　# s2 = s1 # 共用一个
　　　　# s1.append(666)
　　　　# print(s1, s2)

　　　　#浅copy
　　　　# s1 = [1, 2, 3] ####浅copy是第一层级是相对独立
　　　　# s2 = s1.copy()
　　　　# s1.append(666)
　　　　# print(s1, s2)

　　　　# s1 = [1, 2, 3,[11,22]] ### 浅copy 第一层各自独立，从第二层开始，共用一个内存地址。
　　　　# s2 = s1.copy()
　　　　# s1[-1].append(666)
　　　　# # print(s1, s2)
　　　　# print(id(s1), id(s2))
　　　　# print(id(s1[-1]), id(s2[-1]))

　　# 深copy
　　　　import copy ###引用copy模块
　　　　# s1 = [1, 2, 3,[11,22]]
　　　　# s2 = copy.deepcopy(s1)
　　　　# s1.append(666)
　　　　# print(s1, s2)

　　　　# s1 = [1, 2, 3,[11,22]] ### 深copy 无论多少层，都是互相独立的。
　　　　# s2 = copy.deepcopy(s1)
　　　　# s1[-1].append(666)
　　　　# print(s1, s2)