小编tnk*_*epp的帖子

我记得在MatLab的日子里使用结构化数组,你可以将不同的数据存储为主结构的属性.就像是:

a = {}
a.A = magic(10)
a.B = magic(50); etc.

其中aA和aB彼此完全分开,允许您在a中存储不同的类型并根据需要对它们进行操作.熊猫允许我们做类似的事情,但不完全相同.

我正在使用Pandas并希望存储数据帧的属性而不实际将其放在数据帧中.这可以通过以下方式完成:

import pandas as pd

a = pd.DataFrame(data=pd.np.random.randint(0,100,(10,5)),columns=list('ABCED')

# now store an attribute of <a>
a.local_tz = 'US/Eastern'

现在,本地时区存储在a中,但是当我保存数据帧时我无法保存此属性(即重新加载后没有a.local_tz).有没有办法保存这些属性？

目前,我只是在数据框中创建新列来保存时区,纬度,长期等信息,但这似乎有点浪费.此外,当我对数据进行分析时遇到了必须排除这些其他列的问题.

################## BEGIN EDIT ##################

使用unutbu的建议,我现在以h5格式存储数据.如上所述,将元数据作为数据帧的属性重新加载是有风险的.但是,由于我是这些文件(和处理算法)的创建者,我可以选择存储为元数据的内容和不存储的内容.在处理将进入h5文件的数据时,我选择将元数据存储在初始化为类的属性的字典中.我创建了一个简单的IO类来导入h5数据,并将元数据作为类属性.现在我可以处理我的数据帧而不会丢失元数据.

class IO():
    def __init__(self):
        self.dtfrmt = 'dummy_str'

    def h5load(self,filename,update=False):
        '''h5load loads the stored HDF5 file.  Both the dataframe (actual data) and 
        the associated metadata are stored in the H5file

        NOTE: This does not load "any" H5 
        file, it loads H5 files specifically created …

创建我的数据帧:

from pandas import *
arrays = [['bar', 'bar', 'baz', 'baz', 'foo', 'foo', 'qux', 'qux'],
          ['one', 'two', 'one', 'two', 'one', 'two', 'one', 'two']]

tuples = zip(*arrays)

index = MultiIndex.from_tuples(tuples, names=['first','second'])
data = DataFrame(randn(8,2),index=index,columns=['c1','c2'])

data
Out[68]: 
                    c1        c2
first second                    
bar   one     0.833816 -1.529639
      two     0.340150 -1.818052
baz   one    -1.605051 -0.917619
      two    -0.021386 -0.222951
foo   one     0.143949 -0.406376
      two     1.208358 -2.469746
qux   one    -0.345265 -0.505282
      two     0.158928  1.088826

我想重命名"第一"索引值,例如"bar" - >"cat","baz" - >"dog"等.但是,我读过的每个例子都是在单级索引上运行/或循环遍历整个索引,从头开始有效地重新创建它.我想的是:

data = data.reindex(index={'bar':'cat','baz':'dog'})

但是这不起作用,我也不希望它在多个索引上工作.我可以在不循环整个数据框索引的情况下进行这样的替换吗？

开始编辑

我很想在发布之前更新到0.13,所以我使用了以下解决方法:

index = …

对数据帧进行重新采样可以使数据帧达到更高或更低的时间分辨率。大多数时候，这用于降低分辨率（例如，将 1 分钟数据重新采样为每月值）。当数据集稀疏时（例如，2020 年 2 月没有收集任何数据），2020 年 2 月的行将填充重采样数据帧的 NaN。问题是，当数据记录很长且稀疏时，会有大量 NaN 行，这使得数据帧不必要地变大并占用大量 CPU 时间。例如，考虑这个数据帧和重新采样操作：

import numpy as np
import pandas as pd

freq1 = pd.date_range("20000101", periods=10, freq="S")
freq2 = pd.date_range("20200101", periods=10, freq="S")

index = np.hstack([freq1.values, freq2.values])
data = np.random.randint(0, 100, (20, 10))
cols = list("ABCDEFGHIJ")

df = pd.DataFrame(index=index, data=data, columns=cols)

# now resample to daily average
df = df.resample(rule="1D").mean()

该数据框中的大部分数据都是无用的，可以通过以下方式删除：

df.dropna(how="all", axis=0, inplace=True)

然而，这是草率的。是否有另一种方法来重新采样数据帧，该方法不会用 NaN 填充所有数据间隙（即在上面的示例中，生成的数据帧将只有两行）？

在定义刻度标签时，我获得了异常高的精度。例如：

import pylab as pl

fig = pl.figure(figsize=(3.25, 2.5))
ax0 = fig.add_subplot(111)

ax0.set_ylim([0, 0.5])
ax0.set_yticks(np.arange(0, 0.51, 0.1), minor=False)
ax0.set_yticklabels(np.arange(0, 0.51, 0.1), fontsize=8)

ax0.set_xlim([0, 0.5])
ax0.set_xticks(np.arange(0, 0.51, 0.1), minor=False)
ax0.set_xticklabels(np.arange(0, 0.51, 0.1), fontsize=8)

fig.show()

下面的输出图在 0.3 标记（x 轴和 y 轴）上有错误的刻度标签。我尝试过使用 np.linspace，这会产生同样的问题。

我理解浮点精度的问题，但我希望标签能够更快地四舍五入。如何更正此问题以仅显示第一个小数？

使用 matplotlib 2.2.2

在计算四分位数范围时,我遇到了一个有趣的情况.假设我们有一个数据帧,例如:

import pandas as pd
index=pd.date_range('2014 01 01',periods=10,freq='D')
data=pd.np.random.randint(0,100,(10,5))
data = pd.DataFrame(index=index,data=data)

data
Out[90]: 
             0   1   2   3   4
2014-01-01  33  31  82   3  26
2014-01-02  46  59   0  34  48
2014-01-03  71   2  56  67  54
2014-01-04  90  18  71  12   2
2014-01-05  71  53   5  56  65
2014-01-06  42  78  34  54  40
2014-01-07  80   5  76  12  90
2014-01-08  60  90  84  55  78
2014-01-09  33  11  66  90   8
2014-01-10  40   8  35  36  98

# …

我想调整条形图中的错误栏属性.显然,这是通过使用关键字参数(即在error_kw中)来完成的.例如

from pylab import *

fig = figure()
ax  = fig.add_subplot(111)

ax.plot( left=0, width=1, height=5, error_kw=dict(elinewidth=3, ecolor='b') )

但是,我找不到可能的error_kw值的列表.
我提前为提出这样一个微不足道的问题而道歉,但我无法在任何地方找到它,这让我感到疯狂.

我想创建一个过去二十年从四个不同站点收集的数据的箱线图（即每个站点将有 20 年的数据）。这将在图中生成 80 个框。为了使图形清晰易读，我希望每个框都有偏移，并且每个站点都有不同的颜色框。这将产生一系列重复的框（例如，用于 site1、site2、site3、site3、site1、site2、site3...的框）。创建箱线图不是问题；抵消盒子似乎是一个问题。例如

import numpy as np
import pandas as pd
from pylab import *

first  = pd.DataFrame(np.random.rand(10,5),columns=np.arange(0,5))
second = pd.DataFrame(np.random.rand(10,5),columns=np.arange(5,10))

fig = figure( figsize=(9,6.5) )
ax  = fig.add_subplot(111)

box1 = first.boxplot(ax=ax,notch=False,widths=0.20,sym='',rot=-45)
setp(box1['caps'],color='r',linewidth=2)
setp(box1['boxes'],color='r',linewidth=2)
setp(box1['medians'],color='r',linewidth=2)
setp(box1['whiskers'],color='r',linewidth=2,linestyle='-')

box2 = second.boxplot(ax=ax,notch=False,widths=0.20,sym='',rot=-45)
setp(box2['caps'],color='k',linewidth=2)
setp(box2['boxes'],color='k',linewidth=2)
setp(box2['medians'],color='k',linewidth=2)
setp(box2['whiskers'],color='k',linewidth=2,linestyle='-')

最初我希望 Pandas 会按列名索引 x 轴，但 Pandas 似乎是根据列位置索引 x 轴，这令人沮丧。任何人都可以推荐一种抵消盒子的方法，这样它们就不会相互重叠吗？

我想打开一个SQL 2005数据库(文件扩展名为.mdf),我一直在尝试这样做:

import pandas as pd
import pyodbc

server = 'server_name'
db = 'database_name'

conn = pyodbc.connect('DRIVER={SQL Server};SERVER=' + server + ';DATABASE=' + db + ';Trusted_Connection=yes')

sql = """

SELECT * FROM table_name

"""
df = pd.read_sql(sql, conn)

有没有办法查询数据库并使用Pandas或pyodbc列出所有表？我几乎没有数据库经验,所以任何帮助都会很棒.

我有一个要求,我有三个输入文件,需要在两个文件合并到一个数据框之前加载它们在Pandas数据框内.

文件扩展名总是更改,可能是.txt一次,而.xlsx或.csv则是另一次.

如何平行运行此过程以节省等待/加载时间？

这是我目前的代码,

from time import time # to measure the time taken to run the code
start_time = time()

Primary_File = "//ServerA/Testing Folder File Open/Report.xlsx"
Secondary_File_1 = "//ServerA/Testing Folder File Open/Report2.csv"
Secondary_File_2 = "//ServerA/Testing Folder File Open/Report2.csv"

import pandas as pd # to work with the data frames
Primary_df = pd.read_excel (Primary_File)
Secondary_1_df = pd.read_csv (Secondary_File_1)
Secondary_2_df = pd.read_csv (Secondary_File_2)

Secondary_df = Secondary_1_df.merge(Secondary_2_df, how='inner', on=['ID'])
end_time = time()

print(end_time - start_time)

加载我的primary_df和secondary_df需要大约20分钟.所以,我正在寻找一种有效的解决方案,可能使用并行处理来节省时间.我通过阅读操作计时,大部分时间大约需要18分45秒.

硬件配置: - Intel i5处理器,16 GB Ram和64位OS …

我正在使用 pyTorch 在我的 GPU（RTX 3000、CUDA 11.1）上运行计算。一个步骤涉及计算一个点和一组点之间的距离。对于踢球，我测试了 2 个函数来确定哪个更快，如下所示：

import datetime as dt
import functools
import timeit
import torch
import numpy as np

device = torch.device("cuda:0")

# define functions for calculating distance
def dist_geom(a, b):
    dist = (a - b)**2
    dist = dist.sum(axis=1)**0.5

    return dist

def dist_linalg(a, b):
    dist = torch.linalg.norm(a - b, axis=1)

    return dist

   
# create dummy data
a = np.random.randint(0, 100000, (100000, 10, 10)).astype(np.float64)
b = np.random.randint(0, 100000, (1, 10)).astype(np.float64)

# send data to GPU
a = torch.from_numpy(a).to(device) …