第2章，数据类型、字符编码

第二章，数据类型、字符编码

一、二进制

• 定义

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

• 二进制与十进制转换

  填位大法：

  先把他们代表的值依次写出来，然后再根据10进制的值把数填到相应位置，就好了～～～

  十进制转二进制方法相同，只要对照二进制为1的那一位对应的十进制值相加就可以了。

  

二、字符编码

ASCII码

由于计算机是美国人发明的，因此，最早只有127个字母被编码到计算机里，也就是大小写英文字母、数字和一些符号，这个编码表被称为ASCII编码，比如大写字母 A的编码是65，小写字母 z的编码是122。后128个称为扩展ASCII码。

GBK和GB2312

​ 由于ASCII码中没有中文，所以我们还需要一张关于中文和数字对应的关系表。之前我们已经看到了，一个字节只能最多表示256个字符，要处理中文显然一个字节是不够的，所以我们需要采用两个字节来表示，而且还不能和ASCII编码冲突，所以，中国制定了GB2312编码，用来把中文编进去。

​ 后来发现GB2312里面没有繁体字和少数名族的字体，中国后来又发布了兼容GB2312且包含的字体更多的GBK编码。

Unicode

全世界有上百种语言，日本把日文编到Shift_JIS里，韩国把韩文编到Euc-kr里，

各国有各国的标准，就会不可避免地出现冲突，结果就是，在多语言混合的文本中，显示出来会有乱码。

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

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

UTF-8

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

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

字符	ASCII	Unicode	UTF-8
A	01000001	00000000 01000001	01000001
中	x	01001110 00101101	11100100 10111000 10101101

字符编码工作方式

在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。

用记事本编辑的时候，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode转换为UTF-8保存到文件。

文件存取编码转换图

常用编码介绍一览表

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

三、基本数据类型

(一)、数字

整型

Python中的整数属于int类型，默认用十进制表示，此外也支持二进制，八进制,十六进制表示方式。

进制转换

尽管计算机只认识二进制，但是为了迎合我们的习惯，python中的数字默认还是十进制。还提供了一些方法来帮助我们做转换。比如是进制转换为二进制使用bin方法，在转换结果前面还会加上‘0b’表示是一个二进制书。

既然十进制可以转换为二进制，那么其实使用同样的原理也可以转换为其他进制，python也为我们提供了十进制转换成八进制和十六进制的方法，分别是oct和hex。八进制前面以‘0o’标示，十六进制以‘0x’标示

>>> bin(10)
'0b1010'
>>> oct(10)
'0o12'
>>> hex(10)
'0xa'

浮点型

浮点数是属于有理数中某特定子集的数的数字表示，在计算机中用以近似表示任意某个实数。具体的说，这个实数由一个整数或定点数（即尾数）乘以某个基数（计算机中通常是2）的整数次幂得到，这种表示方法类似于基数为10的科学计数法。

在运算中，整数与浮点数运算的结果也是一个浮点数。

为什么要叫做float浮点型？

浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，
一个浮点数的小数点位置是可变的，比如，
1.23109和12.3108是相等的。
浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代：
1.23*109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的而浮点数运算则可能会有四舍五入的误差。

关于小数不精准问题

Python默认的是17位精度,也就是小数点后16位，尽管有16位，但是这个精确度却是越往后越不准的。

首先，这个问题不是只存在在python中，其他语言也有同样的问题

其次，小数不精准是因为在转换成二进制的过程中会出现无限循环的情况，在约省的时候就会出现偏差。

比如：11.2的小数部分0.2转换为2进制则是无限循环的00110011001100110011…

单精度在存储的时候用23bit来存放这个尾数部分（前面9比特存储指数和符号）；同样0.6也是无限循环的；

这里有一个问题，就是当我们的计算需要使用更高的精度（超过16位小数）的时候该怎么做呢？

#借助decimal模块的“getcontext“和“Decimal“ 方法
>>> a = 3.141592653513651054608317828332
>>> a
3.141592653513651
>>> from decimal import *
>>> getcontext()
Context(prec=50, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[FloatOperation], traps=[InvalidOperation, DivisionByZero, Overflow])
>>> getcontext().prec = 50
>>> a = Decimal(1)／Decimal(3)#注，在分数计算中结果正确，如果直接定义超长精度小数会不准确
>>> a
Decimal('0.33333333333333333333333333333333333333333333333333')

>>> a = '3.141592653513651054608317828332'
>>> Decimal(a)
Decimal('3.141592653513651054608317828332')
#不推荐：字符串格式化方式，可以显示，但是计算和直接定义都不准确，后面的数字没有意义。
>>> a = ("%.30f" % (1.0/3))  
>>> a  
'0.333333333333333314829616256247'

复数

复数是由实数和虚数组成的

要了解复数，其实关于复数还需要先了解虚数。虚数(就是虚假不实的数):平方为复数的数叫做虚数。

复数是指能写成如下形式的数a+bi，这里a和b是实数，i是虚数单位(即-1开根)。在复数a+bi中，a称为复数的实部，b称为复数的虚部(虚数是指平方为负数的数)，i称为虚数单位。

当虚部等于零时，这个复数就是实数；当虚部不等于零时，这个复数称为虚数。

注，虚数部分的字母j大小写都可以。

(二)、字符串

字符串的定义与创建

字符串是一个有序的字符的集合，用于存储和表示基本的文本信息，’ ‘或’’ ‘‘或’’’ ‘’'中间包含的内容称之为字符串

创建：

 s = 'Hello,Eva！How are you?'

字符串的特性与常用操作

特性：

1.按照从左到右的顺序定义字符集合，下标从0开始顺序访问，有序

补充：

1.字符串的单引号和双引号都无法取消特殊字符的含义，如果想让引号内所有字符均取消特殊意义，在引号前面加r，如name＝r’l\thf’

2.unicode字符串与r连用必需在r前面，如name＝ur’l\thf’

常用操作：

#索引
s = 'hello'
>>> s[1]
'e'
>>> s[-1]
'o'

>>> s.index('e')
1

#查找
>>> s.find('e')
1
>>> s.find('i')
-1

#移除空白
s = '  hello,world!  '
s.strip()
s.lstrip()
s.rstrip()
s2 = '***hello,world!***'
s2.strip('*')

#长度
>>> s = 'hello,world'
>>> len(s)
11

#替换
>>> s = 'hello world'
>>> s.replace('h','H')
'Hello world'
>>> s2 = 'hi，how are you？'
>>> s2.replace('h','H')
'Hi，How are you？'

#切片
>>> s = 'abcdefghigklmn'
>>> s[0:7]
'abcdefg'
>>> s[7:14]
'higklmn'
>>> s[:7]
'abcdefg'
>>> s[7:]
'higklmn'
>>> s[:]
'abcdefghigklmn'
>>> s[0:7:2]
'aceg'
>>> s[7:14:3]
'hkn'
>>> s[::2]
'acegikm'
>>> s[::-1]
'nmlkgihgfedcba'

(三)、列表

列表的定义和创建

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

列表的创建

list_test=[‘张三‘,‘李四’,'alex']
#或
list_test=list('alex')
#或
list_test=list([‘张三‘,‘李四’,'alex'])

列表的特点和常用操作

特性：

1.可存放多个值

2.按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序

3.可修改指定索引位置对应的值，可变

常用操作：

#索引
>>> l = ['egon','alex','seven','yuan']
>>> l[0]
'egon'
>>> l[2]
'seven'

#切片
>>> l[0:2]
['egon', 'alex']
>>> l[2:5]
['seven', 'yuan']
>>> l[:2]
['egon', 'alex']
>>> l[2:]
['seven', 'yuan']
>>> l[:]
['egon', 'alex', 'seven', 'yuan']
>>> l[::2]
['egon', 'seven']
>>> l[::-1]
['yuan', 'seven', 'alex', 'egon']

#追加
>>> l.append("eva")
>>> l
['egon', 'alex', 'seven', 'yuan', 'eva']

#删除
>>> l.remove('eva')
>>> l
['egon', 'alex', 'seven', 'yuan']
>>> l.pop()
'yuan'
>>> l
['egon', 'alex', 'seven']

#长度
>>> len(l)
3

#包含
>>> 'seven' in l
True
>>> 'yuan' in l
False

#循环:为什么是“i”？
>>> for i in l:
    print(i)


egon
alex
seven

列表与字符串——split和join

#分割
>>> s = 'hello world'
>>> s.split(' ')
['hello', 'world']
>>> s2= 'hello,world'
>>> s2.split(',')

#连接
>>> l = ['hi','eva']
>>> '!'.join(l)
'hi!eva'

(四)、元祖

元组的定义和特性

定义：与列表类似，只不过［］改成（）

特性：

1. 可存放多个值

​ 2. 不可变

​ 3.按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序

元组的创建与常用操作

创建

ages = (11, 22, 33, 44, 55)
#或
ages = tuple((11, 22, 33, 44, 55))

常用操作

#索引
>>> ages = (11, 22, 33, 44, 55)
>>> ages[0]
11
>>> ages[3]
44
>>> ages[-1]
55

#切片:同list　　

#循环
>>> for age in ages:
    print(age)

11
22
33
44
55

#长度
>>> len(ages)
5

#包含
>>> 11 in ages
True
>>> 66 in ages
False
>>> 11 not in ages
False

元组的特性详解

1.可存放多个值

如果元组中只有一个值,需要在第一个值的后面加上逗号（，）括号不代表元祖，逗号才代表元祖

t = (1,)
type(t) #<class 'tuple'>	
t = (1)   
type(t)#<class 'int'>
t=1,
type(t)#<class 'tuple'>

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

2.不可变

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

(五)、集合

认识集合

集合是一个数学概念：由一个或多个确定的元素所构成的整体叫做集合。

集合中的元素有三个特征：

1.确定性（元素必须可hash）

2.互异性（去重）

3.无序性（集合中的元素没有先后之分），如集合{3,4,5}和{3,5,4}算作同一个集合。

注意：集合存在的意义就在于去重和关系运算

用集合解决问题

l= {'张三','李四','老男孩'}  #集合定义
p = {'张三','李四','alex'}
l_p = l&p    #集合求交集
print(l_p)

集合的定义

l= {1,2,3,1}  #此处应说明集合“去重”的效果
#定义可变集合
>>> set_test=set('hello') #此处应说明集合的“无序性”
>>> set_test
{'l', 'o', 'e', 'h'}
#改为不可变集合frozenset
>>> f_set_test=frozenset(set_test)
>>> f_set_test
frozenset({'l', 'e', 'h', 'o'})

集合的关系运算

除了刚刚我们学过的交集之外，集合还可以做其他的关系运算。

继续以引子为例，现在已知两个集合分别是学习linux班的同学和学习python班的同学

&.&=:交集——既学习linux课程也学习python课程的同学

l= {'张三','李四','老男孩'}
p = {'张三','李四','alex'}
print(l.intersection(p))
print(l&p)

|,|=:合集，也叫并集——linux班和python班的所有同学

这里同学们不可以单纯的认为python班的人数+linux班的人数就是结果，如果两班人数相加应该是6人。但学习Linux班的张三和李四还同时在python班学习，因此我们实际上总共只有四个学员。求并集除了合并效果之外还有去重功能

l= {'张三','李四','老男孩'}
p = {'张三','李四','alex'}
print(l.union(p))
print(l|p)

－,－=:差集——只在linux而不python班的同学

l= {'张三','李四','老男孩'}
p = {'张三','李四','alex'}
print(l.difference(p))
print(l-p)

^,=:对称差集——只在linux班或只在python班的同学

a = {1,2,3}
b = {2,3,4,5}
print(a.symmetric_difference(b))
print(a^b)

包含关系

in,not in：判断某元素是否在集合内
＝＝,！＝:判断两个集合是否相等

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

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

集合的常用操作

元素的增加

单个元素的增加 : add()，add的作用类似列表中的append

对序列的增加 : update()，而update类似extend方法，update方法可以支持同时传入多个参数：

>>> a={1,2}
>>> a.update([3,4],[1,2,7])
>>> a
{1, 2, 3, 4, 7}
>>> a.update("hello")
>>> a
{1, 2, 3, 4, 7, 'h', 'e', 'l', 'o'}
>>> a.add("hello")
>>> a
{1, 2, 3, 4, 'hello', 7, 'h', 'e', 'l', 'o'}

元素的删除

集合删除单个元素有两种方法：

元素不在原集合中时：

set.discard(x)不会抛出异常

set.remove(x)会抛出KeyError错误

>>> a={1,2,3,4}
>>> a.discard(1)
>>> a
{2, 3, 4}
>>> a.discard(1)
>>> a
{2, 3, 4}
>>> a.remove(1)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
KeyError: 1

pop()：由于集合是无序的，pop返回的结果不能确定，且当集合为空时调用pop会抛出KeyError错误，

clear():清空集合

>>> a={3,"a",2.1,1}
>>> a.pop()
>>> a.pop()
>>> a.clear()
>>> a
set()
>>> a.pop()
Traceback (most recent call last):
  File "<input>", line 1, in <module>
KeyError: 'pop from an empty set'

(六)、字典

可变与不可变类型

在python中，我们对数据类型还有另外一种分类方式，我们给数据类型分为可变数据类型和不可变数据类型。在了解原理之前，我们先来看看分类情况：

可变类型	不可变类型
列表	数字
集合	字符串
字典	元组

看着上面这句话，我们来看看什么叫可变什么叫不可变

列表

>>> l = [1,2,3,4]
>>> id(l)
4392665160
>>> l[1] = 1.5
>>> l
[1, 1.5, 3, 4]
>>> id(l)
4392665160

数字

>>> a = 1
>>> id(a)
4297537952 
>>> a+=1
>>> id(a)
4297537984

从内存角度看列表与数字的变与不变

字符串

#例1
>>> s = 'hello'
>>> s[1] = 'a'
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    s[1] = 'a'
TypeError: 'str' object does not support item assignment
#例2
>>> s = 'hello'
>>> id(s)
4392917064
>>> s += ' world'
>>> s
'hello world'
>>> id(s)
4393419504

字符串也可以像列表一样使用索引操作，但是通过上例可以看出，我们不能像修改列表一样修改一个字符串的值，当我们对字符串进行拼接的时候，原理和整数一样，id值已经发生了变化，相当于变成了另外一个字符串。

元组——不允许修改

>>> t = (1,2,3,4)
>>> t[1] = 1.5
Traceback (most recent call last):
  File "<pyshell#10>", line 1, in <module>
    t[1] = 1.5
TypeError: 'tuple' object does not support item assignment

hash

用特定的算法计算出一个值用来表示一个不可变类型。

可以被hash的内容

可变的数据类型是不可以被hash的，如果一个值可以hash那么说明这是一个不可变的数据类型。

字典的定义与特性

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

定义：｛key1:value1,key2:value2｝

1、键与值用冒号“：”分开；
2、项与项用逗号“，”分开；

特性：

1.key-value结构
2.key必须可hash、且必须为不可变数据类型、必须唯一
3.可存放任意多个值、可修改、可以不唯一
4.无序

字典的创建与常见操作

字典的创建

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

person = dict((['name','苑昊'],['文周',18]))
{}.fromkeys(seq,100) #不指定100默认为None
#注意
>>> dic={}.fromkeys(['k1','k2'],[])
>>> dic
{'k1': [], 'k2': []}
>>> dic['k1'].append(1)
>>> dic
{'k1': [1], 'k2': [1]}

字典的常见操作

键、值、键值对
　　　　1、dic.keys() 返回一个包含字典所有KEY的列表；
　　　　2、dic.values() 返回一个包含字典所有value的列表；
　　　　3、dic.items() 返回一个包含所有（键，值）元祖的列表；
　　　　4、dic.iteritems()、dic.iterkeys()、dic.itervalues() 与它们对应的非迭代方法一样，不同的是它们返回一个迭代子，而不是一个列表；
新增
　　　　1、dic['new_key'] = 'new_value'；
　　　　2、dic.setdefault(key, None) ,如果字典中不存在Key键，由 dic[key] = default 为它赋值；_
删除
　　　　1、dic.pop(key[,default]) 和get方法相似。如果字典中存在key，删除并返回key对应的vuale；如果key不存在，且没有给出default的值，则引发keyerror异常；
　　　　2、dic.clear() 删除字典中的所有项或元素；    
修改
　　　　1、dic['key'] = 'new_value',如果key在字典中存在，'new_value'将会替代原来的value值；
　　　　2、dic.update(dic2) 将字典dic2的键值对添加到字典dic中
查看
　　　　1、dic['key']，返回字典中key对应的值，若key不存在字典中，则报错；
　　　　2、dict.get(key, default = None) 返回字典中key对应的值，若key不存在字典中，则返回default的值（default默认为None）
循环
　　　　1、for k in dic.keys()
　　　　2、for k,v in dic.items()
　　　　3、for k in dic
长度
　　　　1、len(dic)