前一篇文章，用一天的时间，通过与 JavaScript 做对比的方式，快速领略了 Python 全貌。

梳理了那么多，若忽略细节差异，两门语言只有两个重要差异：

1、书写风格上大相同

2、功能覆盖上，Python ~ ES6 + NodeJs

第 2 条，说的是 Python 的能力，不是入门时所要关注的。那么只有 写法差异 这一条需要重点关注——若经历了第一天的快速入门，现在闭着眼睛还能回想 Python 的写法差异，比如这样：

# 一个简单的 for 循环

for val in ['a', 'b', 'c', 'd']:

print(val)

# 一个简单的函数定义，包含了 if else 语句

def fn(n):

if n >= 0:

return n

else:

return -n

那么，恭喜，你可以对自己说：我已掌握 Python！

之前主要集中在概览和基本的语法规范上，现在我们把目光专注在函数上，详细看看 Python 函数有哪些不一样的特性。

对于 JS 函数我们烂熟于心。JS 函数由函数名、参数、返回值、内置成员、作用域等部分构成。

let a = 1;

function fn (x, ...y) {

// arguments, this

let inner = () => {

a = 100;

}

inner();

console.log(a);

return undefined

}

Python 函数同样由这些部分构成，以下是一个简单的表格将它们进行对比。

函数组成

JS

Python

说明

语法规范

命名函数、匿名函数

和 JS 总体相似，但具体语法处处是差异

关键字+函数名+参数+返回值

内置属性

arguments、this

无内置属性

Python 没有复杂的 this

作用域

全局作用域、局部作用域

和 JS 的意义一致，仅形式差异

无学习压力

以下内容就按照这些对比项依次梳理。(可能内容和顺序稍有变化)

函数的定义规范

Python 函数书写形式上和 JS 有巨大差异(此次迁移学习，适应 Python 代码的书写习惯一直是个重点)，语法上差别也很多。

def py_fn (x):

print(x)

return x

声明函数的关键字是 def，函数名驼峰下划线都行，Python 在意大小写的……这些没啥好说。函数的参数、函数的调用及传参、return 语句、匿名函数等等。

函数的参数

参数种类

JS

Python

说明

位置参数

有序形参

有序形参

必须按照对应的顺序位置传参

默认参数

形参被赋初始值

形参被赋初始值

JS 和 Python 完全一致

关键字参数

无此类型

可通过形参名无序传入

Python 传参更灵活

rest 参数

rest 部分只能是一个数组

rest 部分支持列表、元组、字典

Python 支持对象的 rest 参数

相比起来，JS 对于传参显得不够灵活，比如我们往往会遇到需要传递多个参数的函数，那么形参会列出一长串出来。

——很快会感觉形参过长，定位麻烦，而且再扩展则更难看。

——然后我们选择把它合并在一个对象上 options，利于扩展更多参数，但坏处是所有参数都被隐藏了，意味着语义不明。

——然后我们再做一次变形，突出关键参数，其他参数打包放到 options。

// 参数展开

funtion init (name, age, city, job) {

//

}

// 参数合并在一个对象上

funtion init (options) {

//

}

// 突出关键字 name, job

funtion init (name, job, options) {

//

}

ES6 引入的默认参数、rest 参数很多程度增加了 JS 传参的灵活性。

Python 参数相对更加灵活，其关键字参数是一个聪明的办法，它允许用户无视参数的位置，只要将实参赋值给形参传入即可。另外，它不再有类似arguments的内置对象去管理传入的实参。

# 突出关键字 name, job

def init (name, job, **options):

pass

init(job='writer', name='stone')

Python 的关键字参数是解除对参数顺序的强绑定，JS 的 arguments 则是解除对参数名、实参个数的强绑定。两种语言，从参数的设计上耐人寻味。

除了关键字参数，其他形式的参数两种语言完全一样，在此就不再一 一展开了。

函数调用传参

不过还有一项需要注意，就是 Python 函数调用时传参个数必须和函数定义的形参个数一致，否则会报错。这点，JS 则恰好不同，多传不会报错，少传通过调整函数内容也能避免报错。

// 多传参数

def f(x, y):

print(x+y)

f(4, 5, 6) # TypeError: f() takes 2 positional arguments but 3 were given

// 少传参数

f(4) # TypeError: f() missing 1 required positional argument: 'y'

函数传参的值类型和引用类型

Python 也有值类型和引用类型，让 JSer 欣慰的是它们恰和 JS 的值类型、引用类型表达完全相同的意思。当然也有说是可变类型(mutable)与不可变类型(immutable)，实际上都是一个意思。

在 Python 中，strings, tuples和 numbers 是不可修改的类型，而 list,dict 等则是可修改的类型。只要对不可变类型的变量进行了重新赋值，意味着是在内存中新创建了一个变量，原来的变量不再被使用而可能被垃圾回收机制回收掉；而引用类型，是可以改变其内部成员(元素)的，整体上变量还是指向那块内存区。

函数返回值

函数的定义关键字、函数名、参数都已经依次梳理了，剩下的一项便是函数的 return 语句。

对比项

有 return 语句

无 return 语句

JS

返回 return 语句执行后的值

返回undefined

Python

同上

返回 None

Python 暂不赋值时可以用空值占位，即用 None 表示，仅此而已。它没有 JS 的 undefined(未定义、未赋值)，倒是和 null的意思很接近。

另外，Python 可以一次返回多个值——但这只是写法，并不是真正意义的返回多个值，因为用 , 逗号隔开的返回值，实际上是一个元组，只是看起来像返回了多个值——函数就是数学意义上的函数，可以有多个输入，但输出只有一个。

def f(x, y):

print(x, y)

return x*x, x*y, y*y

z = f(1, 2)

print('z', z) #z (1, 2, 4)

与之有相似用法的是 JS 的解构赋值：

function f(x, y) {

console.log(x, y)

return {x, y}

}

let z = f(1, 2);

console.log(z); // {x: 1, y: 2}

作用域

和 JS 非常相似，Python 同样具有全局作用域和局部作用域。在说这个之前，咱们先比较几个细节点。

Python 没有块级作用域

从 ES6 开始，JS 就有了块级作用域，也就是用 {} + let 或者 {} + const开辟出来的一种局部作用域。

也许 Python 不想把事情搞得很复杂，也许因为比较恨 {}符号，总之它的作用域比较简单，它没有块级作用域。它唯一能用来开辟作用域的就是函数。

Python 不存在变量提升

JS 的变量声明和赋值是分两步进行的，在同一层作用域中，JS 会预先扫描一遍 var、let、const 关键字声明的变量，会对 ES5 时代 的 var 变量进行提升，而 ES6 时代的 let，const 变量不做提升。

Python 声明变量则是一步完成的，也就是它必须是一个带赋值 = 号的声明语句，那样很尴尬。一不带关键字，二则一步完成，剪去了不少的边边角角，这恐怕也是 Python 的简洁之道了。声明和赋值是强绑定在一块的，显然难以做变量提升。

// 因为对 var 变量进行了提升，故报错

function fn (x) {

const y = 100;

{

var y = 200; // Error: Duplicate declaration

}

}

# 因为不存在变量提升，故报错

def fn (x):

print(y) #UnboundLocalError: local variable 'y' referenced before assignment

y = 5

全局作用域和局部作用域

声明在函数外的拥有全局作用域；声明在函数内部的变量，拥有一个局部作用域。全局变量可以在整个程序范围中被访问到，而局部变量只能在函数内部被访问。这与 JS 一致，并无任何差异。

y = 100

def fn ():

x = y + 1

print(x)

变量的声明的差异，则是剪掉了繁琐的声明关键字。

继续来一个例子，对 Python 作用域和变量声明强化下认识。

x = 100

def fn ():

x = x + 1

print(x) #?

如果思维切换的太快，很可能你会认为 x的打印结果为 101——理由是函数里头的赋值语句右边的 x 能够访问到函数之外的全局变量 x。很显然，一时间还不能适应无关键字的声明……因为 Pyhton 声明变量不带关键字，容易把 x = x + 1 当作是对全局变量的访问和改写。

那么，此处实际上是在函数体内声明一个同名局部变量，这个声明已然切断了访问外部 x 的能力，再加上一条不存在变量提升，也就是编译到这行时才去找 x，发现上边无法找到被定义的 x，故报错 local variable 'x' referenced before assignment。

咱再来看看 ES6 同样的代码的执行情况：

let x = 100;

function fn (){

let x = x + 1;

console.log(x); // ReferenceError: x is not defined

}

执行 fn 同样会报错。所以，应该将 Python 和最先进的 JS 比较学习，变量提升神马的让大部分非 JSer 朋友很困惑，所以它俩都不存在变量的提升。

另外需要细细体会的是编译时预先扫描一下这个动作，因为上例改成 ES5 的 var 写法则不会报错！扫描，好比上课前老师对教室的学生扫视一下——扫视容易发现长得像的双胞胎和长得出众的美女——仅此而已，相当于做一个预先的错误排查。

最后关于作用域还补述一个问题：如果想在局部作用域(函数体内)修改一个全局变量咋办？

很简单，JS 直接拿起来重新赋值就好了，因为赋值不带关键字也不是声明；Python 恰好相反，它声明变量不带关键字，那么在局部作用域中重新赋值岂不等于是新声明了一个局部变量？

所以 Python 不得不特殊关照下这种情况，也就是引入关键字 global和 nonlocal，前者表示该关键字之后的变量是全局变量，后者表示该关键字之后是本函数之外的、全局之下的局部变量。

x = 100

def fn ():

global x

x = 99

def f ():

nonlocal y

y = 666

f()

print(y) # 666

fn()

print(x) # 1

闭包

作用域除了上述的 “内访问外，外不能访问内”，闭包也是作用域访问的一种形式，Python 同样拥有闭包特性，且和 JS 的闭包是一个道理，在此不再赘述。

函数内置属性

JS 函数内置了 arguments、this 这俩属性来获取函数调用的一些重要信息，Python 没有提供这样的内置属性，所以完全不必操心这方面的学习。

取而代之的是，Python 提供了一系列的内置函数，来获取函数的相关信息。例如，用dir 函数读取函数相关信息：

info = dir(f)

print(info)

"""

['_annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

"""

这些信息较多，请读者自行百度了解，此节不再详述。

最后

好了，到此已经将 Python 函数各个组成部分和 JS 逐个对比了，总之相似的部分居多，差异的部分只要自己的 Python 代码跑起来，自然很容易发现和掌握。

最后不得不说，从 JS 转学 Python 非常容易，只要时刻记住：缩进、缩进、再缩进！