小编jpp*_*jpp的帖子

我有一个包含重复项目的列表,我想要一个具有频率的唯一项目列表.

例如,我有['a', 'a', 'b', 'b', 'b'],我想要[('a', 2), ('b', 3)].

寻找一种简单的方法来做到这一点,而不需要循环两次.

在我的Android应用程序中.我需要显示明天的日期,例如今天是3月5日,所以我需要显示为3月6日.我知道获取今天的日期,月份和年份的代码.

日期计算

    GregorianCalendar gc = new GregorianCalendar();
    yearat = gc.get(Calendar.YEAR);
    yearstr = Integer.toString(yearat);
    monthat = gc.get(Calendar.MONTH) + 1;
    monthstr = Integer.toString(monthat);
    dayat = gc.get(Calendar.DAY_OF_MONTH);
    daystr = Integer.toString(dayat);

如果我有代码

dayat = gc.get(Calendar.DAY_OF_MONTH) + 1;

它会显示明天的日期.或者只是在今天的日期添加一个？例如,如果今天是1月31日.使用上面的代码,它会显示为1还是32？如果显示32,我需要做出哪些改变？

我需要过滤pandas数据框中的行,以便特定的字符串列包含至少一个提供的子字符串列表.子字符串可能包含异常/正则表达式字符.比较不应涉及正则表达式,并且不区分大小写.

例如:

lst = ['kdSj;af-!?', 'aBC+dsfa?\-', 'sdKaJg|dksaf-*']

我目前正在应用这样的面具:

mask = np.logical_or.reduce([df[col].str.contains(i, regex=False, case=False) for i in lst])
df = df[mask]

我的数据帧很大(约1十亿行),lst长度为100.是否有更有效的方法？例如,如果lst找到第一个项目,我们不应该测试该行的任何后续字符串.

有很多问题(1,2,3)处理的计数值单一系列.

但是,关于计算两个或更多系列组合的最佳方法的问题较少.解决方案呈现(1,2),但是,当和为什么要使用的每个没有讨论.

以下是三种潜在方法的基准测试.我有两个具体问题:

1. 为什么grouper效率更高count？我预计count它会更高效,因为它在C中实现.grouper即使列数从2增加到4 ,优越的性能仍然存在.
2. 为什么这么多value_counter表现不佳grouper？这是由于从列表构建列表或系列的成本吗？

我理解输出是不同的,这也应该告知选择.例如,使用连续numpy数组与字典理解相比,按计数过滤更有效:

x, z = grouper(df), count(df)
%timeit x[x.values > 10]                        # 749µs
%timeit {k: v for k, v in z.items() if v > 10}  # 9.37ms

然而,我的问题的重点是在一系列与字典中建立可比较结果的表现.我的C知识是有限的,但我会感谢任何可以指出这些方法的基础逻辑的答案.

基准代码

import pandas as pd
import numpy as np
from collections import Counter

np.random.seed(0)

m, n = …

我有一个MEMS IMU,我一直在收集数据,我正在使用pandas从中获取一些统计数据.每个循环收集6个32位浮点数.对于给定的集合运行,数据速率是固定的.数据速率在100Hz和1000Hz之间变化,收集时间长达72小时.数据保存在平面二进制文件中.我这样读了数据:

import numpy as np
import pandas as pd
dataType=np.dtype([('a','<f4'),('b','<f4'),('c','<f4'),('d','<f4'),('e','<f4'),('e','<f4')])
df=pd.DataFrame(np.fromfile('FILENAME',dataType))
df['c'].mean()
-9.880581855773926
x=df['c'].values
x.mean()
-9.8332081

-9.833是正确的结果.我可以创建一个类似的结果,有人应该能够这样重复:

import numpy as np
import pandas as pd
x=np.random.normal(-9.8,.05,size=900000)
df=pd.DataFrame(x,dtype='float32',columns=['x'])
df['x'].mean()
-9.859579086303711
x.mean()
-9.8000648778888628

我在Linux和Windows上,在AMD和Intel处理器上,在Python 2.7和3.5中重复了这一点.我很难过.我究竟做错了什么？得到这个:

x=np.random.normal(-9.,.005,size=900000)
df=pd.DataFrame(x,dtype='float32',columns=['x'])
df['x'].mean()
-8.999998092651367
x.mean()
-9.0000075889406528

我可以接受这种差异.它处于32位浮点数精度的极限.

没关系.我星期五写了这个,解决方案今天早上给了我.这是由大量数据加剧的浮点精度问题.我需要在创建数据帧时将数据转换为64位浮点数:

df=pd.DataFrame(np.fromfile('FILENAME',dataType),dtype='float64')

如果其他人遇到类似问题,我会留下帖子.

我想知道是否有更有效的方法在Pandas中使用str.contains()函数,一次搜索两个部分字符串.我想在数据框中搜索包含"nt"或"nv"的数据的给定列.现在,我的代码看起来像这样:

    df[df['Behavior'].str.contains("nt", na=False)]
    df[df['Behavior'].str.contains("nv", na=False)]

然后我将一个结果追加到另一个.我想做的是使用一行代码来搜索包含"nt"或"nv"或"nf"的任何数据.我已经玩了一些我认为应该工作的方法,包括在术语之间插入管道,但所有这些都会导致错误.我已经检查了文档,但我不认为这是一个选项.我得到这样的错误:

    ---------------------------------------------------------------------------
    TypeError                                 Traceback (most recent call last)
    <ipython-input-113-1d11e906812c> in <module>()
    3 
    4 
    ----> 5 soctol = f_recs[f_recs['Behavior'].str.contains("nt"|"nv", na=False)]
    6 soctol

    TypeError: unsupported operand type(s) for |: 'str' and 'str'

有没有快速的方法来做到这一点？感谢您的帮助,我是初学者,但我喜欢数据争夺的熊猫.

在有条件地更新系列中的值时,我经常使用Pandas mask和where方法来获得更清晰的逻辑.但是,对于性能相对较高的代码,我注意到相对于性能的显着下降numpy.where.

虽然我很乐意接受特定情况,但我很想知道:

1. 除了// 参数外, Pandas mask/ where方法是否提供任何其他功能？我理解这3个参数但很少使用它们.例如,我不知道参数引用了什么. inplaceerrorstry-castlevel
2. 是否有任何不平凡的反例,其中mask/ where优于numpy.where？如果存在这样的例子,它可能会影响我选择适当方法的方式.

作为参考,这里有一些关于Pandas 0.19.2/Python 3.6.0的基准测试:

np.random.seed(0)

n = 10000000
df = pd.DataFrame(np.random.random(n))

assert (df[0].mask(df[0] > 0.5, 1).values == np.where(df[0] > 0.5, 1, df[0])).all()

%timeit df[0].mask(df[0] > 0.5, 1)       # 145 ms per loop
%timeit np.where(df[0] > 0.5, 1, df[0])  # 113 ms per loop

对于非标量值,性能似乎进一步分化:

%timeit df[0].mask(df[0] > 0.5, df[0]*2)       # 338 …

我对"内置"功能一词感到困惑.我认为这只意味着内置于解释器中的那些函数并记录在其中 - 2.内置函数
但似乎标准库模块中定义的函数也是内置函数(在某些情况下).例如 -

>>> import os
>>> os.chdir
<built-in function chdir>
>>> import warnings
>>> warnings.warn
<built-in function warn>
>>> import json
>>> json.dumps
<function dumps at 0x7f3643a240d0> # not built-in
>>> dir
<built-in function dir>
>>> 

那么什么时候标准库模块中的函数称为内置函数,何时不是？

我试图在逐步遍历数组的每个n元素时获取m值.例如,对于m = 2和n = 5,并给出

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

我想要检索

b = [1, 2, 6, 7]

有没有办法使用切片来做到这一点？我可以使用嵌套列表理解来做到这一点,但我想知道是否有办法只使用索引来做到这一点.作为参考,列表理解方式是:

 b = [k for j in [a[i:i+2] for i in range(0,len(a),5)] for k in j]

我理解字典是在Python 3.6+中排序的插入,作为3.6中的实现细节和3.7+中的官方.

鉴于它们是有序的,似乎很奇怪,没有方法可以通过插入顺序检索字典的^第i项.该唯一的解决方案可出现有O(ñ)的复杂性,无论是:

1. 通过O(n)进程转换为列表然后使用list.__getitem__.
2. enumerate循环中的字典项,并在达到所需索引时返回值.同样,O(n)时间复杂度.

由于从list具有O(1)复杂度的项目中获取项目,是否有办法通过字典实现相同的复杂性？无论是定期dict还是collections.OrderedDict工作.

如果不可能,是否存在阻止这种方法的结构性原因,或者这只是一个尚未考虑/实施的特征？