enke

你可以 groupby.apply 一个lambda,用于检查每个“订单号”的唯一“项目id”是否同时包含“a”和“B”;然后过滤那些可以:

out = df.groupby('Order_number')['item_id'].apply(lambda x: {'A','B'}.issubset(x.unique().tolist())).pipe(lambda x: x.index[x]).tolist()

另一个选择是使用 groupby.any 两次一次用于“A”,另一次用于“B”,以创建布尔级数对象,如果 item_id Order_number ; 既然我们想要两者都存在,我们就使用 &

out = (df['item_id'].eq('A').groupby(df['Order_number']).any() & df['item_id'].eq('B').groupby(df['Order_number']).any()).pipe(lambda x: x.index[x].tolist())

输出:

[12345, 84573]

一种选择是使用 groupby 使用参数 sort=False ; 然后连接拆分的数据帧。

工作原理:

• 组 df 在破折号前按绳子
• 子句 默认情况下,按groupby键进行排序;当我们指定 sort=False ,我们确保密钥的存储顺序与第一次出现在中的顺序相同 df ,即“GUYPE”留在“SUPAU”后面。
• 子句 对象包含有关组的信息,可以像字典一样解包。然后解包并构建一个生成器表达式,返回分组的数据帧。
• 使用 concat ,将拆分的数据帧连接成一个;通过使用 ignore_index=True ,我们忽略来自拆分数据帧的索引,并重置索引。

out = pd.concat((d for _, d in df.groupby(df['SKU'].str.split('-').str[0], sort=False)), ignore_index=True)

输出:

        SKU
0     FATUT
1  FATUT-01
2  FATUT-02
3     GUYGE
4  GUYGE-01
5     SUPAU
6  SUPAU-01
7     GUYPE

但我觉得为了你的任务, sort_values 也可以工作,即使顺序与所需输出中的顺序不完全相同:

df = df.sort_values(by='SKU', ignore_index=True)

输出:

        SKU
0     FATUT
1  FATUT-01
2  FATUT-02
3     GUYGE
4  GUYGE-01
5     GUYPE
6     SUPAU
7  SUPAU-01

您可以使用 Indices 分别地第一列用于行索引,第二列用于列索引:

out = A[Indices[:, [0]], Indices[:, [1]]]

输出:

array([[2.3],
       [1.4],
       [2.5]])

你可以用 str.findall 在列上拆分为文本和数字;然后使用列表理解,只取第一个字母,并将其与每个列名称的数字连接起来:

xdf.columns = [x[0]+y for li in xdf.columns.str.findall(r'([A-Za-z]+)(\d+)') for x,y in li]

输出:

   C1  C2
0  10  80
1  20  90

因为需要按行应用函数,所以只需要 axis=1 :

from operator import add
df['C'] = df[['A','B']].apply(lambda x: list(map(add,x[0],x[1])), axis=1)

另一种选择是 explode 名单; sum ; 然后 groupby.agg 要重新获取列表,请执行以下操作:

df['C'] = df.explode(['A','B']).sum(axis=1).astype(int).groupby(level=0).agg(list)

输出:

           A          B          C
0  [1, 2, 3]  [4, 5, 6]  [5, 7, 9]
1   [10, 20]   [40, 50]   [50, 70]

你可以用 squeeze :

i = 3
out = df.loc[df['id']==i,'major'].squeeze()

另一个选择是 iat :

out = df.loc[df['id']==i,'major'].iat[0]

输出:

'Science'

我建议使用字典来存储数据帧:

files = {f"data{i}": pd.read_excel(f"{filepath}{i}.xlsx", sheet_name="Q4") for i in range(1,11)}

然后你可以访问 data1 通过 files['data1'] 等

一种选择是使用 numpy.ravel_multi_index 获取 Remove 在展平数组中,然后使用 numpy.delete :

out = np.delete(R, np.ravel_multi_index(tuple(zip(*Remove)), R.shape))

另一种可能是替换中的值 去除 ,然后变平 R 过滤掉这些元素:

R[tuple(zip(*Remove))] = R.max() + 1
arr = R.ravel()
out = arr[arr<R.max()]

输出:

array([1.05567452e+11, 6.94076420e+09, 1.96129124e+10, 1.11642674e+09,
       1.88618492e+10, 1.73640817e+10, 4.84980874e+09])

我认为您需要从每个子列表中连续打印第n个子列表。你可以打开行李拉上拉链 a 要获得元组的iterable,请打印其中的每一对:

for tpl in zip(*a):
    for pair in tpl:
        print(pair)
        

输出:

[0, 0]
[1, 0]
[2, 0]
[3, 0]
[4, 0]
[6, 0]

您希望迭代列表并比较 UserID 使用输入用户ID创建字典:

def find_user(val, lsts):
    for d in lsts:
        if val == d['User_ID']:
            return d
    return "user not found"

然后

print(find_user('Z000', lsts))

印刷品

{'User_ID': 'Z000',
 'DOB': '01.01.1960',
 'State': 'Oregon',
 'Bought': ['P1', 'P2']}

和

print(find_user('000', lsts))

印刷品

user not found

但是,如果您的数据如下所示:

d = { "Data": [{"User_ID":"Z000"},{"User_ID":"A999"} ]}

然后可以将字典中的列表传递给函数,如:

find_user('Z000', d['Data'])

它回来了

{'User_ID': 'Z000'}

如果“值”中的值对于每个“类别”都是唯一的(如示例中所示),我们可以:

(一) groupby “类别”并选择“值”列

(ii)找出每组的第一个和最后一个元素

(iii)创建一个布尔掩码,标识每个组的第一个和最后一个元素

(iv)戴上口罩 df['Value'] 并指定0。

gb_obj = df.groupby('Category')['Value']    
firsts = gb_obj.transform('first')
lasts = gb_obj.transform('last')
msk = (df['Value'] == firsts) | (df['Value'] == lasts)
df.loc[msk, 'Value'] = 0

如果没有,我们可以对“值”应用一个函数,将0分配给每个组中的第一个和最后一个元素:

def first_last_to_zero(g):
    g.iloc[0] = g.iloc[-1] = 0
    return g

df['Value'] = df.groupby('Category')['Value'].apply(first_last_to_zero)

输出:

   Category  Value
0    2000-1      0
1    2000-1    200
2    2000-1     20
3    2000-1      0
4    2000-2      0
5    2000-2    210
6    2000-2      0
7    3000-1      0
8    3000-1    370
9    3000-1      0
10   4000-3      0
11   4000-3     92
12   4000-3      0
13   4000-5      0
14   4000-5     77
15   4000-5      0

你的问题不清楚,但你可能在寻找:

df.groupby(['DC','Brand'])['Rate'].mean()

一种方法是使用 to_numeric 将每个值强制为数值,然后使用 dropna :

out = (df.apply(pd.to_numeric, errors='coerce')
       .apply(lambda x: pd.Series(x.dropna().tolist(), index=df.columns.drop('another_col')), axis=1))

输出:

      A       B    C  Phone Number
0  55.0   454.0  4.0  1.234568e+08
1  27.0   786.0  7.0  2.345679e+08
2  35.0   895.0  7.0  3.456789e+09
3  10.0  3545.0  3.0  4.567890e+09
4  34.0   896.0  1.0  2.154786e+08

一个选项是创建一个要获取的键列表,然后在该列表上迭代以查找值和 join 他们:

keys = ['title', 'streetAddress', 'addressLocality', 'postalCode']
out = [', '.join(d[k] for k in keys) for d in data]

另一个可能比上面更快的选项是映射 operator.itemgetter 要获取值,请映射 参加 :

from operator import itemgetter
out = [*map(', '.join, map(itemgetter(*keys), data))]

输出:

['5280 Cafe At Rallysport, 2727 29th St., Boulder, 80301',
 'Ali Baba Grill Boulder, 3054 28th St, Boulder, 80304']

IIUC,你想数一数前导0的数量,对吗?利用这样一个事实:当整数为 type str 转换为 type int .这里有一个解决方案:

df['leading 0s'] = df['Sequence'].str.len() - df['Sequence'].astype(int).astype(str).str.len()

输出:

    Sequence  leading 0s
0  012312312           1
1  024624624           1
2  036901357           1
3  002486248           2
4  045074305           1
5  080666140           1

您可以迭代这些值并使用 list.sort 要将其排序到位:

for v in graph.values():
    v.sort(key=lambda x:x[1])
print(graph)

如果你想要一本新字典,你可以用 sorted 在听写理解中:

out = {k: sorted(v, key=lambda x:x[1]) for k,v in graph.items()}

输出:

{'A': [('C', 7), ('B', 9)],
 'B': [('E', 1), ('A', 5), ('D', 8)],
 'E': [('B', 1), ('D', 2)],
 'D': [('E', 2), ('C', 2), ('I', 5), ('F', 7), ('B', 8)],
 'F': [('D', 7)],
 'I': [('D', 5), ('G', 14)],
 'G': [('C', 13), ('I', 14)],
 'C': [('D', 2), ('A', 7), ('G', 13)]}

IIUC,数据帧构造器应该完成以下工作:

out = pd.DataFrame(df)

输出:

    id                player_name games  time goals                  xG  \
0  755                Jamie Vardy    35  3034    23  18.903537318110466   
1  318  Pierre-Emerick Aubameyang    36  3143    22  16.352623080834746   

  assists                  xA shots key_passes yellow_cards red_cards  \
0       5  6.3682975601404905    89         32            3         0   
1       3   4.492486916482449    93         26            3         1   

  position team_title npg                npxG             xGChain  \
0      F S  Leicester  19  15.097693115472794   21.02660731226206   
1    F M S    Arsenal  20  14.830358987674117  19.964282035827637   

            xGBuildup  
0  1.7243406660854816  
1   5.339657470583916  

这将创建一个形状为(2,18)的数据框。

如果您想将dict键改为索引,一个选项是转换 df 听写并传给 DataFrame.from_dict :

out = pd.DataFrame(dict(enumerate(df)))

这将生成一个形状为(18,2)的数据帧。

一种方法是使用 dict.setdefault 并在列表上重复:

out = {}
for k, lst in turns.items():
    for v in lst:
        out.setdefault(v, []).append(k)

如果你想让字典按键排序,你可以使用 sorted :

out = {k: out[k] for k in sorted(out)}

输出:

{1: ['Thursday_2022_03_17'],
 2: ['Monday_2022_03_14', 'Wednesday_2022_03_16', 'Friday_2022_03_18'],
 3: ['Tuesday_2022_03_15', 'Wednesday_2022_03_16'],
 5: ['Thursday_2022_03_17', 'Friday_2022_03_18'],
 6: ['Friday_2022_03_18'],
 7: ['Monday_2022_03_14'],
 9: ['Wednesday_2022_03_16'],
 10: ['Tuesday_2022_03_15'],
 14: ['Wednesday_2022_03_16'],
 16: ['Monday_2022_03_14', 'Tuesday_2022_03_15', 'Thursday_2022_03_17'],
 17: ['Monday_2022_03_14', 'Wednesday_2022_03_16', 'Friday_2022_03_18'],
 19: ['Monday_2022_03_14', 'Wednesday_2022_03_16', 'Thursday_2022_03_17'],
 21: ['Tuesday_2022_03_15', 'Wednesday_2022_03_16'],
 22: ['Tuesday_2022_03_15'],
 23: ['Monday_2022_03_14', 'Thursday_2022_03_17'],
 25: ['Monday_2022_03_14', 'Tuesday_2022_03_15'],
 27: ['Wednesday_2022_03_16', 'Thursday_2022_03_17', 'Friday_2022_03_18'],
 28: ['Tuesday_2022_03_15'],
 29: ['Tuesday_2022_03_15', 'Thursday_2022_03_17', 'Friday_2022_03_18'],
 30: ['Tuesday_2022_03_15', 'Thursday_2022_03_17'],
 31: ['Tuesday_2022_03_15'],
 32: ['Monday_2022_03_14'],
 33: ['Tuesday_2022_03_15'],
 40: ['Monday_2022_03_14', 'Wednesday_2022_03_16', 'Friday_2022_03_18'],
 41: ['Tuesday_2022_03_15', 'Friday_2022_03_18'],
 42: ['Thursday_2022_03_17', 'Friday_2022_03_18'],
 43: ['Monday_2022_03_14', 'Tuesday_2022_03_15'],
 44: ['Wednesday_2022_03_16', 'Thursday_2022_03_17', 'Friday_2022_03_18']}

也许你可以把绳子切成薄片,而不是替换:

for i in range(len(s)):
    print(f"{s[:i]}{s[i+1:]}")

输出:

ba
aa
ab

你可以用 groupby + ngroup :

df['colC'] = df.groupby('colA').apply(lambda x: x.groupby('colB').ngroup()+1).droplevel(0)

输出:

    colA colB  colC
0      1    a     1
1      1    a     1
2      1    c     2
3      1    c     2
4      1    f     3
5      1    z     4
6      1    z     4
7      1    z     4
8      2    a     1
9      2    b     2
10     2    b     2
11     2    b     2
12     3    c     1
13     3    d     2
14     3    k     3
15     3    k     3
16     3    m     4
17     3    m     4
18     3    m     4

如果您只想打印第一个过滤器的名称,为什么要对其进行迭代,只需为其编制索引并在“名称”下打印值:

for d in r['detections']:
    print(d['filters'][0]['name'])

你可以 shift 之后 rolling.std 。此外,默认情况下自由度为1,您似乎希望它为0。

df['Stdev'] = df['Amount'].rolling(2).std(ddof=0).shift()

输出:

   Amount  Stdev
0      13    NaN
1      17    NaN
2      31    2.0
3      48    7.0

那是因为 ele 仍在下一次迭代中引用同一词典。你需要创建一个副本。一种方法是把它抛给一条格言:

for ele in oldlist:
    for age in ages.split(','):
        ele['age'] = age
        newlist.append(dict(ele))

或者更好的是,不要使用 oldlist ,只需使用 埃勒 自身进行初始化:

ele = {'name':'cheng'}

for age in ages.split(','):
    ele['age'] = age
    newlist.append(ele)

输出:

[{'name': 'cheng', 'age': '18'}, {'name': 'cheng', 'age': '20'}]

IIUC,这应该管用。自从每个 ticker 是一个文件名,您可以打开并读取每个文件,然后将每行映射到一个浮点并分配给 results 在钥匙下面 f"{ticker}_prices" :

results = {}
for ticker in tickers:
    with open(f"/user/code/{ticker}.txt") as file:
        lines = file.readlines()
        results[f"{ticker}_prices"] = list(map(float, lines))

使用 loc 要指定单行值,请执行以下操作:

report.loc[len(report)] = {"period":period,
                           "symbol":symbol,
                           "start_date":start_date,
                           "start_price":start_price,
                           "start_market_cap":start_market_cap,
                           "end_date":end_date,
                           "end_price":end_price,
                           "end_market_cap":end_market_cap,
                           "return":return_
                          }

你可以用 "Side" 列作为 numpy.where :

df['price_diff'] = np.where(df['Side'].astype(bool), df['ref_price']*df['price']*-1, df['ref_price']*df['price'])

或者在这种特定情况下,使用“Side”列值作为 -1 :

df['price_diff'] = df['ref_price']*df['price']*(-1)**df['Side']

输出:

   Side  ref_price  price  price_diff
0     0        100    110       11000
1     1        110    100      -11000

我假设“a”、“b”是这里的列名。

按列在数据集中的位置创建组,然后 set_index 用它。然后过滤出列名 stack 数据帧。然后我们将有一个多索引系列,其中外部索引级别是组,内部级别是列名。然后 groupby + agg(list) + DataFrame + transpose 将为我们获取所需的数据帧。

cols = df.columns.tolist()
s = df.stack().groupby(level=[0,1]).agg(list)
out = pd.DataFrame(s.tolist(), index=s.index.get_level_values(1)).fillna('').T

输出:

   symbol    weight     lqdty        date  symbol   weight     lqdty        date  symbol    weight     lqdty        date  symbol   weight     lqdty        date  
0  1712.0  0.007871  7.023737  20210104.0  1726.0  0.00765  3.221021  20210104.0  1824.0  0.032955  3.475508  20210104.0  1887.0  0.00784  6.678486  20210105.0  
1  1871.0  0.006443  4.615002  20210105.0  1887.0  0.00784  6.678486  20210105.0  1871.0  0.006443  4.615002  20210105.0                    
2  1871.0  0.006443  4.615002  20210106.0  1887.0  0.00784  6.678486  20210106.0                                                            

你可以分配它,然后 explode :

df['Volatility expected'] = volatility_list
df = df.explode('Volatility expected')

输出:

   Index   Time Currency       Volatility expected                                 Event Actual Forecast Previous  
0      0  02:00      GBP   Low Volatility Expected  U.K. Construction Output (YoY) (Jan)   9.9%     9.2%     7.4%  
1      1  02:00      GBP   Low Volatility Expected       Construction Output (MoM) (Jan)   1.1%     0.5%     2.0%  
2      2  02:00      GBP  High Volatility Expected                             GDP (MoM)   0.8%     0.2%    -0.2%  
3      3  02:00      GBP  High Volatility Expected                             GDP (YoY)  10.0%     9.3%     6.0%  

你可以使用一个循环:

for d in lst:
    for v in d.values():
        for i, num in enumerate(v):
            v[i] = int(float(num))

print(lst)

输出:

[{'point1': [20, 15, 20],
  'point2': [0, 34, 8],
  'point3': [12, 15, 2],
  'point4': [15, 5, 16]}]