thenjs 是一个js的异步控制流程库

特点

• 可以像标准的Promise那样，把N多异步回调函数写成一个长长的then链，并且比Promise更简洁自然。因为使用标准Promise的then链，其中的异步函数都必须转换成Promise，Thenjs则无需转换，像使用CallBack一样执行异步函数即可。
• 强大的Error机制，可以捕捉任何同步和异步的异步错误。
• 开启debug模式，可以把每一个then链，运行结果输出到debug函数，如果没有则使用console.log。

使用

我们先看下thenjs的使用，有两种使用方式。

const Thenjs = require('thenjs')
Thenjs().then((cont, arg) => {
    cont(null, 'thenjs arg')
}).fin((cont, err, result) => {
    console.log(`1、result: ${result}`);
})
// 第二种
Thenjs((cont) => {
    cont(null, 'thenjs arg');
}).then((cont, arg) => {
    console.log(`2、result: ${arg}`);
})

cont就是continue的缩写，就是用来告诉thenjs是否继续执行后面的方法。像上面的第二种，如果不调用cont方法，后面的then链就不会执行。
cont方法的第一个参数是错误信息，第二个参数是用来传递到下一个then链中。如果第一个参数如果传递了错误信息，后面的then链都不会执行，会直接执行后面的fin方法或fail方法。

方法一

使用os.path.exists判断路径是否存在，包括文件夹和文件。

import os.path
os.path.exists(my_file)

方法二

使用os.path.isfile检查路径是否为文件，如果文件存在返回True。

import os.path
os.path.isfile(my_file) 

方法三

面向对象文件系统路径操作包pathlib2，pathlib2兼容python2.7+和python3.4+版本，pathlib只能用在python3.4+

检查文件是否存在

from pathlib import Path

my_file = Path("/path/to/file")
if my_file.is_file():
    # file exists

检查文件夹是否存在

if my_file.is_dir():
    # directory exists

检查路径是否存在（包括文件和文件夹）

if my_file.exists():
    # path exists

try检查路径是否存在

try:
    my_abs_path = my_file.resolve():
except FileNotFoundError:
    # doesn't exist
else:
    # exists

如果需要打开文件，建议使用try来检查异常。

Python定义函数常常会使用关键字参数**kw来接收字典值。

基本语法

def f(p1,p2,**kw)

**kw将接收0个或任意个含参数名的参数，这些关键字参数在函数内部会自动组合为一个字典。

示例

def person(**kw)
    for k in kw:
        print k ,':', kw[k]

>>> person(name='Bob', age=35)
name:Bob
age:35

>>> kw = {'name': 'Bob', 'age': 35}
>>> person(**kw)
name:Bob
age:35

由于关键字参数**kw是可变的，我们在对关键字参数对应的字典做修改时，可能会犹豫下，对kw字典修改是否也修改了函数外的字典呢？

其实在函数内对关键字参数对应的字典做修改是安全的。

根据Python的函数定义，如果函数参数为关键字参数，它会新构建一个有序的map来接收关键字参数组合成字典。

示例

def f(**kwargs):
    print((id(kwargs), kwargs))

kwargs = {'foo': 'bar'}
print(id(kwargs))
# 140185018984344
f(**kwargs)
# (140185036822856, {'foo': 'bar'})

这个示例分别输出函数内的字典和函数外的字典id，你可以看到这两个id不相同。

所以说在函数内修改关键字参数映射的字典是安全的。

列表

list_to_be_sorted = [{'name':'Jack', 'age':39}, {'name':'Bob', 'age':10}]

对列表按name的值排序得到：

list_to_be_sorted = [{'name':'Bob', 'age':39}, {'name':'Jack', 'age':10}]

对列表排序最简便的方式是使用sorted()函数：

方式一

newlist = sorted(list_to_be_sorted, key=lambda k: k['name'],reverse = True)

方式一使用lambda获取列表元素name的值，k为列表元素，k['name']元素name的值

方式二

from operator import itemgetter
newlist = sorted(list_to_be_sorted, key=itemgetter('name'), reverse = True) 

这里使用itemggetter函数来获取name的值

Python 3有多种方法可以用来分割列表。

示例
有以下列表

li = ['a','b','c','.','aa','bb','cc','.','aaa','bbb','ccc']

现需要按“.”分割列表。

使用itertools.groupby

>>>li = ['a','b','c','.','aa','bb','cc','.','aaa','bbb','ccc']
>>>from itertools import groupby
>>>result = [list(g) for k,g in groupby(li,lambda x:x=='.') if not k]
>>>print (result)
[['a', 'b', 'c'], ['a', 'b', 'c'], ['a', 'b', 'c']]

使用join和split（字符串列表）

对于字符串列表可以结合join和split来分割字符串列表

>>>li = ['a','b','c','.','aa','bb','cc','.','aaa','bbb','ccc']
>>>result = [s.split() for s in ' '.join(li).split('.') if s]
>>>print (result)
[['a', 'b', 'c'], ['a', 'b', 'c'], ['a', 'b', 'c']]

lantern的代理端口不是浏览器地址栏上的地址，它隐藏在设置中。

操作如下：

1. 右键工具栏中lantern图标 
2. 选择显示蓝灯，浏览器会打开页面
3. 在页面左上角展开菜单
4. 选择设置，弹出设置框
5. 点击设置中的高级设置，既可以看到lantern的代理地址和端口了。

如图：

需要根据目标网址是使用http还是https来设置代理，python3使用代理IP请求代码如下：

import requests
url = 'https://httpbin.org/ip'
proxies = {
    "http": 'http://209.50.52.162:9050', 
    "https": 'http://209.50.52.162:9050'
}
response = requests.get(url,proxies=proxies)
print(response.json()) 

proxies分别给http和https配置了一个地址用来做代理，示例中：

"http":"http://209.50.52.162:9050"

键http为请求的目标地址的协议，而值“http://209.50.52.162:9050”为代理ip和端口

从Node 8 LTS开始，Node完全支持Async/Await。这里通过示例的方式对比Async/Await和Promise。

简单介绍下Async/Await:

• Async/Await是一种新的编写异步代码的方式。其他方式是回调或者Promise。
  
• Async/Await实质是构建在Promise之上，它不能用于纯的回调或者Node.js的回调中。
  
• 和Promise一样，Async/Await是非阻塞的
  
• Async/Await很大的特点是，它可以让异步代码看起来就像同步代码那样，大大提高了异步代码的可读性。
  

语法

假设函数getJSON()返回一个Promise，基于Promise的调用示例如下：

const makeRequest = () =>
  getJSON()
    .then(data => {
      console.log(data)
      return "done"
    })
makeRequest()

getJSON()返回Promise后，在then()函数里输出结果，并返回done。

使用Async/Await改写如下：

const makeRequest = async () => {
  console.log(await getJSON())
  return "done"
}
makeRequest()

1、在函数前使用关键词async来标记这是一个异步函数，它隐含着表示函数会返回一个Promise，当函数返回值时就表示Promise被处理（resolve）了。

2、await关键字只能用在async标记的函数内，换句话说它是不能用在代码的最顶层。await的意思是等待getJSON()返回的Promise被处理了才会执行。

与Promise对比

简洁干净

与Promise需要使用then()函数来处理Promise返回的结果，而async/await则直接在代码按顺序上处理结果，代码量减少的同时，显得更简洁。

错误处理

async/await让我们可以同时捕获异步和同步代码抛出的异常。Promise如果在then()函数里出现异常，在Promise的外面的try/catch是捕获不到，这种情况我们需要使用Promise的catch()函数。如：

const makeRequest = () => {
  try {
    getJSON()
      .then(result => {
        // this parse may fail
        const data = JSON.parse(result)
        console.log(data)
      })
      .catch((err) => {
        console.log(err)
      })
  } catch (err) {
    console.log(err)
  }
}

async/await异步代码和同步代码共用try/catch

const makeRequest = async () => {
  try {
    const data = JSON.parse(await getJSON())
    console.log(data)
  } catch (err) {
    console.log(err)
  }
}

条件语句

有一种情况是我们会对返回的Promise数据做判断，如果符合某种条件则需要发起另外一个异步请求。使用Promise示例如下：

const makeRequest = () => {
  return getJSON()
    .then(data => {
      if (data.needsAnotherRequest) {
        return makeAnotherRequest(data)
          .then(moreData => {
            console.log(moreData)
            return moreData
          })
      } else {
        console.log(data)
        return data
      }
    })
}

这种嵌套的Promise读起来很容易迷糊。

async/await改写如下：

const makeRequest = async () => {
  const data = await getJSON()
  if (data.needsAnotherRequest) {
    const moreData = await makeAnotherRequest(data);
    console.log(moreData)
    return moreData
  } else {
    console.log(data)
    return data    
  }
}

看起来像同步代码，大大增强了异步代码的可读性。

中间值

有一种情况是需要通过多个嵌套的请求，其中前面的请求返回的是一个中间值，后面的请求需要使用中间值来发起请求。使用Promise如下：

const makeRequest = () => {
  return promise1()
    .then(value1 => {
      // do something
      return promise2(value1)
        .then(value2 => {
          // do something          
          return promise3(value1, value2)
        })
    })
}

async/await改写就很简单：

const makeRequest = async () => {
  const value1 = await promise1()
  const value2 = await promise2(value1)
  return promise3(value1, value2)
}

另外，Async/Await也很方便我们调试代码。

安装环境：Mac OS Sierra，Python 3.5

1、下载安装最新的Anaconda，下载地址：https://www.continuum.io/downloads#macos

2、创建python 环境，虚拟环境使用Python 3.5。

conda create -n myenv python=3.5

3、激活新环境

source activate myenv

4、安装NumPy（opencv依赖于Numpy）

conda install numpy

5、安装anaconda-client命令工具，它用于在Conda搜索OpenCV二进制包

conda install anaconda-client

6、搜索OpenCV 3

anaconda search -t conda opencv3

7、选择搜索结果里支持osx-64的包，例如：https://conda.anaconda.org/menpo

conda install --channel https://conda.anaconda.org/menpo opencv3

8、测试安装

import cv2
print("OpenCV version:")
print(cv2.__version__)

原文：https://gist.github.com/vishwanath79/756185e550556daf19f526984a58a703

原文：https://gist.github.com/satra/aa3d19a12b74e9ab7941

from scipy.spatial.distance import pdist, squareform
import numpy as np

from numbapro import jit, float32

def distcorr(X, Y):
    """ Compute the distance correlation function
    
    >>> a = [1,2,3,4,5]
    >>> b = np.array([1,2,9,4,4])
    >>> distcorr(a, b)
    0.762676242417
    """
    X = np.atleast_1d(X)
    Y = np.atleast_1d(Y)
    if np.prod(X.shape) == len(X):
        X = X[:, None]
    if np.prod(Y.shape) == len(Y):
        Y = Y[:, None]
    X = np.atleast_2d(X)
    Y = np.atleast_2d(Y)
    n = X.shape[0]
    if Y.shape[0] != X.shape[0]:
        raise ValueError('Number of samples must match')
    a = squareform(pdist(X))
    b = squareform(pdist(Y))
    A = a - a.mean(axis=0)[None, :] - a.mean(axis=1)[:, None] + a.mean()
    B = b - b.mean(axis=0)[None, :] - b.mean(axis=1)[:, None] + b.mean()
    
    dcov2_xy = (A * B).sum()/float(n * n)
    dcov2_xx = (A * A).sum()/float(n * n)
    dcov2_yy = (B * B).sum()/float(n * n)
    dcor = np.sqrt(dcov2_xy)/np.sqrt(np.sqrt(dcov2_xx) * np.sqrt(dcov2_yy))
    return dcor

最近在Mac上使用pip 9.0.1安装任何python软件包时会报类似的错误：

Status code 403 not in [200, 203, 300, 301]
Could not fetch URL https://pypi.python.org/simple/<package>/: 403 Client Error: TLSv1.2+ is required for url: https://pypi.python.org/simple/<package>/ - skipping
Could not find a version that satisfies the requirement <package> (from versions: )
Cleaning up...
No matching distribution found for <package>

这是因为Python.org网站停止了对TLS1.0和1.1的支持。 如错误信息的提示，下载https://pypi.python.org/simple/<package>需要使用TLSv1.2+。

对于macOS < 10.13，pip需要升级到9.0.3。pip 9.0.3支持TLSv1.2。升级脚本如下：

curl https://bootstrap.pypa.io/get-pip.py | python

注意：不能使用pip直接升级pip，以下命令是升级不了的：

pip install --upgrade pip

升级pip后，建议也升级setuptools：

pip install --upgrade setuptools

在介绍Python安全创建目录之前，先举一个不安全创建目录的方式：

if not os.path.exists(directory):
    os.makedirs(directory)

在例子里，先判断目录是否存在，然后创建目录。这种方式是不安全的，它会导致竞争条件。在os.path.exists()和os.makedirs()之间的时间可能会出现目录被创建。不推荐使用这种方式。

Python 3.5+:

在python 3.5+可以使用pathlib的mkdir：

import pathlib
pathlib.Path('/my/directory').mkdir(parents=True, exist_ok=True) 

pathlib的mkdir接收两个参数：

• parents：如果父目录不存在，是否创建父目录。
• exist_ok：只有在目录不存在时创建目录，目录已存在时不会抛出异常。

Python 3.2+:

使用pathlib2

python3.2+是和Python3.5+用法一样，但是需要导入的是pathlib2，而不是pathlib。

使用os

import os
os.makedirs(path, exist_ok=True)

Python 2.7+:

使用pathlib2

使用方法和Python3.2一样，导入的是pathlib2.

使用os

为了避免出现竞争条件，使用os需要使用try语句。

import os
try: 
    os.makedirs(path)
except OSError:
    if not os.path.isdir(path):
        raise