拙劣的程序员担心代码。好的程序员担心数据结构及它们的关系。
——林纳斯•托瓦兹
本章介绍Python的基本数据类型和数据结构，它们按照如下方式组织。
3.1节介绍整数、浮点数和字符串等基本数据类型。
3.2节介绍Python的基本数据结构（例如List对象）并阐述控制结构、函数式编程范型以及匿名函数。
本章的主旨是提供Python数据类型和结构细节的一般介绍。如果您有其他编程语言（如C或者Matlab）的背景，应该能够轻松地掌握Python使用方法带来的差异。本章介绍的主题是后续章节的重要基础，涵盖了以下数据类型与结构。
Python是一种动态类型的语言，这意味着，Python解释程序在运行时推断对象的类型。C等编译语言通常是静态类型语言，在这类语言中，对象类型必须在编译之前与对象绑定[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为了让上一个表达式返回所需的值——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 对于某些浮点数，二进制表现形式可能包含大量元素甚至是一个无限系列。但是，考虑到用于表达这种数值的位数是固定的——也就是表现系列中的项目固定，因此结果是不精确的。其他数值可以完整表现，因此在可用位数有限时也可以精确地被存储。考虑如下例子： 0.5可以精确保存，因为它具备精确（有限）的二进制表示：0.5=1/2。但是，b=0.35和预期的实数0.35=7/20不同： 精度取决于表示数值所用的位数。一般来说，Python运行的所有平台使用IEEE 754双精度标准（64位）作为内部表示，这相当于15位数字的相对精度。 由于这个主题在金融应用领域中很重要，所以有时候必须确保数值的精确（至少尽可能达到最佳）。例如，在加总一组数量很多的数值时，这个问题就可能很重要。在这种情况下，某个种类或者幅度的表示误差可能汇聚起来，从而造成和基准值的显著偏差。 decimal模块为浮点数提供了任意精确度的对象，以及使用这些数值时处理精度问题的多个选项： 您可以改变Context对象的各个属性值，从而改变表示的精度： ❶ 精度低于默认值。 ❷ 精度高于默认值。 如果有必要，精度可以这样按照具体的问题进行调整，人们可以使用不同精度的浮点对象进行运算： 任意精度浮点数 decimal模块可提供任意精度浮点数对象。在金融领域中，确保高精度、超出64位双精度标准有时是必要的。 在编程中，比较或者逻辑表达式（如4 > 3, 4.5 <= 3.25 或 (4 > 3) and (3 > 2)）得到的输出为True或者False，这是两个重要的Python关键字。其他重要的关键字有def、for和if等。Python的关键字列表可以在keyword模块中找到： True和Flase的数据类型为bool，表示“布尔值”（Boolean Value）。将Python的比较运算符应用到相同操作数时结果为布尔对象： ❶ 大于。 ❷ 大于或等于。 ❸ 小于。 ❹ 小于或等于。 ❺ 等于。 ❻ 不等于。 逻辑运算往往应用到布尔对象上，然后得出另一个布尔对象： 当然，两类运算符往往组合使用： 布尔值的重要应用领域之一是通过其他Python关键字（如if或while，本章后面将有更多示例）控制代码流程： ❶ 如果条件为真，执行以下代码。 ❷ 如果条件为真，执行这段代码。 ❸ 将参数i初始化为0。 ❹ 只要条件为0，就执行并重复以下代码。 ❺ 打印文本和参数i的值。 ❻ 将参数增加1；i += 1与i = i + 1等价。 从数值上讲，Python为False赋值0，为True赋值1。当通过bool()函数将数值转换成bool对象时，0值转换成False，其他所有值都转换为True： 既然我们已经可以表示自然和浮点数，现在就可以转向文本了。Python中表示文本的基本数据类型是字符串——str，字符串对象有一些真正实用的内建方法。实际上，Python通常被视为处理任何类型、任何尺寸文本文件的很好选择。字符串对象通常由单引号或者双引号定义或者使用str()函数转换而来（也就是使用对象的标准或者用户定义的字符串表示）： 举个内建方法的例子，您可以将对象中的第一个词改为首字母大写： 也可以将字符串拆分成单个词，以获得包含所有单词的列表对象： 您还可以搜索一个单词，如果搜索成功，就可以得到该词第一个字母的位置（即索引值）： 如果这个单词不在字符串对象中，该方法返回-1： 替换字符串中的字符是典型的任务，可以用replace()方法简单地完成： 字符串“剥离”（stripping）操作——删除某些前导或者后缀字符也是必要的： 表3-1列出了字符串对象的一些实用方法。 Unicode字符串 Python 2.7（本书第1版使用）到Python 3.7（本书第2版使用）的根本变化之一是字符串对象的编码与解码方法，以及Unicode的引入。本章不介绍这方面的细节；本书主要处理数值数据和包含英语单词的标准字符串，这种忽略似乎是合理的。 打印字符串对象或者其他Python对象的字符串表示，通常由print()函数完成： ❶ 打印一个str对象。 ❷ 打印变量名引用的字符串对象。 ❸ 打印整数对象的字符串表示。 ❹ 指定打印的结束符，默认为前面见到的换行符（
） Python提供了强大的字符串替换运算。我们可以采用旧方法通过%字符，也可以采用通过花括号（{}）和format()函数的新方法。两种方法在实践中都适用。本节无法提供所有选项的说明，但以下代码片段可以展示一些重要的选项。首先是旧方法： ❶ 整数对象替换。 ❷ 固定数量的字符 ❸ 必要时加上前导0。 ❹ 浮点数对象替换。 ❺ 固定小数位数。 ❻ 固定数量字符（以及填充的小数位数）。 ❼ 固定数量字符和小数位数… ❽ 必要时加上前导0。 ❾ 字符串对象替换。 ❿ 固定字符数。 下面是同样的例子，但用新方法实现。注意某些位置输出的细微差别： 字符串替换在多次打印更新的数据时特别有用，例如在while循环中： 正则表达式是处理字符串对象的一个强大工具。Python在re模块中提供了这个功能： 假定您现在面对一个大的文本文件，例如逗号分隔值（CSV）文件，其中包含了某些事件序列和相应的日期-时间信息。日期-时间信息多半以Python无法直接解释的格式提供。然而，日期-时间信息通常可以通过正则表达式描述。考虑如下的字符串对象，它包含3个日期-时间元素、3个整数和3个字符串。注意，3个引号可以定义多行字符串： 下面的正则表达式描述了上述字符串对象提供的日期-时间信息格式[4]： 使用上述正则表达式，我们可以查找所有日期-时间元素。一般来说，对字符串对象应用正则表达式还能带来典型解析任务性能的提升。 正则表达式 解析字符串对象时，若考虑使用正则表达式，可以为相关操作带来便利和高性能。 然后，可以对结果字符串对象进行解析，生成Python的日期时间（datetime）对象（用Python处理日期和时间数据的概述参见附录A）。要解析包含日期时间信息的字符串对象，我们必须提供解析方法的信息——同样是一个字符串对象： 后续内容会提供关于日期—时间数据、这些数据的处理以及datetime对象及其方法的更多信息。现在我们只是预览一下金融中的这个重要主题。 数据结构是包含其他对象（可能很多）的对象。Python提供了以下内建结构。 任意对象的集合；只有少数可用方法。 任意对象的集合；有许多可用方法。 键-值存储对象。 其他独特对象的无序集合对象。 元组（tuple）是一种高级的数据结构，其应用相当简单有限。它通过圆括号来提供对象定义： 也可以去掉括号，提供以逗号分隔的多个对象： 和Python中几乎所有的数据结构相似，元组有内建的索引，利用该索引可以读取元组的单个或者多个元素。重要的是记住Python使用零起点编号，元组的第3个元素在索引位置2上： 零起点编号 与MATLAB等其他编程语言不同，Python使用零起点编号方案。例如，元组对象的第一个元素索引值为0。 这种对象类型只有两个特殊方法：count()和index()。第一个方法计算某个对象的出现次数，第二个方法给出对象第一次出现位置的索引值： 元组对象是不可变对象，这意味着一旦定义，它们就不容易更改。 与元组对象相比，列表（list）类型的对象更灵活、更强大。从金融角度看，许多工作只能用列表对象完成，例如存储股票报价和附加新数据。列表对象通过方括号定义，其基本功能和行为与元组类似： 列表对象也可以使用list()函数定义或者转换。下面的代码通过转换前一个例子中的元组对象来生成新的列表对象： 除了元组对象的特性之外，列表对象还可以通过不同的方法来扩展和缩小。换句话说，字符串和元组对象是不可变序列对象（具有索引），一经创建不能更改，而列表对象是可变的，可以通过不同操作更改。您可以在现有列表对象中附加一个或者多个列表对象： ❶ 在尾部附加列表对象。 ❷ 附加列表对象元素。 ❸ 在索引位置之前插入对象。 ❹ 删除第一次出现的对象。 ❺ 删除并返回索引位置的对象。 切片操作也很容易实现。这里的切片（slicing）指的是将数据集分解为（感兴趣的）较小部分： ❶ 返回的是第3～5个元素。 表3-2提供了列表对象精选操作和方法的简单说明。 控制结构（如for循环）本身就是一个主题，但是在Python中，最好在列表对象基础上理解它。这是因为：循环一般来说都在列表对象上进行，这与其他语言中的常用标准有很大不同。看下面的例子，for循环在列表对象l索引值为2~4的元素上进行，功能是打印各个元素的平方。注意第二行中缩进（空白）的重要性： 与典型的基于计数器的循环相比，上述循环提供了很高的灵活性。基于计数器的循环也是Python的一个可选项，但是在（标准）列表对象range的基础上完成的： ❶ 参数依次是起始值、结束值和步长。 为了比较，下面我们使用range实现同一个循环： 在列表上循环 在Python中，你可以在任意列表对象上循环，而不用管这些对象的内容是什么，这往往可以避免引入计数器。 Python还提供了典型（条件）控制元素if、elif和else。它们的用途与其他语言的相同： ❶ %代表取模运算。 同样，while提供了另一种流程控制手段： Python的特殊性之一是所谓的列表推导（List Comprehension）。这种方法不在现有列表对象上循环，而是以紧凑的方式通过循环生成列表对象： 在某种意义上，它已经提供了一种方法，以较为隐含（而非显式）的循环生成某种向量化代码段（代码向量化将在第4章和第5章中详细讨论）。 Python也提供一些用于函数式编程支持的工具——在一整组输入（在我们的例子中是列表对象）上应用某个函数。这些工具是过滤（filter）、映射（map）和归纳（reduce）。但是，我们首先需要一个函数定义。从简单的功能出发，考虑以下的函数f，它返回输入x的平方数： 当然，函数可能很复杂，它可能有多个输入（参数对象）甚至多个输出（返回对象）。考虑以下函数： 返回对象是一个布尔值。这样的函数可以用map()应用到整个列表对象： 为此，我们还可以使用lambda或者匿名函数，直接提供一个函数定义作为map()的参数： 函数也可以用于过滤列表对象。在下面的例子中，过滤器返回列表对象中匹配某个布尔条件（由even函数定义）的元素： 列表推导、函数式编程和匿名函数 在Python级别上尽可能避免循环被视为“好的习惯”。列表推导和函数式编程工具（如map、filter和reduce）为编写紧凑（一般来说也更易于理解）无循环代码提供了很大帮助。lambda或者匿名函数也是这方面的强大工具。 字典（dict）对象就是可以按照键码（例如，可能是字符串对象）读取的数据字典，也是一种可变序列，是所谓的键—值存储。列表对象是有序且可排序的，而字典对象通常是无序、不可排序的[5]。示例最能够说明字典和列表对象的不同之处。字典对象定义用花括号实现： 同样，该类对象也有一些内建方法： 从字典对象中获得迭代器（Iterator）对象有多种方法。这种对象在循环时的表现与列表对象的表现类似： 本文截选自《Python金融大数据分析》第2版 本书总计分为5部分，共21章。第1部分介绍了Python在金融学中的应用，其内容涵盖了Python用于金融行业的原因、Python的基础架构和工具，以及Python在计量金融学中的一些具体入门实例；第2部分介绍了Python的基础知识以及Python中非常有名的库NumPy和pandas工具集，还介绍了面向对象编程；第3部分介绍金融数据科学的相关基本技术和方法，包括数据可视化、输入/输出操作和数学中与金融相关的知识等；第4部分介绍Python在算法交易上的应用，重点介绍常见算法，包括机器学习、深度神经网络等人工智能相关算法；第5部分讲解基于蒙特卡洛模拟开发期权及衍生品定价的应用，其内容涵盖了估值框架的介绍、金融模型的模拟、衍生品的估值、投资组合的估值等知识。 本书适合对使用Python进行大数据分析和处理感兴趣的金融行业开发人员阅读。
In [13]: c = 0.5
c.as_integer_ratio()
Out[13]: (1, 2)In [14]: b.as_integer_ratio()
Out[14]: (3152519739159347, 9007199254740992)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')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')3.1.3 布尔值
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']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]: TrueIn [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]: TrueIn [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]: FalseIn [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 = 3In [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]: True3.1.4 字符串
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]: 10In [60]: t.find('Python')
Out[60]: -1In [61]: t.replace(' ', '|')
Out[61]: 'this|is|a|string|object'In [62]: 'http://www.python.org'.strip('htp:/')
Out[62]: 'www.python.org'
3.1.5 题外话：打印和字符串替换
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|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'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 '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 33.1.6 题外话：正则表达式
In [89]: import re
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'
"""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'"]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))
3.2 基本数据结构
元组（tuple）
列表（list）
字典（dict）
集合（set）
3.2.1 元组
In [96]: t = (1, 2.5, 'data')
type(t)
Out[96]: tupleIn [97]: t = 1, 2.5, 'data'
type(t)
Out[97]: tupleIn [98]: t[2]
Out[98]: 'data'
In [99]: type(t[2])
Out[99]: strIn [100]: t.count('data')
Out[100]: 1
In [101]: t.index(1)
Out[101]: 03.2.2 列表
In [102]: l = [1, 2.5, 'data']
l[2]
Out[102]: 'data'In [103]: l = list(t)
l
Out[103]: [1, 2.5, 'data']
In [104]: type(l)
Out[104]: listIn [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]In [110]: l[2:5] ❶
Out[110]: [2.5, 1.0, 1.5]
3.2.3 题外话：控制结构
In [111]: for element in l[2:5]:
print(element ** 2)
6.25
1.0
2.25In [112]: r = range(0, 8, 1) ❶
r
Out[112]: range(0, 8)
In [113]: type(r)
Out[113]: rangeIn [114]: for i in range(2, 5):
print(l[i] ** 2)
6.25
1.0
2.25In [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.In [116]: total = 0
while total < 100:
total += 1
print(total)
100In [117]: m = [i ** 2 for i in range(5)]
m
Out[117]: [0, 1, 4, 9, 16]3.2.4 题外话：函数式编程
In [118]: def f(x):
return x ** 2
f(2)
Out[118]: 4In [119]: def even(x):
return x % 2 == 0
even(3)
Out[119]: FalseIn [120]: list(map(even, range(10)))
Out[120]: [True, False, True, False, True, False, True, False, True, False]In [121]: list(map(lambda x: x ** 2, range(10)))
Out[121]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]In [122]: list(filter(even, range(15)))
Out[122]: [0, 2, 4, 6, 8, 10, 12, 14]3.2.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 64In [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'])
65In [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))
页面更新：2024-04-06
本站资料均由网友自行发布提供，仅用于学习交流。如有版权问题，请与我联系，QQ：4156828
© CopyRight 2020-2024 All Rights Reserved. Powered By 71396.com 闽ICP备11008920号-4
闽公网安备35020302034903号
