【嵌牛導讀】Python 是一門運用很廣泛的語言，自動化腳本、爬蟲，甚至在深度學習領域也都有 Python 的身影。作為一名前端開發者，也了解 ES6 中的很多特性借鑒自 Python (比如默認參數、解構賦值、Decorator等)，同時本文會對 Python 的一些用法與 JS 進行類比。不管是提升自己的知識廣度，還是更好地迎接 AI 時代，Python 都是一門值得學習的語言。

【嵌牛鼻子】python與JS的相似之處

【嵌牛提問】python與JS有哪些相似呢？

【嵌牛正文】

數據類型

在 Python 中，最常用的能夠直接處理的數據類型有以下幾種：

數字[整數(int)、浮點型(float)、長整型(long)、復數(complex)]

字符串(str)

布爾值(bool)

空值(None)

除此之外，Python 還提供了列表[list]、字典[dict] 等多種數據類型，這在下文中會介紹。

類型轉換與類型判斷

與 JS 十分類似，python 也能實現不同數據類型間的強制與隱式轉換，例子如下：

強制類型轉換:

            
int('3') # 3
str(3.14) # '3.14'
float('3.14') # 3.14
# 區別于 JS 只有 Number 一種類型，Python 中數字中的不同類型也能相互強制轉換
float(3) # 3.0
bool(3) # True
bool(0) # False
          

隱式類型轉換:

            
1 + 1.0 # 2.0
1 + False # 1
1.0 + True # 2.0
# 區別于 JS 的 String + Number = String, py 中 str + int 會報錯
1 + '1' # TypeError: cannot concatenate 'str' and 'int' objects
          

此外寫代碼的時候經常會需要判斷值的類型，可以 使用 python 提供的 type() 函數獲取變量的類型，或者使用 isinstance(x, type) 來判斷 x 是否屬于相應的 type 類型。

            
type(1.3) == float # True
isinstance('a', str) # True
isinstance(1.3, int) # False
isinstance(True, bool) # True
isinstance([], list) # True
isinstance({}, dict) # True
          

有序集合類型

集合是指包含一組元素的數據結構，有序集合即集合里面的元素是是按照順序排列的，Python 中的有序集合大概有以下幾類：list, tuple, str, unicode。

list 類型

Python 中 List 類型類似于 JS 中的 Array,

            
L = [1, 2, 3]
print L[-1] # '3'
L.append(4) # 末尾添加元素
print L # [1, 2, 3, 4]
L.insert(0, 'hi') # 指定索引位置添加元素
print L # ['hi', 1, 2, 3, 4]
L.pop() # 末尾移除元素 L.pop(2) ?????? 2 ???
print L # ['hi', 1, 2, 3]
          

tuple 類型

tuple 類型是另一種有序的列表，中文翻譯為" 元組 "。tuple 和 list 非常類似，但是，tuple 一旦創建完畢，就不能修改了。

            
t = (1, 2, 3)
print t[0] # 1
t[0] = 11 # TypeError: 'tuple' object does not support item assignment
t = (1)
print t # 1 t 的結果是整數 1
t = (1,) # 為了避免出現如上有歧義的單元素 tuple，所以 Python 規定，單元素 tuple 要多加一個逗號","
print t # (1,)
          

無序集合類型

dict 類型

Python 中的 dict 類型類似于 JS 中的 {} (最大的不同是它是沒有順序的), 它有如下特點:

查找速度快 (無論 dict 有 10 個元素還是 10 萬個元素，查找速度都一樣)

占用內存大 (與 list 類型相反)

dict 中的 key 不能重復

dict 中存儲的 key-value 序對是沒有順序的

            
d = {
  'a': 1,
  'b': 2,
  'c': 3
}
          

print d # {'a': 1, 'c': 3, 'b': 2}? 可以看出打印出的序對沒有按正常的順序打出

            
# 遍歷 dict
for key,value in d.items():
  print('%s: %s' % (key,value))
# a: 1
# c: 3
# b: 2
          

set 類型

有的時候，我們只想要 dict 的 key，不關心 key 對應的 value，而且要保證這個集合的元素不會重復，這時，set 類型就派上用場了。set 類型有如下特點：

set 存儲的元素和 dict 的 key 類似，必須是不變對象

set 存儲的元素也是沒有順序的

            
s = set(['A', 'B', 'C', 'C'])
print s # set(['A', 'C', 'B'])
s.add('D')
print s # set(['A', 'C', 'B', 'D'])
s.remove('D')
print s # set(['A', 'C', 'B'])
          

Python 中的迭代

在介紹完 Python 中的有序集合和無序集合類型后，必然存在遍歷集合的 for 循環。但是和其它語言的標準 for 循環不同，Python 中的所有迭代是通過 for ... in 來完成的。以下給出一些常用的迭代 demos:

索引迭代：

            
L = ['apple', 'banana', 'orange']
for index, name in enumerate(L): # enumerate() 函數把 ['apple', 'banana', 'orange'] 變成了類似 [(0, 'apple), (1, 'banana'), (2, 'orange')] 的形式
  print index, '-', name
# 0 - apple
# 1 - banana
# 2 - orange
          

迭代 dict 的 value:

            
d = { 'apple': 6, 'banana': 8, 'orange': 5 }
print d.values() # [6, 8, 5]
for v in d.values()
  print v
# 6
# 8
# 5
          

迭代 dict 的 key 和 value:

            
d = { 'apple': 6, 'banana': 8, 'orange': 5 }
for key, value in d.items()
  print key, ':', value
# apple : 6
# banana: 8
# orange: 5
          

切片操作符

Python 提供的切片操作符類似于 JS 提供的原生函數 slice()。有了切片操作符，大大簡化了一些原來得用循環的操作。

            
L = ['apple', 'banana', 'orange', 'pear']
L[0:2] # ['apple', 'banana'] 取前 2 個元素
L[:2] # ['apple', 'banana'] 如果第一個索引是 0，可以省略
L[:] # ['apple', 'banana', 'orange', 'pear'] 只用一個 : ，表示從頭到尾
L[::2] # ['apple', 'orange'] 第三個參數表示每 N 個取一個，這里表示從頭開始，每 2 個元素取出一個來
          

列表生成器

如果要生成 [1x1, 2x2, 3x3, ..., 10x10] 怎么做？方法一是循環：

            
L = []
for x in range(1, 11):
  L.append(x * x)
          

但是循環太繁瑣，而列表生成式則可以用一行語句代替循環生成上面的 list：

# 把要生成的元素 x * x 放到前面，后面跟 for 循環，就可以把 list 創建出來

[x * x for x in range(1, 11)]

# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

列表生成式的 for 循環后面還可以加上 if 判斷(類似于 JS 中的 filter() 函數)，示例如下：

[x * x for x in range(1, 11) if x % 2 == 0]

# [4, 16, 36, 64, 100]

for 循環可以嵌套，因此，在列表生成式中，也可以用多層 for 循環來生成列表。

[m + n for m in 'ABC' for n in '123']
# ['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']

Python 函數

默認參數

JS 中 ES6 的 默認參數正是借鑒于 Python，用法如下：

            
def greet(name='World'):
  print 'Hello, ' + name + '.'
greet() # Hello, World.
greet('Python') # Hello, Python.
          

可變參數

類似于 JS 函數中自動識別傳入參數的個數，Python 也提供了定義可變參數，即在可變參數的名字前面帶上個 * 號。

            
def fn(*args):
  print args
fn() # ()
fn('a') # ('a',)
fn('a', 'b') # ('a', 'b')
          

Python 解釋器會把傳入的一組參數組裝成一個 tuple 傳遞給可變參數，因此，在函數內部，直接把變量 args 看成一個 tuple 就好了。

常用高階函數

Python 中常用的函數 (map、reduce、filter) 的作用和 JS 中一致，只是用法稍微不同。

map 函數: 接收一個函數 f 和一個 list，并通過把函數 f 依次作用在 list 的每個元素上，得到一個新的 list 并返回。

            
def f(x):
  return x * x
print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) # [1, 4, 9, 16, 25, 36, 49, 64, 81]
          

reduce 函數: 接收一個函數 f 和一個 list(可以接受第三個值作為初始值)，reduce() 對 list 的每個元素反復調用函數 f，并返回最終結果值。

            
def f(x, y):
  return x * y
reduce(f, [1, 3, 5]) # 15
          

filter 函數: 接收一個函數 f 和一個list，這個函數 f 的作用是對每個元素進行判斷，返回 True或 False，filter() 根據判斷結果自動過濾掉不符合條件的元素，返回由符合條件元素組成的新 list。

            
def is_odd(x):
  return x % 2 == 1
filter(is_odd, [1, 4, 6, 7, 9, 12, 17]) # [1, 7, 9, 17]
          

匿名函數

和 JS 的匿名函數不同的地方是，Python 的匿名函數中只能有一個表達式，且不能寫 return。拿 map() 函數為例：

            
map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]) # [1, 4, 9, 16, 25, 36, 49, 64, 81]
          

關鍵詞 lambda 表示匿名函數，冒號前面的 x 表示函數參數，可以看出匿名函數 lambda x: x* x實際上就是:

            
def f(x):
  return x * x
          

閉包

之前寫過一些關于 JS 閉包的文章，比如 深入淺出JavaScript之閉包（Closure）、以及 讀書筆記-你不知道的 JavaScript (上)，Python 中閉包的定義和 JS 中的是一致的即：內層函數引用了外層函數的變量，然后返回內層函數。下面來看下 Py 中閉包之 for 循環經典問題：

            
# 希望一次返回3個函數，分別計算1x1,2x2,3x3:
def count():
  fs = []
  for i in range(1, 4):
    def f():
      return i * i
    fs.append(f)
  return fs
f1, f2, f3 = count() # 這種寫法相當于 ES6 中的解構賦值
print f1(), f2(), f3() # 9 9 9
          

老問題了，f1(), f2(), f3() 結果不應該是 1, 4, 9 嗎，實際結果為什么都是 9 呢？

原因就是當 count() 函數返回了 3 個函數時，這 3 個函數所引用的變量 i 的值已經變成了 3。由于 f1、f2、f3 并沒有被調用，所以，此時他們并未計算 i*i，當 f1 被調用時，i 已經變為 3 了。

要正確使用閉包，就要確保引用的局部變量在函數返回后不能變。代碼修改如下:

方法一: 可以理解為創建了一個封閉的作用域，i 的 值傳給 j 之后，就和 i 沒任何關系了。每次循環形成的閉包都存進了內存中。

            
def count():
  fs = []
  for i in range(1, 4):
    def f(j):
      def g(): # 方法一
        return j * j
      return g
    r = f(i)
    fs.append(r)
  return fs
f1, f2, f3 = count()
print f1(), f2(), f3() # 1 4 9
          

方法二：思路比較巧妙，用到了默認參數 j 在函數定義時可以獲取到 i 的值，雖然沒有用到閉包，但是和方法一有異曲同工之處。

            
def count():
  fs = []
  for i in range(1, 4):
    def f(j = i): # 方法二
      return j * j
    fs.append(f)
  return fs
f1, f2, f3 = count()
print f1(), f2(), f3() # 1 4 9
          

decorator 裝飾器

ES6 的語法中的 decorator 正是借鑒了 Python 的 decorator。decorator 本質上就是 一個高階函數，它接收一個函數作為參數，然后返回一個新函數。

那裝飾器的作用在哪呢？先上一段日常項目中用 ts 寫的網關代碼：

            
@Post('/rider/detail') // URL 路由
@log()         // 打印日志
 @ResponseBody
 public async getRiderBasicInfo(
  @RequestBody('riderId') riderId: number,
  @RequestBody('cityId') cityId: number,
 ) {
  const result = await this.riderManager.findDetail(cityId, riderId)
  return result
 }


          

可以看出使用裝飾器可以極大地簡化代碼，避免每個函數(比如日志、路由、性能檢測)編寫重復性代碼。

回到 Python 上，Python 提供的 @ 語法來使用 decorator， @ 等價于 f = decorate(f)。下面來看看 @log() 在 Python 中的實現:

            
# 我們想把調用的函數名字給打印出來
@log()
def factorial(n):
  return reduce(lambda x,y: x*y, range(1, n+1))
print factorial(10)
# 來看看 @log() 的定義
def log():
  def log_decorator(f):
    def fn(x):
      print '調用了函數' + f.__name__ + '()'
      return f(x)
    return fn
  return log_decorator
# 結果
# 調用了函數 factorial()
# 3628800
class
          

面向對象編程

面向對象編程是一種程序設計范式，基本思想是：用類定義抽象類型，然后根據類的定義創建出實例。在掌握其它語言的基礎上，還是比較容易理解這塊知識點的，比如從下面兩種寫法可以看出不同語言的語言特性間竟然有如此多的共性。

es6: (附：本文的主題是 python，所以只是初略展示下 js 中類的定義以及實例的創建，為了說明寫法的相似性)

            
class Person {
  constructor(name, age) {
    this.name = name
    this.age = age
  }
}
const child1 = new Person('Xiao Ming', 10)
          

Python: (核心要點寫在注釋中)

            
# 定義一個 Person 類：根據 Person 類就可以造成很多 child 實例
class Person(object):
  address = 'Earth' # 類屬性 (實例公有)
  def __init__(self, name, age): # 創建實例時，__init__()方法被自動調用
    self.name = name
    self.age = age
  def get_age(self): # 定義實例方法，它的第一個參數永遠是 self，指向調用該方法的實例本身，其他參數和普通函數是一樣的
    return self.age
child1 = Person('Xiao Ming', 10)
child2 = Person('Xiao Hong', 9)
print child1.name # 'Xiao Ming'
print child2.get_age() # 9
print child1.address # 'Earth'
print child2.address # 'Earth'
          

繼承

child 屬于 Student 類，Student 類屬于 People 類，這就引出了繼承: 即獲得了父類的方法屬性后又能添加自己的方法屬性。

            
class Person(object):
  def __init__(self, name, age):
    self.name = name
    self.age = age
class Student(Person):
  def __init__(self, name, age, grade):
    super(Student, self).__init__(name, age) # 這里也能寫出 Person.__init__(self, name, age)
    self.grade = grade
s = Student('Xiao Ming', 10, 90)
print s.name # 'Xiao Ming'
print s.grade # 90
          

可以看到子類在父類的基礎上又增加了 grade 屬性。我們可以再來看看 s 的類型。

            
isinstance(s, Person)
isinstance(s, Student)
          

可以看出，Python 中在一條繼承鏈上，一個實例可以看成它本身的類型，也可以看成它父類的類型。

總結

以上所述是小編給大家介紹的Python 和 JS 有哪些相同之處，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復大家的。在此也非常感謝大家對腳本之家網站的支持！