Cum se selectează rânduri dintr-un DataFrame pe baza valorilor coloanelor (Programare, Python, Pandas, Dataframe)

szli a intrebat.

Cum pot selecta rânduri dintr-un DataFrame pe baza valorilor din anumite coloane în Pandas?

În SQL, aș folosi:

SELECT *
FROM table
WHERE colume_name = some_value

Am încercat să mă uit în documentația Pandas, dar nu am găsit imediat răspunsul.

Comentarii

11 răspunsuri
unutbu

Pentru a selecta rândurile a căror valoare de coloană este egală cu un scalar, some_value, utilizați ==:

df.loc[df['column_name'] == some_value]

Pentru a selecta rândurile a căror valoare de coloană este într-un iterabil, some_values, utilizați isin:

df.loc[df['column_name'].isin(some_values)]

Combinați mai multe condiții cu &:

df.loc[(df['column_name'] >= A) & (df['column_name'] <= B)]

Observați parantezele. Datorită caracteristicilor Python regulile de precedență a operatorilor, & se leagă mai strâns decât <= și >=. Prin urmare, parantezele din ultimul exemplu sunt necesare. Fără paranteze

df['column_name'] >= A & df['column_name'] <= B

este analizat ca

df['column_name'] >= (A & df['column_name']) <= B

ceea ce are ca rezultat o eroare Truth value of a Series is ambiguous.


Pentru a selecta rândurile a căror valoare de coloană nu este egală cu some_value, utilizați !=:

df.loc[df['column_name'] != some_value]

isin returnează o Serie booleană, astfel încât pentru a selecta rândurile a căror valoare este nu este în some_values, negați seria booleană folosind ~:

df.loc[~df['column_name'].isin(some_values)]

De exemplu,

import pandas as pd
import numpy as np
df = pd.DataFrame({'A': 'foo bar foo bar foo bar foo foo'.split(),
                   'B': 'one one two three two two one three'.split(),
                   'C': np.arange(8), 'D': np.arange(8) * 2})
print(df)
#      A      B  C   D
# 0  foo    one  0   0
# 1  bar    one  1   2
# 2  foo    two  2   4
# 3  bar  three  3   6
# 4  foo    two  4   8
# 5  bar    two  5  10
# 6  foo    one  6  12
# 7  foo  three  7  14

print(df.loc[df['A'] == 'foo'])

rezultă

     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14

Dacă aveți mai multe valori pe care doriți să le includeți, puneți-le în alist (sau, mai general, în orice iterabil) și utilizați isin:

print(df.loc[df['B'].isin(['one','three'])])

yields

     A      B  C   D
0  foo    one  0   0
1  bar    one  1   2
3  bar  three  3   6
6  foo    one  6  12
7  foo  three  7  14

Rețineți, totuși, că dacă doriți să faceți acest lucru de mai multe ori, este mai eficient să faceți mai întâi un index și apoi să folosiți df.loc:

df = df.set_index(['B'])
print(df.loc['one'])

yields

       A  C   D
B              
one  foo  0   0
one  bar  1   2
one  foo  6  12

sau, pentru a include mai multe valori din index, utilizați df.index.isin:

df.loc[df.index.isin(['one','two'])]

yields

       A  C   D
B              
one  foo  0   0
one  bar  1   2
two  foo  2   4
two  foo  4   8
two  bar  5  10
one  foo  6  12

Comentarii

    27

  • De fapt, funcționează și df[df[‘nume_coală’]==o anumită valoare]. Dar prima mea încercare, df.where(df[‘nume_colume’]==o anumită valoare) nu funcționează… nu știu sigur de ce… –  > Por szli.
  • 15

  • Atunci când utilizați df.where(condition), condiția trebuie să aibă aceeași formă ca și df. –  > Por unutbu.
  • Aceste linkuri ar putea fi foarte utile pentru mulți dintre voi: pandas.pydata.org/pandas-docs/stable/indexing.html gregreda.com/2013/10/26/working-with-pandas-dataframes –  > Por tremendows.
  • FYI: Dacă doriți să selectați un rând pe baza a două (sau mai multe) etichete (fie că le cereți pe amândouă, fie că le cereți pe amândouă), consultați stackoverflow.com/questions/31756340/… –  > Por Shane.
  • De la df[df['column_name'] == some_value] funcționează, de ce avem nevoie să adăugăm .loc aici? –  > Por qqqwww.
piRSquared

Există mai multe moduri de a selecta rânduri dintr-un cadru de date Pandas:

  1. Indexarea booleană (df[df['col'] == value] )
  2. Indexare pozițională (df.iloc[...])
  3. Indexarea etichetelor (df.xs(...))
  4. df.query(...) API

Mai jos vă prezint exemple pentru fiecare dintre acestea, cu sfaturi când să folosiți anumite tehnici. Să presupunem că criteriul nostru este coloana 'A' == 'foo'

(Notă privind performanța: Pentru fiecare tip de bază, putem păstra lucrurile simple utilizând API-ul Pandas sau ne putem aventura în afara API-ului, de obicei în NumPy, și putem accelera lucrurile).


Configurați

Primul lucru de care vom avea nevoie este să identificăm o condiție care va acționa ca și criteriu al nostru pentru selectarea rândurilor. Vom începe cu cazul PO column_name == some_value, și vom include și alte câteva cazuri de utilizare comune.

Împrumutând de la @unutbu:

import pandas as pd, numpy as np

df = pd.DataFrame({'A': 'foo bar foo bar foo bar foo foo'.split(),
                   'B': 'one one two three two two one three'.split(),
                   'C': np.arange(8), 'D': np.arange(8) * 2})

1. Indexarea booleană

… Indexarea booleană necesită găsirea adevăratei valori a fiecărui rând 'A' fiind egală cu 'foo'și apoi utilizarea acestor valori de adevăr pentru a identifica rândurile care trebuie păstrate. În mod obișnuit, am numi această serie, o matrice de valori de adevăr, mask. Vom face acest lucru și aici.

mask = df['A'] == 'foo'

Putem apoi să folosim această mască pentru a felia sau indexa cadrul de date

df[mask]

     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14

Acesta este unul dintre cele mai simple moduri de a îndeplini această sarcină și, dacă performanța sau intuitivitatea nu reprezintă o problemă, aceasta ar trebui să fie metoda aleasă. Cu toate acestea, dacă performanța este o preocupare, atunci ar fi bine să luați în considerare o modalitate alternativă de creare a mask.


2. Indexarea pozițională

Indexarea pozițională (df.iloc[...]) are cazurile sale de utilizare, dar acesta nu este unul dintre ele. Pentru a identifica locul unde să facem felierea, trebuie mai întâi să efectuăm aceeași analiză booleană pe care am făcut-o mai sus. Acest lucru ne lasă să efectuăm un pas în plus pentru a îndeplini aceeași sarcină.

mask = df['A'] == 'foo'
pos = np.flatnonzero(mask)
df.iloc[pos]

     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14

3. Indexarea etichetelor

Etichetă indexarea poate fi foarte utilă, dar în acest caz, facem din nou mai multă muncă pentru niciun beneficiu

df.set_index('A', append=True, drop=False).xs('foo', level=1)

     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14

4. df.query() API

pd.DataFrame.query este o modalitate foarte elegantă/intuitivă de a îndeplini această sarcină, dar este adesea mai lentă. Cu toate acestea,, dacă acordați atenție timpilor de mai jos, pentru date mari, interogarea este foarte eficientă. Mai mult decât abordarea standard și de o magnitudine similară cu cea mai bună sugestie a mea.

df.query('A == "foo"')

     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14

Preferința mea este de a utiliza Boolean mask

Îmbunătățiri efective pot fi făcute prin modificarea modului în care creăm Boolean mask.

mask alternativa 1Folosiți matricea NumPy de bază și renunțați la costurile de creare a unei alte matrice NumPy pd.Series

mask = df['A'].values == 'foo'

Voi arăta mai multe teste de timp complete la sfârșit, dar aruncați o privire la creșterile de performanță pe care le obținem folosind cadrul de date de probă. În primul rând, ne uităm la diferența de creare a mask

%timeit mask = df['A'].values == 'foo'
%timeit mask = df['A'] == 'foo'

5.84 µs ± 195 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
166 µs ± 4.45 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

evaluarea tabelului mask cu matricea NumPy este de ~ 30 de ori mai rapidă. Acest lucru se datorează parțial faptului că evaluarea NumPy este adesea mai rapidă. De asemenea, se datorează parțial și lipsei de cheltuieli generale necesare pentru a construi un index și un index corespunzător pd.Series obiect corespunzător.

În continuare, vom analiza calendarul pentru felierea cu un singur fișier mask față de celălalt.

mask = df['A'].values == 'foo'
%timeit df[mask]
mask = df['A'] == 'foo'
%timeit df[mask]

219 µs ± 12.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
239 µs ± 7.03 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Câștigurile de performanță nu sunt la fel de pronunțate. Vom vedea dacă acest lucru se confirmă în cadrul unor teste mai solide.


mask alternativa 2Am fi putut reconstrui și cadrul de date. Există un mare avertisment atunci când reconstruiți un cadru de date – trebuie să aveți grijă de dtypes atunci când faceți acest lucru!

În loc de df[mask] vom face astfel

pd.DataFrame(df.values[mask], df.index[mask], df.columns).astype(df.dtypes)

Dacă cadrul de date este de tip mixt, așa cum este exemplul nostru, atunci când obținem df.values matricea rezultată este de tipul dtype object și, în consecință, toate coloanele noului cadru de date vor fi de tipul dtype object. Prin urmare, este nevoie de astype(df.dtypes) și ucigând orice potențial câștig de performanță.

%timeit df[m]
%timeit pd.DataFrame(df.values[mask], df.index[mask], df.columns).astype(df.dtypes)

216 µs ± 10.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
1.43 ms ± 39.6 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Cu toate acestea, în cazul în care cadrul de date nu este de tip mixt, aceasta este o modalitate foarte utilă de a face acest lucru.

Având în vedere

np.random.seed([3,1415])
d1 = pd.DataFrame(np.random.randint(10, size=(10, 5)), columns=list('ABCDE'))

d1

   A  B  C  D  E
0  0  2  7  3  8
1  7  0  6  8  6
2  0  2  0  4  9
3  7  3  2  4  3
4  3  6  7  7  4
5  5  3  7  5  9
6  8  7  6  4  7
7  6  2  6  6  5
8  2  8  7  5  8
9  4  7  6  1  5

%%timeit
mask = d1['A'].values == 7
d1[mask]

179 µs ± 8.73 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

Versus

%%timeit
mask = d1['A'].values == 7
pd.DataFrame(d1.values[mask], d1.index[mask], d1.columns)

87 µs ± 5.12 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

Am redus timpul la jumătate.


mask alternativa 3

@unutbu ne arată, de asemenea, cum să folosim pd.Series.isin pentru a ține cont de fiecare element din df['A'] fiind într-un set de valori. Acest lucru se evaluează la același lucru dacă setul nostru de valori este un set de o singură valoare, și anume 'foo'. Dar se generalizează, de asemenea, pentru a include seturi mai mari de valori, dacă este necesar. Se pare că acest lucru este încă destul de rapid, chiar dacă este o soluție mai generală. Singura pierdere reală este în ceea ce privește intuitivitatea pentru cei care nu sunt familiarizați cu acest concept.

mask = df['A'].isin(['foo'])
df[mask]

     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14

Cu toate acestea, ca și înainte, putem utiliza NumPy pentru a îmbunătăți performanța, fără a sacrifica practic nimic. Vom folosi np.in1d

mask = np.in1d(df['A'].values, ['foo'])
df[mask]

     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14

Timing

Voi include și alte concepte menționate în alte postări, pentru referință.

Codul de mai jos

Fiecare coloană din acest tabel reprezintă un cadru de date de lungime diferită asupra căruia testăm fiecare funcție. Fiecare coloană arată timpul relativ necesar, funcția cea mai rapidă având un indice de bază de 1.0.

res.div(res.min())

                         10        30        100       300       1000      3000      10000     30000
mask_standard         2.156872  1.850663  2.034149  2.166312  2.164541  3.090372  2.981326  3.131151
mask_standard_loc     1.879035  1.782366  1.988823  2.338112  2.361391  3.036131  2.998112  2.990103
mask_with_values      1.010166  1.000000  1.005113  1.026363  1.028698  1.293741  1.007824  1.016919
mask_with_values_loc  1.196843  1.300228  1.000000  1.000000  1.038989  1.219233  1.037020  1.000000
query                 4.997304  4.765554  5.934096  4.500559  2.997924  2.397013  1.680447  1.398190
xs_label              4.124597  4.272363  5.596152  4.295331  4.676591  5.710680  6.032809  8.950255
mask_with_isin        1.674055  1.679935  1.847972  1.724183  1.345111  1.405231  1.253554  1.264760
mask_with_in1d        1.000000  1.083807  1.220493  1.101929  1.000000  1.000000  1.000000  1.144175

Veți observa că cei mai rapizi timpi par să fie împărțiți între mask_with_values și mask_with_in1d.

res.T.plot(loglog=True)

Funcții

def mask_standard(df):
    mask = df['A'] == 'foo'
    return df[mask]

def mask_standard_loc(df):
    mask = df['A'] == 'foo'
    return df.loc[mask]

def mask_with_values(df):
    mask = df['A'].values == 'foo'
    return df[mask]

def mask_with_values_loc(df):
    mask = df['A'].values == 'foo'
    return df.loc[mask]

def query(df):
    return df.query('A == "foo"')

def xs_label(df):
    return df.set_index('A', append=True, drop=False).xs('foo', level=-1)

def mask_with_isin(df):
    mask = df['A'].isin(['foo'])
    return df[mask]

def mask_with_in1d(df):
    mask = np.in1d(df['A'].values, ['foo'])
    return df[mask]

Testarea

res = pd.DataFrame(
    index=[
        'mask_standard', 'mask_standard_loc', 'mask_with_values', 'mask_with_values_loc',
        'query', 'xs_label', 'mask_with_isin', 'mask_with_in1d'
    ],
    columns=[10, 30, 100, 300, 1000, 3000, 10000, 30000],
    dtype=float
)

for j in res.columns:
    d = pd.concat([df] * j, ignore_index=True)
    for i in res.index:a
        stmt = '{}(d)'.format(i)
        setp = 'from __main__ import d, {}'.format(i)
        res.at[i, j] = timeit(stmt, setp, number=50)

Cronometrare specială

Dacă analizăm cazul special în care avem un singur non-obiect dtype pentru întregul cadru de date.

Codul de mai jos

spec.div(spec.min())

                     10        30        100       300       1000      3000      10000     30000
mask_with_values  1.009030  1.000000  1.194276  1.000000  1.236892  1.095343  1.000000  1.000000
mask_with_in1d    1.104638  1.094524  1.156930  1.072094  1.000000  1.000000  1.040043  1.027100
reconstruct       1.000000  1.142838  1.000000  1.355440  1.650270  2.222181  2.294913  3.406735

Se pare că reconstrucția nu merită după câteva sute de rânduri.

spec.T.plot(loglog=True)

Funcții

np.random.seed([3,1415])
d1 = pd.DataFrame(np.random.randint(10, size=(10, 5)), columns=list('ABCDE'))

def mask_with_values(df):
    mask = df['A'].values == 'foo'
    return df[mask]

def mask_with_in1d(df):
    mask = np.in1d(df['A'].values, ['foo'])
    return df[mask]

def reconstruct(df):
    v = df.values
    mask = np.in1d(df['A'].values, ['foo'])
    return pd.DataFrame(v[mask], df.index[mask], df.columns)

spec = pd.DataFrame(
    index=['mask_with_values', 'mask_with_in1d', 'reconstruct'],
    columns=[10, 30, 100, 300, 1000, 3000, 10000, 30000],
    dtype=float
)

Testarea

for j in spec.columns:
    d = pd.concat([df] * j, ignore_index=True)
    for i in spec.index:
        stmt = '{}(d)'.format(i)
        setp = 'from __main__ import d, {}'.format(i)
        spec.at[i, j] = timeit(stmt, setp, number=50)

Comentarii

  • Un răspuns fantastic! 2 întrebări totuși, i) cum ar putea .iloc(numpy.where(..)) compara în această schemă? ii) v-ați aștepta ca clasamentele să fie aceleași atunci când se folosesc mai multe condiții? –  > Por posdef.
  • Pentru performanța de pd.Series.isin, rețineți că face utilizează np.in1d sub capotă într-un anumit scenariu, folosește khash în altele și aplică implicit un compromis între costul hashing-ului și performanță în anumite situații. Acest răspuns are mai multe detalii. –  > Por jpp.
  • La 9 screenfuls, acest răspuns este mult prea încărcat pentru un utilizator nou sau chiar intermediar. Puteți și ar trebui să rezumați singuri tl;dr în primul paragraf. –  > Por smci.
  • @piRSquared Scalarea contează Te-ar deranja, @piRSquared, să postezi și tu experiența ta despre cât de bine a funcționat [{P|EXP}TIME]– și [{C|P|EXP}SPACE]costuri de utilizare a formelor de sintaxă de bloc propuse mai sus ( procesarea de sus în jos a tuturor cadrelor de date deodată ) crescși anume, atunci când sunt scalate la o anumită ~1E6, ~1E9, ~1E12 număr de rânduri? Vă mulțumim că ne arătați imaginea de ansamblu, domnule. Citiri de referință cantitative cu [min, Avg, MAX, StDev] sunt întotdeauna binevenite, deoarece atât min și MAX însoțesc valorile Mean/StDev reliefarea lotului. –  > Por user3666197.
  • @piRSquared, mă confrunt cu o problemă similară, puteți verifica această întrebare, vă rog? stackoverflow.com/questions/63642173/… –  > Por Aaditya Ura.
imolit

tl;dr

Echivalentul Pandas pentru

select * from table where column_name = some_value

este

table[table.column_name == some_value]

Condiții multiple:

table[(table.column_name == some_value) | (table.column_name2 == some_value2)]

sau

table.query('column_name == some_value | column_name2 == some_value2')

Exemplu de cod

import pandas as pd

# Create data set
d = {'foo':[100, 111, 222],
     'bar':[333, 444, 555]}
df = pd.DataFrame(d)

# Full dataframe:
df

# Shows:
#    bar   foo
# 0  333   100
# 1  444   111
# 2  555   222

# Output only the row(s) in df where foo is 222:
df[df.foo == 222]

# Shows:
#    bar  foo
# 2  555  222

În codul de mai sus este linia df[df.foo == 222] care oferă rândurile în funcție de valoarea coloanei, 222 în acest caz.

Sunt posibile și condiții multiple:

df[(df.foo == 222) | (df.bar == 444)]
#    bar  foo
# 1  444  111
# 2  555  222

Dar în acest moment aș recomanda să folosiți query deoarece este mai puțin verbos și oferă același rezultat:

df.query('foo == 222 | bar == 444')

Comentarii

  • query este singurul răspuns aici care este compatibil cu înlănțuirea metodelor. Se pare că este analogul pandas la filter în dplyr. –  > Por Berk U..
  • Bună ziua, în al treilea exemplu (coloane multiple) cred că aveți nevoie de paranteze pătrate [ nu de paranteze rotunde ( în exterior. –  > Por user2739472.
  • la început am crezut că | a fost pentru AND, dar, desigur, este OR-operator… –  > Por O-9.
  • pentru condiții multiple folosind AND, se poate face df[condition1][condition2] –  > Por Ritwik.
  • Lăsând acest lucru aici doar în cazul în care este util pentru cineva: de la 0.25 interogarea poate fi utilizată cu nume de coloane care au spații în nume, prin includerea numelui în ghilimele: df.query('`my col` == 124') –  > Por cs95.
fredcallaway

Sintaxa din răspunsurile anterioare mi se pare redundantă și greu de reținut. Pandas a introdus query() metoda în v0.13 și o prefer cu mult. Pentru întrebarea dumneavoastră, ați putea face df.query('col == val')

Reprodus din http://pandas.pydata.org/pandas-docs/version/0.17.0/indexing.html#indexing-query

In [167]: n = 10

In [168]: df = pd.DataFrame(np.random.rand(n, 3), columns=list('abc'))

In [169]: df
Out[169]: 
          a         b         c
0  0.687704  0.582314  0.281645
1  0.250846  0.610021  0.420121
2  0.624328  0.401816  0.932146
3  0.011763  0.022921  0.244186
4  0.590198  0.325680  0.890392
5  0.598892  0.296424  0.007312
6  0.634625  0.803069  0.123872
7  0.924168  0.325076  0.303746
8  0.116822  0.364564  0.454607
9  0.986142  0.751953  0.561512

# pure python
In [170]: df[(df.a < df.b) & (df.b < df.c)]
Out[170]: 
          a         b         c
3  0.011763  0.022921  0.244186
8  0.116822  0.364564  0.454607

# query
In [171]: df.query('(a < b) & (b < c)')
Out[171]: 
          a         b         c
3  0.011763  0.022921  0.244186
8  0.116822  0.364564  0.454607

Puteți, de asemenea, să accesați variabilele din mediul înconjurător prin adăugarea unui prefix @.

exclude = ('red', 'orange')
df.query('color not in @exclude')

Comentarii

  • Aveți nevoie doar de pachetul numexpr instalat. –  > Por MERose.
  • În cazul meu am avut nevoie de ghilimele pentru că val este un șir de caractere. df.query(‘col == „val”‘) – –  > Por smerlung.
  • Într-adevăr, soluția elegantă de tip SQL. Deși sunt familiarizat cu soluția oferită în răspunsurile de mai sus, am tendința de a trece la utilizarea acestei soluții tot timpul. –  > Por Timbus Calin.
Erfan

Mai multă flexibilitate folosind .query cu Pandas >= 0.25.0:

Nathaniel protestează

queryÎn 2 Împărați 13:14-19, avem o interacțiune între Elisei și Ioas, regele lui Israel, în care Elisei profețește victoria asupra Siriei, dar, din cauza eșecului lui Ioas, victoria va fi doar una parțială.

Există două „evenimente” majore în această poveste – în primul rând, Elisei îi spune lui Ioas să arunce o săgeată pe fereastră, iar în al doilea rând, Elisei îi spune lui Ioas să „lovească pământul cu ei”:

# Example dataframe
df = pd.DataFrame({'Sender email':['[email protected]', "[email protected]", "[email protected]"]})

     Sender email
0  [email protected]
1  [email protected]
2    [email protected]

.query15 Și Elisei i-a zis: „Ia un arc și săgeți”. Și a luat un arc și săgeți. str.endswith16 Apoi i-a spus împăratului lui Israel: „Trage arcul!” Și el l-a tras. Și Elisei și-a pus mâinile pe mâinile regelui.

17

df.query('`Sender email`.str.endswith("@shop.com")')
 Și a zis: "Deschide fereastra spre răsărit", și el a deschis-o. Apoi Elisei a zis: "Trage", și el a tras. Și a zis: "Săgeata de biruință a Domnului, săgeata de biruință asupra Siriei! Căci te vei lupta cu sirienii în Afec, până când îi vei nimici". 

18

Și a zis: „Ia săgețile!” și el le-a luat. Și a zis împăratului lui Israel: „Lovește pământul cu ele”. Și a lovit de trei ori și s-a oprit. [ESV]

Aici mă interesează interpretarea corectă a expresiei „lovește pământul cu [săgețile]” – văd două posibilități:

     Sender email
1  [email protected]
2    [email protected]

Să ții una sau mai multe săgeți în mână și să le bați cu mâna de pământ.

@Puneți săgețile în arcul dumneavoastră și trageți cu ele împotriva pământului

domain = 'shop.com'
df.query('`Sender email`.str.endswith(@domain)')
Personal, tind să prefer cea de-a doua opțiune, deoarece pare mai naturală în context, dar pare să depindă de două lucruri:

Cuvântul „a lovi” – poate cuvântul ebraic de aici să însemne același lucru cu „a trage” sau cel puțin să implice o lovitură la distanță, ca în „lovește pământul de acolo trăgând această săgeată”?

Cuvântul „pământ” – cuvântul ebraic de aici implică în mod necesar pământul fizic sau ar putea însemna și podeaua unei clădiri? Acest lucru poate fi relevant sau nu, deoarece casa lui Elisei ar putea avea o podea de pământ.

     Sender email
1  [email protected]
2    [email protected]

Care este cel mai bun mod de a înțelege ceea ce face Ioas în acest verset?

Comentarii

  • df.query('`Sender email`.str.endswith("@shop.com")', engine="python") 2 Răspunsuri > Por .Bach
Bună întrebare. Deși nu sunt expert în domeniu sunt destul de sigur că prima ta interpretare este cea corectă. Pentru aceasta am două motive convingătoare. În primul rând, nu văd cum termenul הך se poate referi la „trage”, conform celei de-a doua interpretări a dumneavoastră. În măsura în care cunoștințele mele de ebraică se extind, cuvântul הך nu este niciodată folosit pentru a desemna împușcarea, ci doar „bătaia”.
În al doilea rând: Dacă ar fi vorba de o referire la „a trage”, de ce ar schimba textul terminologia în הך în loc să rămână la tema ירה, din moment ce așa a descris versetul anterior mișcarea regelui. Dacă textul dorește doar să transmită faptul că regele a tras săgețile în jos în loc de orizontal, ar spune „

ירה ארצה” (ca în versetul anterior, unde regele a țintit spre est), nu „הך

ארצה”. Acest lucru mă determină să concluzionez că הך înseamnă „bătaie” în sens propriu.

In [76]: df.iloc[np.where(df.A.values=='foo')]
Out[76]: 
     A      B  C   D
0  foo    one  0   0
2  foo    two  2   4
4  foo    two  4   8
6  foo    one  6  12
7  foo  three  7  14
Abu Munir Ibn Ibrahim

MT pentru 2 Împărați 13:18 este:

In [68]: %timeit df.iloc[np.where(df.A.values=='foo')]  # fastest
1000 loops, best of 3: 380 µs per loop

In [69]: %timeit df.loc[df['A'] == 'foo']
1000 loops, best of 3: 745 µs per loop

In [71]: %timeit df.loc[df['A'].isin(['foo'])]
1000 loops, best of 3: 562 µs per loop

In [72]: %timeit df[df.A=='foo']
1000 loops, best of 3: 796 µs per loop

In [74]: %timeit df.query('(A=="foo")')  # slowest
1000 loops, best of 3: 1.71 ms per loop

וַיֹּאמֶר קַח הַחִצִּים וַיִּקָּח וַיֹּאמֶר לְמֶלֶךְ יִשְׂרָאֵל הַךְ אַרְצָה וַיַּךְ שָׁלֹשׁ פְּעָמִים וַיַּעֲמֹד

Traducerea liniară este (a mea):

from pandas import DataFrame

# Create data set
d = {'Revenue':[100,111,222], 
     'Cost':[333,444,555]}
df = DataFrame(d)


# mask = Return True when the value in column "Revenue" is equal to 111
mask = df['Revenue'] == 111

print mask

# Result:
# 0    False
# 1     True
# 2    False
# Name: Revenue, dtype: bool


# Select * FROM df WHERE Revenue = 111
df[mask]

# Result:
#    Cost    Revenue
# 1  444     111
Și a spus "ia săgețile" și a luat, și i-a spus regelui lui Israel "lovește (în jos/pe pământ)" și a lovit de trei ori și s-a oprit.

Există mai mulți factori de care trebuie să ținem cont atunci când interpretăm acest verset:

Versiunea ESV interpolează „them” în: „and he took them” (și le-a luat). Nu există aici niciun pronume „them” în MT.

select col_name1, col_name2 from table where column_name = some_value.
Cuvântul אַרְצָה poate însemna fie "spre pământ" (în jos), fie "pământul", iar traducătorul trebuie să aleagă ce să folosească. ESV alege "pământul"

ESV interpolează „cu ei” după „the ground”. Acest „cu ei” nu se regăsește în MT.

df.loc[df['column_name'] == some_value][[col_name1, col_name2]]

Un al patrulea factor, mai important, este că proza VT nu este întotdeauna secvențială în modul în care se cere ca proza occidentală să fie. Un singur verset poate enumera mai multe lucruri sau acțiuni cu ajutorul conjunctivului

waw

(și) în cazul în care legătura dintre ele este doar circumstanțială și nu sequitur. Acest factor este dificil de luat în considerare de cititorii occidentali atunci când traduc și interpretează versete din VT – sensibilitatea noastră literară cere să existe o conexiune.

df.query['column_name' == 'some_value'][[col_name1, col_name2]]

Așadar, o traducere care să rămână aproape de textul ebraic, păstrând ambiguitatea și minunata sa economie, s-ar citi ca mai sus:

Comentarii

  • Și a spus „ia săgețile” și a luat, și a spus regelui lui Israel „lovește în jos” și a lovit de trei ori și s-a oprit. > Por .
  • unde sensurile

„a luat [săgețile într-o mână] și a lovit în jos [cu cealaltă sau cu aceeași mână]”

„a luat [săgețile] și a lovit [cu ele] pe pământdf.groupby('column_name').get_group('column_desired_value').reset_index()

sunt la fel de probabile, așa cum par a fi în MT Hebrew.

import pandas as pd
df = pd.DataFrame({'A': 'foo bar foo bar foo bar foo foo'.split(),
                   'B': 'one one two three two two one three'.split()})
print("Original dataframe:")
print(df)

b_is_two_dataframe = pd.DataFrame(df.groupby('B').get_group('two').reset_index()).drop('index', axis = 1) 
#NOTE: the final drop is to remove the extra index column returned by groupby object
print('Sub dataframe where B is two:')
print(b_is_two_dataframe)

În orice caz, așa cum notează Bach în răspunsul său la OP, interpretarea lui וַיַּךְ ca însemnând „împușcare” este greu de justificat.

Sfatul meu în citirea acestor versete este să trăim cu ambiguitatea inerentă MT și să apreciem economia limbajului său.

Original dataframe:
     A      B
0  foo    one
1  bar    one
2  foo    two
3  bar  three
4  foo    two
5  bar    two
6  foo    one
7  foo  three
Sub dataframe where B is two:
     A    B
0  foo  two
1  foo  two
2  bar  two

Comentarii

    În 2 Împărați 13:18, a tras Ioas trei săgeți sau le-a bătut de pământ cu mâna?

  • get_group()reset_index()b_is_two_dataframe = df.groupby('B').get_group('two').reset_index(drop=True) > Por .
df.apply(lambda row: row[df['B'].isin(['one','three'])])

   A      B  C   D
0  foo    one  0   0
1  bar    one  1   2
3  bar  three  3   6
6  foo    one  6  12
7  foo  three  7  14

df[[df['B'].isin(['one','three'])]]

df[df["colume_name"] == some_value] #Scalar, True/False..

df[df["colume_name"] == "some_value"] #String

()&|

df[(df["colume_name"] == "some_value1") & (pd[pd["colume_name"] == "some_value2"])]

pandas.notna(df["colume_name"]) == True # Not NaN
df['colume_name'].str.contains("text") # Search for "text"
df['colume_name'].str.lower().str.contains("text") # Search for "text", after converting  to lowercase