小编cs9*_*s95的帖子

出于编程目的,我希望.iloc始终返回数据帧,即使结果数据帧只有一行.怎么做到这一点？

目前,.iloc当结果只有一行时返回一个Series.例:

In [1]: df = pd.DataFrame({'a':[1,2], 'b':[3,4]})

In [2]: df
Out[2]:
   a  b
0  1  3
1  2  4

In [3]: type(df.iloc[0, :])
Out[3]: pandas.core.series.Series

由于两个原因,此行为很差:

• 根据所选行的数量,.iloc可以返回一个系列或一个数据框,迫使我在我的代码中手动检查这一点

- .loc另一方面,总是返回一个数据框,使其pandas内部不一致(错误的信息,如评论中所指出的)

对于R用户,可以使用drop = FALSE或使用tidyverse的tibble 来完成,tidyverse的tibble默认情况下始终返回数据帧.

考虑以下简单设置：

x = pd.Series([1, 2, 3], index=list('abc'))
y = pd.Series([2, 3, 3], index=list('bca'))

x

a    1
b    2
c    3
dtype: int64

y

b    2
c    3
a    3
dtype: int64

如您所见，索引是相同的，只是顺序不同。

现在，考虑使用equals（==）运算符进行简单的逻辑比较：

x == y
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)

抛出ValueError，很可能是因为索引不匹配。另一方面，调用等效eq运算符可以：

x.eq(y)

a    False
b     True
c     True
dtype: bool

OTOH，给定的运算符方法y首先被重新排序...

x == y.reindex_like(x)

a    False
b     True
c     True
dtype: bool

我的理解是，函数和运算符的比较应该做相同的事情，而其他所有事情都是相等的。什么是eq这样做的运营商比较不？

假设我的选择大致如下:

select instrument, price, date from my_prices;

如何将返回的价格打包到单个数据框中,并为每个工具添加一个系列并在日期编制索引？

要明确:我在寻找:

<class 'pandas.core.frame.DataFrame'>
DatetimeIndex: ...
Data columns (total 2 columns):
inst_1    ...
inst_2    ...
dtypes: float64(1), object(1) 

我不是在寻找:

<class 'pandas.core.frame.DataFrame'>
DatetimeIndex: ...
Data columns (total 2 columns):
instrument    ...
price         ...
dtypes: float64(1), object(1)

......这很容易;-)

我正在寻找一种简单的方法来按特定列的绝对值对pandas数据帧进行排序,但不会实际更改数据帧中的值.类似的东西sorted(df, key=abs).所以,如果我有一个数据帧,如:

    a   b
0   1   -3
1   2   5 
2   3   -1
3   4   2
4   5   -9

在"b"上排序时得到的排序数据如下所示:

    a   b
2   3   -1
3   4   2
0   1   -3
1   2   5 
4   5   -9

我偶然发现了大熊猫,它看起来很适合我想做的简单计算.我有一个SAS背景,并且认为它取代了proc freq - 看起来它将扩展到我将来可能要做的事情.不过,我只是似乎无法让我的头围绕一个简单的任务(我不知道如果我应该来看看pivot/crosstab/indexing-我是否应该有一个Panel或DataFrames等...).有人可以给我一些关于如何做以下事项的指示:

我有两个CSV文件(一个用于2010年,一个用于2011年 - 简单的事务数据) - 列是类别和金额

2010:

AB,100.00
AB,200.00
AC,150.00
AD,500.00

2011:

AB,500.00
AC,250.00
AX,900.00

它们被加载到单独的DataFrame对象中.

我想做的是获取类别,类别的总和以及类别的频率,例如:

2010:

AB,300.00,2
AC,150.00,1
AD,500.00,1

2011:

AB,500.00,1
AC,250.00,1
AX,900.00,1

我无法弄清楚我是否应该使用pivot/crosstab/groupby/an index 等...我可以得到总和或频率 - 我似乎无法得到两者......它变得有点复杂,因为我想这样做一个月一个月,但我想如果有人会如此友好地指出我正确的技术/方向,我将能够从那里去.

我目前正在编写一个项目,该项目需要使用返回其自身迭代器的方法的第三方代码,这是我的代码中的示例:

def generate():
    for x in obj.children():
        for y in x.children():
            for z in y.children():
                yield z.thing

目前,这简直使我的代码变得混乱,并且在3个级别之后变得难以阅读.理想情况下,我会让它做这样的事情:

x = recursive(obj, method="children", repeat=3).thing

是否有内置的方法在Python中执行此操作？

这个问题已被问过很多次了,它似乎对其他人NaN有用,但是,当我从不同的DataFrame中复制一个列时,我得到了值(df1并且df2长度相同).

df1

        date     hour      var1
a   2017-05-01  00:00:00   456585
b   2017-05-01  01:00:00   899875
c   2017-05-01  02:00:00   569566
d   2017-05-01  03:00:00   458756
e   2017-05-01  04:00:00   231458
f   2017-05-01  05:00:00   986545

df2

      MyVar1     MyVar2 
 0  6169.719338 3688.045368
 1  5861.148007 3152.238704
 2  5797.053347 2700.469871
 3  5779.102340 2730.471948
 4  6708.219647 3181.298291
 5  8550.380343 3793.580394

我需要这样的 df2

       MyVar1    MyVar2        date        hour
 0  6169.719338 3688.045368  2017-05-01  00:00:00
 1  5861.148007 3152.238704  2017-05-01  01:00:00
 2  5797.053347 2700.469871  2017-05-01  02:00:00
 3 …

我有两个清单:
[a, b, c] [d, e, f]
我想:
[a, d, b, e, c, f]

在Python中执行此操作的简单方法是什么？

我正在对2D列表和numpy数组进行一些实验.由此,我提出了3个问题,我很想知道答案.

首先,我初始化了一个2D python列表.

>>> my_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

然后我尝试使用元组索引列表.

>>> my_list[:,]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: list indices must be integers, not tuple

由于解释器抛出一个TypeError而不是一个SyntaxError,我猜测它实际上可以这样做,但是python本身并不支持它.

然后我尝试将列表转换为numpy数组并执行相同的操作.

>>> np.array(my_list)[:,]
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

当然没问题.我的理解是,其中一个__xx__()方法已被覆盖并在numpy包中实现.

Numpy的索引也支持列表:

>>> np.array(my_list)[:,[0, 1]]
array([[1, 2],
       [4, 5],
       [7, 8]])

这提出了几个问题:

1. 哪个__xx__方法有numpy覆盖/定义来处理花哨的索引？
2. 为什么python列表本身不支持花式索引？

(额外的问题:为什么我的时间显示python2中的切片比python3慢？)

我有一个(长)列表,其中0和1随机出现:

list_a = [1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1]

我想得到list_b

• 列表的总和直到0出现的位置

• 如果出现0,则在列表中保留0

  list_b = [1, 2, 3, 0, 1, 2, 0, 1, 0, 1, 2, 3]
  

  Run Code Online (Sandbox Code Playgroud)

我可以按如下方式实现:

list_b = []
for i, x in enumerate(list_a):
    if x == 0:
        list_b.append(x)
    else:
        sum_value = 0
        for j in list_a[i::-1]:
            if j != 0:
                sum_value += j
            else:
                break
        list_b.append(sum_value)
print(list_b)

但实际列表的长度很长.

所以,我想改进高速代码.(如果不可读)

我改变了这样的代码:

from itertools import takewhile
list_c = [sum(takewhile(lambda x: x != 0, list_a[i::-1])) …