Python是一门“脚本语言”吗？

Posted 2023-03-18

Python是一门通用型的编程语言，而它时常扮演着脚本语言的角色。一般来说，Python可定义为一门面向对象的脚本语言:这个定义把对面向对象的支持和彻底的面向脚本语言的角色融合在一起。如果只用一句话来概括，Python是一门融合了面向过程、函数式和面向对象编程范式的多目标语言。无论怎样，术语“脚本”一词已经同胶水一样黏在了Python 上，这不同于其他需要编写大量繁复代码的语言。例如，人们往往用“脚本”(script)而不是“程序”(program)一词来描述Python的代码文件。由于“脚本语言”的意思可谓众说纷纭，因而，一些人也认为该词在Python中的使用应该被完全禁止。实际上，人们往往给Python三个不同的角色，其中有些角色相对其余的角色更重要:
Shell工具
偶尔当人们听到Python是脚本语言时，他们会认为Python是一个面向系统的脚本语言代码工具。这些程序往往在命令行运行中，实现诸如文本文件的处理以及启动其他程序等任务。
Python程序当然能够以这样的角色工作，但这仅仅是Python常规应用范围的很小一部分。它不只是一种很好的Shell 脚本语言。
控制语言
对其他人而言，脚本意味着控制或重定向其他应用程序组件的“胶水”层。Python经常部署于大型应用之中。例如，测试硬件设备时，Python程序可以调用能够进行硬件底层访问的相关组件。类似地，在终端用户产品定制的过程中，应用程序可以在策略点处调用一些Python 代码，而无需分发或重新编译整个系统代码。
Python的简洁性使其从本质上能够成为一个灵活的控制工具。然而从技术上来讲，这也只是Python的常规角色之一，许多（或许也是绝大多数)Python代码作为独立的脚本执行时无须调用或者了解其他的集成组件。然而，Python不只是一种控制语言。使用便捷可能对“脚本语言”最好的解释，就是一类应用于快速编程任务的一种简单语言。对于Python来说，这确实是实至名归，因为Python和C++之类的编译语言相比，大大提高了程序开发速度。其敏捷的开发周期促进了探索、增量式的软件开发模型，而这些都是必须亲身体验之后才能体会得到。
但是千万别被迷惑，误以为Python仅可以实现简单的任务。恰恰相反，Python的易用性和灵活性使编程任务变得简单。Python有着一些简洁的特性，但是它允许程序按照需求以尽可能优雅的方式扩展。也正是基于这一点，它通常应用于快速作业任务和长期战略开发。
所以，Python是不是脚本语言，这取决于你看待这个问题的视角。一般意义上讲，“脚本语言”一词可能最适用于描述一种 Python所支持的快速和灵活的开发模式，而不是特定的应用领域的概念。 参考技术A

Python是不是脚本语言？这取决于你看待这个问题的视角。一般意义上讲，“脚本语言”一词可能最适用于描述一种Python所支持的快速和灵活的开发模式，而不是特定的应用领域的概念。 

Python是一门通用型的编程语言，而它时常扮演着脚本语言的角色。一般来说，Python可定义为一门面向对象的脚本语言：这个定义把对面向对象的支持和彻底的面向脚本语言的角色融合在一起。如果只用一句话来概括，我想说Python是一门融合了面向过程、函数式和面向对象编程范式的多目标语言。这句话抓住了今天Python涉及的领域及其丰富的内涵。 

无论怎样，术语“脚本”一词已经同胶水一样黏在了Python上，这不同于其他需要编写大量繁复代码的语言。例如，人们往往用“脚本”（script）而不是“程序”（program）一词来描述Python的代码文件。出于对这项传统的沿袭，本书中“脚本”与“程序”是可以相互替代的，其中“脚本”往往倾向于描述简单的顶层代码文件，而“程序”则用来描述那些相对复杂一些的多文件应用。 

由于“脚本语言”的意思可谓众说纷纭，因而，一些人也认为该词在Python中的使用应该被完全禁止。实际上，人们往往给Python冠以以下三个不同的角色，其中有些角色相对其余的角色更重要： 

Shell 工具 

偶尔当人们听到Python是脚本语言时，他们会认为Python是一个面向系统的脚本语言代码工具。这些程序往往在命令行运行中，实现诸如文本文件的处理以及启动其他程序等任务。 

Python程序当然能够以这样的角色工作，但这仅仅是Python常规应用范围的很小一部分。它不只是一种很好的Shell脚本语言。 

控制语言 

对其他人而言，脚本意味着控制或重定向其他应用程序组件的“胶水”层。Python经常部署于大型应用之中。例如，测试硬件设备时，Python程序可以调用能够进行硬件底层访问的相关组件。类似地，在终端用户产品定制的过程中，应用程序可以在策略点处调用一些Python代码，而无需分发或重新编译整个系统代码。 

Python的简洁性使其从本质上能够成为一个灵活的控制工具。然而从技术上来讲，这也只是Python的常规角色之一；许多（或许也是绝大多数）Python代码作为独立的脚本执行时无须调用或者了解其他的集成组件。然而，Python不只是一种控制语言。 

使用便捷 

可能对“脚本语言”最好的解释，就是一类应用于快速编程任务的一种简单语言。对于Python来说，这确实是实至名归，因为Python和C++之类的编译语言相比，大大提高了程序开发速度。其敏捷的开发周期促进了探索、增量式的软件开发模型，而这些都是必须亲身体验之后才能体会得到的。 

但是千万别被迷惑，误以为Python仅可以实现简单的任务。恰恰相反，Python的易用性和灵活性使编程任务变得简单。Python有着一些简洁的特性，但是它允许程序按照需求以尽可能优雅的方式扩展。也正是基于这一点，它通常应用于快速作业任务和长期战略开发。

参考技术B 是的，Python是一门脚本语言。
Python由荷兰数学和计算机科学研究学会的Guido van Rossum 于1990 年代初设计，作为一门叫做ABC语言的替代品。Python提供了高效的高级数据结构，还能简单有效地面向对象编程。Python语法和动态类型，以及解释型语言的本质，使它成为多数平台上写脚本和快速开发应用的编程语言，随着版本的不断更新和语言新功能的添加，逐渐被用于独立的、大型项目的开发。 参考技术C 是的，是脚本语言 参考技术D 是的，就是脚本语言

脚本语言：Xmas

　　自从将Xmas的GC换成现在的非迁移式的全局收集器后，最近几个月一直耗在Xmas上面；最明显的改变就是：更彻底地支持了面向对象、更强大的编译器。

　　所以，本文就来说说，真正的Xmas。

 

　　一、目标

　　一门语言有什么目标吗？比如C#什么的；可惜的是我并不关心。作为一门脚本语言，其目的无非只有一个：简化编程。方式，也是直接明了：在更高的抽象上构建代码。那么什么是“更高的抽象”？个人认为，大抵是两点：1、更方便的操作语义 2、更多的限制。

　　第一点，是指Xmas可以几乎毫无代价地大量使用宿主语言的现有代码；而且是以【语法】的方式。比如，Xmas要有正则表达式，可以有.....只需要使用XmasRef包装宿主语言中的现有Regex即可。事实上，Xmas所有的库函数，都只是C++中本人代码库中的对应物。——这正是脚本，所存在的意义（一旦开始自己构造自己，如C++等，便不再是脚本了）。

　　第二点，这其实是由第一点造成的。很多东西一旦固化到语言本身，便意味着“不可改变”（永远地）。抽象程度越高，意味着，离二进制越远，能控制的东西，更少。最大的限制就是：有了GC，内存是什么？可以吃的吗？在代码里，永远地消失了（意味着，你不再可以控制）。

　　最近，其实一直在思考一个不可能的话题：是否将静态类型加入到Xmas中？  之所以不可能，Xmas只是一门脚本语言。

　　所以，下面，我们就来聊聊“脚本”。

 

　　二、动态

　　一门合格的动态语言：其必须可以【本能】地识别“字符串”。或者说，所有的东西都可以通过“字符串”来构造（替代）：

    func = new Function("print");
    val  = new Integer("12");
    func(val);//打印一个整型12

　　通过字符串，我们构造了一个函数（库打印函数print）和一个数字12。当然，我们可以更彻底一点：

    print  = new Function("print");
    intctr = new Function("Integer");
    val    = intctr("12");
    print(val);

　　是的，在Xmas中，几乎一切都是【函数】。而函数本身，只是由字符串构成的标识符而已；所以，我们可以推迟一切的操作，变成另一门真正的只有函数的语言：

function doSome(str1, str2, str3)
{
    func1 = new Function(str1);
    func2 = new Function(str2);
    value = func2(str3);
    func1(value);
}

　　这时，我们能够通过上面的代码，做任何能够想象的事情（只要有对应的函数，和对应的逻辑）。但是，这种“究极”的动态，有意义吗？没有。因为，上面的代码除了符合Xmas的语法外，并没有任何可识别的逻辑。

    doSome("print", "Integer", "12");
    print(12);

　　上面两行代码，执行了相同的逻辑：打印数字12。

　　动态能力，是为了在必要的时候，绕过编译器的语法/语义检查，而通过“自定义”的方式，访问Xmas的运行时。这个能够在很多时候是有那么一些用处的：

function to_string(val)
{
    if(typedef(val.toString) == Function && Function.argNum(val.toString) == 0){
        return val.toString();
    }
    return new String(val);
}

　　这是早些时候，Xmas将一个对象转化为String的函数。在动态语言中，很多动态性是直接由【语法】本身直接提供的；这也正是“动态”之处。而其他类型的语言，想要达到相同的目的：1、通过反射（java/c#等）2、通过类型系统（C++的类型萃取，通过模板元编程）。

　　当然，这一切是有足够的代价的：更慢、更多的错误。

 

　　三、便捷

    var1 = new Exp.Var(new var1);
    var2 = new Exp.Var(new var2);
    cond = new Exp.Less(var1, var2);
    set1 = new Exp.Set(new var3, var1);
    set2 = new Exp.Set(new var3, var2);
    exp1 = new Exp.Select(cond, set1, set2);
    exp2 = new Exp.Set(new var4, new Exp.Val(12));
    exps = new Exp.Exps();
    exps.addExp(exp1);
    exps.addExp(exp2);
    env = new Exp.Env();
    env.addVar(new var1, 11);
    env.addVar(new var2, 2);
    exps.exec(env);
    put(exps);
    put(env);

　　上面的代码，是以面向对象的方式构建了一颗表达式树（可对应C#）；其执行后的结果：

    ((var1 < var2) ? var3 = var1 : var3 = var2)
    var4 = Integer:12
    //以上，对应了put(exps)，打印表达式树本身

    var3:2 var4:12 var1:11 var2:2
    //以上，是树执行后的结果

　　上面的代码只是干了两件事：1、获取var1与var2中的最小值，并将其赋给var3   2、将var4设置为数字12

　　这些代码本身没有任何惊奇的地方；甚至有些多余：

    var1 = 11;
    var2 = 2;
    var3 = eval("function main(var1, var2){ if(var1 < var2) return var1; return var2;}", var1, var2);
    var4 = 12;

　　这四行代码干了同样的事情，以更清晰和动态的方式。所以，重要的并非这些代码，而是支撑这些代码的“代码”，居然出奇的少：只有97行。

 1 class Exp{
 2 class Env: Xmas{
 3     function Env(){
 4         this.vars = new Map();
 5     }
 6     function addVar(label, val){
 7         this.vars[label] = val;
 8     }
 9     function setVar(label, val){
10         this.vars[label] = val;
11     }
12     function var(label){
13         return this.vars[label];
14     }
15     function toString(){
16         ret new String(this.vars);
17     }
18 }
19 class Val: Xmas{
20     function Val(val){
21         this.val = val;
22     }
23     function exec(){
24         return this.val;
25     }
26     function toString(){
27         return String.format("{}:{}", typeof(this.val), this.val);
28     }
29 }
30 class Var: Xmas{
31     function Var(label){
32         this.label = label;
33     }
34     function exec(env){
35         return env.var(this.label);
36     }
37     function toString(){
38         return new String(this.label);
39     }
40 }
41 class Set: Xmas{
42     function Set(label, val){
43         this.label = label;
44         this.val = val;
45     }
46     function exec(env){
47         env.setVar(this.label, this.val.exec(env));
48     }
49     function toString(){
50         ret String.format("{} = {}", this.label, this.val.toString());
51     }
52 }
53 class Less: Xmas{
54     function Less(a, b){
55         this.a = a;
56         this.b = b;
57     }
58     function exec(env){
59         return this.a.exec(env) < this.b.exec(env);
60     }
61     function toString(){
62         return String.format("({} < {})", this.a.toString(), this.b.toString());
63     }
64 }
65 class Select: Xmas{
66     function Select(condition, a, b){
67         this.condition = condition;
68         this.a = a;
69         this.b = b;
70     }
71     function exec(env){
72         if(this.condition.exec(env)){
73             return this.a.exec(env);
74         }
75         return this.b.exec(env);
76     }
77     function toString(){
78         return String.format("({} ? {} : {})", this.condition.toString(), this.a.toString(), this.b.toString());
79     }
80 }
81 class Exps: Xmas{
82     function Exps(){
83         this.exps = new Array();
84     }
85     function addExp(exp){
86         Array.push_back(this.exps, exp);
87     }
88     function exec(env){
89         foreach(this.exps, function(exp){ exp.exec(env);});
90     }
91     function toString(){
92         str = new Object{ str : ""};
93         foreach(this.exps, function(exp){ str.str += exp.toString() + String.line();});
94         ret str.str;
95     }
96 }
97 }//CLASS OF EXPRESSIONS

　　我并不知道C#中为了相同的目的，需要多少行代码的支持；但无疑，会高一个数量级。这正是脚本的力量，Xmas的力量——可以更快，更高效地构建我们想要的东西。

 

　　四、结语

　　我有在想过，是否要讲讲Xmas的编译器？词法分析、语法分析、代码生成.......

　　也有思考有没有必要说说Xmas的虚拟机？GC、运行时环境、字节码......

　　无疑，我都不想讲。毕竟那些都是那么低枯燥而乏味。

　　Xmas本身肯定不止前面所讲的这些；但，又如何？其不过是本人库中的一个较大的子模块，而已。所以，本系列，完。

　　PS：另外的两个系列，多半是要“太监”。