⑴ python可以做数据分析，好处是什么呢怎么学习

Python做数据分析，肯定是因为Python更简单，内置了很多库，用简单的代码就可以实现强大的功专能，想学习属Python数据分析，可以找一些Python培训或者大数据培训的视频看看，里面都包含这一部分内容的！

⑵ Python中做了相关性分析发现相关系数太低，接下来应该怎么做

你这问题问得太简略了啊，多给点细节看一下

⑶ python做数据分析怎么样

我使用python这门语言也有三年了，被其简洁、易读、强大的库所折服，我已经深深爱上了python。其pythonic语言特性，对人极其友好，可以说，一个完全不懂编程语言的人，看懂python语言也不是难事。

在数据分析和交互、探索性计算以及数据可视化等方面，相对于R、MATLAB、SAS、Stata等工具，Python都有其优势。近年来，由于Python库的不断发展（如pandas），使其在数据挖掘领域崭露头角。结合其在通用编程方面的强大实力，我们完全可以只使用Python这一种语言去构建以数据为中心的应用程序。

由于python是一种解释性语言，大部分编译型语言都要比python代码运行速度快，有些同学就因此鄙视python。但是小编认为，python是一门高级语言，其生产效率更高，程序员的时间通常比CPU的时间值钱，因此为了权衡利弊，考虑用python是值得的。


Python强大的计算能力依赖于其丰富而强大的库：

  • Numpy

Numerical Python的简称，是Python科学计算的基础包。其功能：

1. 快速高效的多维数组对象ndarray。

2. 用于对数组执行元素级计算以及直接对数组执行数学运算的函数。

3. 线性代数运算、傅里叶变换，以及随机数生成。

4. 用于将C、C++、Fortran代码集成到Python的工具。


除了为Python提供快速的数组处理能力，NumPy在数据分析方面还有另外一个主要作用，即作为在算法之间传递数据的容器。对于数值型数据，NumPy数组在存储和处理数据时要比内置的Python数据结构高效得多。此外，由低级语言（比如C和Fortran）编写的库可以直接操作NumPy数组中的数据，无需进行任何数据复制工作。


  • SciPy

是一组专门解决科学计算中各种标准问题域的包的集合，主要包括下面这些包：

1. scipy.integrate：数值积分例程和微分方程求解器。

2. scipy.linalg：扩展了由numpy.linalg提供的线性代数例程和矩阵分解功能。

3. scipy.optimize：函数优化器（最小化器）以及根查找算法。

4. scipy.signal：信号处理工具。

5. scipy.sparse：稀疏矩阵和稀疏线性系统求解器。

6. scipy.special：SPECFUN（这是一个实现了许多常用数学函数（如伽玛函数）的Fortran库）的包装器。

7. scipy.stats：标准连续和离散概率分布（如密度函数、采样器、连续分布函数等）、各种统计检验方法，以及更好的描述统计法。

8. scipy.weave：利用内联C++代码加速数组计算的工具。


注：NumPy跟SciPy的有机结合完全可以替代MATLAB的计算功能（包括其插件工具箱）。


  • SymPy

是python的数学符号计算库，用它可以进行数学表达式的符号推导和演算。


  • pandas

提供了使我们能够快速便捷地处理结构化数据的大量数据结构和函数。你很快就会发现，它是使Python成为强大而高效的数据分析环境的重要因素之一。

pandas兼具NumPy高性能的数组计算功能以及电子表格和关系型数据库(如SQL)灵活的数据处理功能。它提供了复杂精细的索引功能，以便更为便捷地完成重塑、切片和切块、聚合以及选取数据子集等操作。

对于使用R语言进行统计计算的用户，肯定不会对DataFrame这个名字感到陌生，因为它源自于R的data.frame对象。但是这两个对象并不相同。R的data.frame对象所提供的功能只是DataFrame对象所提供的功能的一个子集。也就是说pandas的DataFrame功能比R的data.frame功能更强大。


  • matplotlib

是最流行的用于绘制数据图表的Python库。它最初由John D. Hunter（JDH）创建，目前由一个庞大的开发人员团队维护。它非常适合创建出版物上用的图表。它跟IPython（马上就会讲到）结合得很好，因而提供了一种非常好用的交互式数据绘图环境。绘制的图表也是交互式的，你可以利用绘图窗口中的工具栏放大图表中的某个区域或对整个图表进行平移浏览。


  • TVTK

是python数据三维可视化库，是一套功能十分强大的三维数据可视化库，它提供了Python风格的API，并支持Trait属性(由于Python是动态编程语言，其变量没有类型，这种灵活性有助于快速开发，但是也有缺点。而Trait库可以为对象的属性添加检校功能，从而提高程序的可读性，降低出错率。) 和NumPy数组。此库非常庞大，因此开发公司提供了一个查询文档，用户可以通过下面语句运行它：

>>> from enthought.tvtk.toolsimport tvtk_doc

>>> tvtk_doc.main()


  • Scikit-Learn

是基于python的机器学习库，建立在NumPy、SciPy和matplotlib基础上，操作简单、高效的数据挖掘和数据分析。其文档、实例都比较齐全。


小编建议：初学者使用python(x, y)，其是一个免费的科学和工程开发包，提供数学计算、数据分析和可视化展示。非常方便！

其官网：www.pythonxy.com（由于某种原因，国内上不去，需要翻墙）

下载地址：ftp://ftp.ntua.gr/pub/devel/pythonxy/（小编到网上搜到的一个地址，亲测可以用）

下图展示了python(x, y) 强大功能。

⑷ 如何进行python性能分析

使用time工具粗糙定时

首先，我们可以使用快速然而粗糙的工具：古老的unix工具time，来为我们的代码检测运行时间。
1 $ time python yourprogram.py
2
3 real 0m1.028s
4 user 0m0.001s
5 sys 0m0.003s
上面三个输入变量的意义在文章 stackoverflow article 中有详细介绍。简单的说：

real - 表示实际的程序运行时间
user - 表示程序在用户态的cpu总时间
sys - 表示在内核态的cpu总时间

通过sys和user时间的求和，你可以直观的得到系统上没有其他程序运行时你的程序运行所需要的CPU周期。

若sys和user时间之和远远少于real时间，那么你可以猜测你的程序的主要性能问题很可能与IO等待相关。

使用计时上下文管理器进行细粒度计时

我们的下一个技术涉及访问细粒度计时信息的直接代码指令。这是一小段代码，我发现使用专门的计时测量是非常重要的：

timer.py
01 import time
02
03 class Timer(object):
04 def __init__(self, verbose=False):
05 self.verbose = verbose
06
07 def __enter__(self):
08 self.start = time.time()
09 return self
10
11 def __exit__(self, *args):
12 self.end = time.time()
13 self.secs = self.end - self.start
14 self.msecs = self.secs * 1000 # millisecs
15 if self.verbose:
16 print 'elapsed time: %f ms' % self.msecs

为了使用它，你需要用Python的with关键字和Timer上下文管理器包装想要计时的代码块。它将会在你的代码块开始执行的时候启动计时器，在你的代码块结束的时候停止计时器。

这是一个使用上述代码片段的例子：
01 from timer import Timer
02 from redis import Redis
03 rdb = Redis()
04
05 with Timer() as t:
06 rdb.lpush("foo", "bar")
07 print "=> elasped lpush: %s s" % t.secs
08
09 with Timer as t:
10 rdb.lpop("foo")
11 print "=> elasped lpop: %s s" % t.secs

我经常将这些计时器的输出记录到文件中，这样就可以观察我的程序的性能如何随着时间进化。

使用分析器逐行统计时间和执行频率

Robert Kern有一个称作line_profiler的不错的项目，我经常使用它查看我的脚步中每行代码多快多频繁的被执行。

想要使用它，你需要通过pip安装该python包：
1 $ pip install line_profiler

一旦安装完成，你将会使用一个称做“line_profiler”的新模组和一个“kernprof.py”可执行脚本。

想要使用该工具，首先修改你的源代码，在想要测量的函数上装饰@profile装饰器。不要担心，你不需要导入任何模组。kernprof.py脚本将会在执行的时候将它自动地注入到你的脚步的运行时。

primes.py
01 @profile
02 def primes(n):
03 if n==2:
04 return [2]
05 elif n<2:
06 return []
07 s=range(3,n+1,2)
08 mroot = n ** 0.5
09 half=(n+1)/2-1
10 i=0
11 m=3
12 while m <= mroot:
13 if s[i]:
14 j=(m*m-3)/2
15 s[j]=0
16 while j
17 s[j]=0
18 j+=m
19 i=i+1
20 m=2*i+3
21 return [2]+[x for x in s if x]
22 primes(100)
一旦你已经设置好了@profile装饰器，使用kernprof.py执行你的脚步。
1 $ kernprof.py -l -v fib.py
-l选项通知kernprof注入@profile装饰器到你的脚步的内建函数，-v选项通知kernprof在脚本执行完毕的时候显示计时信息。上述脚本的输出看起来像这样：
01 Wrote profile results to primes.py.lprof
02 Timer unit: 1e-06 s
03
04 File: primes.py
05 Function: primes at line 2
06 Total time: 0.00019 s
07
08 Line # Hits Time Per Hit % Time Line Contents
09 ==============================================================
10 2 @profile
11 3 def primes(n):
12 4 1 2 2.0 1.1 if n==2:
13 5 return [2]
14 6 1 1 1.0 0.5 elif n<2:
15 7 return []
16 8 1 4 4.0 2.1 s=range(3,n+1,2)
17 9 1 10 10.0 5.3 mroot = n ** 0.5
18 10 1 2 2.0 1.1 half=(n+1)/2-1
19 11 1 1 1.0 0.5 i=0
20 12 1 1 1.0 0.5 m=3
21 13 5 7 1.4 3.7 while m <= mroot:
22 14 4 4 1.0 2.1 if s[i]:
23 15 3 4 1.3 2.1 j=(m*m-3)/2
24 16 3 4 1.3 2.1 s[j]=0
25 17 31 31 1.0 16.3 while j
26 18 28 28 1.0 14.7 s[j]=0
27 19 28 29 1.0 15.3 j+=m
28 20 4 4 1.0 2.1 i=i+1
29 21 4 4 1.0 2.1 m=2*i+3
30 22 50 54 1.1 28.4 return [2]+[x for x in s if x]

寻找具有高Hits值或高Time值的行。这些就是可以通过优化带来最大改善的地方。

程序使用了多少内存？

现在我们对计时有了较好的理解，那么让我们继续弄清楚程序使用了多少内存。我们很幸运，Fabian Pedregosa模仿Robert Kern的line_profiler实现了一个不错的内存分析器。

首先使用pip安装:
1 $ pip install -U memory_profiler
2 $ pip install psutil

（这里建议安装psutil包，因为它可以大大改善memory_profiler的性能）。

就像line_profiler，memory_profiler也需要在感兴趣的函数上面装饰@profile装饰器：
1 @profile
2 def primes(n):
3 ...
4 ...
想要观察你的函数使用了多少内存，像下面这样执行：
1 $ python -m memory_profiler primes.py
一旦程序退出，你将会看到看起来像这样的输出：
01 Filename: primes.py
02
03 Line # Mem usage Increment Line Contents
04 ==============================================
05 2 @profile
06 3 7.9219 MB 0.0000 MB def primes(n):
07 4 7.9219 MB 0.0000 MB if n==2:
08 5 return [2]
09 6 7.9219 MB 0.0000 MB elif n<2:
10 7 return []
11 8 7.9219 MB 0.0000 MB s=range(3,n+1,2)
12 9 7.9258 MB 0.0039 MB mroot = n ** 0.5
13 10 7.9258 MB 0.0000 MB half=(n+1)/2-1
14 11 7.9258 MB 0.0000 MB i=0
15 12 7.9258 MB 0.0000 MB m=3
16 13 7.9297 MB 0.0039 MB while m <= mroot:
17 14 7.9297 MB 0.0000 MB if s[i]:
18 15 7.9297 MB 0.0000 MB j=(m*m-3)/2
19 16 7.9258 MB -0.0039 MB s[j]=0
20 17 7.9297 MB 0.0039 MB while j
21 18 7.9297 MB 0.0000 MB s[j]=0
22 19 7.9297 MB 0.0000 MB j+=m
23 20 7.9297 MB 0.0000 MB i=i+1
24 21 7.9297 MB 0.0000 MB m=2*i+3
25 22 7.9297 MB 0.0000 MB return [2]+[x for x in s if x]

line_profiler和memory_profiler的IPython快捷方式

memory_profiler和line_profiler有一个鲜为人知的小窍门，两者都有在IPython中的快捷命令。你需要做的就是在IPython会话中输入以下内容：
1 %load_ext memory_profiler
2 %load_ext line_profiler

在这样做的时候你需要访问魔法命令%lprun和%mprun，它们的行为类似于他们的命令行形式。主要区别是你不需要使用@profiledecorator来修饰你要分析的函数。只需要在IPython会话中像先前一样直接运行分析：
1 In [1]: from primes import primes
2 In [2]: %mprun -f primes primes(1000)
3 In [3]: %lprun -f primes primes(1000)

这样可以节省你很多时间和精力，因为你的源代码不需要为使用这些分析命令而进行修改。

内存泄漏在哪里？

cPython解释器使用引用计数做为记录内存使用的主要方法。这意味着每个对象包含一个计数器，当某处对该对象的引用被存储时计数器增加，当引用被删除时计数器递减。当计数器到达零时，cPython解释器就知道该对象不再被使用，所以删除对象，释放占用的内存。

如果程序中不再被使用的对象的引用一直被占有，那么就经常发生内存泄漏。

查找这种“内存泄漏”最快的方式是使用Marius Gedminas编写的objgraph，这是一个极好的工具。该工具允许你查看内存中对象的数量，定位含有该对象的引用的所有代码的位置。

⑸ python相关性分析如何生成两个相关性最强的两门

方法/步骤

  • 第一步我们首先需要知道相关性主要有两个方向，一个是正方向一个是负方向，相关性系数是衡量两个变量之间影响程度，如下图所示：

⑹ 如何利用python进行数据的相关性分析

1. 运算优先级
括号、指数、乘、除、加、减
2
如果你使用了非 ASCII 字符而且碰到了编码错误，记得在最顶端加一行 # -- coding: utf-8 --
3. Python格式化字符
使用更多的格式化字符。例如 %r 就是是非常有用的一个，它的含义是“不管什么都打印出来”。
%s -- string
%% 百分号标记 #就是输出一个%
%c 字符及其ASCII码
%s 字符串
%d 有符号整数(十进制)
%u 无符号整数(十进制)
%o 无符号整数(八进制)
%x 无符号整数(十六进制)
%X 无符号整数(十六进制大写字符)
%e 浮点数字(科学计数法)
%E 浮点数字(科学计数法，用E代替e)
%f 浮点数字(用小数点符号)
%g 浮点数字(根据值的大小采用%e或%f)
%G 浮点数字(类似于%g)
%p 指针(用十六进制打印值的内存地址)
%n 存储输出字符的数量放进参数列表的下一个变量中
%c 转换成字符（ASCII 码值，或者长度为一的字符串）
%r 优先用repr()函数进行字符串转换（Python2.0新增）
%s 优先用str()函数进行字符串转换
%d / %i 转成有符号十进制数
%u 转成无符号十进制数
%o 转成无符号八进制数
%x / %X (Unsigned)转成无符号十六进制数（x / X 代表转换后的十六进制字符的大小写）
%e / %E 转成科学计数法（e / E控制输出e / E）
%f / %F 转成浮点数（小数部分自然截断）
%g / %G : %e和%f / %E和%F 的简写
%% 输出%
辅助符号 说明
* 定义宽度或者小数点精度
- 用做左对齐
+ 在正数前面显示加号(+)
<sp> 在正数前面显示空格
# 在八进制数前面显示零(0)，在十六进制前面显示“0x”或者“0X”（取决于用的是“x”还是“X”）
0 显示的数字前面填充“0”而不是默认的空格
m.n m 是显示的最小总宽度，n 是小数点后的位数（如果可用的话）

⑺ 初学python，怎样用python做pearson相关系数的检验呢，求指导啊

scipy.stats.pearsonr(x, y)

x和y为相同长来度的两组数据

返回值 r, p-value

r是相关源系数，取值-1~1. 表示线性相关程度
p-value越小，表示相关程度越显著。按照文档的说法“The p-values are not entirely reliable but are probably reasonable for datasets larger than 500 or so.”，p-value在500个样本值以上有较高的可靠性

⑻ python中如何分析这是一本关于什么的文档

最基本的就是做来分词后取自最高频词。

作为优化，可以从词性角度排除一些高频词，如高频词“的”之类的。
如果还想进一步优化，就需要使用大数据了，建立一个词相关性评分表，对文档分词后的词频与这相应的相关度做加权，选取加权最高的一组词或几组词为文档的索引词表。
然后从文档中提取整句与提取的索引词表履盖度最高的若干句作为文档的摘要。
大部分的摘要算法就是按这个思路来完成的。