^`:匹配行首
`$`:匹配结尾
`*`:（**贪婪**）前面字符匹配任意多次
`+`:（**懒惰**）前面字符匹配1或者更多次
`?`:前面字符匹配0或1次，还作为懒惰限定符使用，详看后面

`{m}`:前面字符匹配m次
`{m,n}`:前面字符匹配m~n次
`{m,}`:前面字符匹配m或更多次
`{,n}`:前面字符匹配0~n次

`|`:或,必须加括号

`.`:匹配除换行符以外的任意字符
`[1357]`:匹配1，3,5,7中其中一个数字，当然也可以是字母
`[0-9]`:匹配0到9的其中一个数字，类似用法还有：[a-zA-Z]
`[\u4E00-\u9FA5]`:匹配中文
`[^012]`:表示除012外的任意字符，包括3-9,a-z,A-Z,等等
注意：[]里面的.和*等一些特殊字符都失去特殊意义，只表示本身。

code block：作为一个单元(Unit)被执行的一段python程序文本。例如一个模块、函数体和类的定义等。
scope：在一个code block中定义name的可见性；
block’s environment：对于一个code block，其所有scope中可见的name的集合构成block的环境。
bind name：下面的操作均可视为绑定操作
函数的形参
import声明
类和函数的定义
赋值操作
for循环首标
异常捕获中相关的赋值变量
local variable：如果name在一个block中被绑定，该变量便是该block的一个local variable。
global variable：如果name在一个module中被绑定，该变量便称为一个global variable。
free variable: 如果一个name在一个block中被引用，但没有在该代码块中被定义，那么便称为该变量为一个free variable。

5.4 “四舍五入”结果为：5，int(5.4+0.5) == 5  
5.6 “四舍五入”结果为：6，int(5.6+0.5) == 6  
``` 
另一种方式round函数  
round() 函数作用就是，返回浮点数x的四舍五入值。

for (i=0;i<100;i++){
    echartsPlots(xxx[i]);
}

dict["w"] = "watermelon"  
dict.get("c", "apple")    
print dict.pop("b")  
dict.update(dict2)  
dict.items()  
dict.keys()  
dict.values()  
dict.clear()  
print d.popitem()   
#按照key排序print sorted(dict.items(), key=lambda d: d[0])  
#按照value排序print sorted(dict.items(), key=lambda d: d[1])  
#字典的浅拷贝dict2 = dict.copy()  
#深拷贝import copy，dict3 = copy.copy(dict)

package com.yuan.demo.multiThreadTest;
 
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
 
/**
 * 多线程测试框架，可用来测试json接口，webservice接口，或一般性的httpclient客户端等
 * 支持对线程传入参数以及取得线程返回值（此例子是list<string>，并且对返回值进行重复性的校验），
 *
 * @author yuan
 * @version 1.0.0
 */
public class MultiThreadTest {
    /**
     * 程序总入口
     */
    public static void main(String[] args) {
        long millis_start = System.currentTimeMillis();
        int threadNum = 5;
        List<String> list = new ArrayList<String>();
 
        //创建线程池
        ExecutorService pool = Executors.newCachedThreadPool();
 
        List<String> tenantIdList = new ArrayList<String>();
        tenantIdList.add("000001");
        tenantIdList.add("000011");
        List<String> keyList = new ArrayList<String>();
        keyList.add("STOCKID");
        keyList.add("STOCKNAME");
        for (int i = 0; i < threadNum; i++) {
            Callable<List<String>> myThread = new CallThread(i, keyList, tenantIdList);
            Future<List<String>> future = pool.submit(myThread);
            try {
                list.addAll(future.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        pool.shutdown();
        Set<String> listSet = new HashSet<String>(list);
        System.out.println("list_size:" + list.size() + " list_set_size:" + listSet.size());
        if (list.size() != listSet.size()) {
            System.out.println("数据有重复");
            System.out.println("list:" + list);
            System.out.println("listSet:" + listSet);
        }else{
            System.out.println("数据无重复");
        }
 
        long millis_end = System.currentTimeMillis();
        System.out.println("总耗时(s):" + (millis_end - millis_start));
    }
 
}
 
/**
 * 可返回list<String>数据的线程，需要自己实现其中的call函数
 */
class CallThread implements Callable<List<String>> {
    private int i; // 第几个线程
    List<String> tenantIdList;
    List<String> keyList;
    List<String> genIDs = new ArrayList<String>();
 
    /**
     * 构造函数，可将任务依赖的变量传入
     *
     * @param keyList,任务依赖的变量
     * @param tenantIdList,任务依赖的变量
     * @return list<String>
     */
    public CallThread(int i, List<String> keyList, List<String> tenantIdList) {
        this.i = i;
        this.keyList = keyList;
        this.tenantIdList = tenantIdList;
    }
 
    public List<String> call() throws Exception {
        for (int j = 0; j < this.keyList.size(); j++) {
            for (int k = 0; k < this.tenantIdList.size(); k++) {
                /*这里的yourdata实际可能为webservice接口的调用，或client的调用*/
                String yourData = this.i+this.keyList.get(j) + this.tenantIdList.get(k);
                genIDs.add(yourData);
            }
        }
        return genIDs;
    }
}

URL相关
URLConnection使用代理：
URL url = new URL(purl);
SocketAddress add = new InetSocketAddress("110.4.12.170", 83);
Proxy p = new Proxy(Proxy.Type.HTTP, add);
URLConnection turl = url.openConnection(p);
turl.setConnectTimeout(urlTimeout);
turl.setReadTimeout(urlTimeout);
BufferedReader in = new BufferedReader(new InputStreamReader(turl.getInputStream(), charset));

socket相关
创建socket:st = new Socket(HOST, PORT);
构造输入输出流:BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(st
                    .getOutputStream()));
(读)写数据：bw.write(startConnection);
刷新缓冲区：bw.flush();
关闭缓冲区：bw.close();

servlet：
request.setCharacterEncoding("UTF-8");
String wechatid = request.getParameter("openID");//微信号
Map<String, String[]> tmpMap = request.getParameterMap();
response.setCharacterEncoding("UTF-8");
response.getOutputStream().write(errormsg.getBytes("UTF-8"));

网页内容读取URLConnection：
URL url = new URL(purl);
URLConnection turl = url.openConnection();
turl.setConnectTimeout(urlTimeout);
turl.setReadTimeout(urlTimeout);
BufferedReader in = new BufferedReader(new InputStreamReader(
        turl.getInputStream()));
 
while ((line = in.readLine()) != null) {
    content += line;
}
in.close();


httpclient文件发送：
Protocol myhttps = new Protocol("https",new MySecureProtocolSocketFactory(),443);
Protocol.registerProtocol("https", myhttps);//https需要
HttpClient httpclient=new HttpClient();
 
PostMethod filePost = new PostMethod("https://api.ffan.com/zhaofangbao/v1/bosera/upload");
 
//使用系统提供的默认的恢复策略
//filePost.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,new DefaultHttpMethodRetryHandler());     
 
String param = "verify=" + URLEncoder.encode("verifytest", "utf-8") + "&type=" + "1";
filePost.setQueryString(param);
String filepath = "D:\\工作文件夹\\工作文档\\filetest.txt";
File targetFile = new File(filepath);
Part parts[] = {new FilePart("file", targetFile) };
filePost.setRequestEntity(new MultipartRequestEntity(parts,filePost.getParams()));
httpclient.getHttpConnectionManager().getParams().setConnectionTimeout(50000);
//执行PostMethod
int statusCode = httpclient.executeMethod(filePost);
System.out.println("thirdChannel batchFileUpload http status:" + statusCode);
if (statusCode != HttpStatus.SC_OK) {
    System.err.println("Method failed: "+ filePost.getStatusLine());
    }
//读取内容
byte[] responseBody = filePost.getResponseBody();
//处理内容
System.out.println(new String(responseBody,"UTF-8"));
TrustAnyTrustManager.java
MySecureProtocolSocketFactory.java
connect.java

参考文章：
http://blog.csdn.net/noodies/article/details/17240805
http://tc.chinawin.net/it/softwaredev/article-eaa5.html
http://www.91r.net/ask/7684654.html
http://blog.sina.com.cn/s/blog_74cef98a0101pl16.html
http://hougbin.iteye.com/blog/1196063

# Copyright (C) 2011-2012 YuanJh
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
 
"""yuanJh's fft and ifft module.
the detail about fft you can see "http://en.wikipedia.org/wiki/Fast_Fourier_transform"
Main functions:
  fft(a)
  ifft(a)
"""
from math import * 
from cmath import * 
import sys
from numpy import *
pi=3.1414926
 
#version infomation
__version__ = '1.0'
 
#################### function recursive FFT ####################
def RECURSIVE_FFT(a):
    "Use recursive method to realize FFT"
    n=len(a)
    if n==1:
        return a
    wn=complex(cos(-2*pi/n),sin(-2*pi/n))    #create the complex number wn=cos(-2pi/n)+sin(-2pi/n)i
    w=1
 
    a0=[]
    a1=[]
    for i in range(0,n-1,2):
        a0.append(a[i])        #pick up the even number
        a1.append(a[i+1])    #pick up the odd number 
 
    y0=RECURSIVE_FFT(a0)    #translate the even part
    y1=RECURSIVE_FFT(a1)    #translate the odd part
 
    y=[0 for i in range(n)]
    for k in range(0,int(n/2)):    #combine the even part and the odd part
        y[k]=y0[k]+w*y1[k]
        y[k+int(n/2)]=y0[k]-w*y1[k]
        w*=wn
    return y
#################### end function recursive FFT ####################
 
#################### function recursive IFFT ####################    
def RECURSIVE_IFFT(a):
    "Use recursive method to realize IFFT"
    n=len(a)
    if n==1:
        return a
    wn=complex(cos(2*pi/n),sin(2*pi/n))    #create the complex number wn=cos(2pi/n)+sin(2pi/n)i
    w=1
 
    a0=[]
    a1=[]
    for i in range(0,n-1,2):
        a0.append(a[i])        #pick up the even number
        a1.append(a[i+1])    #pick up the odd number
 
    y0=RECURSIVE_IFFT(a0)
    y1=RECURSIVE_IFFT(a1)
 
    y=[0 for i in range(n)]
    for k in range(0,int(n/2)):    #combine the even part and the odd part
        y[k]=y0[k]+w*y1[k]
        y[k+int(n/2)]=y0[k]-w*y1[k]
        w*=wn
    return y
#################### end function recursive IFFT ####################
 
#################### got data and verify the program ####################
a=input("please input the number (use ',' split):")
a=a.split(',')
n=len(a)
#tempn=ceil(log2(n))
#tempn=tempn**2
 
for i in range(0,n):
    a[i]=int(a[i])
 
#################### verify the FFT ####################
print ("the results of my program fft")
b=RECURSIVE_FFT(a)
for i in range(0,n):
    print ("%4d: %4.4f+%4.4fi"%(a[i],b[i].real,b[i].imag))
 
print ("the results of the numpy program fft")    #Use the function in the package numpy
b=fft.fft(a)
for i in range(0,n):
    print ("%4d: %4.4f+%4.4fi"%(a[i],b[i].real,b[i].imag))
 
#################### verify the IFFT ####################
#test the my ifft program is right or not by compare with the ifft function in numpy package
print ("the results of my program ifft")
lenb=len(b)
a=RECURSIVE_IFFT(b)
for i in range(0,n):
    print("%4.4f+%4.4fi: %4.4f+%4.4fi"%(b[i].real,b[i].imag,a[i].real/lenb,a[i].imag/lenb))
 
print ("the results of the numpy program ifft")
a=fft.ifft(b)
for i in range(0,n):
    print("%4.4f+%4.4fi: %4.4f+%4.4fi"%(b[i].real,b[i].imag,a[i].real,a[i].imag))
 
文件名：fft.py
实现语言：PYTHON
1，系统概述
利用递归的方法实现快速傅里叶变化（FFT）和快速傅里叶逆变换（IFFT）。
2，模块层次
主要包含三部分：
    1，递归实现快速傅里叶变换（FFT）。
    2，快速傅里叶逆变换（IFFT）。
    3，数据录入以及结果正确性验证。
3，函数声明表
def RECURSIVE_FFT(a):
    功能说明：递归实现快速傅里叶变换。
    参数说明：
        a:需要进行快速傅里叶变换的数据，以列表（类似C,JAVA中数组）形式存储。
def RECURSIVE_IFFT(a):
    功能说明：递归实现快速傅里叶逆变换，
    参数说明：
        a:需要进行快速傅里叶逆变换的数据，以列表（类似C,JAVA中数组）形式存储。
 
filename:fft.py
language:python
1,System overview 
Using recursive method to realize Fast Fourier Transform (FFT) and inverse Fast Fourier Transform (IFFT).
2,Module and level
Mainly includes three parts:
    1, The recursive Fast Fourier Transform(FFT).
    2, Inverse Fast Fourier Transform(IFFT).
    3, Got data and verify the results.
3,Function declaration table
def RECURSIVE_FFT (a):
    Function introduction:recursive realize Fast Fourier Transform.
    Parameters:
        a: the data need for Fast Fourier Transform store as a list (similar to C, JAVA the array).
def RECURSIVE_IFFT (a):
    Function introduction: recursive inverse Fast Fourier Transform.
    Parameters:
        a: the data need for inverse Fast Fourier Transform store as a list.