收藏，751 浏览
当你知道某些详细地址信息，该如何利用。本文通过调用百度地图接口，实现用户可视化展示，便于更清楚地了解用户。
注册百度地图开放平台帐号
首先先到上注册一个开发者帐号，然后找到，如下图所示：
Python调用
通过http调用接口格式如下：
http://api./geocoder/v2/?address=百度大厦&output=json&ak=Ede693a3fe707cdc962045&callback=showLocation
利用python批量调用，先定义一个函数：
def getlnglat(address):
url = 'http://api./geocoder/v2/'
output = 'json'
ak = '[*百度开发平台上申请的*]'
uri = url + '?' + 'address=' + address + '&output=' + output + '&ak=' + ak
temp = urllib.urlopen(uri)
temp = json.loads(temp.read())
return temp
接下来就可以通过调用该函数去批量处理地址数据，并将相应的结果存入到数据库中。
百度地图接口这点确实做的不错，返回的结果中包含两个相当有用的信息，一个是置信度（可以简单理解为计算结果的准确性），另一个是地址类型，即标识某个地址是商务大厦、村庄、道路、宾馆等一些语义化的标签。
Tableau数据可视化
Tableau的可视化功能较为方便和强大，以下是基于刚才处理后的数据得到的相应的可视化图：
整体分布图
局部分布图
有了这样一幅图，大家就可以很清楚地了解用户：住哪 、那个小区，周边商业环境等相关信息。基于此，在移动互联网环境下，我们也可以发现其它的机会点，如果某个小区或者大厦有很多人使用应用，可以基于此部分用户做专门的分析，观察这部分用户的时间信息流，想像一下千万溪流汇聚成大海，大海就是我们观察到的小区或者厦，溪河就是可能的商业机会，大的溪河需要重点挖掘，小的溪河看潜力。
你可能感兴趣的文章
2 收藏，451 浏览
3 收藏，9.2k 浏览
6 收藏，2.7k 浏览
本文隶属于专栏
分享到微博？
与我们一起探索更多的未知
专业的开发者技术社区，为用户提供多样化的线上知识交流，丰富的线下活动及给力的工作机会
加入只需一步
举报理由：
推广（招聘、广告、SEO 等）方面的内容
带有人身攻击、辱骂、仇恨等违反条款的内容
与已有问题重复（请编辑该提问指向已有相同问题）
不友善内容
答非所问，不符合答题要求
其他原因（请补充说明）
补充说明：
扫扫下载 App
SegmentFault
一起探索更多未知科学计算：Python&VS.&MATLAB(3)----线性代数基础
科学计算：Python VS.
MATLAB(3)----线性代数基础
按：在介绍工具之前先对理论基础进行必要的回顾是很必要的。没有理论的基础，讲再多的应用都是空中楼阁。本文主要设涉及线性代数和矩阵论的基本内容。先回顾这部分理论基础，然后给出MATLAB，继而给出Python的处理。个人感觉，因为Python是面向对象的，操纵起来会更接近人的正常思维；而MATLAB大多是以函数实现的，是向对象施加的一个操作。比如，A是一个矩阵，它有一个属性attr。用Python更可能是A.attr，而用MATLAB更可能是attr(A)。
一、线形代数理论基础
线形代数（linear
algebra）是数学的一个分支，研究矩阵理论、向量空间、线性变换和有限维线形方程组等内容。
比较重要的思想有：1.线性代数的核心内容是研究有限维线性空间的结构和线性空间的线性变换；2.向量的线性相关性是研究线性空间结构与线性变换理论的基础；3.矩阵是有限维线性空间的线性变换的表示形式；4.线性方程组的求解问题是n维空间到m维空间线性映射求核和全体原象的问题；5.行列式是研究这些问题的一个工具。
主要内容有：1.矩阵运算：加减乘除、转置、逆矩阵、行列式、矩阵的幂、伴随矩阵；2.矩阵分块、秩、迹；3.解方程；4.线性相关；5.向量空间；6.特征值和特征向量；7.对称、相似；8.二次标准型；9.线性空间和基变换；10.正交空间；11.矩阵对角化；13.矩阵分解；14.重要数字特征。
二、MATLAB的处理
1.建立矩阵
MATLAB中，矩阵是默认的数据类型。它把向量看做1&N或者N&1的矩阵。
%建立了一个行向量，不同元素之间使用空格或者逗号分开都是可以的。
A=[1,2,3]&&
或者& A=[1 2 3]
%建立一个矩阵，使用分号隔开不同的行。
A=[1,2,3;4,5,6]
%那么，建立一个列向量就好办了。每行一个元素，分号分开即可。当然也可以使用行向量的转置（一个撇号表示转置）。
A=[1;2;3]&&
或者&& A=[1,2,3]’
MATLAB内置了很多特殊的矩阵生成函数，建立特殊矩阵十分方便。
i)第一组用来生成特殊规则的矩阵。如全零、全一、随机、等步长等形式。
X=zeros(m,n)&&&
%生成一个m*n的全0矩阵。同理，ones(m,n)生成一个全1矩阵；eye(m,n)生成一个单位阵。它们的重要作用在于预先分配矩阵空间，所以，在预知矩阵规模但是不知道矩阵具体数据的情况下，先用这几个函数生成一个矩阵，对提高运算速度十分有用。
X=rand(m,n)&&
%生成一个平均分布的随机矩阵，数值区间[0,1]。同理，randn(m,n)生成一个服从正态分布的随机矩阵。注意，这些所谓的随机实际上都是伪随机。
v=linspace(a,b,n)&&&
%产生线性空间矢量。a和b分别是起点和终点，n是本区间内的点数，默认100个点。同理，logspace(a,b,n)产生对数空间矢量。不过它默认点数是50个。
v=1:0.1:10&&&
%产生一个线性的矢量。规格是---起点：步长值：终点
ii)第二组用来在原有矩阵基础上获得一个具有某些特征的矩阵。
X=diag(v,k)和v=diag(X,k)&
%前者用矢量v中的元素生成一个对角矩阵，k是对角移位因子，默认为0，即主对角。k&0，对角线右移。后者返回矩阵X的对角元素，存在矢量v中。k的意义相同。
X1=triu(X,k)和X1=tril(X,k)&&
&%分别产生矩阵X的上三角矩阵和下三角矩阵。
fliplr(X)/flipud(X)/rot90(X)&&&
%这都是对矩阵的翻转操作，获得新的矩阵。分别是左右翻转（left-right）、上下翻转（up-down）和逆时针旋转90°操作。
iii)第三组用来生成一些具有理论价值的，往往是以数学家命名的矩阵。
magic(n)生成行列相加均为同一个数字的方阵。pascal(n)生成帕斯卡尔矩阵。hilb(n)生成希尔伯特矩阵。vander(v)生成范德蒙德矩阵。等等。
这些矩阵一般都有相应的学术背景，用到的时候，可以用命令help
elmat在最后一个栏目中看看有没有自己要找的特殊矩阵，如果有，点进去进一步研究即可。
2.矩阵的特征信息
%获得矩阵X的行、列数。比如，X是一个3*5的矩阵，p=size(X)返回p=[3
length()&&
%对于矢量，返回的是矢量的长度；对数组，返回的是数组最长的那一个维度的长度。
%相当于length(size(x))。
%数组中元素的个数。
isempty()和isequal()等is*型函数&&&
%测试矩阵是否满足某些条件
eig(A)& %矩阵A的特征值D和特征向量V。
rank(A)&& %矩阵A的秩
trace(A)& %矩阵A的迹，即对角线元素之和
%方阵A的行列式
inv(X)&& %矩阵X的逆矩阵
norm(X,option)&&
%矩阵或者向量的范数，具体使用用到再说
cond(X)&&&
%矩阵X的条件数
3.矩阵分解
矩阵分解是矩阵论的重要内容。常用的分解形式在MATLAB中都有函数予以实现，并且有些分解考虑了多种情况。常见的如：eig()、qr()、schur()、svd()、chol()、lu()等。具体使用的时候
4.矩阵运算
MATLAB默认的是矩阵运算，所以如果想要按元素依次计算，在原来运算符前加一个.号。比如.*表示按元素相乘。
每一个运算符都有一个对应的函数。如：
A+B=plus(A,B)、A-B=minus(A,B)
A*B=mtimes(A,B)、A.*B=times(A,B)
A/B=mrdivide(A,B)、A./B=rdivide(A,B)、A\B=mldivide(A,B)、A.\B=ldivide(A,B)
A^B=mpower(A,B)、A.^B=power(A,B)
A'=ctranspose(A)、A.'=transpose(A)
其中的前缀m自然是表示matrix的意思。没有m前缀的就是按元素进行的意思。最后那个转置操作，c前缀表示的是按照复数操作进行转置。
此外，还有一些比较常用的运算：
C=cross(A,B)&&
%矢量叉乘。类似的，C=dot(A,B)& 是矢量点乘
prod(A,dim)&&&
%数组元素的乘积，默认按列计算。dim=1是列，dim=2是按行。这个概念很重要！！
类似的，B = sum(A,dim)&&
求数组元素的和。dim意义和以上同。
%矩阵指数运算。与此类似的logm(),
sqrtm()。其中，funm(A,fun)用来计算矩阵A对通用函数fun的函数值。
5.矩阵索引
选择使用矩阵中的某些元素，就是所谓的矩阵索引了。
A(:,j)&& %选取矩阵A的所有行，第j列，同理，A(i,:)是第i行，所有列
A(:,j:k)&&&
%所有行，第j列至第k列（起点和终点均含）
三、Python的处理
Python使用NumPy包完成了对N-维数组的快速便捷操作。使用这个包，需要导入numpy。SciPy包以NumPy包为基础，大大的扩展了numpy的能力。为了使用的方便，scipy包在最外层名字空间中包括了所有的numpy内容，因此只要导入了scipy，不必在单独导入numpy了！但是为了明确哪些是numpy中实现的，哪些是scipy中实现的，本文还是进行了区分。以下默认已经：import
numpy as np 以及 impor scipy as sp
下面简要介绍Python和MATLAB处理数学问题的几个不同点。1.MATLAB的基本是矩阵，而numpy的基本类型是多为数组，把matrix看做是array的子类。2.MATLAB的索引从1开始，而numpy从0开始。
1.建立矩阵
a1=np.array([1,2,3],dtype=int)&&
#建立一个一维数组，数据类型是int。也可以不指定数据类型，使用默认。几乎所有的数组建立函数都可以指定数据类型，即dtype的取值。
a2=np.array([[1,2,3],[2,3,4]])&&
#建立一个二维数组。此处和MATLAB的二维数组（矩阵）的建立有很大差别。
同样，numpy中也有很多内置的特殊矩阵：
b1=np.zeros((2,3))&&&
#生成一个2行3列的全0矩阵。注意，参数是一个tuple：(2,3)，所以有两个括号。完整的形式为：zeros(shape,dtype=)。相同的结构，有ones()建立全1矩阵。empty()建立一个空矩阵，使用内存中的随机值来填充这个矩阵。
b2=identity(n)&&
#建立n*n的单位阵，这只能是一个方阵。
b3=eye(N,M=None,k=0)&&&
#建立一个对角线是1其余值为0的矩阵，用k指定对角线的位置。M默认None。
此外，numpy中还提供了几个like函数，即按照某一个已知的数组的规模（几行几列）建立同样规模的特殊数组。这样的函数有zeros_like()、empty_like()、ones_like()，它们的参数均为如此形式：zeros_like(a,dtype=)，其中，a是一个已知的数组。
c1=np.arange(2,3,0.1)&&
#起点，终点，步长值。含起点值，不含终点值。
c2=np.linspace(1,4,10)&&&
#起点，终点，区间内点数。起点终点均包括在内。同理，有logspace()函数
d1=panion(a)&&&
d2=np.linalg.triu()/tril()&&
#作用同MATLAB中的同名函数
e1=np.random.rand(3,2)&&&
#产生一个3行2列的随机数组。同一空间下，有randn()/randint()等多个随机函数
fliplr()/flipud()/rot90()&&&
#功能类似MATLAB同名函数。
xx=np.roll(x,2)&&
#roll()是循环移位函数。此调用表示向右循环移动2位。
2.数组的特征信息
先假设已经存在一个N维数组X了，那么可以得到X的一些属性，这些属性可以在输入X和一个.之后，按tab键查看提示。这里明显看到了Python面向对象的特征。
X.flags&&&
#数组的存储情况信息。
X.shape&&&
#结果是一个tuple，返回本数组的行数、列数、……
X.ndim&& #数组的维数，结果是一个数
#数组中元素的数量
X.itemsize&&&
#数组中的数据项的所占内存空间大小
X.dtype&&&
X.T&& #如果X是矩阵，发挥的是X的转置矩阵
X.trace()&&&
#计算X的迹
np.linalg.det(a)&&
#返回的是矩阵a的行列式
np.linalg.norm(a,ord=None)&&&
#计算矩阵a的范数
np.linalg.eig(a)&&&
#矩阵a的特征值和特征向量
np.linalg.cond(a,p=None)&&&
#矩阵a的条件数
np.linalg.inv(a)&&&
#矩阵a的逆矩阵
3.矩阵分解
常见的矩阵分解函数，numpy.linalg均已经提供。比如cholesky()/qr()/svd()/lu()/schur()等。某些算法为了方便计算或者针对不同的特殊情况，还给出了多种调用形式，以便得到最佳结果。
4.矩阵运算
np.dot(a,b)用来计算数组的点积；vdot(a,b)专门计算矢量的点积，和dot()的区别在于对complex数据类型的处理不一样；innner(a,b)用来计算内积；outer(a,b)计算外积。
专门处理矩阵的数学函数在numpy的子包linalg中定义。比如np.linalg.logm(A)计算矩阵A的对数。可见，这个处理和MATLAB是类似的，使用一个m后缀表示是矩阵的运算。在这个空间内可以使用的有cosm()/sinm()/signm()/sqrtm()等。其中常规exp()对应有三种矩阵形式：expm()使用Pade近似算法、expm2()使用特征值分析算法、expm3()使用泰勒级数算法。在numpy中，也有一个计算矩阵的函数：funm(A,func)。
numpy中的数组索引形式和Python是一致的。如：
x=np.arange(10)
#单个元素，从前往后正向索引。注意下标是从0开始的。
#从后往前索引。最后一个元素的下标是-1
#多个元素，左闭右开，默认步长值是1
#多个元素，从后向前，制定了结束的位置，使用默认步长值
x[1:7:2]&& #指定步长值
x.shape=(2,5)&
& #x的shape属性被重新赋值，要求就是元素个数不变。2*5=10
#二维数组索引单个元素，第2行第4列的那个元素
x[0]&& #第一行所有的元素
y=np.arange(35).reshape(5,7)&&&
#reshape()函数用于改变数组的维度
y[1:5:2,::2]&&&
#选择二维数组中的某些符合条件的元素
-------------------------------------------------分割线-------------------------------------------------
作为第一篇正式的介绍技术操作的文章，终于写完了，很费劲。恰恰就是在这个费劲的过程中，让我能更好的认识两者的区别和联系，同时梳理了展开的思路，摸索出了进一步学习的方法。
我们可以看到，MATLAB中实现了的函数或者功能，在numpy中都有了对应，并且有些实现的更好。当然，这只是冰山一角。如果你不愿意通读文档（很枯燥，谁也不愿意干！）也应该有理由相信，Python有能胜任工作的实现已经存在。后面的内容，将不再这样列出各种函数和功能，而是以某一个实际问题为核心，进行专题式的研究。至于全方位的了解，请自己查阅文档。有个经验之谈，就是，应该充分的利用文档中的【see
also】功能，依此追踪下去，必然会获得关于某主题的全方位的认识。比如，在查阅ones()的时候，MATLAB的【see
also】就给出了complex|eye|true|zeros四个链接。这就说明，这几个函数其实是有关联的，点进去进行简单的学习，找到共性，那么，可能很多人都遇到过的最大的困惑——那么多函数怎么记住呀？——就已经解决了。因为，我们不需要记住所有的函数，我们只需要记住有那么回事，只需要记住一个类似的函数，就可以很轻易的在用的时候顺藤摸瓜找出需要的函数。
下面简单的给出MATLAB和Python的自查自学方法吧！
%在控制台给出某函数或者主题的帮助信息
%在帮助浏览器中给出帮助信息，这个界面更友好。在help
browser中既有MATLAB整个产品的浏览左窗口，也有一个搜索框。同时还有大量存在的超链接。就一个感兴趣的主题，点下去，全面学习。不过要记住:别分神哦~~点到最后都忘了自己究竟要做什么！
%这是一个模糊寻找，含有关键词的词条入口都会给出来
help(np.array)&&&
#查看关于array的帮助信息
help(np.add)& #查看关于add的帮助信息
================update
=================
关于python科学计算，隆重推荐sage
math，sage的特点和用法，在本博客较新博文中有介绍。
我的更多文章：
( 13:41:19)( 16:45:22)
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。大家正在求推荐
&·&·&·&·&·&·
&(1 人参与)
&(0 人参与)
&(2 人参与)
&(1 人参与)
&(1 人参与)
第三方登录：使用 Python 计算 π 值 - Python高级教程- Python进阶|Scrapy教程|Python高级|Python深入
官方微博：
使用 Python 计算 π 值
π是一个无数人追随的真正的神奇数字。我不是很清楚一个永远重复的无理数的迷人之处。在我看来，我乐于计算π，也就是计算π的值。因为π是...
π是一个无数人追随的真正的神奇数字。我不是很清楚一个永远重复的无理数的迷人之处。在我看来，我乐于计算π，也就是计算π的值。因为π是一个无理数，它是无限的。这就意味着任何对π的计算都仅仅是个近似值。如果你计算100位，我可以计算101位并且更精确。迄今为止，有些人已经选拔出超级计算机来试图计算最精确的π。一些极值包括 计算π的5亿位。你甚至能从网上找到包含 π的一百亿位的文本文件（注意啦！下载这个文件可能得花一会儿时间，并且没法用你平时使用的记事本应用程序打开。）。对于我而言，如何用几行简单的Python来计算π才是我的兴趣所在。你总是可以 使用 math.pi 变量的 。它被 包含在 标准库中， 在你试图自己 计算它之前，你应该去使用它 。 事实上 ， 我们将 用它来计算 精度 。作为 开始， 让我们看 一个 非常直截了当的 计算Pi的 方法 。像往常一样，我将使用Python 2.7，同样的想法和代码可能应用于不同的版本。我们将要使用的大部分算法来自 Pi WikiPedia page并加以实现。让我们看看下面的代码：importsys
importmath
defmain(argv):
iflen(argv) !=1:
sys.exit('Usage: calc_pi.py &n&')
print'\nComputing Pi v.01\n'
b=1.0/math.sqrt(2)
foriinrange(int(sys.argv[1])):
at=(a+b)/2
bt=math.sqrt(a*b)
tt=t-p*(a-at)**2
a=b=t=p=pt
my_pi=(a+b)**2/(4*t)
accuracy=100*(math.pi-my_pi)/my_pi
print"Pi is approximately: "+str(my_pi)
print"Accuracy with math.pi: "+str(accuracy)
if__name__=="__main__":
main(sys.argv[1:])这是个非常简单的脚本，你可以下载，运行，修改，和随意分享给别人。你能够看到类似下面的输出结果：你会发现，尽管 n 大于4 ,我们逼近 Pi 精度却没有多大的提升。 我们可以猜到即使 n的值更大，同样的事情（pi的逼近精度没有提升）依旧会发生。幸运的是，有不止一种方法来揭开这个谜。使用 Python Decimal （十进制）库，我们可以就可以得到更高精度的值来逼近Pi。让我们来看看库函数是如何使用的。这个简化的版本，可以得到多于11位的数字 通常情况小Python 浮点数给出的精度。下面是Python Decimal 库中的一个例子 ：看到这些数字。不对！ 我们输入的仅是 3.14，为什么我们得到了一些垃圾(junk)？ 这是内存垃圾(memory junk)。 在坚果壳，Python给你你想要的十进制数，再加上一点点额外的值。 只要精度小于垃圾号码开始时，它不会影响任何计算只要精度小于前面的垃圾号码(junk number)开始时。 您可以指定你想要多少位数的通过设置getcontext().prec 。我们试试。很好。 现在让我们 试着用这个 来 看看我们是否能 与我们以前的 代码 有更好的 逼近 。 现在， 我通常 是反对 使用“ from library import * ” ， 但在这种情况下， 它会 使代码 看起来更漂亮 。importsys
importmath
fromdecimalimport*
defmain(argv):
iflen(argv) !=1:
sys.exit('Usage: calc_pi.py &n&')
print'\nComputing Pi v.01\n'
a=Decimal(1.0)
b=Decimal(1.0/math.sqrt(2))
t=Decimal(1.0)/Decimal(4.0)
p=Decimal(1.0)
foriinrange(int(sys.argv[1])):
at=Decimal((a+b)/2)
bt=Decimal(math.sqrt(a*b))
tt=Decimal(t-p*(a-at)**2)
pt=Decimal(2*p)
a=b=t=p=pt
my_pi=(a+b)**2/(4*t)
accuracy=100*(Decimal(math.pi)-my_pi)/my_pi
print"Pi is approximately: "+str(my_pi)
print"Accuracy with math.pi: "+str(accuracy)
if__name__=="__main__":
main(sys.argv[1:])输出结果:好了。我们更准确了，但看起来似乎有一些舍入。从n = 100和n = 1000，我们有相同的精度。现在怎么办？好吧，现在我们来求助于公式。到目前为止，我们计算Pi的方式是通过对几部分加在一起。我从DAN 的关于 Calculating Pi 的文章中发现一些代码。他建议我们用以下3个公式：Bailey–Borwein–Plouffe 公式Bellard的公式Chudnovsky 算法让我们从Bailey–Borwein–Plouffe 公式开始。它看起来是这个样子：在代码中我们可以这样编写它：import sys
import math
from decimal import *
def bbp(n):
pi=Decimal(0)
while k & n:
pi+=(Decimal(1)/(16**k))*((Decimal(4)/(8*k+1))-(Decimal(2)/(8*k+4))-(Decimal(1)/(8*k+5))-(Decimal(1)/(8*k+6)))
def main(argv):
if len(argv) !=2:
sys.exit('Usage: BaileyBorweinPlouffe.py &prec& &n&')
getcontext().prec=(int(sys.argv[1]))
my_pi=bbp(int(sys.argv[2]))
accuracy=100*(Decimal(math.pi)-my_pi)/my_pi
print"Pi is approximately "+str(my_pi)
print"Accuracy with math.pi: "+str(accuracy)
if __name__=="__main__":
main(sys.argv[1:])抛开“ 包装”的代码，BBP（N）的功能是你真正想要的。你给它越大的N和给 getcontext().prec 设置越大的值，你就会使计算越精确。让我们看看一些代码结果：这有许多数字位。你可以看出，我们并没有比以前更准确。所以我们需要前进到下一个公式，贝拉公式，希望能获得更好的精度。它看起来像这样：我们将只改变我们的变换公式，其余的代码将保持不变。。让我们看一看bellards(n)：def bellard(n):
pi=Decimal(0)
while k & n:
pi+=(Decimal(-1)**k/(1024**k))*( Decimal(256)/(10*k+1)+Decimal(1)/(10*k+9)-Decimal(64)/(10*k+3)-Decimal(32)/(4*k+1)-Decimal(4)/(10*k+5)-Decimal(4)/(10*k+7)-Decimal(1)/(4*k+3))
pi=pi*1/(2**6)
return pi输出结果：哦，不，我们得到的是同样的精度。好吧，让我们试试第三个公式， Chudnovsky 算法，它看起来是这个样子：再一次，让我们看一下这个计算公式（假设我们有一个阶乘公式）。。下面是程序和输出结果：def chudnovsky(n):
pi=Decimal(0)
while k & n:
pi+=(Decimal(-1)**k)*(Decimal(factorial(6*k))/((factorial(k)**3)*(factorial(3*k)))*(140134*k)/(640320**(3*k)))
pi=pi*Decimal(10005).sqrt()/
pi=pi**(-1)
return pi所以我们有了什么结论？花哨的算法不会使机器浮点世界达到更高标准。我真的很期待能有一个比我们用求和公式时所能得到的更好的精度。我猜那是过分的要求。如果你真的需要用PI，就只需使用math.pi变量了。然而，作为乐趣和测试你的计算机真的能有多快，你总是可以尝试第一个计算出Pi的百万位或者更多位是几。
相关文章：
相关词搜索：
如对本文内容有疑问，或想进一步交流学习，欢迎通过以下方式：
2. python技术互助群:
群④ ： （已满）
3. 关注PythonTab微信，获取精彩资讯教程，公众号：Pythontab中文网
版权声明：本站文章除非注明，均为原创内容，如需转载请务必注明出处，违者本站保留追究其法律责任之权利。
频道总排行
频道本月排行怎样使python计算结果显示小数？
我编程小白，前几天开始学习用python分析自然语言。但是发现教材上的from _future_ import division 在我的2.7.3上面不成功。我的计算结果都是整数，如3/5=0.要如何才能使运算结果显示更精确的结果？
按投票排序
传统整数除法会舍去小数部分，返回一个整型。如果操作数之一是浮点型，则执行真正的除法。比如： &&& 5/0.316.668&&& 3/float(5)0.6
3/5是整数除法，返回结果也是整数，所以结果是0。这个不是隐藏了，是的确没有。事实上不光python这样处理，C/C++也都是这样的，因为整数和浮点数本来就是两回事，用来计算除法的部件也不是同一个。如果想做浮点除法，就应该把至少一个操作数转化为浮点型。最简单的方法就是在后面加上.0，例如3.0/5。这里3.0就自动是一个浮点数。当然也可以也可以用类型转换的方法：(float)3/5。这样做实际上是强制系统把整数3转化为浮点数用，做除法时5也会自动被转换为浮点数再进行除操作。
是from __future__ import division 不是from _future_ import division}