第一模块：数据类型，字符编码，文件操作(三)

@

目录

• 1.字符编码
  • • 二进制
    • 十进制转换二进制
    • 文字转二进制
    • GBK和GB2312
    • Unicode 万国码
    • UTF-8
• 2.数据类型
  • • 列表
    • 元组
    • 字典
    • 集合 (set)
      • 集合的 曾 删 改 查
      • 集合的关系测试

1.字符编码

• bin()函数将十进制转换成而进制

• oct()函数将十进制转换成八进制

• hex()函数将十进制转换成十六进制

二进制

二进制是计算技术中广泛采用的一种数制。二进制数据是用0和1两个数码来表示的数。它的基数为2，进位规则是“逢二进一”，借位规则是“借一当二”，由18世纪德国数理哲学大师莱布尼兹发现。当前的计算机系统使用的基本上是二进制系统，数据在计算机中主要是以补码的形式存储的。计算机中的二进制则是一个非常微小的开关，用“开”来表示1，“关”来表示0。

十进制转换二进制

……	256	128	64	32	16	8	4	2	1
-	1	0	1	0	0	0	1	0	0

既324

在Python中快速转成二进制用bin()

# Author:Nepoleon
bin(324)

输出为'0b101000100' 0b表示二进制

文字转二进制

把文字和数字对应上，这张表就相当于翻译，我们可以拿着一个数字来对比对应表找到相应的文字

将"zhou"按照ASCII码转化二进制

字母	ASCII对应数字	128 64 32 16 8 4 2 1
z	138	1 0 0 0 1 0 1 0
h	120	0 1 1 1 1 0 0 0
o	127	0 1 1 1 1 1 1 1
u	133	1 0 0 0 0 1 0 1

zhou 的二进制为 10001010 1111000 1111111 10000101

如何分清哪个代表z哪个代表h
正是由于这些字符串长短不一，写在一起难以区分起始位置，所以想到一个解决的办法，既一共255个字符，那最长的也就是11111111八位，不如我们把所有的二进制都转成8位的，不足的用0来替换。

每一位0或者1所占的空间单位为bit(比特)，这是计算机中最小的表示单位。

8bit = 1 bytes 最小的存储单位，1bytes 缩写 1B
1kb = 1024b
1Mb = 1024kb
1Gb = 1024Mb
1Tb = 1024Gb
1Pb = 1024Tb
1Eb = 1024Pb
1Zb = 1024Eb
1Yb = 1024Zb
1Bb = 1024Yb

GBK和GB2312

对于我们来说能在计算机中显示中文字符是至关重要的，然而刚学习的ASCII表里连一个偏旁部首也没有。所以我们还需要一张关于中文和数字对应的关系表。之前我们已经看到了，一个字节只能最多表示256个字符，要处理中文显然一个字节是不够的，所以我们需要采用两个字节来表示，而且还不能和ASCII编码冲突，所以，中国制定了GB2312编码，用来把中文编进去。

GB2312(1980年)一共收录了7445个字符，包括6763个汉字和682个其它符号。汉字区的内码范围高字节从B0-F7，低字节从A1-FE，占用的码位是72*94=6768。其中有5个空位是D7FA-D7FE。

GB2312 支持的汉字太少。1995年的汉字扩展规范GBK1.0收录了21886个符号，它分为汉字区和图形符号区。汉字区包括21003个字符。2000年的 GB18030是取代GBK1.0的正式国家标准。该标准收录了27484个汉字，同时还收录了藏文、蒙文、维吾尔文等主要的少数民族文字。现在的PC平台必须支持GB18030，对嵌入式产品暂不作要求。所以手机、MP3一般只支持GB2312。

从ASCII、GB2312、GBK 到GB18030，这些编码方法是向下兼容的，即同一个字符在这些方案中总是有相同的编码，后面的标准支持更多的字符。在这些编码中，英文和中文可以统一地处理。区分中文编码的方法是高字节的最高位不为0。按照程序员的称呼，GB2312、GBK到GB18030都属于双字节字符集 (DBCS)。

有的中文Windows的缺省内码还是GBK，可以通过GB18030升级包升级到GB18030。不过GB18030相对GBK增加的字符，普通人是很难用到的，通常我们还是用GBK指代中文Windows内码。

显然ASCII码无法将世界上的各种文字和符号全部表示，所以，就需要新出一种可以代表所有字符和符号的编码，即：Unicode

Unicode 万国码

Unicode把所有语言都统一到一套编码里，这样就不会再有乱码问题了。

Unicode标准也在不断发展，但最常用的是用两个字节表示一个字符（如果要用到非常偏僻的字符，就需要4个字节）。现代操作系统和大多数编程语言都直接支持Unicode。

现在，捋一捋ASCII编码和Unicode编码的区别：

ASCII编码是1个字节，而Unicode编码通常是2个字节。

字母A用ASCII编码是十进制的65，二进制的01000001；

字符0用ASCII编码是十进制的48，二进制的00110000；

汉字“中”已经超出了ASCII编码的范围，用Unicode编码是十进制的20013，二进制的01001110 00101101。

你可以猜测，如果把ASCII编码的A用Unicode编码，只需要在前面补0就可以，因此，A的Unicode编码是00000000 01000001。

如果统一成Unicode编码，乱码问题从此消失了。但是，如果你写的文本基本上全部是英文的话，用Unicode编码比ASCII编码需要多一倍的存储空间，在存储和传输上就十分不划算。

UTF-8

所以，本着节约的精神，又出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符，用UTF-8编码就能节省空间：

字符	ASCII	Unicode	UTF-8
A	01000001	00000000	01000001
中	x	01001110	00101101
从上面的表格还可以发现，UTF-8编码有一个额外的好处，就是ASCII编码实际上可以被看成是UTF-8编码的一部分，所以，大量只支持ASCII编码的历史遗留软件可以在UTF-8编码下继续工作。

常用编码介绍一览表

编码	制定时间	作用	所占字节数
ASCII	1967年	表示英语及西欧语言	8bit/1bytes
GB2312	1980年	国家简体中文字符集，兼容ASCII	2bytes
Unicode	1991年	国际标准组织统一标准字符集	2bytes
GBK	1995年	GB2312的扩展字符集，支持繁体字，兼容GB2312	2bytes
UTF-8	1992年	不定长编码	1-3bytes

2.数据类型

列表

定义：[]内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素

lis = ["a","b","c"]            # 创建列表
lis1 = ["a","adsa",["cx"],"gb"]
lis2 = list()   

查询

l2 = ["a","b","c","d","a","e",1,2]
>>> l2[2]    # 通过索引取值
>>> "c"
>>> l2[-2]    #通过索引从右边开始取值
>>> 1
>>> l2.index("a")  # 返回指定元素的索引值
>>> 0
>>> l2.count("a")   #  统计指定元素重复的个数
>>> 2

切片

>>> L2 =["a","b","c","d","e","a","e",1,2]
>>> L2
['a', 'b', 'c', 'd', 'e', 'a', 'e', 1, 2]
>>> L2[0:3]     # 返回从0 到 3的位置的元素，不包括3，顾头不顾尾
['a', 'b', 'c']
>>> L2[0:-1]     # 返回从 0到最后一个元素的值，不包括最后一个元素
['a', 'b', 'c', 'd', 'e', 'a', 'e', 1]
>>> L2[3:6]    # 返回索引3 到6的元素
['d', 'e', 'a']
>>> L2[3:]  # 返回从索引3到最后一个元素
['d', 'e', 'a', 'e', 1, 2]
>>> L2[:3]  # 返回从索引0 到 3的值
['a', 'b', 'c']
>>> L2[1:6:2]  # 返回索引 1 到6的值，步长是2(每隔一个元素取一个值)
['b', 'd', 'a']
>>> L2[:]  # 返回所有的值
['a', 'b', 'c', 'd', 'e', 'a', 'e', 1, 2]
>>> L2[::2]   # 返回所有的值，步长是为2
['a', 'c', 'e', 'e', 2]
>>>

修改及删除

>>> L2
['a', 'b', 'c', 'd', 'e', 'a', 'e', 1, 2]
>>> L2.append("A")      # 列表最后添加“A”
>>> L2
['a', 'b', 'c', 'd', 'e', 'a', 'e', 1, 2, 'A']
>>> L2.insert(3,"B")     # 在3的位置添加“B”
>>> L2
['a', 'b', 'c', 'B', 'd', 'e', 'a', 'e', 1, 2, 'A']
>>> L2
['a', 'b', 'c', 'B', 'd', 'e', 'a', 'e', 1, 2, 'A']
>>> L2[3] = "CTY"   # 把索引3号的值修改为 “CTY”
>>> L2
['a', 'b', 'c', 'CTY', 'd', 'e', 'a', 'e', 1, 2, 'A']
>>> L2[4:6] = "NEOP"   # 把索引4 到6的元素替换”NEPO“ ，不够的元素自动添加
>>> L2
['a', 'b', 'c', 'CTY', 'N', 'E', 'O', 'P', 'a', 'e', 1, 2, 'A']
>>> L2
['a', 'b', 'c', 'CTY', 'N', 'E', 'O', 'P', 'a', 'e', 1, 2, 'A']
>>> L2.pop()    # 删除最后一个元素 并返回删除的值
'A'
>>> L2.remove("N")    # 从左开始删除第一个指定的元素
>>> L2
['a', 'b', 'c', 'CTY', 'E', 'O', 'P', 'a', 'e', 1, 2]
>>> del L2[4]   # 用 python全局的方法 删除指定元素
>>> L2
['a', 'b', 'c', 'CTY', 'O', 'P', 'a', 'e', 1, 2]
>>> del L2[3:7]    # 删除多个元素
>>> L2
['a', 'b', 'c', 'e', 1, 2]
>>>

排序

>>> L2 = ["a","b","c","d",1,2]
>>> L2
['a', 'b', 'c', 'd', 1, 2]
>>> del L2[-2:]
>>> L2
['a', 'b', 'c', 'd']
>>> L2.sort()    # 不能对包含str 和int的列表进行排序
>>> L2
['a', 'b', 'c', 'd']
>>> L2.insert(3,"#")    # 插入
>>> L2.insert(1,"!")
>>> L2
['a', '!', 'b', 'c', '#', 'd']
>>> L2.sort()    # 按照 ASCII表排序
>>> L2
['!', '#', 'a', 'b', 'c', 'd']
>>> L2.reverse()   # 反转
>>> L2
['d', 'c', 'b', 'a', '#', '!']

其他用法

>>> L2
['d', 'c', 'b', 'a', '#', '!']
>>> L2.extend([1,2,3,4])    # 把一个列表扩展到L2列表
>>> L2
['d', 'c', 'b', 'a', '#', '!', 1, 2, 3, 4]
>>> L2[4]= ["1","abs","tom"]    
>>> L2
['d', 'c', 'b', 'a', ['1', 'abs', 'tom'], '!', 1, 2, 3, 4]
>>> L2[4][1]  # 嵌套取值
>>> "1"
>>> L2.clear()   #  清空列表
>>> L2
[]

元组

元组跟列表类似，也是存一组数，元组一旦创建就不能再修改，所以又叫只读列表

特性

• 不可变
• 元组本身不可变，但是如果元组还包含其他可变元素，这些可变元素是可以改变的

>>> s = ("a","b","c")
>>> s
('a', 'b', 'c')
>>> s.index("b")  # 索引
1 
>>> s.count("a")   # 相同元素
1
>>> s[1]    # 切片 跟 列表类似
'b'
>>>

元组中不仅可以存放数字、字符串，还可以存放更加复杂的数据类型

字典

字典是Python语言中唯一的映射类型。
字典的创建

person = {"name": "kity", 'age': 20}
#或
person = dict(name='seven', age=20)
#或
person = dict({"name": "kity", 'age': 20})

特性

• key - value 结构
• key 必须可hash，且必须是不可变的数据类型，必须是唯一的
• 可存放任意多个值，可修改，可以不唯一
• 无序
• 查找速度快
  增加

>>> info
{'name1': 'zhangsan', 'name2': 'lisi', 'name3': 'wanger'}
>>> info["name4"] = "mazi"  # 增加
>>> info
{'name1': 'zhangsan', 'name2': 'lisi', 'name3': 'wanger', 'name4': 'mazi'}
>>> info["name1"] = "张三"  # 修改
>>> info
{'name1': '张三', 'name2': 'lisi', 'name3': 'wanger', 'name4': 'mazi'}
>>>

查找

>>> info
{'name1': 'zhangsan', 'name2': 'lisi', 'name3': 'wanger'}
>>> "name1" in info     # 标准用法
True
>>> info.get("name1")    #获取
'zhangsan'
>>> info["zhangsan"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'zhangsan'
>>> info["name1"]
'zhangsan'
>>> info["name4"]     # 如果key 不存在，就会报错 get不会报错，返回None
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'name4'
>>> info.get("dsd")

删除

>>> info
{'chenyang': [23, 'mp'], 'hanchen': [25, 'anm'], 'zk': [20, 'lead'], 'weijia': [22, 'comp']}
>>> info.popitem()      #随机删
('weijia', [22, 'comp'])   #返回删除的值
>>> info.pop("hanchen")     # 删除指定的key
[25, 'anm'] 

其他用法

>>> info
{'chenyang': [23, 'mp'], 'zk': [20, 'lead'], 'chenzhao': [22, 'vfx']}
>>> info.keys()    # 返回所有的key
dict_keys(['chenyang', 'zk', 'chenzhao'])
>>> info.items()  # 返回所有的值
dict_items([('chenyang', [23, 'mp']), ('zk', [20, 'lead']), ('chenzhao', [22, 'vfx'])])
>>> info1
{'zk': ['zs', 22, 'CTO'], 'jiayu': [29, 'lay']}
>>>info.update(info1)    # 覆盖
>>> info
{'chenyang': [23, 'mp'], 'zk': ['zs', 22, 'CTO'], 'chenzhao': [22, 'vfx'], 'jiayu': [29, 'lay']}

>>> info.setdefault("zk",["heihei"])    # 设置一个 key 对应一个值，如果本来里面有设置的key，就还是原来的。
			  
['zs', 22, 'CTO']
>>> info.setdefault("chang",[22,"mod"])    # 设置一个key，字典里没有这个key，就会新生成一个 key-value
			  
[22, 'mod']
>>> info
			  
{'chenyang': [23, 'mp'], 'zk': ['zs', 22, 'CTO'], 'chenzhao': [22, 'vfx'], 'jiayu': [29, 'lay'], 'chang': [22, 'mod']}
##########################################################################
>>> lis = ["a","b","c"]
			  
>>> lis_dic = dict.fromkeys(lis,"stud")     # 批量 创建
			   
>>> lis_dic
			  
{'a': 'stud', 'b': 'stud', 'c': 'stud'}

集合 (set)

集合是一个无序的，不重复的数据组合，它的作用：

• 去重，把一个列表变成集合，自动去重
• 关系测试，测试两组数据之前的交集，差集，并集等关系

集合的定义

s = {1,2,3}   # 大括号定义
>>> l = [1,2,3,3,4,5,6]
>>> set(l)   # 将列表转成集合
{1, 2, 3, 4, 5, 6}

集合的 曾 删 改 查

>>> s
{1, 2, 3, 4, 5, 6}
>>> s.add(7)     # 增加
>>> s
{1, 2, 3, 4, 5, 6, 7}
>>> s.pop()    # 随机删除一个值，集合是无序的
1
>>> s.remove(2)   # 删除某个元素
>>> s
{3, 4, 5, 6, 7}
>>> s.discard(8)    #  也是删除，跟remove的区别是删除没有的元素不会报错
>>> s.discard(3)
>>> s
{4, 5, 6, 7}
>>> s.update("a")   #     覆盖
>>> s
{4, 5, 6, 7, 'a'}
>>> s.update([1,2,3,4,45,6,7])
>>> s
{2, 1, 4, 5, 6, 7, 3, 'a', 45}
>>> s.clear()    # 清空

集合的关系测试

并集

>>> a = {1,2,3,4,5}
>>> b = {4,5,6,7,8}
>>> a.union(b)          #合并集合 去重
{1, 2, 3, 4, 5, 6, 7, 8}
>>> a|b        # 管道符
{1, 2, 3, 4, 5, 6, 7, 8}

差集

>>> a = {1,2,3,4,5}
>>> b = {4,5,6,7,8}
>>> a.difference(b)    # 只在a里不在b里的集合
{1, 2, 3}  
>>> a-b
{1, 2, 3}

对称差集

>>> a = {1,2,3,4,5}
>>> b = {4,5,6,7,8}
>>> a.symmetric_difference(b)   # 只在a,或只在b里的元素
{1, 2, 3, 6, 7, 8}     
>>> a^b
{1, 2, 3, 6, 7, 8}

包含关系

in,not in：判断某元素是否在集合内
==,!= 判断2个集合是否相等

两个集合之间一般有三种关系，相交、包含、不相交。在Python中分别用下面的方法判断：

• set.isdisjoint(s)：判断两个集合是不是不相交
• set.issuperset(s)：判断集合是不是包含其他集合，等同于a>=b
• set.issubset(s)：判断集合是不是被其他集合包含，等同于a<=b