Python提供的一些相当实用而灵活的通用数据结构
拙劣的程序员担心代码。好的程序员担心数据结构及它们的关系。
——林纳斯•托瓦兹
本章介绍Python的基本数据类型和数据结构，它们按照如下方式组织。
基本数据类型
3.1节介绍整数、浮点数和字符串等基本数据类型。
基本数据结构
3.2节介绍Python的基本数据结构（例如List对象）并阐述控制结构、函数式编程范型以及匿名函数。
本章的主旨是提供Python数据类型和结构细节的一般介绍。如果您有其他编程语言（如C或者Matlab）的背景，应该能够轻松地掌握Python使用方法带来的差异。本章介绍的主题是后续章节的重要基础，涵盖了以下数据类型与结构。
3.1 基本数据类型
Python是一种动态类型的语言，这意味着，Python解释程序在运行时推断对象的类型。C等编译语言通常是静态类型语言，在这类语言中，对象类型必须在编译之前与对象绑定[1]。
3.1.1 整数
最基本的数据类型是整数int：
In [1]: a = 10
type(a)
Out[1]: int
内建函数type为所有使用标准和内建类型的对象、新创建的类及对象提供类型信息。在后一种情况下，提供的信息取决于程序员存储在类中的描述。有一种说法：“在Python中，一切都是对象。”这意味着，即使我们刚刚定义的简单对象int也有内建方法。例如，您可以调用bit_length方法，获得表现整数对象所需的位数：
In [2]: a.bit_length() Out[2]: 4
您将会看到，我们为该对象所赋的整数值越大，需要的位数就越多：
In [3]: a = 100000
a.bit_length()
Out[3]: 17
一般来说，这类方法很多，很难记住所有类和对象的所有方法。高级Python环境（如IPython）提供Tab键完成功能，以显示对象连接的所有方法。您只需要输入对象名和一个点（如a.）然后按下Tab键，就会提供一组可以在该对象上调用的方法。也可以使用Python内建函数dir显示任何对象属性和方法的完整列表。
Python的特殊性之一是整数可以任意大。例如，考虑天文数字10100。Python处理这样大的数毫无问题，这从技术上说是一个很“长”的对象：
In [4]: googol = 10 ** 100
googol
Out[4]: 1000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000
In [5]: googol.bit_length()
Out[5]: 333
大整数
Python整数可以为任意大。解释程序简单地使用所需的位/字节数就可表现数值。
整数的算术运算也很容易实现：
In [6]: 1 + 4 Out[6]: 5 In [7]: 1 / 4 Out[7]: 0.25 In [8]: type(1 / 4) Out[8]: float
3.1.2 浮点数
为了让上一个表达式返回所需的值——0.25[2]，我们必须在浮点（float）对象上操作，这很自然地把我们带到下一种基本数据类型。在整数值上加一个点比如1.或者1.0，会导致Python将该对象解释为浮点数。涉及浮点数的表达式通常也必须返回一个浮点对象[3]：
In [9]: 1.6 / 4 Out[9]: 0.4 In [10]: type (1.6 / 4) Out[10]: float
浮点数与通常不精确的实数计算机表现形式关系更大，取决于所采用的具体技术方法。为了说明其中的含义，我们定义另一个浮点对象b，这种浮点对象在内部总是只表现为某种精度。将b加上0.1时，这一点变得很明显：
In [11]: b = 0.35
type(b)
Out[11]: float
In [12]: b + 0.1
Out[12]: 0.44999999999999996
出现以上结果的原因是浮点数在计算机内部以二进制形式表示；也就是说，十进制数n（0<n<1）表现为如下形式：
对于某些浮点数，二进制表现形式可能包含大量元素甚至是一个无限系列。但是，考虑到用于表达这种数值的位数是固定的——也就是表现系列中的项目固定，因此结果是不精确的。其他数值可以完整表现，因此在可用位数有限时也可以精确地被存储。考虑如下例子：
In [13]: c = 0.5
c.as_integer_ratio()
Out[13]: (1, 2)
0.5可以精确保存，因为它具备精确（有限）的二进制表示：0.5=1/2。但是，b=0.35和预期的实数0.35=7/20不同：
In [14]: b.as_integer_ratio() Out[14]: (3152519739159347, 9007199254740992)
精度取决于表示数值所用的位数。一般来说，Python运行的所有平台使用IEEE 754双精度标准（64位）作为内部表示，这相当于15位数字的相对精度。
由于这个主题在金融应用领域中很重要，所以有时候必须确保数值的精确（至少尽可能达到最佳）。例如，在加总一组数量很多的数值时，这个问题就可能很重要。在这种情况下，某个种类或者幅度的表示误差可能汇聚起来，从而造成和基准值的显著偏差。
decimal模块为浮点数提供了任意精确度的对象，以及使用这些数值时处理精度问题的多个选项：
In [15]: import decimal
from decimal import Decimal
In [16]: decimal.getcontext()
Out[16]: Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999,
Emax=999999, capitals=1, clamp=0, flags=[], traps=
[InvalidOperation, DivisionByZero, Overflow])
In [17]: d = Decimal(1) / Decimal (11)
d
Out[17]: Decimal('0.09090909090909090909090909091')
您可以改变Context对象的各个属性值，从而改变表示的精度：
In [18]: decimal.getcontext().prec = 4❶
In [19]: e = Decimal(1) / Decimal (11)
e
Out[19]: Decimal('0.09091')
In [20]: decimal.getcontext().prec = 50❷
In [21]: f = Decimal(1) / Decimal (11)
f
Out[21]: Decimal('0.090909090909090909090909090909090909090909090909091')
❶ 精度低于默认值。
❷ 精度高于默认值。
如果有必要，精度可以这样按照具体的问题进行调整，人们可以使用不同精度的浮点对象进行运算：
In [22]: g = d + e + f
g
Out[22]: Decimal('0.27272818181818181818181818181909090909090909090909')
任意精度浮点数
decimal模块可提供任意精度浮点数对象。在金融领域中，确保高精度、超出64位双精度标准有时是必要的。
3.1.3 布尔值
在编程中，比较或者逻辑表达式（如4 > 3, 4.5 <= 3.25 或 (4 > 3) and (3 > 2)）得到的输出为True或者False，这是两个重要的Python关键字。其他重要的关键字有def、for和if等。Python的关键字列表可以在keyword模块中找到：
In [23]: import keyword
In [24]: keyword.kwlist
Out[24]: ['False',
'None',
'True',
'and',
'as',
'assert',
'async',
'await',
'break',
'class',
'continue',
'def',
'del',
'elif',
'else',
'except',
'finally',
'for',
'from',
'global',
'if',
'import',
'in',
'is',
'lambda',
'nonlocal',
'not',
'or',
'pass',
'raise',
'return',
'try',
'while',
'with',
'yield']
True和Flase的数据类型为bool，表示“布尔值”（Boolean Value）。将Python的比较运算符应用到相同操作数时结果为布尔对象：
In [25]: 4 > 3❶ Out[25]: True In [26]: type(4 > 3) Out[26]: bool In [27]: type(False) Out[27]: bool In [28]: 4 >= 3❷ Out[28]: True In [29]: 4 < 3❸ Out[29]: False In [30]: 4 <= 3❹ Out[30]: False In [31]: 4 == 3❺ Out[31]: False In [32]: 4 != 3❻ Out[32]: True
❶ 大于。
❷ 大于或等于。
❸ 小于。
❹ 小于或等于。
❺ 等于。
❻ 不等于。
逻辑运算往往应用到布尔对象上，然后得出另一个布尔对象：
In [33]: True and True Out[33]: True In [34]: True and False Out[34]: False In [35]: False and False Out[35]: False In [36]: True or True Out[36]: True In [37]: True or False Out[37]: True In [38]: False or False Out[38]: False In [39]: not True Out[39]: False In [40]: not False Out[40]: True
当然，两类运算符往往组合使用：
In [41]: (4 > 3) and (2 > 3) Out[41]: False In [42]: (4 == 3) or (2 != 3) Out[42]: True In [43]: not (4 != 4) Out[43]: True In [44]: (not (4 != 4)) and (2 == 3) Out[44]: False
布尔值的重要应用领域之一是通过其他Python关键字（如if或while，本章后面将有更多示例）控制代码流程：
In [45]: if 4 > 3: ❶
print('condition true') ❷
condition true
In [46]: i = 0 ❸
while i < 4: ❹
print('condition true, i = ', i) ❺
i += 1 ❻
condition true, i = 0
condition true, i = 1
condition true, i = 2
condition true, i = 3
❶ 如果条件为真，执行以下代码。
❷ 如果条件为真，执行这段代码。
❸ 将参数i初始化为0。
❹ 只要条件为0，就执行并重复以下代码。
❺ 打印文本和参数i的值。
❻ 将参数增加1；i += 1与i = i + 1等价。
从数值上讲，Python为False赋值0，为True赋值1。当通过bool()函数将数值转换成bool对象时，0值转换成False，其他所有值都转换为True：
In [47]: int(True) Out[47]: 1 In [48]: int(False) Out[48]: 0 In [49]: float(True) Out[49]: 1.0 In [50]: float(False) Out[50]: 0.0 In [51]: bool(0) Out[51]: False In [52]: bool(0.0) Out[52]: False In [53]: bool(1) Out[53]: True In [54]: bool(10.5) Out[54]: True In [55]: bool(-2) Out[55]: True
3.1.4 字符串
既然我们已经可以表示自然和浮点数，现在就可以转向文本了。Python中表示文本的基本数据类型是字符串——str，字符串对象有一些真正实用的内建方法。实际上，Python通常被视为处理任何类型、任何尺寸文本文件的很好选择。字符串对象通常由单引号或者双引号定义或者使用str()函数转换而来（也就是使用对象的标准或者用户定义的字符串表示）：
In [56]: t = 'this is a string object'
举个内建方法的例子，您可以将对象中的第一个词改为首字母大写：
In [57]: t.capitalize() Out[57]: 'This is a string object'
也可以将字符串拆分成单个词，以获得包含所有单词的列表对象：
In [58]: t.split() Out[58]: ['this', 'is', 'a', 'string', 'object']
您还可以搜索一个单词，如果搜索成功，就可以得到该词第一个字母的位置（即索引值）：
In [59]: t.find('string')
Out[59]: 10
如果这个单词不在字符串对象中，该方法返回-1：
In [60]: t.find('Python')
Out[60]: -1
替换字符串中的字符是典型的任务，可以用replace()方法简单地完成：
In [61]: t.replace(' ', '|')
Out[61]: 'this|is|a|string|object'
字符串“剥离”（stripping）操作——删除某些前导或者后缀字符也是必要的：
In [62]: 'http://www.python.org'.strip('htp:/')
Out[62]: 'www.python.org'
表3-1列出了字符串对象的一些实用方法。
Unicode字符串
Python 2.7（本书第1版使用）到Python 3.7（本书第2版使用）的根本变化之一是字符串对象的编码与解码方法，以及Unicode的引入。本章不介绍这方面的细节；本书主要处理数值数据和包含英语单词的标准字符串，这种忽略似乎是合理的。
3.1.5 题外话：打印和字符串替换
打印字符串对象或者其他Python对象的字符串表示，通常由print()函数完成：
In [63]: print('Python for Finance') ❶
Python for Finance
In [64]: print(t) ❷
this is a string object
In [65]: i = 0
while i < 4:
print(i) ❸
i += 1
0
1
2
3
In [66]: i = 0
while i < 4:
print(i, end='|') ❹
i += 1
0|1|2|3|
❶ 打印一个str对象。
❷ 打印变量名引用的字符串对象。
❸ 打印整数对象的字符串表示。
❹ 指定打印的结束符，默认为前面见到的换行符（\n）
Python提供了强大的字符串替换运算。我们可以采用旧方法通过%字符，也可以采用通过花括号（{}）和format()函数的新方法。两种方法在实践中都适用。本节无法提供所有选项的说明，但以下代码片段可以展示一些重要的选项。首先是旧方法：
In [67]: 'this is an integer %d' % 15 ❶ Out[67]: 'this is an integer 15' In [68]: 'this is an integer %4d' % 15 ❷ Out[68]: 'this is an integer 15' In [69]: 'this is an integer %04d' % 15 ❸ Out[69]: 'this is an integer 0015' In [70]: 'this is a float %f' % 15.3456 ❹ Out[70]: 'this is a float 15.345600' In [71]: 'this is a float %.2f' % 15.3456 ❺ Out[71]: 'this is a float 15.35' In [72]: 'this is a float %8f' % 15.3456 ❻ Out[72]: 'this is a float 15.345600' In [73]: 'this is a float %8.2f' % 15.3456 ❼ Out[73]: 'this is a float 15.35' In [74]: 'this is a float %08.2f' % 15.3456 ❽ Out[74]: 'this is a float 00015.35' In [75]: 'this is a string %s' % 'Python' ❾ Out[75]: 'this is a string Python' In [76]: 'this is a string %10s' % 'Python' ❿ Out[76]: 'this is a string Python'
❶ 整数对象替换。
❷ 固定数量的字符
❸ 必要时加上前导0。
❹ 浮点数对象替换。
❺ 固定小数位数。
❻ 固定数量字符（以及填充的小数位数）。
❼ 固定数量字符和小数位数…
❽ 必要时加上前导0。
❾ 字符串对象替换。
❿ 固定字符数。
下面是同样的例子，但用新方法实现。注意某些位置输出的细微差别：
In [77]: 'this is an integer {:d}'.format(15)
Out[77]: 'this is an integer 15'
In [78]: 'this is an integer {:4d}'.format(15)
Out[78]: 'this is an integer 15'
In [79]: 'this is an integer {:04d}'.format(15)
Out[79]: 'this is an integer 0015'
In [80]: 'this is a float {:f}'.format(15.3456)
Out[80]: 'this is a float 15.345600'
In [81]: 'this is a float {:.2f}'.format(15.3456)
Out[81]: 'this is a float 15.35'
In [82]: 'this is a float {:8f}'.format(15.3456)
Out[82]: 'this is a float 15.345600'
In [83]: 'this is a float {:8.2f}'.format(15.3456)
Out[83]: 'this is a float 15.35'
In [84]: 'this is a float {:08.2f}'.format(15.3456)
Out[84]: 'this is a float 00015.35'
In [85]: 'this is a string {:s}'.format('Python')
Out[85]: 'this is a string Python'
In [86]: 'this is a string {:10s}'.format('Python')
Out[86]: 'this is a string Python '
字符串替换在多次打印更新的数据时特别有用，例如在while循环中：
In [87]: i = 0
while i < 4:
print('the number is %d' % i)
i += 1
the number is 0
the number is 1
the number is 2
the number is 3
In [88]: i = 0
while i < 4:
print('the number is {:d}'.format(i))
i += 1
the number is 0
the number is 1
the number is 2
the number is 3
3.1.6 题外话：正则表达式
正则表达式是处理字符串对象的一个强大工具。Python在re模块中提供了这个功能：
In [89]: import re
假定您现在面对一个大的文本文件，例如逗号分隔值（CSV）文件，其中包含了某些事件序列和相应的日期-时间信息。日期-时间信息多半以Python无法直接解释的格式提供。然而，日期-时间信息通常可以通过正则表达式描述。考虑如下的字符串对象，它包含3个日期-时间元素、3个整数和3个字符串。注意，3个引号可以定义多行字符串：
In [90]: series = """
'01/18/2014 13:00:00', 100, '1st';
'01/18/2014 13:30:00', 110, '2nd';
'01/18/2014 14:00:00', 120, '3rd'
"""
下面的正则表达式描述了上述字符串对象提供的日期-时间信息格式[4]：
In [91]: dt = re.compile("'[0-9/:\s]+'") # datetime
使用上述正则表达式，我们可以查找所有日期-时间元素。一般来说，对字符串对象应用正则表达式还能带来典型解析任务性能的提升。
In [92]: result = dt.findall(series)
result
Out[92]: ["'01/18/2014 13:00:00'", "'01/18/2014 13:30:00'", "'01/18/2014
14:00:00'"]
正则表达式
解析字符串对象时，若考虑使用正则表达式，可以为相关操作带来便利和高性能。
然后，可以对结果字符串对象进行解析，生成Python的日期时间（datetime）对象（用Python处理日期和时间数据的概述参见附录A）。要解析包含日期时间信息的字符串对象，我们必须提供解析方法的信息——同样是一个字符串对象：
In [93]: from datetime import datetime
pydt = datetime.strptime(result[0].replace("'", ""),
'%m/%d/%Y %H:%M:%S')
pydt
Out[93]: datetime.datetime(2014, 1, 18, 13, 0)
In [94]: print(pydt)
2014-01-18 13:00:00
In [95]: print(type(pydt))
<class 'datetime.datetime'>
后续内容会提供关于日期—时间数据、这些数据的处理以及datetime对象及其方法的更多信息。现在我们只是预览一下金融中的这个重要主题。
3.2 基本数据结构
数据结构是包含其他对象（可能很多）的对象。Python提供了以下内建结构。
元组（tuple）
任意对象的集合；只有少数可用方法。
列表（list）
任意对象的集合；有许多可用方法。
字典（dict）
键-值存储对象。
集合（set）
其他独特对象的无序集合对象。
3.2.1 元组
元组（tuple）是一种高级的数据结构，其应用相当简单有限。它通过圆括号来提供对象定义：
In [96]: t = (1, 2.5, 'data')
type(t)
Out[96]: tuple
也可以去掉括号，提供以逗号分隔的多个对象：
In [97]: t = 1, 2.5, 'data'
type(t)
Out[97]: tuple
和Python中几乎所有的数据结构相似，元组有内建的索引，利用该索引可以读取元组的单个或者多个元素。重要的是记住Python使用零起点编号，元组的第3个元素在索引位置2上：
In [98]: t[2] Out[98]: 'data' In [99]: type(t[2]) Out[99]: str
零起点编号
与MATLAB等其他编程语言不同，Python使用零起点编号方案。例如，元组对象的第一个元素索引值为0。
这种对象类型只有两个特殊方法：count()和index()。第一个方法计算某个对象的出现次数，第二个方法给出对象第一次出现位置的索引值：
In [100]: t.count('data')
Out[100]: 1
In [101]: t.index(1)
Out[101]: 0
元组对象是不可变对象，这意味着一旦定义，它们就不容易更改。
3.2.2 列表
与元组对象相比，列表（list）类型的对象更灵活、更强大。从金融角度看，许多工作只能用列表对象完成，例如存储股票报价和附加新数据。列表对象通过方括号定义，其基本功能和行为与元组类似：
In [102]: l = [1, 2.5, 'data']
l[2]
Out[102]: 'data'
列表对象也可以使用list()函数定义或者转换。下面的代码通过转换前一个例子中的元组对象来生成新的列表对象：
In [103]: l = list(t)
l
Out[103]: [1, 2.5, 'data']
In [104]: type(l)
Out[104]: list
除了元组对象的特性之外，列表对象还可以通过不同的方法来扩展和缩小。换句话说，字符串和元组对象是不可变序列对象（具有索引），一经创建不能更改，而列表对象是可变的，可以通过不同操作更改。您可以在现有列表对象中附加一个或者多个列表对象：
In [105]: l.append([4, 3]) ❶
l
Out[105]: [1, 2.5, 'data', [4, 3]]
In [106]: l.extend([1.0, 1.5, 2.0]) ❷
l
Out[106]: [1, 2.5, 'data', [4, 3], 1.0, 1.5, 2.0]
In [107]: l.insert(1, 'insert') ❸
l
Out[107]: [1, 'insert', 2.5, 'data', [4, 3], 1.0, 1.5, 2.0]
In [108]: l.remove('data') ❹
l
Out[108]: [1, 'insert', 2.5, [4, 3], 1.0, 1.5, 2.0]
In [109]: p = l.pop(3) ❺
print(l, p)
[1, 'insert', 2.5, 1.0, 1.5, 2.0] [4, 3]
❶ 在尾部附加列表对象。
❷ 附加列表对象元素。
❸ 在索引位置之前插入对象。
❹ 删除第一次出现的对象。
❺ 删除并返回索引位置的对象。
切片操作也很容易实现。这里的切片（slicing）指的是将数据集分解为（感兴趣的）较小部分：
In [110]: l[2:5] ❶ Out[110]: [2.5, 1.0, 1.5]
❶ 返回的是第3～5个元素。
表3-2提供了列表对象精选操作和方法的简单说明。
3.2.3 题外话：控制结构
控制结构（如for循环）本身就是一个主题，但是在Python中，最好在列表对象基础上理解它。这是因为：循环一般来说都在列表对象上进行，这与其他语言中的常用标准有很大不同。看下面的例子，for循环在列表对象l索引值为2~4的元素上进行，功能是打印各个元素的平方。注意第二行中缩进（空白）的重要性：
In [111]: for element in l[2:5]:
print(element ** 2)
6.25
1.0
2.25
与典型的基于计数器的循环相比，上述循环提供了很高的灵活性。基于计数器的循环也是Python的一个可选项，但是在（标准）列表对象range的基础上完成的：
In [112]: r = range(0, 8, 1) ❶
r
Out[112]: range(0, 8)
In [113]: type(r)
Out[113]: range
❶ 参数依次是起始值、结束值和步长。
为了比较，下面我们使用range实现同一个循环：
In [114]: for i in range(2, 5):
print(l[i] ** 2)
6.25
1.0
2.25
在列表上循环
在Python中，你可以在任意列表对象上循环，而不用管这些对象的内容是什么，这往往可以避免引入计数器。
Python还提供了典型（条件）控制元素if、elif和else。它们的用途与其他语言的相同：
In [115]: for i in range(1, 10):
if i % 2 == 0: ❶
print("%d is even" % i)
elif i % 3 == 0:
print("%d is multiple of 3" % i)
else:
print("%d is odd" % i)
1 is odd
2 is even
3 is multiple of 3
4 is even
5 is odd
6 is even
7 is odd
8 is even
9 is multiple of 3
% stands for modulo.
❶ %代表取模运算。
同样，while提供了另一种流程控制手段：
In [116]: total = 0
while total < 100:
total += 1
print(total)
100
Python的特殊性之一是所谓的列表推导（List Comprehension）。这种方法不在现有列表对象上循环，而是以紧凑的方式通过循环生成列表对象：
In [117]: m = [i ** 2 for i in range(5)]
m
Out[117]: [0, 1, 4, 9, 16]
在某种意义上，它已经提供了一种方法，以较为隐含（而非显式）的循环生成某种向量化代码段（代码向量化将在第4章和第5章中详细讨论）。
3.2.4 题外话：函数式编程
Python也提供一些用于函数式编程支持的工具——在一整组输入（在我们的例子中是列表对象）上应用某个函数。这些工具是过滤（filter）、映射（map）和归纳（reduce）。但是，我们首先需要一个函数定义。从简单的功能出发，考虑以下的函数f，它返回输入x的平方数：
In [118]: def f(x):
return x ** 2
f(2)
Out[118]: 4
当然，函数可能很复杂，它可能有多个输入（参数对象）甚至多个输出（返回对象）。考虑以下函数：
In [119]: def even(x):
return x % 2 == 0
even(3)
Out[119]: False
返回对象是一个布尔值。这样的函数可以用map()应用到整个列表对象：
In [120]: list(map(even, range(10))) Out[120]: [True, False, True, False, True, False, True, False, True, False]
为此，我们还可以使用lambda或者匿名函数，直接提供一个函数定义作为map()的参数：
In [121]: list(map(lambda x: x ** 2, range(10))) Out[121]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
函数也可以用于过滤列表对象。在下面的例子中，过滤器返回列表对象中匹配某个布尔条件（由even函数定义）的元素：
In [122]: list(filter(even, range(15))) Out[122]: [0, 2, 4, 6, 8, 10, 12, 14]
列表推导、函数式编程和匿名函数
在Python级别上尽可能避免循环被视为“好的习惯”。列表推导和函数式编程工具（如map、filter和reduce）为编写紧凑（一般来说也更易于理解）无循环代码提供了很大帮助。lambda或者匿名函数也是这方面的强大工具。
3.2.5 字典
字典（dict）对象就是可以按照键码（例如，可能是字符串对象）读取的数据字典，也是一种可变序列，是所谓的键—值存储。列表对象是有序且可排序的，而字典对象通常是无序、不可排序的[5]。示例最能够说明字典和列表对象的不同之处。字典对象定义用花括号实现：
In [123]: d = {
'Name' : 'Angela Merkel',
'Country' : 'Germany',
'Profession' : 'Chancelor',
'Age' : 64
}
type(d)
Out[123]: dict
In [124]: print(d['Name'], d['Age'])
Angela Merkel 64
同样，该类对象也有一些内建方法：
In [125]: d.keys()
Out[125]: dict_keys(['Name', 'Country', 'Profession', 'Age'])
In [126]: d.values()
Out[126]: dict_values(['Angela Merkel', 'Germany', 'Chancelor', 64])
In [127]: d.items()
Out[127]: dict_items([('Name', 'Angela Merkel'), ('Country', 'Germany'),
('Profession', 'Chancelor'), ('Age', 64)])
In [128]: birthday = True
if birthday:a
d['Age'] += 1
print(d['Age'])
65
从字典对象中获得迭代器（Iterator）对象有多种方法。这种对象在循环时的表现与列表对象的表现类似：
In [129]: for item in d.items():
print(item)
('Name', 'Angela Merkel')
('Country', 'Germany')
('Profession', 'Chancelor')
('Age', 65)
In [130]: for value in d.values():
print(type(value))
<class 'str'>
<class 'str'>
<class 'str'>
<class 'int'>
本文截选自《Python金融大数据分析》第2版
本书总计分为5部分，共21章。第1部分介绍了Python在金融学中的应用，其内容涵盖了Python用于金融行业的原因、Python的基础架构和工具，以及Python在计量金融学中的一些具体入门实例；第2部分介绍了Python的基础知识以及Python中非常有名的库NumPy和pandas工具集，还介绍了面向对象编程；第3部分介绍金融数据科学的相关基本技术和方法，包括数据可视化、输入/输出操作和数学中与金融相关的知识等；第4部分介绍Python在算法交易上的应用，重点介绍常见算法，包括机器学习、深度神经网络等人工智能相关算法；第5部分讲解基于蒙特卡洛模拟开发期权及衍生品定价的应用，其内容涵盖了估值框架的介绍、金融模型的模拟、衍生品的估值、投资组合的估值等知识。
本书适合对使用Python进行大数据分析和处理感兴趣的金融行业开发人员阅读。