day07（数据类型的相互转换 ，字符编

'''
1，深浅拷贝  
　　ls = [1,'a',[10]]
　　值拷贝：直接赋值 ls1 = ls，ls中的任何值发生改变，ls1也随之发生改变
　　浅拷贝：通过copy()方法 ls2 = ls.copy()，ls中存放的值的地址没有改变, 但内部的值发生改变，ls2会随之改变

　　　　-- ls = [1, 'a', [10]]  =>  [1, 'a', [100]] = ls2

　　深拷贝：通过deepcopy()方法 ls3 = deepcopy(ls)，ls中存放的值发生任何改变，ls3都不会随之改变

2.元组类型
    t = tuple()
    元组：
　　　　1.就可以理解为不可变的list
　　　  2.有序 - 可以索引取值，可以切片 
　　　　3.不可变 - 长度和内容都不能发生改变
    细节：元组中可以存放所有的数据类型，所以存放可变类型数据后，可变类型依然可以发生改变

3.字典类型
    d1 = {}
    d2 = dict({'a': 1})
    d3 = dict(name='Bob')  # 所有的key都会用合法的变量名，最终转化为字符串类型的key
    d4 = {}.fromkeys('abc', 0) => {'a': 0, 'b': 0, 'c': 0}
    key: 要确保唯一性，所以必须为不可变类型
    value：存放可以存放的所有类型数据，所以支持所有类型
    字典：1.可变 2.没有索引，通过key取值 3.无序的
    增删改查：字典名[key名] | 字典名[key名] = 值 | update(dict) | setdefault(key, d_value) | get(key, default)
            | pop(key) | popitem() | clear()
    循环：keys() | values() | items()
    for k, v in dic.items():  # (k, v)
        pass

    字典的成员运算：完成的就是 key 在不在 目标字典中

4.集合类型
    s = set()
    集合：1.可变 - 可增可删  2.无序无索引无key - 不能取值不能改值 3.for可以对集合取值，取值的结果顺序不确定
    特定：不能存放重复的数据（去重效果）

　　# s1.symmetric_difference_update(s2)  # 将集合s1与s2的运算结果设置给s1

'''

'''
 1，哪些类型可以转化为数字
  　　res = int('10')
　　　print(res)
　　　res = int('-3')
　　　print(res)
　　　res = float('.15')
　　  print(res)
　　  res = float('-.15')
　　　print(res)
　　  res = float('-3.15')
　　　print(res)
　　

　2，数字转化字符串
　　　print(str(10))


　3，字符串与列表相互转换*****

　　  s = 'abc123呵呵'
　　　print(list(s))　　　#['a', 'b', 'c', '1', '2', '3', '呵', '呵']  没有对应的 str(ls)
　　  ls = ['a', 'b', 'c', '1', '2', '3', '呵', '呵'] 
　　　n_s = ''.join(ls)
　　　print(n_s)  　　　　　　　　#abc123呵呵
　　  

　　  s1 = 'a b c 1 2 3 呵 呵'
　　　res = s1.split() 　　　　#默认按空格拆分
　　　print(res)　　　　　　　　#['a', 'b', 'c', '1', '2', '3', '呵', '呵']

　　　
　#必须掌握*****

　　列表与字符串相互转换*****

　　　s2 = 'ie=UTF-8&wd=你好帅'
　　　res = s2.split('&')
　　  print(res)　　　　　　　　# ['ie=UTF-8', 'wd=你好帅']

　　  ls2 = ['ie=UTF-8','wd=你好帅']
　　　n_s2 = '@'.join(ls2)
　　　print(n_s2)　　　　　　　　# ie=UTF-8@wd=你好帅

　4，需求： 字符串与列表的相互转换： "ie=UTF-8&wd=你好帅" => [('ie', 'UTF-8'), ('wd', '你好帅')]

　　 res = []
　　 s4 = "ie=UTF-8&wd=你好帅" 
　　 ls4 = s4.split('&')　　　　　 # ['ie=UTF-8', 'wd=你好帅']

　　 for ele in ls4:　　　　　　　　# v = ie=UTF-8 | wd=你好帅
　　　　　　k,v = ele.split('=')　 # k: ie  v: UTF-8
　　　　　　res.append((k,v))
　　　print(res)　　　　　　　　　　 #[('ie', 'UTF-8'), ('wd', '你好帅')]

　5,需求：字符串与字典的相互转换： "ie=UTF-8&wd=你好帅" => {'ie': 'UTF-8', 'wd': '你好帅'}
　　 res = {}
　　 s5 = "ie=UTF-8&wd=你好帅"
　　 ls5 = s5.split('&')   　　　　# ['ie=UTF-8', 'wd=你好帅']　　　

　　 for ele in ls5:　　　　　　　　
　　　　　　k,v = ele.split('=')   #k:ie  v=UTF-8
　　　　　　res[k] = v
　　 print(res)　　　　　　　　　　　#{'ie': 'UTF-8', 'wd': '你好帅'}

　6，需求：列表与字典的相互转换：[('ie', 'UTF-8'), ('wd', '你好帅')] => {'ie': 'UTF-8', 'wd': '你好帅'}

　　 res = {}
　　 ls6 = [('ie', 'UTF-8'), ('wd', '你好帅')]
　　 for k,v in ls6:
　　　　　　res[k] = v
　　  print(res)

　7，list 与taple ，set 直接转换——直接 类型（）

  8.需求：将汉字转化为数字
　　# 将 壹、贰、叁、肆、伍、陆、柒、捌、玖、拾、佰、仟
　　# 转化为 1、2、3、4、5、6、7、8、9、10、100、100
　　## 作业：壹仟捌佰玖拾叁 => 1893

　　num_map = {
    　　'壹': 1,
    　　'贰': 2,
   　　 '仟': 1000
　　}

　　ls8 =['贰', '壹', '仟']
　　res = []
　　for v in ls8:
　　　　num = num_map[v]　　#通过key去映射拿到对应的值，完成 '贰' => 2
　　　　res.append(num)
　　print(res)

'''

# 测试一下
# 学习字符编码的问题：解决乱码问题

# 数据 从 硬盘 => 内存 => cpu

# 应用程序打开文本文件的三步骤
# 1.打开应用程序
# 2.将数据加载到内存中
# 3.cpu将内存中的数据直接翻译成字符显示给用户

# python解释器
# 1.打开python解释器
# 2.将数据加载到内存中
# 3.cpu将内存中的数据解释执行将结果显示给用户，如何解释执行不能通过，将错误信息提供给用户

# 编码的发展史
# 电脑只能识别高低电频对应的0,1信息 => 问题：如何将世间万物信息存放到内存中
# 世间万物信息 => 0,1形式的数据 => 电脑中存放，将该过程逆向操作，就是访问已存储的数据信息

# 编码表
# 人能识别的字符 <=> 机器能识别的字符：一定存在一种固定的对应关系
# 编码表：一定范围内人能识别的字符与机器能识别的字符形成的对应关系表(映射表)

# 1.ASCII表：英文字母、英文符号、数字与机器能识别的字符的对应关系表，8个二进制位就能存放完这所有的对应关系 => 1字节
#       python2采用的默认编码是ASCII，早期并不支持中文编程
# 2_1.GBK：中文与与机器能识别的字符的对应关系表（完全兼容ASCII表）,16个二进制位能存放所有汉字与ASCII之前的对应关系 => 2个字节
#       2个字节能否存放常用汉字 => 16个二进制位 2^15
#       print(pow(2, 15))
# 2_2.Shift_JIS | Euc-kr：日文 | 韩文 与机器能识别的字符的对应关系表（完全兼容ASCII表）

# 乱码：存的编码格式与取的编码格式不一致
# 3.Unicode万国码：世间中常用国家的常用字符与机器能识别的字符的对应关系表

# 转码：Unicode存在汉字与二进制对应关系，GBK也存在汉字与二进制对应关系，将GBK存放的数据转存到Unicode数据

# 均采用Unicode编码表，只是存放数据采用字节数不一致，utf-8与utf-16是Unicode编码表的两种体现方式


# utf-8：以1个字节存放英文，以3 | 6个字节存放汉字，在英文数据过多时，更深空间，用来传输效率更高
# utf-16：所有支持的符号都采用2个字节存放，读存数据采用定长，不用计算，读存效率高

# 硬盘到内存需要数据的传输，内存到CPU需要数据的传输，所有都采用utf-8
# 内存需要高速读写，采用utf-16

# 学习的结晶：编码与解码要统一编码
# 操作文本字符
res = "汉字呵呵".encode('utf-8')  # 编码：将普通字符串转化为二进制字符串
print(res)

res = b'\xe5\x91\xb5\xe5\x91\xb5'.decode('GBK')  # 解码：将二进制字符串转化为普通字符串
print(res)
res = b'\xe5\x91\xb5\xe5\x91\xb5'.decode('utf-8')
print(res)