jpp

你可以 mask 您的系列:

ids = [2, 4, 5, 6, 8]
df['Final'] = df['Final'].mask(df['id'].isin(ids), 0)

你可以使用 nrows 论证 pd.read_csv 要分别读取列标签:

# read in column labels as list
cols = pd.read_csv('file.csv', nrows=0).columns.tolist()

# read in data; use default pd.RangeIndex, i.e. 0, 1, 2, etc., as columns
data = pd.read_csv('file.csv', header=None, skiprows=[0])

如果需要指定编码,可以通过 encoding 论证,例如。 encoding='latin-1' .

fillna + groupby + transform + mean

这似乎很直观:

df['value'] = df['value'].fillna(df.groupby('name')['value'].transform('mean'))

这个 子句 + 转型 语法将GroupWise平均值映射到原始数据帧的索引。这大致相当于 @DSM's solution ,但不需要定义匿名 lambda 功能。

你可以使用 collections.defaultdict ,迭代和更新由bucket边界确定的键。这比创建可变数量的变量更好。

d = {(0, 2): 1, (0, 4): 2, (0, 10): 3, (0, 3): 4,
     (0, 11): 5, (0, 20): 6, (0, 8): 7, (0, 14): 8}

L = [0, 5, 10, 15, float('inf')]  # include infinite to facilitate later comparisons

from collections import defaultdict

dd = defaultdict(dict)

for k, v in d.items():
    for i, j in zip(L, L[1:]):
        if i <= k[1] < j:
            dd[i].update({k: v})
            break

print(dd)

defaultdict(dict,
            {0: {(0, 2): 1, (0, 3): 4, (0, 4): 2},
             5: {(0, 8): 7},
             10: {(0, 10): 3, (0, 11): 5, (0, 14): 8},
             15: {(0, 20): 6}})

该算法可以通过使用 bisect 而不是在 L 按顺序。

第一步是删除索引上的循环,并用 np.maximum . 这样做是因为 np.where(a > 0, a, 0) 就我们的目的而言 np.maximum(0, a) .

同时,分别定义较长的表达式以使代码可读:

s1 = df['colum4'] - (df['result'].shift(1) * (df['colum1'] * df['colum3']))
s2 = df['colum4'] - (df['result'].shift(1) * df['colum1'])

df['result'] = np.where(df['colum2'] <= 5,
                        np.where(df['colum2'] == 1, df['colum4'],
                                 np.maximum(0, s1)),
                        np.maximum(0, s2))

下一步是使用 np.select 删除嵌套的 np.where 声明:

m1 = df['colum2'] <= 5
m2 = df['colum2'] == 1

conds = [m1 & m2, m1 & ~m2]
choices = [df['colum4'], np.maximum(0, s1)]

df['result'] = np.select(conds, choices, np.maximum(0, s2))

这个版本会更容易管理。

您可以使用字典理解将输入重组为字典字典。然后使用 from_dict 具有 orient='index' :

user_dict = {'Category 1': ['att_1: 1', 'att_2:  whatever'],
             'Category 2': ['att_1 : 23', 'att_2 : another']}

d = {k: dict(map(str.strip, x.split(':')) for x in v) for k, v in user_dict.items()}

df = pd.DataFrame.from_dict(d, orient='index')

df['att_1'] = pd.to_numeric(df['att_1'])

print(df)

           att_1     att_2
Category 1     1  whatever
Category 2    23   another

如上所述,您需要根据需要将序列转换为数字。

这是蛮力法。假设与您的数据一样,每个子列表中的项目都是唯一的,您可以使用 set 理解列表:

a_sets = list(map(set, a))
b_sets = list(map(set, b))

res = [sublist for idx, sublist in enumerate(a) if not \
       any(len(a_sets[idx] & b_set) > 3 for b_set in b_sets)]

[(1, 5, 20, 22, 24, 31), (1, 5, 20, 22, 24, 41)]

一 for 不需要循环。如果您喜欢使用第三方库,可以使用numpy:

import numpy as np

A = np.array(li)

res = A[np.r_[:4, 9:len(A)]]

# array([ 1,  2,  3, 10, 11, 12, 13, 14, 15, 16])

或者使用普通的python slice 物体:

from operator import itemgetter
from itertools import chain

slices = (slice(0, 4), slice(9, None))

res = list(chain.from_iterable(itemgetter(*slices)(li)))

# [1, 2, 3, 4, 10, 11, 12, 13, 14, 15, 16]

有一种方法:

df = pd.DataFrame([d])

df.to_csv('out.csv', index=False)

print(df)

   key1  key2 key3
0     1    42  foo

注意 pd.DataFrame 构造函数接受 list 字典。这里的列表恰好只有一个字典,但这已经足够了。

如果您愿意使用第三方图书馆,您可以使用熊猫:

import pandas as pd

s = pd.to_datetime(pd.Series(c))
res = s[s.between(a, b)].tolist()

print(res)

[Timestamp('2017-01-08 00:00:00'),
 Timestamp('2017-08-20 00:00:00'),
 Timestamp('2017-08-21 00:00:00'),
 Timestamp('2017-08-22 00:00:00'),
 Timestamp('2017-08-23 00:00:00'),
 Timestamp('2017-08-24 00:00:00')]

按照 @TimPeters' answer ,在O(1)时间中,有结构原因无法按位置访问字典项。

如果您正在寻找O(1)按键查找,则值得考虑其他选项。 或 位置。有第三方库,如numpy/pandas,提供此类功能、高效 尤其地 对于不需要指针的数值数组。

使用pandas,您可以构建一个“类似字典”的系列,其唯一标签提供O(1)按“标签”或位置查找。你牺牲的是删除标签时的性能,这会导致( n )成本,很像 list .

import pandas as pd

s = pd.Series(list(range(n)))

# O(n) item deletion
del s[i]
s.drop(i)
s.pop(i)

# O(1) lookup by label
s.loc[i]
s.at[i]
s.get(i)
s[i]

# O(1) lookup by position
s.iloc[i]
s.iat[i]

pd.Series dict . 例如,如果序列主要用作映射,则不会阻止重复键,并且会导致问题。但是,如果数据存储在一个连续的内存块中,如上面的示例所示,您可能会看到显著的性能改进。

参见:

1. What are the advantages of NumPy over regular Python lists? .
2. What is the performance impact of non-unique indexes in pandas?
3. Pandas DataFrame search is linear time or constant time?

你可以使用 dict.__getitem__ 或者它的句法糖 [] :

res = sorted(AccountValues, key=lambda x: (x['portfolio_ref'], -x['percent']))

请记住,字典不能通过整数进行索引。历史上(3.6之前),它们甚至没有被订购。即使在Python3.7中,也不能直接提取 n th键或值。

结果:

print(res)

[{'portfolio_ref': 1, 'tag': 'NetLiq', 'value': '70976.05', 'currency': 'USD', 'percent': 100.0},
 {'portfolio_ref': 1, 'tag': 'FullInit', 'value': '20642.95', 'currency': 'USD', 'percent': 0.0},
 {'portfolio_ref': 1, 'tag': 'FullMaint', 'value': '21350.54', 'currency': 'USD', 'percent': 0.0}]