python内置函数与 javascript对照表

因为 python 与 javascript 都是动态脚本语言，在语法上有很多共通之处，为了更好地加深对 python语法的印象，避免看完即忘，就想着对照 javascript语法来理解 python语法，这里稍稍记录一下。

---

内置函数

• input([prompt]) – prompt(text,defaultText)

input 用于获取控制台的输入，而 prompt 是浏览器弹窗获取用户输入，二者使用的形式不同，但都是获取外部输入，并返回外部输入的值。

• **、pow(x, y[, z]) – Math.pow(base, exponent)

**、pow(x, y[, z])都可以用于计算数字乘方，python中的 pow()比 js中的 Math.pow()多了一个可选参数，此可选参数用于对乘方结果取模，即 pow(x, y, z) == pow(x, y) % z

• abs(x) – Math.abs(x)

对数字进行绝对值运算

• max(x,y,z,...)、min(x,y,z,...) – Math.max(x,y,z,...)、Math.min(x,y,z,...)

max() 方法返回给定参数的最大值，参数可以为序列（例如元祖、列表等）

• round(x[,n]) – Math.round(x)

round() 方法返回浮点数x的四舍五入值。

相比于 Math.round，多了一个可选参数，用于指定四舍五入后数字的有些数字位数

• divmod

  divmod(a, b) 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)，如果把元祖看成是数组的话，大致相当于下述 js函数：

  function divmod(a, b) {
  return [Math.floor(a/b), a%b]
  }

  另外，python2.3之后，此函数支持复数运算，例如 divmod(1+2j,1+0.5j) ==> ((1+0j), 1.5j)

  • sum(iterable[, start])

  对系列进行求和计算，第一个参数接受一个可迭代对象，例如列表、元祖、字典，指定相加的参数，如果没有设置这个值，默认为0

  大致相当于下述 js函数：

  function sum(iterable, start = 0) {
  for(let i of iterable) {
   start += i
  }
  return start
  }

• all(iterable)

all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否不为 0、''、False 或者 iterable 为空，如果是返回 True，否则返回 False。

大致相当于下述 js函数：

function all(iterable) {
  let result = false
  for(let i of iterable) {
    result = true
    let type = i[Symbol.iterator]
    if(typeof type === 'function' && typeof type === 'function') {
      if(!all(i)) return false
    } else if(i === 0 || i=== '' || i===false) {
      result = false
      break
    }
  }
  return result
}

如果 iterable限定为数组的话，还相当于以下函数：

function all(iterable) {
  if(!iterable.length) return false
  return iterable.every((v, k, arr)=>{
    if(toString.call(v).slice(8,-1) === 'Array') {
      if(!v.length || !all(v)) return false
    }
    return (v === 0 || v=== '' || v===false) ? false : true
  })
}

• any
any() 函数用于判断给定的可迭代参数 iterable 是否全部为空对象，如果都为空、0、false，则返回 False，如果不都为空、0、false，则返回 True

大致相当于下述 js函数：

function any(iterable) {
  let result = false
  for(let i of iterable) {
    let type = i[Symbol.iterator]
    if(typeof type === 'function' && typeof type === 'function') {
      if(!all(i)) return false
    } else if(i !== 0 && i!== '' && i!==false) {
      result = true
      break
    }
  }
  return result
}

如果 iterable限定为数组的话，还相当于以下函数：

function any(iterable) {
  if(!iterable.length) return false
  return iterable.some((v, k, arr)=>{
    if(toString.call(v).slice(8,-1) === 'Array') {
      if(!v.length || !any(v)) return false
    }
    return (v !== 0 && v!== '' && v!==false) ? true : false
  })
}

• int(x, base=10) – parseInt(x, base=10)

int() 函数用于将一个字符串会数字转换为整型,与 js中的 parseInt功能大体相同

• ord(c) – charCodeAt(c) 或 codePointAt

ord 以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值

// python
ord('a')  => 97

// js
'a'.charCodeAt(0) => 97
'a'.codePointAt(0) => 97

• str(object='') – JSON.stringify(value[, replacer[, space]])

str() 函数将对象转化为适于人阅读的形式(例如字符串)

• eval(expressionStr[, globals[, locals]]) – eval(string)

eval() 函数用来执行一个字符串表达式，并返回表达式的值，相比于 js的 eval，多出了两个可选参数，用于指定变量作用域。

eval('3 * 2') ==> 6

• isinstance(object, classinfo) – instanceof

isinstance() 函数来判断一个对象是否是一个已知的类型，与 js中的 instanceof大体功能类似，不过用法有些差别

isinstance(2, int) ==> True
isinstance('s', (str, int, list)) => True

• print(*objects, sep=' ', end='\n', file=sys.stdout) – console.log(msg [, subst1, ..., substN])

都是控制台打印方法，在python2.x中，print为关键字，3.x版本中则是一个函数

// python
print 'hello', 'world' => hello world

/ js
console.log('hello', 'world') => hello world

• bind(x) – (x).toString(2)

bin() 返回一个整数 int 或者长整数 long int 的二进制表示

// python
bin(10) => 0b1010

// js
(10).toString(2) => 1010

• iter(object[, sentinel]) – Symbol.iterator

iter() 函数用来生成迭代器，有点类似于 js中的 Symbol.iterator，后者用于为可遍历对象部署 iterator接口

// python
for i in iter([1,2,3]):
  print(i)
=> 1 2 3

// js
let obj = {}, arr=[1,2,3]
obj[Symbol.iterator] = arr[Symbol.iterator].bind(arr)
for(let v of obj) {
  console.log(v)
}
=> 1 2 3

• bool([x]) – Boolean([x])

bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。

// python
bool(0) => False

// js
Boolean(0) => false

• filter(function, iterable) – filter

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

// python
def is_odd(n):
  return n%2 == 1

print filter(is_odd, [1,2,3,4,5,6,7,8])
=> [1,3,5,7]

// js
[1,2,3,4,5,6,7,8].filter((v,k)=>{
  return v%2 === 1
})

=> [1,3,5,7]

• len(s) – length

len() 方法返回对象（字符、列表、元组等）长度或项目个数

// python
len([1,2,3]) => 3

// js
[1,2,3].length =>3

• range(start, stop[, step])

range() 函数可创建一个整数列表，一般用在 for 循环中，大致相当于下述 js函数：

function range(start=0, end, step=1) {
  if(!end || (start>end && step>0)) return []
  let arr = [0]
  let temp = Math.ceil((end - start)/step)

  while(arr.length < temp) {
    start += step
    arr.push(start)
  }
  return arr
}

• slice(stop)、slice(start, stop(,step)) – slice(start[,end])

slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。

// python
myslice = slice(3, 7, 1)
arr = range(10)
arr[myslice] => [3, 4, 5, 6]

// js
arr = [0,1,2,3,4,5,6,7,8,9]
arr.slice(3, 7) => [3,4,5,6]

• dict(**kwarg)、dict(mapping, **kwarg)、dict(iterable, **kwarg)

dict() 函数用于创建一个字典，类似于 js中的对象，属性无序

dict(a='a', b='b') => {a:'a', b:'b'}
dict(zip(['one', 'two'], [1,2,3])) => {'two': 2, 'one': 1}
dict([('one', 1), ('two', 2)]) => {'two': 2, 'one': 1}

• type(name, bases, dict) – typeof

函数重载，如果只有一个参数返回对象的类型，三个参数则返回新的类型对象，相比于 js的 typeof多出了第二个重载函数的功能

// python
type(1) => 'int'>

// js
typeof(1) => number

• float([x]) – parseFloat([x])

float() 函数用于将整数和字符串转换成浮点数，与 js 中的 parseFloat基本功能相同，但用法上有点区别

• unichr(i)、chr(i) – String.fromCharCode(i)、String.fromCodePoint(i)

// python
unichr(97) => u'a'
chr(97) => 'a'

// js
String.fromCharCode(97) => 'a'
String.fromCodePoint(97) => 'a'

• reduce(fn, iterable, initializer) – reduce(fn, initialValue)

reduce() 函数会对参数序列中元素进行累积。

// python
reduce(lambda x,y: x+y, [1,2,3,4,5]) => 15


// js
[1,2,3,4,5].reduce((total, v) => {
  return total + v
})
=> 15

• map(fn, iterable, ...) – map(fn[,thisObject])

map() 会根据提供的函数对指定序列做映射，相比于 js中的 map函数，前者可以接收更多的可迭代对象进行函数计算

map(lambda x: x*2, [2,3,4,1,5]) => [4, 6, 8, 2, 10]
[2,3,4,1,5].map(v=> {
  return v*2
})

• frozenset([iterable]) – Object.freeze(obj)

frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

• getattr(object, name[, default])

getattr() 函数用于返回一个对象属性值，大致相当于下述 js函数：

function getattr(object, name, default) {
  return object[name] || default
}

• setattr(object, name, value)

set() 用于设置属性值，该属性必须存在

• cmp(x,y)

cmp(x,y) 函数用于比较2个对象，如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1，大致相当于下述 js函数：

function cmp(x, y) {
  if(x===y) return 0
  return x < y ? -1 : 1
}

• reverse() – reverse()

reverse() 函数用于反向列表中元素

• hasattr(obj, name)

hasattr() 函数用于判断对象是否包含对应的属性。

// python
class obj:
  x=10
  y=-5

print(hasattr(obj, 'x')) => True

// js
let obj = {x: 10}
console.log(obj.hasOwnProperty('x')) => true

• set([iterable]) – set([iterable])

set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，，与 js 中的 set相比，多处了还可以计算交集、差集、并集等的功能。

// python
set([2,3,5,7,5]) => set([2,3,5,7])

// js
new Set([2,3,5,7,5]) => {2,3,5,7}

• delattr(obj, name)、del – delete

delattr 函数用于删除属性，delattr(x, 'foobar') 相等于 del x.foobar

delattr 与 js中的 delete都是用于删除对象中的属性，如果删除一个不存在的属性，前者会报错，后者静默失败。

• next(iterator[,default]) - next()

next() 返回迭代器的下一个项目，ES6中新增了Generator函数，next的作用就是让 Generator函数继续执行，功能相同但用法有些不一样

// python
it = iter(['a', 'b', 'c'])
x = next(it)
print(x) => 'a'

// js
const g = function* (arr) {
  while (arr.length) {
    yield arr.shift()
  }
}

const gen = g(['a', 'b', 'c'])
let x = gen.next()
console.log(x) => {value: "a", done: false}

• hex(x) – toString(16)

hex() 函数用于将 10进制整数转换成 16进制整数，类似于 js中的 toString(16)

// python
hex(255) => '0xff'

// js
(255).toString(16) => 'ff'

• oct(x) – toString(8)

oct() 函数将一个整数转换成 8进制字符串。

// python
oct(10) => '012'

// js
(10).toString(8) => '12'