小编Bra*_*mon的帖子

如何使用group by绘制带有pandas DataFrame.hist()的直方图？我有一个包含5列的数据框:"A","B","C","D"和"Group"

有两个组类:"是"和"否"

使用:

df.hist() 

我得到了4列中每一列的直方图.

现在我想得到相同的4个图,但有蓝色条(group ="yes")和红色条(group ="no").

我试过这个没有成功:

df.hist(by = "group")

索引MultiIndex-ed DataFrame时,似乎.iloc假设您在.loc查看外层时引用索引的"内部级别" .

例如:

np.random.seed(123)
iterables = [['bar', 'baz', 'foo', 'qux'], ['one', 'two']]
idx = pd.MultiIndex.from_product(iterables, names=['first', 'second'])
df = pd.DataFrame(np.random.randn(8, 4), index=idx)

# .loc looks at the outer index:

print(df.loc['qux'])
# df.loc['two'] would throw KeyError
              0        1        2        3
second                                    
one    -1.25388 -0.63775  0.90711 -1.42868
two    -0.14007 -0.86175 -0.25562 -2.79859

# while .iloc looks at the inner index:

print(df.iloc[-1])
0   -0.14007
1   -0.86175
2   -0.25562
3   -2.79859
Name: (qux, two), dtype: float64

两个问题:

首先,这是为什么？这是一个刻意的设计决定吗？

其次,我可以 …

熊猫的内部问题:我一直惊讶地发现了几次,明确传递调用到date_parser内pandas.read_csv导致多慢读取时间比单纯使用infer_datetime_format=True.

为什么是这样？这两个选项之间的时间差异是特定于日期格式的,还是其他因素会影响它们的相对时间？

在下面的例子中,infer_datetime_format=True传递具有指定格式的日期解析器的时间的十分之一.我天真地认为后者会更快,因为它是明确的.

文档注意到,

[如果为True,] pandas将尝试推断列中日期时间字符串的格式,如果可以推断,请切换到更快的解析方法.在某些情况下,这可以将解析速度提高5-10倍.

但是没有给出太多细节,我无法完全通过源头工作.

建立:

from io import StringIO

import numpy as np
import pandas as pd

np.random.seed(444)
dates = pd.date_range('1980', '2018')
df = pd.DataFrame(np.random.randint(0, 100, (len(dates), 2)),
                  index=dates).add_prefix('col').reset_index()

# Something reproducible to be read back in
buf = StringIO()
df.to_string(buf=buf, index=False)

def read_test(**kwargs):
    # Not ideal for .seek() to eat up runtime, but alleviate
    # this with more loops than needed in timing below
    buf.seek(0)
    return …

结果会numpy.lib.stride_tricks.as_strided取决于NumPy数组的dtype吗？

这个问题来自于定义.strides,即

遍历数组时每个维度中的字节元组.

在这里使用我在其他问题中使用的以下功能.它需要1d或2d数组并创建长度重叠的窗口window.结果将比输入大一维.

def rwindows(a, window):
    if a.ndim == 1:
        a = a.reshape(-1, 1)
    shape = a.shape[0] - window + 1, window, a.shape[-1]
    strides = (a.strides[0],) + a.strides
    windows = np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)
    return np.squeeze(windows)

# examples
# rwindows(np.arange(5), window=2)
# rwindows(np.arange(20).reshape((5,4)), window=2)

由于进步的定义,因为,例如,的D类的其他等效的阵列float32,并float64会有不同的步伐,将这个不断炸掉我的rwindows功能上面？

我试过测试,但它一直是一种非详尽的方式,我正在寻找一个答案,(1)解释功能文档中的免责声明/警告是否与我在这里要求的内容有关,(2)解释为什么或为什么不具有不同的dtypes和strides的等效数组在上面会产生不同的结果.

我们正在从Django 1.8 - > 2.1和Python 2.7 - > 3.6过渡Django项目.

在旧项目版本中,有一些看起来像这样的Django模型,例如:

# models.py

from django.db import models

class RowStatusModel(models.Model):
    active = models.BooleanField(default=True, db_column='is_active')
    # ...
    class Meta:
        abstract = True

请注意,from __future__ import unicode_literals是不是这个模块中使用.这意味着它db_column是Python 2 str,与bytesPython 3 相对应.初始迁移0001_initial.py如下所示:

# 0001_initial.py

operations = [
    # ...
    ('row_ef', models.BooleanField(default=True, db_column=b'is_active')
    # ...
]

请注意字节文字b'is_active,我想这是由Django完成的,为了更明确,但我不确定.

现在,在将大部分代码库转换为2to3并运行之后makemigrations,Python 3将字符串文字视为Python 2中的unicode类型,并因此db_column为每个继承自的模型生成一个字符串文字的迁移RowStatusModel:

# migrations/0023_auto_20180827_1955.py 
migrations.AlterField(
    # ...
    field=models.BooleanField(default=True, db_column='is_active')
), # …

我正在使用yarl图书馆的URL对象。

它有一个准私有属性 ，._val它是一个urllib.parse.SplitResult对象，但在 中没有类型注释yarl/__init__.pyi。（如果开发人员不想正式将其纳入公共 API，这是可以理解的。）

但是，我选择使用URL._val，风险自负。一个虚拟示例：

# urltest.py
from urllib.parse import SplitResult
from typing import Tuple

from yarl import URL


def foo(u: URL) -> Tuple[str, str, str]:
    sr: SplitResult = u._val
    return sr[:3]

但mypy不喜欢这个，因为它抱怨：

$ mypy urltest.py
"URL" has no attribute "_val"

那么，在我自己的项目中，我如何“附加”（或扩展）实例属性注释，以便URL它可以在我的项目的其余部分中使用？IE

from yarl import URL

URL._val: SplitResult
# ...

（mypy 也不喜欢这样；“不能在对非 self 属性的赋值中声明类型。”）

更新

我尝试在以下位置创建一个新的存根文件stubs/yarl/__init__.pyi：

from urllib.parse import SplitResult

class …

我正在编写我的第一个Python模块,我想知道物流:具体来说,人们如何处理设置/构建.

它是标准的做法,所有的开始了distutils在地方的东西,并在virtualenv运行setup.py的每次修改和测试等？

人们更经常创建一个工作代码,然后担心将其转换为可分发的包吗？

非常具体的示例问题:我的代码需要访问数据文件.我应该只是在文件地址中硬编码,DATA_FILE_PATH = "./data/DATA.npz"或者我应该从一开始就弄清楚如何使用所有这些MANIFEST.in/ setup(..., package_data={ ... }, ...)东西？

编辑:@LukasGraf的这个惊人的答案提供了一些很棒的工作流程信息,很大程度上回答了我的问题.请给他一些赞成票!

我刚开始学习大熊猫的基础知识,有一件事让我思考.

import pandas as pd
data = pd.DataFrame({'Column1': ['A', 'B', 'C']})
data['Column2'] = map(str.lower, data['Column1'])
print(data)

该程序的输出是:

   Column1                             Column2
 0       A  <map object at 0x00000205D80BCF98>
 1       B  <map object at 0x00000205D80BCF98>
 2       C  <map object at 0x00000205D80BCF98>

获得所需输出的一种可能解决方案是将地图对象类型转换为列表.

import pandas as pd
data = pd.DataFrame({'Column1': ['A', 'B', 'C']})
data['Column2'] = list(map(str.lower, data['Column1']))
print(data)

输出:

   Column1 Column2
 0       A       a
 1       B       b
 2       C       c

但是,如果我使用range(),它也在Python 3中返回自己的类型,则无需将对象类型转换为列表.

import pandas as pd
data = pd.DataFrame({'Column1': ['A', 'B', 'C']})
data['Column2'] = range(3) …

我正在阅读Raymond Hettinger的Python超级()被认为超级! 关于页面,有这个例子:

class Shape:
    def __init__(self, shapename, **kwds):
        self.shapename = shapename
        super().__init__(**kwds)        

class ColoredShape(Shape):
    def __init__(self, color, **kwds):
        self.color = color
        super().__init__(**kwds)

cs = ColoredShape(color='red', shapename='circle')

为什么有必要super()在Shape这里打电话？我的理解是这个调用object.__init__(**kwds)自从Shape隐式继承object.

即使没有这种说法,我们已经有了

• shapename在父母的已经建立__init__,
• color在显式方法覆盖中建立子类,
• 然后__init__使用super()in 调用父项ColoredShape.

据我所知,删除此行会产生相同的行为和功能:

class Shape:  # (object)
    def __init__(self, shapename, **kwds):
        self.shapename = shapename
        # super().__init__(**kwds)

class ColoredShape(Shape):
    def __init__(self, color, **kwds):
        self.color = color
        super().__init__(**kwds)
    def check(self): …

Pandas有一个广泛使用的groupby工具,可以根据相应的映射分割DataFrame,从中可以对每个子组应用计算并重新组合结果.

这可以在没有原生Python for循环的NumPy中灵活地完成吗？使用Python循环,这看起来像:

>>> import numpy as np

>>> X = np.arange(10).reshape(5, 2)
>>> groups = np.array([0, 0, 0, 1, 1])

# Split up elements (rows) of `X` based on their element wise group
>>> np.array([X[groups==i].sum() for i in np.unique(groups)])
array([15, 30])

15以上是前三行X的总和,30是剩下的两行的总和.

通过"灵活地",我只是意味着我们不关注一个特定的计算,如总和,计数,最大值等,而是将任何计算传递给分组数组.

如果没有,是否有比上述更快的方法？