Python vs. Javascript

Vor kurzem habe ich aus beruflichen Gründen begonnen, einige Python-Dinge zu entwickeln. Da ich zuvor Javascript verwendet habe, verwende ich unbewusst einige Javascript-Konzepte, Syntax usw. und falle oft in Schwierigkeiten. Ich denke, es ist notwendig, die Unterschiede zwischen ihnen beim Wechsel von Javascript zu Python zusammenzufassen.

Grundlegende Konzepte

Python und Javascript sind beide Skriptsprachen, daher haben sie viele gemeinsame Funktionen, beide erfordern zur Ausführung einen Interpreter, beide sind dynamische Typen und beide unterstützen Automatische Speicherverwaltung: Sie können eval() aufrufen, um Skripte und andere Funktionen auszuführen, die in Skriptsprachen üblich sind.

Sie sind jedoch auch sehr unterschiedlich. Javascript wurde ursprünglich als clientseitige Skriptsprache entwickelt, die hauptsächlich in Browsern verwendet wird, während Python aufgrund seiner „Eleganz“ „It“ ist ist wegen seines „klaren“ und „einfachen“ Designs beliebt und wird in verschiedenen Szenarien wie Bildung, wissenschaftlichem Rechnen und Webentwicklung eingesetzt.

Programmierparadigmen

Sowohl Python als auch Javascript unterstützen eine Vielzahl verschiedener Programmierparadigmen und unterscheiden sich stark in Bezug auf die objektorientierte Programmierung. Der objektorientierte Ansatz von Javascript basiert auf Prototypen. Die Vererbung von Objekten erfolgt durch Prototypen (auch Objekte, die durch Prototypobjekte erstellt werden, erben die Methoden in der Prototypenkette). Python hingegen ist ziemlich standardisiert und basiert auf der Klassenvererbung und unterstützt natürlich Polymorphismus (Polymorphin).

OO in Pyhton

class Employee:
   'Common base class for all employees'
   empCount = 0 ##类成员
   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
    
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount
   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary
## 
创建实例
ea = Employee("a",1000)
eb = Employee("b",2000)

var empCount = 0;
//构造函数
function Employee(name, salary){
    this.name = name;
    this.salary = salary;   
    this.empCount += 1;
}
Employee.prototype.displayCount = function(){
    console.log("Total Employee " + empCount );
}
Employee.prototype.displayEmployee = function(){
    console.log("Name " + this.name + ", Salary " + this.salary );
}
//创建实例
var ea = new Employee("a",1000);
var eb = new Employee("b", 2000);

Da es auf Objektvererbung basiert, können wir in Javascript das Klassenmitglied empCount nicht verwenden, daher müssen wir natürlich eine globale Variable deklarieren Bei der tatsächlichen Entwicklung werden wir einen geeigneteren Bereich verwenden. Beachten Sie, dass Javascript zum Erstellen von Objekten das Schlüsselwort new benötigt, Python jedoch nicht.

Zusätzlich zur nativen prototypbasierten Vererbung gibt es viele Javascript-OO-Tools, die Abschlüsse oder Prototypen verwenden, um die Klassenvererbung zu simulieren. Da es sich nicht um eine Eigenschaft der Sprache selbst handelt, werden wir nicht darauf eingehen.

Threading-Modell

Es gibt kein Konzept für Multithreading in der Welt von Javascript. Parallelität wird mithilfe eines ereignisgesteuerten Ansatzes durchgeführt. Alle JavaScript-Programme laufen in einem Thread. Die Einführung von Web-Workern in HTML5 kann Aufgaben gleichzeitig verarbeiten, ändert jedoch nichts an der Single-Thread-Beschränkung von Javascript.

Python unterstützt Multithreading durch das Thread-Paket.

Unveränderlicher Typ

In Python sind einige Datentypen unveränderlich, was bedeutet, dass dieser Datentyp nicht geändert werden kann und alle Änderungen neue Objekte zurückgeben. Alle Datentypen in Javascript können geändert werden. Ich denke, Python hat unveränderliche Typen eingeführt, um die Thread-Sicherheit zu unterstützen, und da Javascript ein Single-Thread-Modell ist, besteht keine Notwendigkeit, unveränderliche Typen einzuführen.

Natürlich können Sie in Javascript die Eigenschaften eines Objekts als schreibgeschützt definieren.

var obj = {};Object.defineProperty(obj, "prop", {
    value: "test",
    writable: false});

Mit ECMAScript5-Unterstützung können Sie auch die Freeze-Methode von Object aufrufen, um das Objekt nicht änderbar zu machen.

Object.freeze(obj)

Datentypen

Javascript-Datentypen sind relativ einfach und umfassen Objekt, Zeichenfolge, Boolescher Wert, Zahl, Null und Undefiniert insgesamt Sechs

Alles in Python ist ein Objekt, wie ein Modul, eine Funktion, eine Klasse usw.

Python verfügt über fünf integrierte einfache Datentypen: Bool, Int, Long, Float und Complex sowie Containertypen, Codetypen, interne Typen usw.

Boolean

Javascript hat wahr und falsch. Python hat Wahr und Falsch. Es gibt keinen Unterschied zwischen ihnen, außer der Groß- und Kleinschreibung.

String

Javascript verwendet UTF16-Kodierung.

Python verwendet ASCII-Code. Sie müssen encode und decode aufrufen, um die Codierungskonvertierung durchzuführen. Verwenden Sie „u“ als Präfix, um anzugeben, dass die Zeichenfolge Unicode-Codierung verwendet.

Numerischer Wert

Alle numerischen Typen in Javascript werden als 64-Bit-Gleitkommazahlen implementiert. Unterstützt NaN (keine Zahl), plus oder minus unendlich (+/-unendlich).

Python verfügt über viele numerische Typen, von denen der Pluraltyp sehr praktisch ist, sodass Python in den Bereichen wissenschaftliche Forschung und Bildung sehr beliebt ist. Dies dürfte einer der Gründe sein. NaN ist in Python nicht definiert und eine Division durch Null löst eine Ausnahme aus.

Liste

Javascript verfügt über einen integrierten Array-Typ (Array ist auch ein Objekt)

Pythons Liste (List) ähnelt dem Array von Javascript , und das Element Eine Gruppe (Tupel) kann als unveränderliche Liste verstanden werden.

Zusätzlich zur Verwendung der integrierten Methode len zum Ermitteln der Länge in Python bieten sowohl Javascript als auch Python grundsätzlich ähnliche Methoden zum Betreiben von Listen. Der Betrieb von Listenindizes in Python ist sehr flexibel und bequem, was Javascript nicht bietet. Zum Beispiel l[5:-1], l[:6] usw.

Wörterbuch, Hash-Tabelle, Objekt

{} wird in Javascript häufig zum Erstellen von Objekten verwendet. Es gibt keinen Unterschied zwischen diesen Objekten und Wörterbüchern. Sie können [] verwenden. oder um auf die Mitglieder des Objekts zuzugreifen. Mitglieder können dynamisch hinzugefügt, geändert und gelöscht werden. Sie können sich ein Objekt als Javascript-Wörterbuch oder Hash-Tabelle vorstellen. Der Schlüssel des Objekts muss eine Zeichenfolge sein.

Python verfügt über eine integrierte Hash-Tabelle (dictS). Im Gegensatz zu Javascript kann dictS verschiedene Arten von Schlüsselwerten haben.

Nullwert

Javascript定义了两种空值。 undefined表示变量没有被初始化，null表示变量已经初始化但是值为空。

Python中不存在未初始化的值，如果一个变量值为空，Python使用None来表示。

Javascript中变量的声明和初始化

v1;
v2 = null;
var v3;
var v4 = null;
var v5 = 'something';

在如上的代码中v1是全局变量，未初始化，值为undefined；v2是全局变量，初始化为空值；v3为局部未初始化变量，v4是局部初始化为空值的变量；v5是局部已初始化为一个字符处的变量。

Python中变量的声明和初始化

v1 = None
v2 = 'someting'

Python中的变量声明和初始化就简单了许多。当在Python中访问一个不存在的变量时，会抛出NameError的异常。当访问对象或者字典的值不存在的时候，会抛出AttributeError或者KeyError。因此判断一个值是否存在在Javascript和Python中需要不一样的方式。

Javascript中检查某变量的存在性：

if (!v ) {
    // do something if v does not exist or is null or is false
}
if (v === undefined) {
    // do something if v does not initialized
}

注意使用!v来检查v是否初始化是有歧义的因为有许多种情况!v都会返回true

Python中检查某变量的存在性：

try:
    v
except NameError
    ## do something if v does not 
exist

在Python中也可以通过检查变量是不是存在于局部locals（）或者全局globals（）来判断是否存在该变量。

类型检查

Javascript可以通过typeof来获得某个变量的类型：

typeof in Javascript 的例子：

typeof 3 // "number"
typeof "abc" // "string"
typeof {} // "object"
typeof true // "boolean"
typeof undefined // "undefined"
typeof function(){} // "function"
typeof [] // "object"
typeof null // "object"

要非常小心的使用typeof，从上面的例子你可以看到，typeof null居然是object。因为javscript的弱类型特性，想要获得更实际的类型，还需要结合使用instanceof，constructor等概念。具体请参考这篇文章(http://tobyho.com/2011/01/28/checking-types-in-javascript/)

Python提供内置方法type来获得数据的类型。

>>> type([]) is list
True
>>> type({}) is dict
True
>>> type('') is str
True
>>> type(0) is int
True

同时也可以通过isinstance()来判断类的类型

class A:
    pass
class B(A):
    pass
isinstance(A(), A)  # returns True
type(A()) == A      # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False

但是注意Python的class style发生过一次变化，不是每个版本的Python运行上述代码的行为都一样，在old style中，所有的实例的type都是‘instance’，所以用type方法来检查也不是一个好的方法。这一点和Javascript很类似。

自动类型转换

当操作不同类型一起进行运算的时候，Javascript总是尽可能的进行自动的类型转换，这很方便，当然也很容易出错。尤其是在进行数值和字符串操作的时候，一不小心就会出错。我以前经常会计算SVG中的各种数值属性，诸如x，y坐标之类的，当你一不小心把一个字符串加到数值上的时候，Javascript会自动转换出一个数值，往往是NaN，这样SVG就完全画不出来啦，因为自动转化是合法的，找到出错的地方也非常困难。

Python在这一点上就非常的谨慎，一般不会在不同的类型之间做自动的转换。

语法

风格

Python使用缩进来决定逻辑行的结束非常具有创造性，这也许是Python最独特的属性了，当然也有人对此颇具微词，尤其是需要修改重构代码的时候，修改缩进往往会引起不小的麻烦。

Javascript虽然名字里有Java，它的风格也有那么一点像Java，可是它和Java就好比雷峰塔和雷锋一样，真的没有半毛钱的关系。到时语法上和C比较类似。这里必须要提到的是coffeescript作为构建与Javascript之上的一种语言，采用了类似Python的语法风格，也是用缩进来决定逻辑行。

Python风格

def func(list):
    for i in range(0,len(list)):
        print list[i]

Javascript风格

function funcs(list) {
    for(var i=0, len = list.length(); i < len; i++) {
        console.log(list[i]);
    }
}

从以上的两个代码的例子可以看出，Python确实非常简洁。

作用范围和包管理

Javascript的作用域是由方法function来定义的，也就是说同一个方法内部拥有相同的作用域。这个严重区别与C语言使用{}来定义的作用域。Closure是Javascript最有用的一个特性。

Python的作用域是由module，function，class来定义的。

Python的import可以很好的管理依赖和作用域，而Javascript没有原生的包管理机制，需要借助AMD来异步的加载依赖的js文件，requirejs是一个常用的工具。

赋值逻辑操作符

Javascript使用=赋值，拥有判断相等（==）和全等（===）两种相等的判断。其它的逻辑运算符有&& 和||，和C语言类似。

Python中没有全等，或和与使用的时and 和 or，更接近自然语言。Python中没有三元运算符 A ：B ？C，通常的写法是

（A and B) or 
C

因为这样写有一定的缺陷，也可以写作

B if A else 
C

Python对赋值操作的一个重要的改进是不允许赋值操作返回赋值的结果，这样做的好处是避免出现在应该使用相等判断的时候错误的使用了赋值操作。因为这两个操作符实在太像了，而且从自然语言上来说它们也没有区别。

++运算符

Python不支持++运算符，没错你再也不需要根据++符号在变量的左右位置来思考到底是先加一再赋值呢还是先赋值再加一。

连续赋值

利用元组（tuple），Python可以一次性的给多个变量赋值

(MONDAY, TUESDAY, 
WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY) = 
range(7)

函数参数

Python的函数参数支持命名参数和可选参数（提供默认值），使用起来很方便，Javascript不支持可选参数和默认值（可以通过对arguments的解析来支持）

def info(object, spacing=10, collapse=1):
    ... ...

其它

立即调用函数表达式 （IIFE）

Javascript的一个方便的特性是可以立即调用一个刚刚声明的匿名函数。也有人称之为自调用匿名函数。

下面的代码是一个module模式的例子，使用闭包来保存状态实现良好的封装。这样的代码可以用在无需重用的场合。

var counter = (function(){
    var i = 0;
    return {
        get: function(){
            return i;
            },
        set: function( val ){
            i = val;
            },
        increment: function() {
            return ++i;
            }
        };
    }());

Python没有相应的支持。

生成器和迭代器（Generators & Iterator）

在我接触到的Python代码中，大量的使用这样的生成器的模式。

Python生成器的例子

# 
a generator that yields items instead of returning a list
def firstn(n):
    num = 0
    while num < n:
        yield num
        num += 1
   
sum_of_first_n = sum(firstn(1000000))

Javascript1.7中引入了一些列的新特性，其中就包括生成器和迭代器。然而大部分的浏览器除了Mozilla（Mozilla基本上是在自己玩，下一代的Javascript标准应该是ECMAScript5）都不支持这些特性

Javascript1.7 迭代器和生成器的例子。

function fib() {
  var i = 0, j = 1;
  while (true) {
    yield i;
    var t = i;
    i = j;
    j += t;
  }
}；
var g = fib();
for (var i = 0; i < 10; i++) {
  console.log(g.next());
}

列表（字典、集合）映射表达式 （List、Dict、Set Comprehension）

Python的映射表达式可以非常方便的帮助用户构造列表、字典、集合等内置数据类型。

下面是列表映射表达式使用的例子：

>>> [x + 3 for x in range(4)]
[3, 4, 5, 6]
>>> {x + 3 for x in range(4)}
{3, 4, 5, 6}
>>> {x: x + 3 for x in range(4)}
{0: 3, 1: 4, 2: 5, 3: 6}

Javascript1.7开始也引入了Array Comprehension

var numbers = [1, 2, 3, 4];
var doubled = [i * 2 for (i of numbers)];

Lamda表达式 （Lamda Expression ）

Lamda表达式是一种匿名函数，基于著名的λ演算。许多语言诸如C#，Java都提供了对lamda的支持。Pyhton就是其中之一。Javascript没有提供原生的Lamda支持。但是有第三方的Lamda包。

g = lambda x : 
x*3

装饰器（Decorators）

Decorator是一种设计模式，大部分语言都可以支持这样的模式，Python提供了原生的对该模式的支持，算是一种对程序员的便利把。

Decorator的用法如下。

@classmethod
def foo (arg1, arg2):
    ....

以上就是Python 与 Javascript 之比较 的内容，更多相关内容请关注PHP中文网（www.php.cn）！