打开APP
userphoto
未登录

开通VIP,畅享免费电子书等14项超值服

开通VIP
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        googolOut[4]:  1000000000000000000000000000000000000000000000000000000000000        000000000000000000000000000000000000000In [5]: googol.bit_length()Out[5]: 333

大整数

Python整数可以为任意大。解释程序简单地使用所需的位/字节数就可表现数值。

整数的算术运算也很容易实现:

In [6]: 1 + 4Out[6]: 5In [7]: 1 / 4Out[7]: 0.25In [8]: type(1 / 4)Out[8]: float
3.1.2 浮点数

为了让上一个表达式返回所需的值——0.25[2],我们必须在浮点(float)对象上操作,这很自然地把我们带到下一种基本数据类型。在整数值上加一个点比如1.或者1.0,会导致Python将该对象解释为浮点数。涉及浮点数的表达式通常也必须返回一个浮点对象[3]:

In [9]: 1.6 / 4Out[9]: 0.4In [10]: type (1.6 / 4)Out[10]: float

浮点数与通常不精确的实数计算机表现形式关系更大,取决于所采用的具体技术方法。为了说明其中的含义,我们定义另一个浮点对象b,这种浮点对象在内部总是只表现为某种精度。将b加上0.1时,这一点变得很明显:

In [11]: b = 0.35 type(b)Out[11]: floatIn [12]: b + 0.1Out[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 DecimalIn [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)dOut[17]: Decimal('0.09090909090909090909090909091')

您可以改变Context对象的各个属性值,从而改变表示的精度:

In [18]: decimal.getcontext().prec = 4❶In [19]: e = Decimal(1) / Decimal (11) eOut[19]: Decimal('0.09091')In [20]: decimal.getcontext().prec = 50❷In [21]: f = Decimal(1) / Decimal (11) fOut[21]: Decimal('0.090909090909090909090909090909090909090909090909091')

❶ 精度低于默认值。

❷ 精度高于默认值。

如果有必要,精度可以这样按照具体的问题进行调整,人们可以使用不同精度的浮点对象进行运算:

In [22]: g = d + e + f         gOut[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 keywordIn [24]: keyword.kwlistOut[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]: TrueIn [26]: type(4 > 3)Out[26]: boolIn [27]: type(False)Out[27]: boolIn [28]: 4 >= 3❷Out[28]: TrueIn [29]: 4 < 3❸Out[29]: FalseIn [30]: 4 <= 3❹Out[30]: FalseIn [31]: 4 == 3❺Out[31]: FalseIn [32]: 4 != 3❻Out[32]: True

❶ 大于。

❷ 大于或等于。

❸ 小于。

❹ 小于或等于。

❺ 等于。

❻ 不等于。

逻辑运算往往应用到布尔对象上,然后得出另一个布尔对象:

In [33]: True and TrueOut[33]: TrueIn [34]: True and FalseOut[34]: FalseIn [35]: False and FalseOut[35]: FalseIn [36]: True or TrueOut[36]: TrueIn [37]: True or FalseOut[37]: TrueIn [38]: False or FalseOut[38]: FalseIn [39]: not TrueOut[39]: FalseIn [40]: not FalseOut[40]: True

当然,两类运算符往往组合使用:

In [41]: (4 > 3) and (2 > 3)Out[41]: FalseIn [42]: (4 == 3) or (2 != 3)Out[42]: TrueIn [43]: not (4 != 4)Out[43]: TrueIn [44]: (not (4 != 4)) and (2 == 3)Out[44]: False

布尔值的重要应用领域之一是通过其他Python关键字(如if或while,本章后面将有更多示例)控制代码流程:

In [45]: if 4 > 3: ❶ print('condition true') ❷ condition trueIn [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]: 1In [48]: int(False)Out[48]: 0In [49]: float(True)Out[49]: 1.0In [50]: float(False)Out[50]: 0.0In [51]: bool(0)Out[51]: FalseIn [52]: bool(0.0)Out[52]: FalseIn [53]: bool(1)Out[53]: TrueIn [54]: bool(10.5)Out[54]: TrueIn [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 FinanceIn [64]: print(t) ❷         this is a string objectIn [65]: i = 0         while i < 4:             print(i) ❸             i += 1         0         1         2         3In [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 3In [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) resultOut[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')         pydtOut[93]: datetime.datetime(2014, 1, 18, 13, 0)In [94]: print(pydt)         2014-01-18 13:00:00In [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]: 1In [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)          lOut[103]: [1, 2.5, 'data']In [104]: type(l)Out[104]: list

除了元组对象的特性之外,列表对象还可以通过不同的方法来扩展和缩小。换句话说,字符串和元组对象是不可变序列对象(具有索引),一经创建不能更改,而列表对象是可变的,可以通过不同操作更改。您可以在现有列表对象中附加一个或者多个列表对象:

In [105]: l.append([4, 3]) ❶ lOut[105]: [1, 2.5, 'data', [4, 3]]In [106]: l.extend([1.0, 1.5, 2.0]) ❷ lOut[106]: [1, 2.5, 'data', [4, 3], 1.0, 1.5, 2.0]In [107]: l.insert(1, 'insert') ❸ lOut[107]: [1, 'insert', 2.5, 'data', [4, 3], 1.0, 1.5, 2.0]In [108]: l.remove('data') ❹ lOut[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) ❶          rOut[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)]          mOut[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]: dictIn [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进行大数据分析和处理感兴趣的金融行业开发人员阅读。

本站仅提供存储服务,所有内容均由用户发布,如发现有害或侵权内容,请点击举报
打开APP,阅读全文并永久保存 查看更多类似文章
猜你喜欢
类似文章
【热】打开小程序,算一算2024你的财运
Python技法:浮点数取整、格式化和NaN处理
你不知道的Python特性,其实可以解决很多问题!
Python中分数的相关使用教程
刻意练习:Python基础 -- Task01. 变量、运算符与数据类型
python内置函数有多少?记得收藏!
python基本元素:数字、字符串和变量,那些经常忽略的知识点
更多类似文章 >>
生活服务
热点新闻
分享 收藏 导长图 关注 下载文章
绑定账号成功
后续可登录账号畅享VIP特权!
如果VIP功能使用有故障,
可点击这里联系客服!

联系客服