前一篇文章，用一天的时间，通过与 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 函数同样由这些部分构成，以下是一个简单的表格将它们进行对比。

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

函数的定义规范

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

def py_fn (x):
    print(x)
    return x

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

函数的参数

相比起来，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 语句。

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 非常容易，只要时刻记住：缩进、缩进、再缩进！