前一篇文章，用一天的时间，通过与 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 非常容易，只要时刻记住：缩进、缩进、再缩进！
网友评论