Python pandas 데이터 확인, 정렬, 선택하는 법

python
data = {'포켓몬명': ['피카츄', '파이리', '꼬부기', '잠만보'],
        '수면시간': [7, 5, 8, 18],
        '능력치': [40, 60, 80, 90],
        '과': ['이과', '문과', '이과', '문과']}
df = pd.DataFrame(data).set_index('포켓몬명') # 행 색인명 지정
df

python
type(df)

# 결과
pandas.core.frame.DataFrame

python
df.shape

# 결과
(4, 3) # 4개 행과 3개 열: 4개의 데이터 레코드와 3개의 속성

python
df.head

# 또는 

df.head() # 1행부터 5행까지 총 5개 행 출력

python
df.head(2) # 1행부터 2행까지 총 2개 행 출력

python
df.tail

# 또는 

df.tail() # 맨 마지막 행부터 총 5개 행 출력
df.tail(7) # 맨 마지막 행부터 총 7개 행 출력

python
df.sample() # 임의의 1개 행 추출
df.sample(n=3) # 임의의 3개 행 추출
df.sample(n=1, axis=1) # 임의의 1개 열 추출
df.sample(frac=0.2) # 원본 데이터의 20%만큼 비복원추출
df.sample(frac=0.3, replace=True) # 원본 데이터의 30% 만큼 복원추출
df.sample(frac=1.5, replace=True) # 원본 데이터의 1.5배 만큼 복원추출
df.sample(n=2, weights='열1') # '열1'에서 값이 가장 큰 순서대로 2개 행 추출
df.sample(n=4, random_state=1) # 임의의 4개 행 추출, random_state로 숫자를 지정해 동일 결과 재추출 가능

python
df.info()

# 결과
<class 'pandas.core.frame.DataFrame'>
Index: 4 entries, 피카츄 to 잠만보
Data columns (total 3 columns):
 #   Column  Non-Null Count  Dtype 
---  ------  --------------  ----- 
 0   수면시간    4 non-null      int64 
 1   능력치     4 non-null      int64 
 2   과       4 non-null      object
dtypes: int64(2), object(1)
memory usage: 128.0+ bytes

python
df.describe()

# 결과
수면시간    능력치
count   4.000000    4.000000     # 빈도
mean    9.500000    67.500000    # 평균
std   5.802298  22.173558    # 표준편차
min   5.000000  40.000000    # 최솟값
25%   6.500000  55.000000    # 제1사분위수
50%   7.500000  70.000000    # 제2사분위수
75%   10.500000 82.500000    # 제3사분위수
max   18.000000 90.000000    # 최댓값

python
df.describe(include='all')

python
df.values

# 결과
array([[7, 40, '이과'],
       [5, 60, '문과'],
       [8, 80, '이과'],
       [18, 90, '문과']], dtype=object)

python
df.index

python
pd.isnull(df)

# 결과
    수면시간    능력치     과
포켓몬명            
피카츄 False   False   False
파이리 False   False   False
꼬부기 False   False   False
잠만보 False   False   False

python
df.isnull().sum()

# 결과
수면시간    0
능력치     0
과       0
dtype: int64

python
pd.notnull(df)

#결과
    수면시간    능력치 과
포켓몬명            
피카츄 True    True    True
파이리 True    True    True
꼬부기 True    True    True
잠만보 True    True    True

python
df.sort_values('수면시간')

# 또는 

df.sort_values(by='수면시간') # 열 이름이 '수면시간'인 열의 원소 크기에 따라 오름차순 정렬

# 결과
수면시간 능력치  과
포켓몬명            
파이리 5   60  문과
피카츄 7   40  이과
꼬부기 8   80  이과
잠만보 18  90  문과

python
df.sort_values(by=['능력치', '수면시간']) # 열 이름을 기준으로 오름차순 정렬

# 결과
수면시간    능력치 과
포켓몬명            
피카츄 7   40  이과
파이리 5   60  문과
꼬부기 8   80  이과
잠만보 18  90  문과

python
# 과를 기준으로 오름차순으로 정렬한 다음 수면시간을 기준으로 내림차순 정렬 
df.sort_values(['과', '수면시간'], 
                ascending=[True, False])

python
df.rank() 

# 결과
 수면시간 능력치 과
포켓몬명            
피카츄 2.0 1.0 3.5
파이리 1.0 2.0 1.5
꼬부기 3.0 3.0 3.5
잠만보 4.0 4.0 1.5

python
df.rank(axis=1)

# 결과
    수면시간    능력치
포켓몬명        
피카츄 1.0 2.0
파이리 1.0 2.0
꼬부기 1.0 2.0
잠만보 1.0 2.0

python
df.rank(ascending=False)

# 결과
수면시간    능력치 과
포켓몬명            
피카츄 3.0 4.0 1.5
파이리 4.0 3.0 3.5
꼬부기 2.0 2.0 1.5
잠만보 1.0 1.0 3.5

python
df['수면시간'] # 사전 형식 표기법: Series로 추출
df.수면시간    # 속성 형식 표기법: Series로 추출

# 결과
포켓몬명
피카츄     7
파이리     5
꼬부기     8
잠만보    18
Name: 수면시간, dtype: int64

python
df[['수면시간']] # DataFrame으로 추출

python
df['수면시간']['꼬부기'] # 꼬부기의 수면시간 추출하기

# 결과
8

python
df[['수면시간', '능력치']] # 여러 변수 추출하기

# 결과
          수면시간  능력치
포켓몬명        
피카츄       7        40
파이리       5        60
꼬부기       8        80
잠만보       18       90

python
df['능력치'][['피카츄', '꼬부기']]

# 결과
포켓몬명
피카츄    40
꼬부기    80
Name: 능력치, dtype: int64

python
df['수면시간']['피카츄', '잠만보'] = 5

# 결과
    수면시간    능력치 과
포켓몬명            
피카츄 5   40  이과 # 7에서 5로 변경됨
파이리 5   60  문과
꼬부기 8   80  이과
잠만보 5   90  문과 # 18에서 5로 변경됨

python
df.columns[0] # 0번째 열이름 가져오기

# 결과
'수면시간'

python
df[df.columns[0]] # 첫 번째 열 전체 가져오기

# 결과
포켓몬명
피카츄     7
파이리     5
꼬부기     8
잠만보    18
Name: 수면시간, dtype: int64

python
df[df.columns[-1]] # 마지막 열 전체 가져오기

# 결과
포켓몬명
피카츄    이과
파이리    문과
꼬부기    이과
잠만보    문과
Name: 과, dtype: object

python
df['수면시간'][3] # 잠만보 수면시간

# 결과
18

python
df['수면시간']['피카츄':'꼬부기']

# 결과
포켓몬명
피카츄    7
파이리    5
꼬부기    8
Name: 수면시간, dtype: int64

python
df['수면시간'][1:3] # 1행부터 2행까지 가져오기

# 결과
포켓몬명
파이리    5
꼬부기    8
Name: 수면시간, dtype: int64

python
df['수면시간'][:2]

# 결과
포켓몬명
피카츄    7
파이리    5
Name: 수면시간, dtype: int64

python
df.loc['잠만보'] # 행색인 '잠만보'에 해당하는 열 반환

# 결과
수면시간    18
능력치     90
Name: 잠만보, dtype: int64

python
df.loc['잠만보', ['수면시간', '능력치']] 

# 결과
수면시간    18
능력치      90
Name: 잠만보, dtype: object

python
df.loc[:'꼬부기', '능력치'] # 꼬부기까지 포함

# 결과
포켓몬명
피카츄    40
파이리    60
꼬부기    80
Name: 능력치, dtype: int64

python
df.iloc[2] # 3번째 행 꼬부기 정보 가져오기

# 결과
수면시간     8
능력치     80
Name: 꼬부기, dtype: int64

python
df.iloc[2, [1, 0]]

# 결과
능력치     80
수면시간     8
Name: 꼬부기, dtype: int64

python
df.iloc[[1, 3], [0, 1]]

# 결과
    수면시간    능력치
포켓몬명        
파이리 5   60
잠만보 18  90

python
df.iloc[1:3, 0:2]

# 결과
    수면시간    능력치
포켓몬명        
파이리 5   60
꼬부기 8   80

python
df['수면시간'] >= 7 # 수면시간이 7시간 이상인 데이터 가져오기

# 결과
포켓몬명
피카츄     True
파이리    False
꼬부기     True
잠만보     True
Name: 수면시간, dtype: bool

python
filt = (df['수면시간'] >= 7) 
df[filt]

# 또는 

df[df['수면시간'] >= 7]

# 결과
    수면시간    능력치 과
포켓몬명            
피카츄 7   40  이과
꼬부기 8   80  이과
잠만보 18  90  문과

python
filt = (df['수면시간'] >= 7)
df[~filt] # 수면시간이 7시간 미만인 데이터 가져오기

# 결과
    수면시간    능력치 과
포켓몬명            
파이리 5   60  문과

python
df.loc[df['수면시간'] > 7, '능력치'] # 1개 열 가져오기
                                    # 수면시간이 7시간 초과인 행들 중 열 이름이 능력치인 데이터 가져오기

# 결과
포켓몬명
꼬부기    80
잠만보    90
Name: 능력치, dtype: int64

df.loc[df['수면시간'] > 7, ['능력치', '과']] # 2개 열 가져오기
                                            # 수면시간이 7시간 초과인 데이터 중 열 이름이 능력치와 과인 데이터 가져오기

# 결과
능력치 과
포켓몬명        
꼬부기 80  이과
잠만보 90  문과

python
df.iloc[:, :2][df['수면시간'] > 7] 

# 결과
    수면시간    능력치
포켓몬명        
꼬부기 8   80
잠만보 18  90

python
df.query('과 == "이과"') # 과가 이과인 데이터만 선택

# 또는 

df.query('과 != "이과"') # 과가 이과가 아닌 데이터만 선택

python
condition = '이과'
df.query('과 == @condition')

python
df.query("과 == '이과'")['수면시간'] # 열 이름이 과인 데이터에서 값이 이과인 데이터들의 수면시간 데이터 추출

python
df.query("과 == '이과'")[['수면시간', '능력치']]  # 열 이름이 과인 데이터에서 값이 이과인 데이터들의 수면시간과 능력치 데이터 추출

python
df.groupby('과').get_group('이과') # 가 이과인 데이터만 선택

python
df.loc[(df['수면시간'] > 7) & (df['과'] == '이과')]

# 또는 

df.query('수면시간 > 7 & 과 == "이과"')

# 결과
    수면시간    능력치 과
포켓몬명            
꼬부기 8   80  이과

python
df.loc[(df['수면시간'] > 7) | (df['과'] == '이과')]

# 또는 

df.query('수면시간 > 7 | 과 == "이과"')

# 결과
수면시간    능력치 과
포켓몬명            
피카츄 7   40  이과
꼬부기 8   80  이과
잠만보 18  90  문과

python
result = df['과'].isin(['이과', '감자']) # '과' 열의 값으로 '이과' 또는 '감자'가 있는지를 확인
result

# 결과
포켓몬명
피카츄     True
파이리    False
꼬부기     True
잠만보    False
Name: 과, dtype: bool

python
filt = df['과'].isin(['이과', '감자'])  # '과'가 '이과' 또는 '감자'인 포켓몬
df[filt] # filt를 조건 필터로 사용

# 결과
    수면시간    능력치 과
포켓몬명            
피카츄 7   40  이과
꼬부기 8   80  이과

python
df.query('과 in ["이과", "감자"]')

python
to_match = pd.Series(['셀러리', '고구마', '호박', '고구마', '감자', '고구마'])
unique_values = pd.Series(to_match.unique()) # 셀러리, 고구마, 호박, 감자 순
pd.Index(unique_values).get_indexer(to_match)

# 결과
array([0, 1, 2, 1, 3, 1], dtype=int64)

python
filt = df['과'].str.startswith('이') # '이'로 시작
df[filt]

# 결과
수면시간    능력치 과
포켓몬명            
피카츄 7   40  이과
꼬부기 8   80  이과

python
filt = df['과'].str.endswith('능') # 예체능에서 '능'으로 끝남
df[filt]

# 결과
없음

python
df['과'].str.contains('문') 

# 결과 
포켓몬명
피카츄    False
파이리     True
꼬부기    False
잠만보     True
Name: 과, dtype: bool

python
filt = df['과'].str.contains('문') # '문' 포함
df[filt]

# 결과
    수면시간    능력치 과
포켓몬명            
파이리 5   60  문과
잠만보 18  90  문과

python
filt = df['과'].str.contains('문') # '문' 포함
df[~filt] # '과'에 '문'이 들어가는 데이터 제외

# 결과
    수면시간    능력치 과
포켓몬명            
피카츄 7   40  이과
꼬부기 8   80  이과

python
filt = df['과'].str.contains('문', na=False) # NaN으로 된 데이터를 False로 처리
df[~filt]

python
df['과'].unique()

# 결과
array(['이과', '문과'], dtype=object)

python
uniques = df['과'].unique()
uniques.sort()
uniques

# 결과
array(['문과', '이과'], dtype=object)

python
df['과'].nunique()

# 결과
2

python
df['과'].value_counts()
df['과']

# 결과
이과    2
문과    2
Name: 과, dtype: int64

python
pd.value_counts(df['과'].values, sort=False)

# 결과
이과    2
문과    2
dtype: int64

python
df['과'] = df['과'].value_counts().sort_index()
df['과']

# 결과
문과    2
이과    2
Name: 과, dtype: int64

python
df['과'].value_counts(normalize=True)

# 결과
이과    0.5
문과    0.5
Name: 과, dtype: float64

python
df2 = pd.DataFrame({'1분기': [5, 3, 4, 1, 2],
                    '2분기': [2, 3, 5, 1, 3],
                    '3분기': [4, 1, 5, 2, 1]})

result = df2.apply(pd.value_counts).fillna(0)

# 결과
  1분기  2분기  3분기
1   1    1.0    2.0
2   1    1.0    1.0
3   1    2.0    0.0
4   1    0.0    1.0
5   1    1.0    1.0

python
df_group = pd.DataFrame(list("aaaba"), columns=['열이름'])
df_group.groupby('열이름').cumcount()

# 결과
0    0 # a
1    1 # a
2    2 # a
3    0 # b
4    3 # a
dtype: int64