小编Dan*_*ein的帖子

这个问题似乎很容易,但我不能得到一个漂亮的解决方案.我有两个numpy数组(A和B),我想获得A的索引,其中A的元素在B中,并且还得到A的索引,其中元素不在B中.

因此,如果

A = np.array([1,2,3,4,5,6,7])
B = np.array([2,4,6])

目前我正在使用

C = np.searchsorted(A,B)

它利用了A有序的事实,并给了我[1, 3, 5],元素的索引A.这很好,但我怎么得到D = [0,2,4,6],元素的索引A不在B？

我最喜欢在Matplotlib上做的事情之一就是设置颜色循环以匹配一些颜色图,以便生成线条图,颜色在线条上有很好的渐变.像这个:

以前,这是一行代码使用set_color_cycle:

ax.set_color_cycle([plt.cm.spectral(i) for i in np.linspace(0, 1, num_lines)])

但是,最近我看到一个警告:

MatplotlibDeprecationWarning: 
The set_color_cycle attribute was deprecated in version 1.5. 
Use set_prop_cycle instead.

使用set_prop_cycle,我可以实现相同的结果,但我需要import cycler,并且语法不那么紧凑:

from cycler import cycler
colors = [plt.cm.spectral(i) for i in np.linspace(0, 1, num_lines)]
ax.set_prop_cycle(cycler('color', colors))

所以,我的问题是:

我使用set_prop_cycle得当吗？(并以最有效的方式？)

有没有更简单的方法将颜色周期设置为色彩图？换句话说,这样有一些神话般的功能吗？

ax.set_colorcycle_to_colormap('jet', nlines=30)

以下是完整示例的代码:

import numpy as np
import matplotlib.pyplot as plt

ax = plt.subplot(111)
num_lines = 30

colors = [plt.cm.spectral(i) for i in np.linspace(0, 1, num_lines)]

# old way: 
ax.set_color_cycle(colors) …

我见过两个:

import scipy as sp

和:

import scipy as sc

在任何地方都有官方偏好吗？

例如,在Scipy文档的介绍中,建议使用

import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

但是Scipy软件包没有类似的缩写.

在这个问题,sp建议,但链接到SciPy的文档实际上并没有指定sp过sc.

在某些LCD显示器上,图例中水平线的颜色很难区分.(见附图).因此,不是在图例中画一条线,是否可以只对文本本身进行颜色编码？换句话说,蓝色为"y = 0x",绿色为"y = 1x"等...

import matplotlib.pyplot as plt
import numpy as np

x = np.arange(10)

fig = plt.figure()
ax = plt.subplot(111)

for i in xrange(5):
    ax.plot(x, i * x, label='$y = %ix$' % i)

ax.legend()

plt.show()

PS.如果线条可以在图例中变厚,但在图表中没有,这也可以.

我需要在4个维度(纬度,经度,高度和时间)中线性插值温度数据.
点数相当高(360x720x50x8),我需要一种快速的方法来计算数据范围内空间和时间任意点的温度.

我尝试过使用scipy.interpolate.LinearNDInterpolator但是使用Qhull进行三角测量在矩形网格上效率低下并且需要数小时才能完成.

通过阅读此SciPy票证,解决方案似乎是使用标准实现新的nd插值器interp1d来计算更多数据点,然后使用"最近邻居"方法和新数据集.

然而,这需要很长时间(分钟).

有没有一种快速的方法可以在4维的矩形网格上插入数据而无需花费几分钟才能完成？

我想过使用interp1d4次而不计算更高密度的点,但留给用户用坐标调用,但我无法理解如何做到这一点.

否则我会根据自己的需要编写自己的4D内插器吗？

这是我用来测试这个的代码:

使用scipy.interpolate.LinearNDInterpolator:

import numpy as np
from scipy.interpolate import LinearNDInterpolator

lats = np.arange(-90,90.5,0.5)
lons = np.arange(-180,180,0.5)
alts = np.arange(1,1000,21.717)
time = np.arange(8)
data = np.random.rand(len(lats)*len(lons)*len(alts)*len(time)).reshape((len(lats),len(lons),len(alts),len(time)))

coords = np.zeros((len(lats),len(lons),len(alts),len(time),4))
coords[...,0] = lats.reshape((len(lats),1,1,1))
coords[...,1] = lons.reshape((1,len(lons),1,1))
coords[...,2] = alts.reshape((1,1,len(alts),1))
coords[...,3] = time.reshape((1,1,1,len(time)))
coords = coords.reshape((data.size,4))

interpolatedData = LinearNDInterpolator(coords,data)

使用scipy.interpolate.interp1d:

import numpy as np
from scipy.interpolate import LinearNDInterpolator

lats = np.arange(-90,90.5,0.5) …

我有基本随机间隔采样的数据.我想用numpy(或其他python包)来计算加权移动平均线.我有一个移动平均线的粗略实现,但我很难找到一个好的方法来进行加权移​​动平均线,因此朝向边框中心的值的加权大于边缘的值.

在这里,我生成一些样本数据,然后采用移动平均线.我怎样才能最轻松地实现加权移动平均线？谢谢!

import numpy as np
import matplotlib.pyplot as plt

#first generate some datapoint for a randomly sampled noisy sinewave
x = np.random.random(1000)*10
noise = np.random.normal(scale=0.3,size=len(x))
y = np.sin(x) + noise

#plot the data
plt.plot(x,y,'ro',alpha=0.3,ms=4,label='data')
plt.xlabel('Time')
plt.ylabel('Intensity')

#define a moving average function
def moving_average(x,y,step_size=.1,bin_size=1):
    bin_centers  = np.arange(np.min(x),np.max(x)-0.5*step_size,step_size)+0.5*step_size
    bin_avg = np.zeros(len(bin_centers))

    for index in range(0,len(bin_centers)):
        bin_center = bin_centers[index]
        items_in_bin = y[(x>(bin_center-bin_size*0.5) ) & (x<(bin_center+bin_size*0.5))]
        bin_avg[index] = np.mean(items_in_bin)

    return bin_centers,bin_avg

#plot the moving average
bins, average = moving_average(x,y)
plt.plot(bins, average,label='moving average')

plt.show() …

这可能是一个愚蠢的问题,但......

我有几千个图像,我想加载到Python然后转换为numpy数组.显然这有点慢.但是,我实际上只对每张图片的一小部分感兴趣.(相同的部分,图像中心只有100x100像素.)

有没有办法加载图像的一部分,以使事情变得更快？

下面是一些示例代码,我生成一些示例图像,保存并重新加载.

import numpy as np
import matplotlib.pyplot as plt
import Image, time

#Generate sample images
num_images = 5

for i in range(0,num_images):
    Z = np.random.rand(2000,2000)
    print 'saving %i'%i
    plt.imsave('%03i.png'%i,Z)

%load the images
for i in range(0,num_images):
    t = time.time()

    im = Image.open('%03i.png'%i)
    w,h = im.size
    imc = im.crop((w-50,h-50,w+50,h+50))

    print 'Time to open: %.4f seconds'%(time.time()-t)

    #convert them to numpy arrays
    data = np.array(imc)

今天我偶然发现了这一点:如果线宽小于1.0,似乎在matplotlib中绘制线要快得多.我只在Mac上测试了这个,但效果似乎很强.

例如,如果您尝试使用此代码,您将看到数据绘制速度提高约10倍,线宽为0.5而不是线宽为1.0.

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0,10,20000)
y = np.sin(x) + np.random.random(len(x))*0.1

plt.ion()
plt.show()

plt.plot(x,y,lw=0.5)
plt.draw()

plt.figure()

plt.plot(x,y,lw=1.0)
plt.draw()

我用这段代码制作了线宽和速度之间关系的图表:

import numpy as np
import matplotlib.pyplot as plt
import time

x = np.linspace(0,10,10000)
y = np.sin(x) + np.random.random(len(x))*0.1

plt.ion()
plt.show()

linewidths = np.linspace(2,0,20)
times = []

for lw in linewidths:
    t = time.time()

    plt.plot(x,y,lw=lw)
    plt.draw()

    times.append(time.time()-t)

    plt.figure()



plt.ioff()
plt.plot(linewidths[1:],times[1:],'ro')

plt.xlabel('Linewidth (points)')
plt.ylabel('Time (seconds)')
plt.show()

这是结果:

使用小于1.0的线宽可提供~10倍的加速,而在1.0之后,时间会线性增加.如果数据点的数量很大,大于约5000点左右,我只会观察到这种效应.我觉得如果我要求matplotlib显示更多的像素,那么制作绘图可能需要更长的时间,但我并不期望使用略小的线宽(0.5对1.0)的巨大加速.

谁能解释为什么会这样？我很高兴发现它,因为它使显示大型数据集的速度更快.

有人认为这可能是MacOSX后端特有的.这似乎很可能.如果我尝试以png格式保存绘图而不是将它们绘制到屏幕上,则时间似乎更随机分布:

我使用numpy和scipy来处理用CCD相机拍摄的大量图像.这些图像具有许多具有非常大(或小)值的热(和死)像素.这些会干扰其他图像处理,因此需要将其删除.不幸的是,虽然一些像素卡在0或255并且在所有图像中总是处于相同的值,但是有些像素暂时停留在其他值上几分钟(数据跨度)很长时间).

我想知道是否有一种方法来识别(和删除)已在python中实现的热像素.如果没有,我想知道这样做的有效方法是什么.通过将它们与相邻像素进行比较,相对容易识别热/坏像素.我可以看到编写一个查看每个像素的循环,将其值与其最近的8个邻居的值进行比较.或者,使用某种卷积来生成更平滑的图像然后从包含热像素的图像中减去这种图像似乎更好,这使得它们更容易识别.

我在下面的代码中尝试了这种"模糊方法",它运行正常,但我怀疑它是最快的.此外,它在图像的边缘变得混乱(可能因为gaussian_filter函数正在进行卷积并且卷积在边缘附近变得奇怪).那么,还有更好的方法吗？

示例代码:

import numpy as np
import matplotlib.pyplot as plt
import scipy.ndimage

plt.figure(figsize=(8,4))
ax1 = plt.subplot(121)
ax2 = plt.subplot(122)

#make a sample image
x = np.linspace(-5,5,200)
X,Y = np.meshgrid(x,x)
Z = 255*np.cos(np.sqrt(x**2 + Y**2))**2


for i in range(0,11):
    #Add some hot pixels
    Z[np.random.randint(low=0,high=199),np.random.randint(low=0,high=199)]= np.random.randint(low=200,high=255)
    #and dead pixels
    Z[np.random.randint(low=0,high=199),np.random.randint(low=0,high=199)]= np.random.randint(low=0,high=10)

#Then plot it
ax1.set_title('Raw data with hot pixels')
ax1.imshow(Z,interpolation='nearest',origin='lower')

#Now we try to find the hot pixels
blurred_Z = scipy.ndimage.gaussian_filter(Z, sigma=2)
difference = Z - blurred_Z

ax2.set_title('Difference with hot …

我在matplotlib中制作了一些等高线图,破折号的长度太长了.虚线也不好看.我想手动设置短划线的长度.当我使用plt.plot()制作一个简单的绘图时,我可以设置精确的短划线长度,但是我无法弄清楚如何用等高线图做同样的事情.

我认为以下代码应该可以工作,但我收到错误:

File "/Library/Python/2.7/site-packages/matplotlib-1.2.x-py2.7-macosx-10.8-intel.egg/matplotlib/backends/backend_macosx.py", line 80, in draw_path_collection
    offset_position)
TypeError: failed to obtain the offset and dashes from the linestyle

以下是我正在尝试做的一个示例,改编自MPL示例:

import numpy as np
import matplotlib.mlab as mlab
import matplotlib.pyplot as plt


delta = 0.025
x = np.arange(-3.0, 3.0, delta)
y = np.arange(-2.0, 2.0, delta)
X, Y = np.meshgrid(x, y)
Z1 = mlab.bivariate_normal(X, Y, 1.0, 1.0, 0.0, 0.0)
Z2 = mlab.bivariate_normal(X, Y, 1.5, 0.5, 1, 1)
# difference of Gaussians
Z = 10.0 * (Z2 - Z1)

plt.figure()

CS …