【翻译】《利用Python进行数据分析·第2版》第2章（中）Python语法基础，IPython和Jupyter

作者：SeanCheney   Python爱好者社区专栏作者

简书专栏：https://www.jianshu.com/u/130f76596b02

前文传送门：

2.3 Python语法基础

在本节中，我将概述基本的Python概念和语言机制。在下一章，我将详细介绍Python的数据结构、函数和其它内建工具。

语言的语义

Python的语言设计强调的是可读性、简洁和清晰。有些人称Python为“可执行的伪代码”。

使用缩进，而不是括号

Python使用空白字符（tab和空格）来组织代码，而不是像其它语言，比如R、C++、JAVA和Perl那样使用括号。看一个排序算法的for循环：

for x in array:    if x < pivot:        less.append(x)    else:        greater.append(x)

冒号标志着缩进代码块的开始，冒号之后的所有代码的缩进量必须相同，直到代码块结束。不管是否喜欢这种形式，使用空白符是Python程序员开发的一部分，在我看来，这可以让python的代码可读性大大优于其它语言。虽然期初看起来很奇怪，经过一段时间，你就能适应了。

笔记：我强烈建议你使用四个空格作为默认的缩进，可以使用tab代替四个空格。许多文本编辑器的设置是使用制表位替代空格。某些人使用tabs或不同数目的空格数，常见的是使用两个空格。大多数情况下，四个空格是大多数人采用的方法，因此建议你也这样做。

你应该已经看到，Python的语句不需要用分号结尾。但是，分号却可以用来给同在一行的语句切分：

a = 5; b = 6; c = 7

Python不建议将多条语句放到一行，这会降低代码的可读性。

万物皆对象

Python语言的一个重要特性就是它的对象模型的一致性。每个数字、字符串、数据结构、函数、类、模块等等，都是在Python解释器的自有“盒子”内，它被认为是Python对象。每个对象都有类型（例如，字符串或函数）和内部数据。在实际中，这可以让语言非常灵活，因为函数也可以被当做对象使用。

注释

任何前面带有井号#的文本都会被Python解释器忽略。这通常被用来添加注释。有时，你会想排除一段代码，但并不删除。简便的方法就是将其注释掉：

results = [] for line in file_handle:    # keep the empty lines for now    # if len(line) == 0:    #   continue    results.append(line.replace('foo', 'bar'))

也可以在执行过的代码后面添加注释。一些人习惯在代码之前添加注释，前者这种方法有时也是有用的：

print("Reached this line")  # Simple status report

函数和对象方法调用

你可以用圆括号调用函数，传递零个或几个参数，或者将返回值给一个变量：

result = f(x, y, z) g()

几乎Python中的每个对象都有附加的函数，称作方法，可以用来访问对象的内容。可以用下面的语句调用：

obj.some_method(x, y, z)

函数可以使用位置和关键词参数：

result = f(a, b, c, d=5, e='foo')

后面会有更多介绍。

变量和参数传递

当在Python中创建变量（或名字），你就在等号右边创建了一个对这个变量的引用。考虑一个整数列表：

In [8]: a = [1, 2, 3]

假设将a赋值给一个新变量b：

In [9]: b = a

在有些方法中，这个赋值会将数据[1, 2, 3]也复制。在Python中，a和b实际上是同一个对象，即原有列表[1, 2, 3]（见图2-7）。你可以在a中添加一个元素，然后检查b：

In [10]: a.append(4) In [11]: b Out[11]: [1, 2, 3, 4]

图2-7 对同一对象的双重引用

理解Python的引用的含义，数据是何时、如何、为何复制的，是非常重要的。尤其是当你用Python处理大的数据集时。

笔记：赋值也被称作绑定，我们是把一个名字绑定给一个对象。变量名有时可能被称为绑定变量。

当你将对象作为参数传递给函数时，新的局域变量创建了对原始对象的引用，而不是复制。如果在函数里绑定一个新对象到一个变量，这个变动不会反映到上一层。因此可以改变可变参数的内容。假设有以下函数：

def append_element(some_list, element):    some_list.append(element)

然后有：

In [27]: data = [1, 2, 3] In [28]: append_element(data, 4) In [29]: data Out[29]: [1, 2, 3, 4]

动态引用，强类型

与许多编译语言（如JAVA和C++）对比，Python中的对象引用不包含附属的类型。下面的代码是没有问题的：

In [12]: a = 5 In [13]: type(a) Out[13]: int In [14]: a = 'foo' In [15]: type(a) Out[15]: str

变量是在特殊命名空间中的对象的名字，类型信息保存在对象自身中。一些人可能会说Python不是“类型化语言”。这是不正确的，看下面的例子：

In [16]: '5' + 5 --------------------------------------------------------------------------- TypeError                                 Traceback (most recent call last) <ipython-input-16-f9dbf5f0b234> in <module>() ----> 1 '5' + 5 TypeError: must be str, not int

在某些语言中，例如Visual Basic，字符串‘5’可能被默许转换（或投射）为整数，因此会产生10。但在其它语言中，例如JavaScript，整数5个能被投射成字符串，结果是联结字符串‘55’。在这个方面，Python被认为是强类型化语言，意味着每个对象都有明确的类型（或类），默许转换只会发生在特定的情况下，例如：

In [17]: a = 4.5 In [18]: b = 2 # String formatting, to be visited later In [19]: print('a is {0}, b is {1}'.format(type(a), type(b))) a is <class 'float'>, b is <class 'int'> In [20]: a / b Out[20]: 2.25

知道对象的类型很重要，最好能让函数可以处理多种类型的输入。你可以用isinstance函数检查对象是某个类型的实例：

In [21]: a = 5 In [22]: isinstance(a, int) Out[22]: True

isinstance可以用类型元组，检查对象的类型是否在元组中：

In [23]: a = 5; b = 4.5 In [24]: isinstance(a, (int, float)) Out[24]: True In [25]: isinstance(b, (int, float)) Out[25]: True

属性和方法

Python的对象通常都有属性（其它存储在对象内部的Python对象）和方法（对象的附属函数可以访问对象的内部数据）。可以用obj.attribute_name访问属性和方法：

In [1]: a = 'foo' In [2]: a.<Press Tab> a.capitalize  a.format      a.isupper     a.rindex      a.strip a.center      a.index       a.join        a.rjust       a.swapcase a.count       a.isalnum     a.ljust       a.rpartition  a.title a.decode      a.isalpha     a.lower       a.rsplit      a.translate a.encode      a.isdigit     a.lstrip      a.rstrip      a.upper a.endswith    a.islower     a.partition   a.split       a.zfill a.expandtabs  a.isspace     a.replace     a.splitlines a.find        a.istitle     a.rfind       a.startswith

也可以用getattr函数，通过名字访问属性和方法：

In [27]: getattr(a, 'split') Out[27]: <function str.split>

在其它语言中，访问对象的名字通常称作“反射”。本书不会大量使用getattr函数和相关的hasattr和setattr函数，使用这些函数可以高效编写原生的、可重复使用的代码。

鸭子类型

经常地，你可能不关心对象的类型，只关心对象是否有某些方法或用途。这通常被称为“鸭子类型”，来自“走起来像鸭子、叫起来像鸭子，那么它就是鸭子”的说法。例如，你可以通过验证一个对象是否遵循迭代协议，判断它是可迭代的。对于许多对象，这意味着它有一个__iter__魔术方法，其它更好的判断方法是使用iter函数：

def isiterable(obj):    try:        iter(obj)        return True    except TypeError: # not iterable        return False

这个函数会返回字符串以及大多数Python集合类型为True：

In [29]: isiterable('a string') Out[29]: True In [30]: isiterable([1, 2, 3]) Out[30]: True In [31]: isiterable(5) Out[31]: False

我总是用这个功能编写可以接受多种输入类型的函数。常见的例子是编写一个函数可以接受任意类型的序列（list、tuple、ndarray）或是迭代器。你可先检验对象是否是列表（或是NumPy数组），如果不是的话，将其转变成列表：

if not isinstance(x, list) and isiterable(x):    x = list(x)

引入

在Python中，模块就是一个有.py扩展名、包含Python代码的文件。假设有以下模块：

# some_module.py PI = 3.14159 def f(x):    return x + 2 def g(a, b):    return a + b

如果想从同目录下的另一个文件访问some_module.py中定义的变量和函数，可以：

import some_module result = some_module.f(5) pi = some_module.PI

或者：

from some_module import f, g, PI result = g(5, PI)

使用as关键词，你可以给引入起不同的变量名：

import some_module as sm from some_module import PI as pi, g as gf r1 = sm.f(pi) r2 = gf(6, pi)

二元运算符和比较运算符

大多数二元数学运算和比较都不难想到：

In [32]: 5 - 7 Out[32]: -2 In [33]: 12 + 21.5 Out[33]: 33.5 In [34]: 5 <= 2 Out[34]: False

表2-3列出了所有的二元运算符。

要判断两个引用是否指向同一个对象，可以使用is方法。is not可以判断两个对象是不同的：

In [35]: a = [1, 2, 3] In [36]: b = a In [37]: c = list(a) In [38]: a is b Out[38]: True In [39]: a is not c Out[39]: True

因为list总是创建一个新的Python列表（即复制），我们可以断定c是不同于a的。使用is比较与==运算符不同，如下：

In [40]: a == c Out[40]: True

is和is not常用来判断一个变量是否为None，因为只有一个None的实例：

In [41]: a = None In [42]: a is None Out[42]: True

表2-3 二元运算符

可变与不可变对象

Python中的大多数对象，比如列表、字典、NumPy数组，和用户定义的类型（类），都是可变的。意味着这些对象或包含的值可以被修改：

In [43]: a_list = ['foo', 2, [4, 5]] In [44]: a_list[2] = (3, 4) In [45]: a_list Out[45]: ['foo', 2, (3, 4)]

其它的，例如字符串和元组，是不可变的：

In [46]: a_tuple = (3, 5, (4, 5)) In [47]: a_tuple[1] = 'four' --------------------------------------------------------------------------- TypeError                                 Traceback (most recent call last) <ipython-input-47-b7966a9ae0f1> in <module>() ----> 1 a_tuple[1] = 'four' TypeError: 'tuple' object does not support item assignment

记住，可以修改一个对象并不意味就要修改它。这被称为副作用。例如，当写一个函数，任何副作用都要在文档或注释中写明。如果可能的话，我推荐避免副作用，采用不可变的方式，即使要用到可变对象。

标量类型

Python的标准库中有一些内建的类型，用以处理数值数据、字符串、布尔值，和日期时间。这些单值类型被称为标量类型，本书中称其为标量。表2-4列出了主要的标量。日期和时间处理会另外讨论，因为它们是标准库的datetime模块提供的。

表2-4 Python的标量

数值类型

Python的主要数值类型是int和float。int可以存储任意大的数：

In [48]: ival = 17239871 In [49]: ival ** 6 Out[49]: 26254519291092456596965462913230729701102721

浮点数使用Python的float类型。每个数都是双精度（64位）的值。也可以用科学计数法表示：

In [50]: fval = 7.243 In [51]: fval2 = 6.78e-5

不能得到整数的除法会得到浮点数：

In [52]: 3 / 2 Out[52]: 1.5

要获得C-风格的整除（去掉小数部分），可以使用底除运算符//：

In [53]: 3 // 2 Out[53]: 1

字符串

许多人是因为Python强大而灵活的字符串处理而使用Python的。你可以用单引号或双引号来写字符串：

a = 'one way of writing a string' b = "another way"

对于有换行符的字符串，可以使用三引号，'''或"""都行：

c = """ This is a longer string that spans multiple lines """

字符串c实际包含四行文本，"""后面和lines后面的换行符。可以用count方法计算c中的新的行：

In [55]: c.count('\n') Out[55]: 3

Python的字符串是不可变的，不能修改字符串：

In [56]: a = 'this is a string' In [57]: a[10] = 'f' --------------------------------------------------------------------------- TypeError                                 Traceback (most recent call last) <ipython-input-57-5ca625d1e504> in <module>() ----> 1 a[10] = 'f' TypeError: 'str' object does not support item assignment In [58]: b = a.replace('string', 'longer string') In [59]: b Out[59]: 'this is a longer string'

经过以上的操作，变量a并没有被修改：

In [60]: a Out[60]: 'this is a string'

许多Python对象使用str函数可以被转化为字符串：

In [61]: a = 5.6 In [62]: s = str(a) In [63]: print(s) 5.6

字符串是一个序列的Unicode字符，因此可以像其它序列，比如列表和元组（下一章会详细介绍两者）一样处理：

In [64]: s = 'python' In [65]: list(s) Out[65]: ['p', 'y', 't', 'h', 'o', 'n'] In [66]: s[:3] Out[66]: 'pyt'

语法s[:3]被称作切片，适用于许多Python序列。后面会更详细的介绍，本书中用到很多切片。

反斜杠是转义字符，意思是它备用来表示特殊字符，比如换行符\n或Unicode字符。要写一个包含反斜杠的字符串，需要进行转义：

In [67]: s = '12\\34' In [68]: print(s) 12\34

如果字符串中包含许多反斜杠，但没有特殊字符，这样做就很麻烦。幸好，可以在字符串前面加一个r，表明字符就是它自身：

In [69]: s = r'this\has\no\special\characters' In [70]: s Out[70]: 'this\\has\\no\\special\\characters'

r表示raw。

将两个字符串合并，会产生一个新的字符串：

In [71]: a = 'this is the first half ' In [72]: b = 'and this is the second half' In [73]: a + b Out[73]: 'this is the first half and this is the second half'

字符串的模板化或格式化，是另一个重要的主题。Python 3拓展了此类的方法，这里只介绍一些。字符串对象有format方法，可以替换格式化的参数为字符串，产生一个新的字符串：

In [74]: template = '{0:.2f} {1:s} are worth US${2:d}'

在这个字符串中，

• {0:.2f}表示格式化第一个参数为带有两位小数的浮点数。

• {1:s}表示格式化第二个参数为字符串。

• {2:d}表示格式化第三个参数为一个整数。

要替换参数为这些格式化的参数，我们传递format方法一个序列：

In [75]: template.format(4.5560, 'Argentine Pesos', 1) Out[75]: '4.56 Argentine Pesos are worth US$1'

字符串格式化是一个很深的主题，有多种方法和大量的选项，可以控制字符串中的值是如何格式化的。推荐参阅Python官方文档。

这里概括介绍字符串处理，第8章的数据分析会详细介绍。

赞赏作者

Python爱好者社区历史文章大合集：

福利：文末扫码立刻关注公众号，“Python爱好者社区”，开始学习Python课程：

关注后在公众号内回复“课程”即可获取：

小编的Python入门视频课程！！！

崔老师爬虫实战案例免费学习视频。

丘老师数据科学入门指导免费学习视频。

陈老师数据分析报告制作免费学习视频。

玩转大数据分析！Spark2.X+Python 精华实战课程免费学习视频。

丘老师Python网络爬虫实战免费学习视频。