3.1 Python的数据类型
Python 3有6个标准的数据类型：
· 数字（Number）。
· 字符串（String）。
· 序列或列表（List）。
· 元组（Tuple）。
· 集合（Set）。
· 字典（Dictionary）。
1．数字（Number）
Python 3支持整数（int）、浮点数（float）、布尔值（bool）、复数（complex）4种数字类型。
1）整数
整数通常被称为整型，可分为正整数或负整数，不带小数点。Python 3整型是不限制大小的，可以当作长整型“Long”类型使用，所以Python 3没有Python 2的长整数类型。
整数可以用数字表示，也可以用十六进制或八进制表示。数字表示方法和数学上的写法一样，而不同的电脑系统、编程语言对于十六进制数值有不同的表示方式。Python, Java及其他相近的语言使用字首“0x”，如“0x5A3”，其中开头的“0”可使解析器更容易辨认数，而“x”则代表十六进制，另外“o”代表八进制。在“0x”中，“x”可以大写也可以小写。0x作为前缀和0～9, a～f或A～F等来表示十六进制数，如“0x3F8E00”。下面给出整数示例。
见示例3-1。
a=-12345678
b=0x12345678
c=0o20
print（'a=', a）
print（'b=', b）
print（'b= 0x%x'%b）
print（'c=', c）
print（'c= 0o%o'%c）
命令执行结果：
a= -12345678
b= 305419896
b= 0x12345678
c=16
c= 0o20
2）浮点数
浮点数也就是带小数点的数值，浮点数由整数部分与小数部分组成。浮点数可以用数学写法，如1.23,3.14, -9.01等形式来表示，但是对于很大或很小的浮点数，就必须用科学计数法表示。例如，2.5e3中的“e”表示数字10,“e3”表示10的3次方，因此2.5e3 = 2500。下面给出浮点数示例3-2。
a=-12.345678
b=-1.85324534234e8
print（'a=', a）
print（'b=', b）
print（'b= %e'%b）
命令执行结果：
a= -12.345678
b= -185324534.234
b= -1.853245e+08
浮点数可以用round（）函数来改变小数点后面的位数。例如，c=round（12.34567894）的结果为c=12.3456。
浮点数可以用int（）函数来取整数。例如，d=int（12.3456789）的结果为d=12。
见示例3-3。
c=round（12.3456789,4）
print（'c= ', c）
d=int（12.3456789）
print（'d= ', d）
命令执行结果：
c= 12.3457
d= 12
3）布尔值
Python 3的布尔值有True（真）和False（假），它们与整数中的1和0有对应关系。下面给出布尔值示例3-4。
a=True
b=False
print（'a=', a）
print（'b=', b）
print（'a==1 ', a==1）
print（'b==0 ', b==0）
print（'a==18 ', a==18）
print（'a==0 ', a==0）
print（'a==-1 ', a==-1）
命令执行结果：
a= True
b= False
a==1 True
b==0 True
a==18 False
a==0 False
a==-1 False
4）复数
Python 3的复数类型存放的是一对浮点数，一个表示实数部分（real），另一个表示虚数部分（imag，跟随一个字母j）。
复数由实数部分和虚数部分构成，可以用“a + bj”或者“complex（a, b）”表示，其中实部“a”和虚部“b”都是浮点型。
例如，整数“20”，浮点数“3.45+e12”，复数“4.53-7.2j”。
除了“//”“%”运算符和个别不支持复数的函数外，其他操作符与函数都可以用于复数操作。
下面给出复数示例3-5。
a=2.912+3.289j
print（’复数a= ', a）
print（’实部： ', a.real, ' , 虚部： ', a.imag）
print（’共轭复数： ', a.conjugate（）） #输出该复数的共轭复数
print（）
b=complex（1.23,4.56）
print（’复数b= ', b）
print（’实部： ', b.real, ' , 虚部： ', b.imag）
print（’共轭复数： ', b.conjugate（）） #输出该复数的共轭复数
命令执行结果：
复数a= （2.912+3.289j）
实部： 2.912 , 虚部： 3.289
共轭复数： （2.912-3.289j）
复数b= （1.23+4.56j）
实部： 1.23 , 虚部： 4.56
共轭复数： （1.23-4.56j）
2．字符串（String）
字符串属于序列类型（sequence type）。字符串是以单引号“'”、双引号“"”、三个单引号“'''”或者三个双引号“"""”括起来的任意文本，如’abcd', "1234"等。请注意，单引号、双引号等本身只是一种表示方式，不是字符串的一部分。
如果要表示字符单引号或双引号，就要使用转义符“\”来标识。例如，I'm fine !用字符串表示为’I\'m fine ! '，这个字符串的长度为10。
字符串的转义字符同C++的转义字符。见表3-1。
表3-1 Python 3字符串的转义字符
Python 3使用len（str）函数来获取字符串“str”的长度。
前面介绍了Python 3的字符串属于序列类型，其相当于其他计算机语言中的数组类型。因此，Python 3有序列索引，而其他语言称其为数组下标。Python 3的序列索引第一个值是0。例如，在b='1234’中b[0]的值是字符1, b[2]的值是字符3。
Python 3的序列类型都可以进行切片操作（slice），即从一个字符串中获取子字符串（字符串的一部分）。我们使用方括号“[]”、起始偏移量“start”、终止偏移量“end”，以及可选的步长“step”来定义一个切片。
格式：序列类型值或序列变量[start:end:step]
下面给出字符串示例3-6。
a='I\'m fine ! '
b=len（a） #获取字符串长度
print（'a=', a）
print（'b=len（a）=', b）
#字符串转换为浮点数
c='1234'
d=float（c）
print（'d=float（c）= ', d）
#字符串切片操作
e='abcdefghijk'
print（'e= \'%s\''%e）
print（'e[0]= ', e[0]）
print（'e[-1]= ', e[-1]）
print（'e[2:4]= ', e[2:4]）
print（'e[5:]= ', e[5:]）
print（'e[:5]= ', e[:5]）
print（'e[::2]= ', e[::2]）
f='123456789'
print（'f= \'%s\''%f）
print（'f[::2]= ', f[::2]）
命令执行结果：
a= I'm fine !
b=len（a）= 10
d=float（c）= 1234.0
e= 'abcdefghijk'
e[0]= a
e[-1]= k
e[2:4]= cd
e[5:]= fghijk
e[:5]= abcde
e[::2]= acegik
f= '123456789'
f[::2]= 13579
3．列表（List）
Python 3内置的一种数据类型是列表，也称为序列。列表类似于数组，可以随时添加和删除其中的元素。列表是在方括号之间，用逗号分隔开的元素，列表的索引号从0开始。
列表中的元素可以是数字类型、字符串类型，也可以是列表数据类型（嵌套列表）。列表元素类型可以不相同，也可以有重复（后面介绍的集合元素无重复）。另外，列表元素有顺序，除非用程序或命令改变顺序（后面介绍的集合元素没有顺序）。
在量化程序中，我们经常用列表来存放股票代码和股票行情数据。例如：
stocks=['0000800', '300050', '600001']
4．元组（Tuple）
元组是一种有序列表。元组和列表非常类似，但是元组一旦初始化就不能修改。元组使用小括号“（）”来包含元素，也用逗号“,”来分隔元素，其索引号也是从0开始的。例如：
stocks=（'000001', '600080', '300005'）
5．集合（Set）
在集合中，没有重复的元素。另外，由于集合元素没有顺序，因此也不存在集合索引。
在Python 3中，集合使用大括号“{}”来包含元素，也用逗号“,”来分隔元素。
下面看一个列表、元组、集合的示例，见示例3-7。
stock1=['000001', '600080', '300005'] #列表
stock2=（'000001', '600080', '300005'） #元组
stock3={'000001', '600080', '300005'} #集合
print（'stock1= ', stock1, type（stock1））
print（'stock1[0]= ', stock1[0]）
print（'stock2= ', stock2, type（stock2））
print（'stock2[1]= ', stock2[1]）
print（'stock3= ', stock3, type（stock3））
print（' \'600080\' in stock3 :', '600080' in stock3）
命令执行结果：
stock1= ['000001', '600080', '300005'] <class 'list'>
stock1[0]= 000001
stock2= （'000001', '600080', '300005'）<class 'tuple'>
stock2[1]= 600080
stock3= {'300005', '600080', '000001'} <class 'set'>
'600080' in stock3 : True
6．字典（Dictionary）
由于Python 3内置了字典数据类型，因此其具有极快的查找速度。字典使用大括号“{}”来包含元素，其中元素使用“键值（key）：数值（value）”的形式存储。键值必须是数字、字符串或元组，这些数据对象不可变动，如{key1:value1, key2: value2}。
同一个字典的键值不能相同，如果相同，后面的数值就会取代前面键值的数据。
在设计量化软件中，我们就可以使用字典数据来存放颜色及对应的RGB编码表。
下面给出字典的示例3-8。
cla={1:2,2:3,1:5} #字典
print（’原始输入数据cla={1:2 , 2:3 , 1:5}'）
print（’实际内容cla= ', cla）
#颜色编码表
cns = {
'aliceblue': '#F0F8FF'，
'black': '#000000'，
'blue': '#0000FF'，
'brown': '#A52A2A'，
'coral': '#FF7F50'，
'cornflowerblue': '#6495ED'，
'cornsilk': '#FFF8DC'，
'crimson': '#DC143C'，
'cyan': '#00FFFF'，
'darkblue': '#00008B'}
print（'cns[\'blue\']= ', cns['blue']）
print（'cns[\'darkblue\']= ', cns['darkblue']）
print（'cns[\'cyan\']= ', cns['cyan']）
命令执行结果：
原始输入数据cla={1:2 , 2:3 , 1:5}
实际内容cla= {1: 5, 2: 3}
cns['blue']= #0000FF
cns['darkblue']= #00008B
cns['cyan']= #00FFFF
len（dict）中的dict表示字典数据，用来计算字典元素个数，即键的总数。
str（dict）可把字典转换成可打印的字符串。
type（variable）中的variable表示变量，用于返回变量类型。
请看示例3-9。
a={1:2 , 2:3 , 1:5,3:4}
b=a.copy（）
print（a==b）
print（'len（a）= ', len（a））
print（a）
print（'str（b）= ' +str（b））
print（'type（b）= ', type（b））
程序运行结果：
True
len（a）= 3
{1: 5, 2: 3, 3: 4}
str（b）= {1: 5, 2: 3, 3: 4}
type（b）= <class 'dict'>
Python字典包含了以下内置方法：
dict.clear（）：删除字典内所有元素。
dict.copy（）：返回一个字典的复制。
dict.fromkeys（seq:val）：创建一个新字典，以序列“seq”中的元素作为字典的键，val为字典所有键对应的初始值。
dict.get（key, default=None）：返回指定键的值。如果值不在字典中，就返回default的值。
dict.has_key（key）：如果键在字典“dict”中就返回True，否则返回False。
dict.items（）：以列表返回可遍历的“（键，值）”元组数组。例如：
di={1:2,2:3,3:5}
print（di.items（））
输出结果：
dict_items（[（1, 2）,（2, 3）,（3, 5）]）
dict.keys（）：以列表返回一个字典所有的键。
radiansdict.setdefault（key, default=None）：和get（）函数类似，但如果键不存在于字典中，就会添加键并将值设为default。
dict.update（dict2）：把字典dict2的“（键，值）”对更新到dict中。
dict.values（）：以列表返回字典中的所有值。
见示例3-10。
#字典练习
#1．创建空字典
d={}
print（'type（d）', type（d））
#2．直接赋值创建
di={1:2,2:3,3:5}
print（’原始输入数据di={1:2 , 2:3 , 3:5}'）
print（’实际内容di= ', di）
print（di.items（））
#3．通过关键字dict和关键字参数创建
dic = dict（spam = 1, egg = 2, bar =3）
print（’实际内容dic= ', dic）
#4．通过二元组列表创建
list = [（'spam', 1）,（'egg', 2）,（'bar', 3）]
dic2 = dict（list）
print（’实际内容dic2= ', dic2）
#5.dict和zip结合创建
dic3 = dict（zip（'abc', [1, 2, 3]））
print（’实际内容dic3= ', dic3）
#6．通过字典推导式创建
dic4 = {i:2＊i for i in range（4）}
print（’实际内容dic4= ', dic4）
#7．通过dict.fromkeys（）函数创建
dic5 = dict.fromkeys（range（4）, 'x'）
print（’实际内容dic5= ', dic5）
#8．其他方法
list = ['x', 1, 'y', 2, 'z', 3]
dic6 = dict（zip（list[::2], list[1::2]））
print（’实际内容dic6= ', dic6）
#9.radiansdict.clear（）：删除字典内所有元素
di.clear（）
print（'di.clear（）'）
print（’实际内容di= ', di）
dica=dic
dicb=dic.copy（）
dica.clear（）
print（'dica.clear（）'）
print（’实际内容dic= ', dic）
print（’实际内容dicb= ', dicb）
print（' dic4.get（2）= ', dic4.get（2））
print（' dic6.keys（）= ', dic6.keys（））
print（' dic6.values（）= ', dic6.values（））
程序运行结果：
type（d）<class 'dict'>
原始输入数据di={1:2 , 2:3 , 3:5}
实际内容di= {1: 2, 2: 3, 3: 5}
dict_items（[（1, 2）,（2, 3）,（3, 5）]）
实际内容dic= {'spam': 1, 'egg': 2, 'bar': 3}
实际内容dic2= {'spam': 1, 'egg': 2, 'bar': 3}
实际内容dic3= {'a': 1, 'b': 2, 'c': 3}
实际内容dic4= {0: 0, 1: 2, 2: 4, 3: 6}
实际内容dic5= {0: 'x', 1: 'x', 2: 'x', 3: 'x'}
实际内容dic6= {'x': 1, 'y': 2, 'z': 3}
di.clear（）
实际内容di= {}
dica.clear（）
实际内容dic= {}
实际内容dicb= {'spam': 1, 'egg': 2, 'bar': 3}
dic4.get（2）= 4
dic6.keys（）= dict_keys（['x', 'y', 'z']）
dic6.values（）= dict_values（[1, 2, 3]）