Panda는 시리즈/데이터프레임 컬럼을 조건부 생성

Panda는 시리즈/데이터프레임 컬럼을 조건부 생성

「 」를 해야 요?color하여 ada 음데 데 column column column column column column column column column column column column column column column column column column columncolor='green'Set == 'Z' , , , , 입니다.color='red'렇지않??? ??

    Type       Set
1    A          Z
2    B          Z           
3    B          X
4    C          Y

선택할 수 있는 옵션이 2개뿐인 경우:

df['color'] = np.where(df['Set']=='Z', 'green', 'red')

예를들면,

import pandas as pd
import numpy as np

df = pd.DataFrame({'Type':list('ABBC'), 'Set':list('ZZXY')})
df['color'] = np.where(df['Set']=='Z', 'green', 'red')
print(df)

수율

  Set Type  color
0   Z    A  green
1   Z    B  green
2   X    B    red
3   Y    C    red

---

조건이 3개 이상인 경우 를 사용합니다.예를 들면,color

• yellow 때(df['Set'] == 'Z') & (df['Type'] == 'A')
• 않으면blue 때(df['Set'] == 'Z') & (df['Type'] == 'B')
• 않으면purple 때(df['Type'] == 'B')
• 않으면black ,

그 후

df = pd.DataFrame({'Type':list('ABBC'), 'Set':list('ZZXY')})
conditions = [
    (df['Set'] == 'Z') & (df['Type'] == 'A'),
    (df['Set'] == 'Z') & (df['Type'] == 'B'),
    (df['Type'] == 'B')]
choices = ['yellow', 'blue', 'purple']
df['color'] = np.select(conditions, choices, default='black')
print(df)

그 결과

  Set Type   color
0   Z    A  yellow
1   Z    B    blue
2   X    B  purple
3   Y    C   black

목록 이해는 조건부로 다른 열을 만드는 또 다른 방법입니다.예시와 같이 컬럼에서 오브젝트 dtype을 사용하는 경우 목록 압축은 일반적으로 다른 대부분의 메서드를 능가합니다.

목록 이해의 예:

df['color'] = ['red' if x == 'Z' else 'green' for x in df['Set']]

%timeit 테스트:

import pandas as pd
import numpy as np

df = pd.DataFrame({'Type':list('ABBC'), 'Set':list('ZZXY')})
%timeit df['color'] = ['red' if x == 'Z' else 'green' for x in df['Set']]
%timeit df['color'] = np.where(df['Set']=='Z', 'green', 'red')
%timeit df['color'] = df.Set.map( lambda x: 'red' if x == 'Z' else 'green')

1000 loops, best of 3: 239 µs per loop
1000 loops, best of 3: 523 µs per loop
1000 loops, best of 3: 263 µs per loop

이를 실현하기 위한 또 다른 방법은

df['color'] = df.Set.map( lambda x: 'red' if x == 'Z' else 'green')

다음은 여기서 시간화된 접근법보다 느리지만 여러 열의 내용을 기반으로 추가 열을 계산할 수 있으며 추가 열에 대해 세 개 이상의 값을 계산할 수 있습니다.

"Set" 열만 사용하는 간단한 예:

def set_color(row):
    if row["Set"] == "Z":
        return "red"
    else:
        return "green"

df = df.assign(color=df.apply(set_color, axis=1))

print(df)

  Set Type  color
0   Z    A    red
1   Z    B    red
2   X    B  green
3   Y    C  green

더 많은 색상과 더 많은 열을 고려한 예:

def set_color(row):
    if row["Set"] == "Z":
        return "red"
    elif row["Type"] == "C":
        return "blue"
    else:
        return "green"

df = df.assign(color=df.apply(set_color, axis=1))

print(df)

  Set Type  color
0   Z    A    red
1   Z    B    red
2   X    B  green
3   Y    C   blue

편집 (2019/06/21):plydata 사용

또한 이러한 작업을 수행하기 위해 plydata를 사용할 수도 있습니다(이것은 사용하는 것보다 더 느린 것 같습니다).assign ★★★★★★★★★★★★★★★★★」apply(표준,

from plydata import define, if_else

한 '심플한'if_else:

df = define(df, color=if_else('Set=="Z"', '"red"', '"green"'))

print(df)

  Set Type  color
0   Z    A    red
1   Z    B    red
2   X    B  green
3   Y    C  green

「」if_else:

df = define(df, color=if_else(
    'Set=="Z"',
    '"red"',
    if_else('Type=="C"', '"green"', '"blue"')))

print(df)                            

  Set Type  color
0   Z    A    red
1   Z    B    red
2   X    B   blue
3   Y    C  green

사전을 사용하여 목록의 키에 새 값을 매핑하는 또 다른 방법은 다음과 같습니다.

def map_values(row, values_dict):
    return values_dict[row]

values_dict = {'A': 1, 'B': 2, 'C': 3, 'D': 4}

df = pd.DataFrame({'INDICATOR': ['A', 'B', 'C', 'D'], 'VALUE': [10, 9, 8, 7]})

df['NEW_VALUE'] = df['INDICATOR'].apply(map_values, args = (values_dict,))

어떻게 생겼어요?

df
Out[2]: 
  INDICATOR  VALUE  NEW_VALUE
0         A     10          1
1         B      9          2
2         C      8          3
3         D      7          4

이 많은 것을 있을 때 할 수 .ifelse-입력할문(바꿀수있는많은유일한값)을입력합니다.

물론 언제든지 이렇게 할 수 있습니다.

df['NEW_VALUE'] = df['INDICATOR'].map(values_dict)

그 .apply위에서 접근해서 내 기계로 접근해보세요.

이렇게 할 요.dict.get:

df['NEW_VALUE'] = [values_dict.get(v, None) for v in df['INDICATOR']]

한 ★★★★★★★★★★★★★를 간단하게 사용할 수 있습니다..loc필요에 따라 한 가지 조건 또는 여러 조건을 사용합니다(판다=1.0.5와 함께 사용).

코드 요약:

df=pd.DataFrame(dict(Type='A B B C'.split(), Set='Z Z X Y'.split()))
df['Color'] = "red"
df.loc[(df['Set']=="Z"), 'Color'] = "green"

#practice!
df.loc[(df['Set']=="Z")&(df['Type']=="B")|(df['Type']=="C"), 'Color'] = "purple"

설명:

df=pd.DataFrame(dict(Type='A B B C'.split(), Set='Z Z X Y'.split()))

# df so far: 
  Type Set  
0    A   Z 
1    B   Z 
2    B   X 
3    C   Y

'color' 열을 추가하고 모든 값을 'red'로 설정합니다.

df['Color'] = "red"

단일 조건 적용:

df.loc[(df['Set']=="Z"), 'Color'] = "green"


# df: 
  Type Set  Color
0    A   Z  green
1    B   Z  green
2    B   X    red
3    C   Y    red

또는 여러 조건(필요한 경우)을 클릭합니다.

df.loc[(df['Set']=="Z")&(df['Type']=="B")|(df['Type']=="C"), 'Color'] = "purple"

팬더 논리 연산자 및 조건부 선택에 대한 내용은 여기를 참조하십시오.팬더에서 부울 인덱싱을 위한 논리 연산자

팬더 방법 및 다음을 사용할 수 있습니다.

df['color'] = 'green'
df['color'] = df['color'].where(df['Set']=='Z', other='red')
# Replace values where the condition is False

또는

df['color'] = 'red'
df['color'] = df['color'].mask(df['Set']=='Z', other='green')
# Replace values where the condition is True

'먹다'라는 .transform다다함함함:

df['color'] = df['Set'].transform(lambda x: 'green' if x == 'Z' else 'red')

출력:

  Type Set  color
1    A   Z  green
2    B   Z  green
3    B   X    red
4    C   Y    red

@chai에서의 퍼포먼스 비교:

import pandas as pd
import numpy as np
df = pd.DataFrame({'Type':list('ABBC')*1000000, 'Set':list('ZZXY')*1000000})
 
%timeit df['color1'] = 'red'; df['color1'].where(df['Set']=='Z','green')
%timeit df['color2'] = ['red' if x == 'Z' else 'green' for x in df['Set']]
%timeit df['color3'] = np.where(df['Set']=='Z', 'red', 'green')
%timeit df['color4'] = df.Set.map(lambda x: 'red' if x == 'Z' else 'green')

397 ms ± 101 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
976 ms ± 241 ms per loop
673 ms ± 139 ms per loop
796 ms ± 182 ms per loop

선택지가 2개뿐이라면np.where()

df = pd.DataFrame({'A':range(3)})
df['B'] = np.where(df.A>2, 'yes', 'no')

두 가지 이상의 선택지가 있다면apply()작업 입력 가능

arr = pd.DataFrame({'A':list('abc'), 'B':range(3), 'C':range(3,6), 'D':range(6, 9)})

그리고 아르는

    A   B   C   D
0   a   0   3   6
1   b   1   4   7
2   c   2   5   8

열 E를 원하는 경우if arr.A =='a' then arr.B elif arr.A=='b' then arr.C elif arr.A == 'c' then arr.D else something_else

arr['E'] = arr.apply(lambda x: x['B'] if x['A']=='a' else(x['C'] if x['A']=='b' else(x['D'] if x['A']=='c' else 1234)), axis=1)

그리고 마지막으로 아르는

    A   B   C   D   E
0   a   0   3   6   0
1   b   1   4   7   4
2   c   2   5   8   8

라이너 1대.apply()방법은 다음과 같습니다.

df['color'] = df['Set'].apply(lambda set_: 'green' if set_=='Z' else 'red')

그 후로는df데이터 프레임은 다음과 같습니다.

>>> print(df)
  Type Set  color
0    A   Z  green
1    B   Z  green
2    B   X    red
3    C   Y    red

대량의 데이터를 취급하는 경우는, 메모화된 어프로치가 최적입니다.

# First create a dictionary of manually stored values
color_dict = {'Z':'red'}

# Second, build a dictionary of "other" values
color_dict_other = {x:'green' for x in df['Set'].unique() if x not in color_dict.keys()}

# Next, merge the two
color_dict.update(color_dict_other)

# Finally, map it to your column
df['color'] = df['Set'].map(color_dict)

이 방법은 반복된 값이 많을 때 가장 빠릅니다.나의 일반적인 경험적 규칙은 다음과 같은 경우 메모하는 것이다.data_size>10**4&n_distinct<>data_size/4

E.x. 2,500개 이하의 고유 값을 가진 10,000개의 행에 메모합니다.

pyjanitor의 case_when 함수는 랩핑입니다.pd.Series.mask는, 복수의 조건에 대응한 체인 가능/컴피니언스 폼을 제공합니다.

단일 조건의 경우:

df.case_when(
    df.col1 == "Z",  # condition
    "green",         # value if True
    "red",           # value if False
    column_name = "color"
    )

  Type Set  color
1    A   Z  green
2    B   Z  green
3    B   X    red
4    C   Y    red

여러 조건의 경우:

df.case_when(
    df.Set.eq('Z') & df.Type.eq('A'), 'yellow', # condition, result
    df.Set.eq('Z') & df.Type.eq('B'), 'blue',   # condition, result
    df.Type.eq('B'), 'purple',                  # condition, result
    'black',              # default if none of the conditions evaluate to True
    column_name = 'color'  
)
  Type  Set   color
1    A   Z  yellow
2    B   Z    blue
3    B   X  purple
4    C   Y   black

자세한 예시는 이쪽에서 보실 수 있습니다.

를 사용한 보다 적은 상세 접근법np.select:

a = np.array([['A','Z'],['B','Z'],['B','X'],['C','Y']])
df = pd.DataFrame(a,columns=['Type','Set'])

conditions = [
    df['Set'] == 'Z'
]

outputs = [
    'Green'
    ]
             # conditions Z is Green, Red Otherwise.
res = np.select(conditions, outputs, 'Red')
res 
array(['Green', 'Green', 'Red', 'Red'], dtype='<U5')
df.insert(2, 'new_column',res)    

df
    Type    Set new_column
0   A   Z   Green
1   B   Z   Green
2   B   X   Red
3   C   Y   Red

df.to_numpy()    
    
array([['A', 'Z', 'Green'],
       ['B', 'Z', 'Green'],
       ['B', 'X', 'Red'],
       ['C', 'Y', 'Red']], dtype=object)

%%timeit conditions = [df['Set'] == 'Z'] 
outputs = ['Green'] 
np.select(conditions, outputs, 'Red')

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

df2 = pd.DataFrame({'Type':list('ABBC')*1000000, 'Set':list('ZZXY')*1000000})
%%timeit conditions = [df2['Set'] == 'Z'] 
outputs = ['Green'] 
np.select(conditions, outputs, 'Red')

188 ms ± 26.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

언급URL : https://stackoverflow.com/questions/19913659/pandas-conditional-creation-of-a-series-dataframe-column