拙劣的程序员担心代码。好的程序员担心数据结构及它们的关系。
——林纳斯•托瓦兹
本章介绍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进行大数据分析和处理感兴趣的金融行业开发人员阅读。