本文记录 Python 语言在语言语义层面上的语言特性。

动态引用、强类型

Python 是动态引用语言，类似 PHP。比如：

In [18]: a = 5

In [19]: type(a)
Out[19]: int

In [20]: a = 'foo'

In [21]: type(a)
Out[21]: str

我们给 a 复制 int 类型和 string 类型都是没问题的。变量实际上更像是一个特定命名空间中的名称。

但是以下情况是不行的：

In [22]: '5' + 5
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-22-4dd8efb5fac1> in <module>
----> 1 '5' + 5

TypeError: can only concatenate str (not "int") to str

用 string 类型加上一个 int 类型，会直接报错，这种情况下，Python 是强类型语言，隐式转换只有在某些情况下出现，比如用一个 float 类型除以 一个 int 类型。

变量和参数传递

变量

对变量赋值时，就创建了一个指向等号右边对象的引用，而不是数据拷贝过程。

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

In [7]: a
Out[7]: [1, 2, 3]

In [8]: b = a

In [9]: b
Out[9]: [1, 2, 3]

In [10]: a.append(4)

In [11]: a
Out[11]: [1, 2, 3, 4]

In [12]: b
Out[12]: [1, 2, 3, 4]

所以赋值也被称为绑定。

需要注意了，下面这个操作慎用：

positive_x1 = positive_x2 = negative_x1 = negative_x2 = []

当你初始化值的时候，千万不要这样，在有些语言这样做比较方便，但是在 Python 里这样赋值，他们相互影响，后面的操作就麻烦了。我们可以这样：

positive_x1, positive_x2, negative_x1, negative_x2 = [], [], [], []

函数参数传递

当将对象作为参数传给一个函数时，指向原始对象的新的本地变量就会被创建而无须复制。如果将新的对象绑定到一个函数内部的变量上，这种变更不会在上级范围中产生影响。意思是，函数中参数传递，类似于引用传递而不是值传递。

In [13]: def append_element(some_list, element):
    ...:     some_list.append(element)
    ...: 

In [14]: data = [1, 2, 3]

In [15]: data
Out[15]: [1, 2, 3]

In [16]: append_element(data, 4)

In [17]: data
Out[17]: [1, 2, 3, 4]

属性和方法

Python 中的对象通常都会与属性和方法。 属性和对象通过形如 obj.attribute_name 的语法进行调用。

In [32]: a.capitalize
Out[32]: <function str.capitalize()>

In [33]: a.capitalize()
Out[33]: 'Foo'

鸭子类型（Duck Typing）

一个东西走起来像鸭子叫起来像鸭子，那么它就是一只鸭子。

Duck Typing 是动态编程语言用来实现多态的一种方式。

以下这个例子，来自 SF 一篇文章：

def download(fetcher):
     return fetcher.get("http://xxx");

有一个 download 函数，传过来一个 fetcher 参数，fetcher 有一个 get 方法。这个 fetcher 就是一个 Duck Typing 的对象，如果 fetcher 实现了 get，那么就一定可以调用 get，使用者约定好这个 fetcher 会有一个 get 方法就可以了。

导入

以 .py 为后缀的 Python 代码文件就是模块。

导入模块：

import some_module

## 调用 some_module.py 中的 f 方法
result = some_module.f()

或者直接导入方法：

from some_module import f

## 调用 some_module.py 中的 f 方法
result = f()

导入时起别名：

import some_module sm
from some_module import f as smf

result1 = sm.g()
result2 = smf()

可变对象和不可变对象

Python 中大部分对象，例如列表、字典、NumPy 数组都是可变对象；字符串、元组是不可变对象。

Reference

  • 利用 Python 进行数据分析（Python for Data Analysis: Data Wrangling with Pandas, NumPy, and IPython）Wes Mckinney 著, 徐敬一 译
  • 编程语言中的 DUCK TYPING