django进阶04部署上线(nginx,uwsgi,supervisor)

django自身服务ok

python manage.py runserver,验证可正常访问

django进阶03静态文件和模板

静态文件和模板

静态文件:css,js,image,如果作为纯粹的web应用来看,静态文件的响应并不属于web应用范畴,因为静态文件不涉及业务逻辑,也不需开发业务代码。但几乎100%的web应用都支持对静态文件的直接访问。为何?主要是web应用基本上必然依赖css,js,img等静态资源,我们不可能固执的开发一个纯粹的web应用,只支持从url里进入视图函数,也只能从视图函数返回内容(简单来说所有请求路径都必须体现在url_route和view视图中)。而要求用户独立开启静态资源的请求处理服务。所以,先把静态资源服务和包含业务逻辑的web应用独立认识,二者并不相同,但强相关。其本身是独立于应用的
模板:在代码中response渲染中使用的,可以看做view视图的组成部分.所以没有独立url配置,依赖view视图存在,属于应用一部分,包含了业务逻辑(需要渲染),这一点也可以从配置上看出来。

django进阶02websocket

本文适合有一定websocket基础的,至少完整看过前后端demo的读者,一窍不通的小白建议先阅读“参考”部分的博文扫扫盲。
基于django的dwebsocket组件(目前虽然不在维护,但正常使用没问题)

前端方法

python进阶21之actor

actor模型。actor模式是一种最古老的也是最简单的并行和分布式计算解决方案。
优点:充分利用单线程+事件机制,达到了多线程效果。
缺点,对python而言,由于GIL的存在,毕竟只是单线程,难以匹敌多进程,目前使用并不多。

简单任务调度器

python进阶20装饰器

Nested functions

Python允许创建嵌套函数,这意味着我们可以在函数内声明函数并且所有的作用域和声明周期规则也同样适用。

python进阶19垃圾回收GC

垃圾收集三大手段

一、引用计数(计数器)

python进阶18正则表达式

正则基础知识

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
^`:匹配行首
`$`:匹配结尾
`*`:(**贪婪**)前面字符匹配任意多次
`+`:(**懒惰**)前面字符匹配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,等等
注意:[]里面的.和*等一些特殊字符都失去特殊意义,只表示本身。

python进阶17炫技巧

原则:可读性第一(效率固然重要,除非非常明显的效率差异,否则可读性优先)
学习炫技巧,更多为了读懂他人代码,自己开发过程中,相似代码量(可读性),建议使用通俗写法。反对为炫而炫。

可直接运行的 zip 包

python进阶16多继承与Mixin

Mixin解释

为了让大家,对这个 Mixin 有一个更直观的理解,摘录了网上一段说明。
民航飞机是一种交通工具,对于土豪们来说直升机也是一种交通工具。对于这两种交通工具,它们都有一个功能是飞行,但是轿车没有。所以,我们不可能将飞行功能写在交通工具这个父类中。但是如果民航飞机和直升机都各自写自己的飞行方法,又违背了代码尽可能重用的原则(如果以后飞行工具越来越多,那会出现许多重复代码)。
怎么办,那就只好让这两种飞机同时继承交通工具以及飞行器两个父类,这样就出现了多重继承。这时又违背了继承必须是”is-a”关系。这个难题该怎么破?
这时候 Mixin 就闪亮登场了。飞行只是飞机做为交通工具的一种(增强)属性,我们可以为这个飞行的功能单独定义一个(增强)类,称之为 Mixin 类。这个类,是做为增强功能,添加到子类中的。为了让其他开发者,一看就知道这是个 Mixin 类,一般都要求开发者遵循规范,在类名末尾加上 Mixin 。

python进阶15变量作用域LEGB

作用域

“作用域”定义了Python在哪一个层次上查找某个“变量名”对应的对象。接下来的问题就是:“Python在查找‘名称-对象’映射时,是按照什么顺序对命名空间的不同层次进行查找的?”
答案就是:使用的是LEGB规则,表示的是Local -> Enclosed -> Global -> Built-in,其中的箭头方向表示的是搜索顺序。

python进阶14文件路径(找不到文件)

开发时遇到问题,文件路径不正确,找不到文件等等,都是这一类问题.

curdir,argv,file

python进阶13并发之九多进程和数据共享

使用进程,大概率出现情况是,想当然以为共享了,实际没共享。所以最终程序大概率卡死(部分逻辑没有数据进来,导致的业务逻辑性卡住,并非程序死锁)

哪些共享,哪些不共享

python进阶12并发之八多线程与数据同步

python并发首选进程,但偶尔有场景进程无法搞定,比如有些变量是无法序列化的,就无法使用工具包manager()的工具类进行共享。如果自己实现新的共享方法,可能开发量较大,且质量难以保证。此时可考虑用线程处理,规避进程的变量共享难题,而且实际场景中,IO大概率都是瓶颈,所以使用线程其实也的确有些优势。个人而言,选择进程和线程较为重视的安全性,进程数据隔离较好,互不干扰。其次就是公用数据占比,如果大多数数据都需公用,那么线程也会比进程更佳,避免了进程较多的数据共享问题。
线程而言,难点数据一致性,

哪些共享,哪些不共享

浅谈nginx,gunicorn,flask差异比对

角色划分

flask(django):Python的Web应用程序(如Flask,django)
nginx:web服务器,用户角度直接对接使用,请求响应的request-response出入口
WSGI(Web Server Gateway Interface),翻译为Python web服务器网关接口,即Python的Web应用程序(如Flask)和Web服务器(如Nginx)之间的一种通信协议。也就是说,如果让你的Web应用在任何服务器上运行,就必须遵循这个协议。

python进阶11并发之七多种并发方式的效率测试

测试map,apply_async,gevent协程爬虫
测试代码:网页爬虫

函数代码

python进阶10并发之六并行化改造

图示变量含义说明:
1个大step中包含3个小step,大step内部的第一步,二步,三步存在依赖关系(就是内部保持顺序执行)
a1,b1,c1,表示子任务a的第一步,b的第一步,c的第一步.同理a2,表示子任务a的第二步。

无并行

python进阶09并发之五生产者消费者

这也是实际项目中使用较多的一种并发模式,用Queue(JoinableQueue)实现,是Python中最常用的方式(这里的queue特指multiprocess包下的queue,非queue.Queue)。

Queue

python进阶08并发之四map, apply, map_async, apply_async差异

差异矩阵

python封装了4种常用方法,用于实现并发
其差异如下

python进阶07并发之三其他问题

何时使用多进程(线程)

使用多进程or线程,对于python,考虑到GIL锁,基本上默认使用多进程就对了。
除此之外,线程共享全局变量,进程全局变量则是隔离的,实际进程大多数情况需要通信的,所以也需要考虑共享数据读写问题处理。 决定因素稳定性和数据共享要求上(操作系统差异性,win偏好线程,linux偏好进程)
性能上虽然线程较好,但实际除了大型互联网公司和部分专业性质软件,大多数中小型公司的并发量,并不会带来很大影响,况且目前服务器领域,基本上LInux和Unix占比较高,线程相比进程在性能上优势并不十分突出。所以这方面考量不会太大的。

python进阶06并发之二技术点关键词

GIL,线程锁

python中存在GIL这个”线程锁”,
关键地方可以使用c语言解决 GIL问题 然后可以提高cpu占用效率

python进阶05并发之一基本概念

大多编程语言,一旦涉及并发,都会比较复杂,知识点也较多(大多为历史问题,很多技术点现在非常少使用了,但语言层面也提供支持,对于这些冷门点,只需要知道即可,使用时也尽量避免使用这种冷门技术,除非和应用场景非常匹配)。实际使用过程中,只需要知道各名词以及大概功能,大多现用现查,毕竟涉及点太多,而且使用频率也并非很高,一般也就新系统研发会使用,后续维护时基本不会涉及太多。

进程状态和调度

python进阶04IO的同步异步,阻塞非阻塞

同步和异步

同步和异步关注的是消息通信机制
所谓同步,就是在发出一个调用时,在没有得到结果之前,该调用就不返回。但是一旦调用返回,就得到返回值了。
换句话说,就是由调用者主动等待这个调用的结果。
而异步则是相反,调用在发出之后,这个调用就直接返回了,所以没有返回结果。换句话说,当一个异步过程调用发出后,调用者不会立刻得到结果。而是在调用发出后,被调用者通过状态、通知来通知调用者,或通过回调函数处理这个调用。
举个通俗的例子:你打电话问书店老板有没有《分布式系统》这本书,如果是同步通信机制,书店老板会说,你稍等,”我查一下”,然后开始查啊查,等查好了(可能是5秒,也可能是一天)告诉你结果(返回结果)。而异步通信机制,书店老板直接告诉你我查一下啊,查好了打电话给你,然后直接挂电话了(不返回结果)。然后查好了,他会主动打电话给你。在这里老板通过“回电”这种方式来回调。
同步的整个流程就1部分,1问答,异步模式2部分,1问空答复+无问1答复。

python进阶03UnboundLocalError和NameError错误

几个概念

1
2
3
4
5
6
7
8
9
10
11
12
13
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。

深入理解字符,字符集,gbk,utf8

字符,字符集,字符编码概念

字节

django学习笔记03

第一章,模型层

查询集API

django学习笔记02

第一章:模型层

1.8 查询操作

django学习笔记01

基于教程,刘江的博客教程Django教程:https://www.liujiangblog.com/course/django/87

第一章:模型层

python进阶02yield

yield关键字之前见过,也能读懂,但开发时也不大敢使用,感觉理解还是不够充分。刚好项目代码中有涉及,顺便再学习学习。
在理解yield之前,

可迭代,迭代器,生成器

django快捷复习手册

建立项目

django startproject projectname

django进阶01信号

看起来简单,用起来简单。理解起来则未必容易。上学那会这一块就没整明白,这两天又查了下资料,算是基本弄懂了。
为何难以理解?个人感觉起名占了很大一部分,如果signal命名为“观察者”,“监控者”,“盯梢者”,就容易理解多了。其本质就是一种典型观察者模式。命名为信号,第一感觉是”信号量“类似的东西。

定义信号:

python进阶01偏函数

定义:偏函数的第二个部分(可变参数),按原有函数的参数顺序进行补充,参数将作用在原函数上,最后偏函数返回一个新函数(类似于,装饰器decorator,对于函数进行二次包装,产生特殊效果;但又不同于装饰器,偏函数产生了一个新函数,而装饰器,可改变被装饰函数的函数入口地址也可以不影响原函数)

效果:固定一部分参数,在后续调用时只需传递少量参数即可

python中int的四舍五入

默认:向下取整。
正常情况下 int(5.5) 结果为5

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

python简明python教程笔记

原始文档见:http://sebug.net/paper/python/

PART1-3USELESS

js休眠实现sleep

首先js原生并不支持sleep,所有目前的方案都是间接实现的.
需求:

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

python异常报错

百度自然语言处理报错:UnicodeEncodeError: ‘gbk’ codec can’t encode character ‘\U0001f602’ in posit

原因:ubuntu机器编码utf8,接口尝试用gbk解析,在对str转换格式时报错
解决:比如title变量.str(title.encode(“GBK”,’ignore’))

java之StringDateTimestampCalendar之间的关系及转换

SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);

1.Calendar 转化 String

python数据可视化

百度搜索:
python特征工程,绘图
python特征工程 数据可视化

简介

python之map,numpy,pandas速查

Map操作

1
2
3
4
5
6
7
8
9
10
11
12
13
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)

python廖雪峰python教程笔记

高级特性

切片:前10个数,每两个取一个: L[:10:2]:[0, 2, 4, 6, 8]
可迭代对象的判断: isinstance(‘abc’, Iterable)
list变成索引-元素对:for i, value in enumerate([‘A’, ‘B’, ‘C’]):print(i, value)
列表生成式:一行语句生成list:[x * x for x in range(1, 11)]
生成器:一边循环一边计算的机制,称为生成器:generator。
第一种方法很简单,只要把一个列表生成式的[]改成(),就创建了一个generator:g = (x * x for x in range(10))
另一种方法。如果一个函数定义中包含yield关键字,那么这个函数就不再是一个普通函数,而是一个generator:
f = fib(6)
f
<generator object fib at 0x104feaaa0>

mysql常用操作速查

简介
mysql速查
net start MySQL服务名
net stop MySQL服务名

mysql -h主机名 -u用户名 [-P端口] -p
quit;或exit;

java多线程测试框架

 最近要对一个webservice接口做测试,需测试高并发接口是否会以异常数据返回,编写了如下demo,有类似需求的可以参考下。
 注意事项:
1,线程使用了callable接口形式,call相对runable接口有个好处是允许带有返回值。
2,线程需要的入参可以在初始化时带入。比如本例中的ListkeyList, ListtenantIdList,就是线程入参。
3,线程出参return 出来即可。使用线程提交到线程池submit时返回的future对象的get()方法可以取得线程的最终返回值,本例中future.get()取得的就是各个线程返回的genIDs的list对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
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;
}
}

java常用代码速查

网络

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
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

python之FFT快速傅里叶变换

本科小作业,快速傅里叶变换
python3.2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
# 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.
Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×