pandas 데이터 구조 - DataFrame

DataFrame 소개
Series 와 달리 DataFrame 은 데이터 와 줄, 열 색인 으로 구 성 된 2 차원 데이터 구조 입 니 다.
DataFrame 속성:

values: 표 의 중간 값

열: 열 색인

index: 줄 색인

shape: 모양

DataFrame 만 들 기
DataFrame 을 만 드 는 방법 은 목록, 원본, 사전, 외부 가 져 오기 등 을 통 해 다양 합 니 다.
1. 리스트, 모듈 의 전송
목록 과 원본 전송 방식 이 기본적으로 일치 합 니 다.

데이터 시트 목록 에 들 어 갑 니 다. 이 목록 의 값 은 한 열 로 표시 되 고 줄, 열 색인 은 모두 기본 값 0 에서 시 작 됩 니 다.

import pandas as pd
df1 = pd.DataFrame(['a','b','c'])
df1

#    
	0
0	a
1	b
2	c

다 열 데이터 내장 목록 에 들 어 갑 니 다. 내장 목록 에 따라 다 열 데이터 로 표 시 됩 니 다.포 함 된 목록 도 원 그룹 으로 바 꿀 수 있 습 니 다.

df2 = pd.DataFrame ([['a','A'],['b','B'],['c','C']])
df2

#    
    0	1
0	a	A
1	b	B
2	c	C

#     ，        
df3 = pd.DataFrame ((['a','A'],['b','B'],['c','C']))
df3

2. 사전 이 사전 에 들 어 올 때 사전 의 key 값 은 열 색인 에 해당 합 니 다. 줄 색인 을 설정 하지 않 으 면 0 으로 계산 합 니 다.

data = {
     '  ':['a','b','c'],'  ':['A','b','C']}
df3 = pd.DataFrame (data)
df3

#   

          
0	a	A
1	b	b
2	c	C

줄, 열 색인 설정, 조회, 절편
1. 행렬 색인 설정
DataFrame 에 서 는 index 와 columns 를 사용 하여 색인 값 을 정할 수 있 습 니 다.

df4 = pd.DataFrame ((['a','A'],['b','B'],['c','C']),index = [1,2,3],columns =['  ','  '])
df4

#   
       
1	a	A
2	b	B
3	c	C

2. 행렬 색인 검색

#      
df4.columns  

#   
Index(['  ', '  '], dtype='object')

#     
df4 .index

#   
Int64Index([1, 2, 3], dtype='int64')

3. 데이터 절편 DataFrame 은 줄, 열 을 색인 을 통 해 절편 처리 할 수 있 습 니 다.

#     DataFrame
import pandas as pd
import  numpy as np
df5 = pd.DataFrame(np.arange(16).reshape((4,4)),index = [1,2,3,4],columns=['A','B','C','D'])
df5

#   

	A	B	C	D
1	0	1	2	3
2	4	5	6	7
3	8	9	10	11
4	12	13	14	15

추출 할 열 이름 을 선택 하 십시오

df5["A"]

#   
1     0
2     4
3     8
4    12
Name: A, dtype: int32

여러 열 을 선택 하여 필요 한 열 이름 을 목록 으로 전송 합 니 다

df5[["A",'B']]

#   
	A	B
1	0	1
2	4	5
3	8	9
4	12	13

한 줄 의 입력 에 필요 한 줄 번호 선택

df5[2:3]

#   	
    A	B	C	D
3	8	9	10	11

여러 줄 을 선택 하 는 것 은 한 줄 을 선택 하 는 방법 과 같다 (강박 증 0.0)

df5[:3]

#   	

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

조건 에 따라 줄 을 선택 하여 이 방법 은 단일 조건 상황 만 적용 되 는 지, 아니면 pandas 중의 loc 함수

를 사용 하 는 것 을 추천 합 니까?

df5[df5["A"]>5]

#   
	A	B	C	D
3	8	9	10	11
4	12	13	14	15

색인 수정

속성 수정 을 통 해 색인 수정

import  numpy as np
import pandas as pd
df6 = pd.DataFrame(np.arange(16).reshape((4,4)),index = list('abcd'),columns=['A','B','C','D'])

df6.columns = [1,2,3,4]		#     
df6.index = [1,2,3,4]		#     

#   

	1	2	3	4
1	0	1	2	3
2	4	5	6	7
3	8	9	10	11
4	12	13	14	15

rename () 함수 형식: df. rename (색인 = {}, inplace = False / True) 에서 inplace 인자 가 False 일 때 원본 데 이 터 를 수정 하지 않 고 True 일 때 원본 데 이 터 를 수정 합 니 다.기본 false

df7 = pd.DataFrame(np.arange(16).reshape((4,4)),index = list('abcd'),columns=['A','B','C','D'])

df8 = df7.rename(columns={
     'A':'a', 'B':'b', 'C':'c', 'D':'d'},inplace = False)
print(df8),print(df7)

#   

    a	b	c	d
a	0	1	2	3
b	4	5	6	7
c	8	9	10	11
d	12	13	14	15

	A	B	C	D
a	0	1	2	3
b	4	5	6	7
c	8	9	10	11
d	12	13	14	15

소 은 열 및 다 층 색인 설정

dataframe 은 setindex () 함수 로 색인 열 과 다 중 색인 을 설정 합 니 다.포맷: df. setindex (keys, drop, append, inplace) 인자: keys: 색인 으로 설 정 된 열 이름 drop: 색인 으로 설 정 된 열 을 삭제 할 지 여부, 기본 True (삭제).append: 새 색인 열 을 이전 색인 열 에 추가 할 지 여부 입 니 다. 기본 False (추가 하지 않 음) inplace: 원본 데 이 터 를 수정 할 지, 기본 False (수정 하지 않 음)

'''    df,   A   '''
import pandas as pd
import numpy as np
df = pd.DataFrame(np.arange(16).reshape((4,4)),index = list('abcd'),columns=['A','B','C','D'])
df['rank']=df['A'].rank(method='first')
df


''' rank      '''
df.set_index('rank')

#   

		A	B	C	D
rank				
1.0		0	1	2	3
2.0		4	5	6	7
3.0		8	9	10	11
4.0		12	13	14	15


'''       '''
df.set_index(['A','B'])

#   

		C	D	rank
A	B			
0	1	2	3	1.0
4	5	6	7	2.0
8	9	10	11	3.0
12	13	14	15	4.0


'''  drop  '''
df.set_index('rank',drop=False)

#   

		A	B	C	D	rank
rank					
1.0		0	1	2	3	1.0
2.0		4	5	6	7	2.0
3.0		8	9	10	11	3.0
4.0		12	13	14	15	4.0


'''  append  '''
df.set_index('rank',append=True)

#   

			A	B	C	D
	rank				
a	1.0		0	1	2	3
b	2.0		4	5	6	7
c	3.0		8	9	10	11
d	4.0		12	13	14	15

색인 을 열 로 변환

reset_index () 방법 은 색인 을 열 형식 으로 다시 바 꿀 수 있 습 니 다: resetindex (level, drop, inplace) 인자: level: 계층 화 된 색인 의 몇 번 째 층 을 columns 로 바 꿀 지 지정 합 니 다. 첫 번 째 색인 은 0 급, 두 번 째 는 1 급, 기본 값 은 None (모든 색인) 입 니 다.drop: 색인 열 을 삭제 할 지 여부 입 니 다. 기본 False 입 니 다.inplace: 원본 데 이 터 를 수정 할 지 여부 입 니 다. 기본 False (수정 하지 않 음)

가로 세로 표 변환

가로 표 변 세로 표 는 stack () 또는 melt () 함 수 를 통 해 df 구조의 표를 트 리 표 로 바 꿀 수 있다.stack () 은 줄 색인 이 변 하지 않도록 한 다음 에 열 색인 을 줄 색인 으로 바 꿉 니 다.melt () 는 변 하지 않 는 열 을 매개 변수 로 가리 키 고 전환 합 니 다.melt () 형식: melt (id vars = [], var name = [], value name) 인자: idvars: 변 하지 않 는 열 varname: 전환 후 열 을 추가 하 는 열 이름 valuename: 새 색인 에 대응 하 는 값 을 표시 하 는 이름

stack () 예제:

import pandas as pd
tree = pd.DataFrame({
     "A":[1,4],"B":[2,5],"C":[3,6]})
tree

#   

	A	B	C
0	1	2	3
1	4	5	6

'''  stack()     '''
tree.stack()

#   
0  A    1
   B    2
   C    3
1  A    4
   B    5
   C    6
dtype: int64

melt () 예제:

import pandas as pd
student = pd.DataFrame({
     "school":["   ","   ","  "],"grade1":[623,466,285],'grade2':[668,485,226],'grade3':[621,429,281]})
student

#   
	school	grade1	grade2	grade3
0	   	623		668		621
1	   	466		485		429
2	  	285		226		281


student.melt(id_vars="school",value_name="number",var_name="grade")

#   

	school	grade	number
0	   	grade1	623
1	   	grade1	466
2	  	grade1	285
3	   	grade2	668
4	   	grade2	485
5	  	grade2	226
6	   	grade3	621
7	   	grade3	429
8	  	grade3	281

세로 표 변 가로 표 는 unstack () 또는 pivottable () 함수, 트 리 표를 df 구조의 표

로 바 꿀 수 있 습 니 다.

'''unstack()    stack()  '''
tree.stack().unstack()

#   

	A	B	C
0	1	2	3
1	4	5	6


'''pivot_table()                '''
student1 = student.melt(id_vars="school",value_name="number",var_name="grade")
student1

#   

	school	grade	number
0	   	grade1	623
1	   	grade1	466
2	  	grade1	285
3	   	grade2	668
4	   	grade2	485
5	  	grade2	226
6	   	grade3	621
7	   	grade3	429
8	  	grade3	281

student1.pivot_table(index="school",columns="grade",values= "number")

#   
grade	grade1	grade2	grade3
school			
  	285		226		281
   	623		668		621
   	466		485		429

데이터 수정
1. 교체 용 loc 를 찾 아 할당 할 때 원본 데 이 터 를 수정 합 니 다.replace () 함수 로 교체 할 때 원본 데 이 터 를 수정 하지 않 습 니 다.

포 지 셔 닝 교 체 는 제 공 된 행렬 색인 에 따라 포 지 셔 닝 값 을 교체 합 니 다

'''    'a','A'       1'''

df5.loc['a',"A"]=1
df5

#   
	A	B	C	D
a	1	1	2	3
b	4	5	6	7
c	8	9	10	11
d	12	13	14	15

포 지 셔 닝 조건 은 제 공 된 조건 과 색인 에 따라 데 이 터 를 할당 합 니 다

.

''' A ，  5     1'''

df5.loc[df5['A']>5,'A']=1
df5

#   
	A	B	C	D
a	0	1	2	3
b	4	5	6	7
c	1	9	10	11
d	1	13	14	15

replace 함수 교 체 는 replace 함 수 를 통 해 데 이 터 를 교체 합 니 다.근 데 별로 안 좋 은 것 같 아 요.

단일 값 교체

''' A  0   10'''
df5[['A']].replace(0,10)

#   
	A
a	0
b	4
c	8
d	0

단일 다 중 값 교체

'''  A  0   10，4   20'''
df5[['A']].replace([0,4],[10,20])

#   

    A
a	10
b	20
c	8
d	12

다 열 동일 값 교체 규칙

'''  A、B  0   10，4   20'''
df5[['A','B']].replace([0,1],[10,20])

#   

    A	B
a	10	20
b	4	5
c	8	9
d	12	13

2. 행렬 을 늘 리 면 목록 등 방식 으로 줄, 열 에 데 이 터 를 추가 할 수 있 지만 길이 가 dataframe 과 일치 하도록 해 야 합 니 다.series 색인 을 통 해 값 을 정확하게 부여 할 수도 있다.

증가 행

df5.loc['e']=[16,17,18,19]
df5

#   

    A	B	C	D
a	0	1	2	3
b	4	5	6	7
c	8	9	10	11
d	12	13	14	15
e	16	17	18	19

증가 열

df5.loc[:,'E']=[10,20,30,40,50]
df5

#   

    A	B	C	D	E
a	0	1	2	3	10
b	4	5	6	7	20
c	8	9	10	11	30
d	12	13	14	15	40
e	16	17	18	19	50

series 로 정확 한 할당

'''   series    ， series  E  ，   nan'''

a=pd.Series([10,20,30,40],index=['A','B','C','D'])
df5.loc['f']=a
df5

#   

    A		B		C		D		E
a	0.0	    1.0	    2.0		3.0		10.0
b	4.0		5.0		6.0		7.0		20.0
c	8.0		9.0		10.0	11.0	30.0
d	12.0	13.0	14.0	15.0	40.0
e	16.0	17.0	18.0	19.0	50.0
f	10.0	20.0	30.0	40.0	NaN

3. 부족 값 교체 fillna () 함 수 는 부족 값 을 교체 할 수 있 습 니 다.
데이터 조작
2. 데이터 조작 은 df 에 대한 조작 이 많 습 니 다. 자주 사용 하 는 것 은 유 니 크 (), isin (), cut (), qcut (), T 입 니 다.
school 데이터 만 들 기:

import pandas as pd
school=pd.DataFrame({
     "id":[1,2,3,4,5,6,7,8,9],"grade":[98,95,96,86,94,92,94,95,94]})
school

#   

	id	grade
0	1	98
1	2	95
2	3	96
3	4	86
4	5	94
5	6	92
6	7	94
7	8	95
8	9	94

유일한 값 가 져 오기: unique () 열 데이터 의 유일한 값 가 져 오기

school["grade"].unique()

#   
array([98, 95, 96, 86, 94, 92], dtype=int64)

검색 값: isin () 선택 한 범위 내 에 어떤 값 이 포함 되 어 있 는 지 확인 합 니 다.

'''  grade     96 '''
school["grade"].isin([96])

#   
0    False
1    False
2     True
3    False
4    False
5    False
6    False
7    False
8    False
Name: grade, dtype: bool



'''   6     96 '''
school.iloc[0:6,0:2].isin([96])

#   

	id		grade
0	False	False
1	False	False
2	False	True
3	False	False
4	False	False
5	False	False

구간 절 분: cut () 는 규정된 절 분 값 에 따라 데이터 절 분 을 하고 cut () 함 수 는 Series 형식 데 이 터 를 사용 할 수 없습니다.

''' grade            '''
pd.cut(school['grade'],bins = [85,90,95,100])

#   
0    (95, 100]
1     (90, 95]
2    (95, 100]
3     (85, 90]
4     (90, 95]
5     (90, 95]
6     (90, 95]
7     (90, 95]
8     (90, 95]
Name: grade, dtype: category
Categories (3, interval[int64]): [(85, 90] < (90, 95] < (95, 100]]

분 에 따라 qcut () qcut () 함 수 는 데 이 터 를 지정 한 분 수 에 따라 나 눌 수 있 으 며, 가능 한 한 각 부의 수량 차이 가 많 지 않도록 보장 할 수 있다.

'''     3 '''
pd.qcut(school['grade'],3)

#   
0      (95.0, 98.0]
1      (94.0, 95.0]
2      (95.0, 98.0]
3    (85.999, 94.0]
4    (85.999, 94.0]
5    (85.999, 94.0]
6    (85.999, 94.0]
7      (94.0, 95.0]
8    (85.999, 94.0]
Name: grade, dtype: category
Categories (3, interval[float64]): [(85.999, 94.0] < (94.0, 95.0] < (95.0, 98.0]]

데이터 변환: T 데이터 변환 은 데이터 행렬 을 교환 할 수 있 습 니 다

'''       '''
school.T

#   

		0	1	2	3	4	5	6	7	8
id		1	2	3	4	5	6	7	8	9
grade	98	95	96	86	94	92	94	95	94

데이터 연산
1. 연산

가산

전체 값 이 1 개 증가

import  numpy as np
import pandas as pd
df = pd.DataFrame(np.arange(16).reshape((4,4)),index = list('abcd'),columns=['A','B','C','D'])

#    
	A	B	C	D
a	0	1	2	3
b	4	5	6	7
c	8	9	10	11
d	12	13	14	15

'''      5'''
df+5

#   

	A	B	C	D
a	5	6	7	8
b	9	10	11	12
c	13	14	15	16
d	17	18	19	20

단독 행, 열, 범위 에 하나의 값

''' A +5'''
df['A']=df['A']+5
df

#   

	A	B	C	D
a	5	1	2	3
b	9	5	6	7
c	13	9	10	11
d	17	13	14	15


''' a +5'''
df.loc['a']=df.loc['a']+5
df

#   
	A	B	C	D
a	5	6	7	8
b	4	5	6	7
c	8	9	10	11
d	12	13	14	15


''' A,B  ,b   +5'''
df.iloc[0:2,0:2]=df.iloc[0:2,0:2]+10
df

#   

	A	B	C	D
a	10	11	2	3
b	14	15	6	7
c	8	9	10	11
d	12	13	14	15

두 dataframe 에 두 개의 df 를 더 하면 같은 줄, 열 색인 명 을 가 져 야 합 니 다.색인 이름 이 다 르 면 NAN 으로 돌아 갑 니 다.

'''      4*4 3*3 df df1。  df1   D ，d ，  df+df1 ，     NAN'''
df = pd.DataFrame(np.arange(16).reshape((4,4)),index = list('abcd'),columns=['A','B','C','D'])
df1= pd.DataFrame(np.arange(9).reshape((3,3)),index = list('abc'),columns=['A','B','C'])
df+df1

#   
	A		B		C		D
a	0.0		2.0		4.0		NaN
b	7.0		9.0		11.0	NaN
c	14.0	16.0	18.0	NaN
d	NaN		NaN		NaN		NaN

add () 함 수 를 사용 할 때 fill 을 사용 할 수 있 습 니 다.value 방법 은 하나의 df 에 부족 한 데 이 터 를 채 웁 니 다. 그러나 두 df 에 모두 NAN 의 데이터 가 있 으 면 이 방법 은 채 우지 않 습 니 다.

'''  add  ，        0'''
df.add(df1,fill_value=0)

#   

	A		B		C		D
a	0.0		2.0		4.0		3.0
b	7.0		9.0		11.0	7.0
c	14.0	16.0	18.0	11.0
d	12.0	13.0	14.0	15.0

곱 하기 연산 * 벌칙 연산 은 덧셈 연산 과 유사 하 며, Python 은 같은 색인 을 가 진 값 에 대해 자동 으로 대응 연산 을 하고, 색인 이 다른 값 은 NAN 으로 되 돌려 줍 니 다.

''' df df1'''
df*df1

#   

	A		B		C		D
a	0.0		1.0		4.0		NaN
b	12.0	20.0	30.0	NaN
c	48.0	63.0	80.0	NaN
d	NaN		NaN		NaN		NaN

연산 자 와 pandas 조작 함수

연산 자
조작 함수
주석
+
add()
덧셈
-
sub()
감법
*
mul()
곱셈
/
div()
나눗셈
//
floordiv()
정돈 하 다
**
pow()
제곱
%
mod()
나머지 를 취하 다

집합 함수 pandas 에서 자주 사용 하 는 집합 함수: max (), min (), mean (), sum (), count (), valuecounts (), 등

sun () 과 count () 를 예 로 들 면:

''' df     '''
df.sum(axis=1)

#   
a     6
b    22
c    38
d    54
dtype: int64


''' df     '''
df.count(axis=0)

#   
A    4
B    4
C    4
D    4
dtype: int64

apply () 는 apply map () 함수 apply () 와 apply map () 함수 와 유사 하여 함수 와 결합 하여 사용 해 야 합 니 다.apply () 는 주로 DataFrame 의 한 column 이나 row 의 요 소 를 함수 로 조작 하 는 데 사 용 됩 니 다.

tree = pd.DataFrame({
     "A":[1,4],"B":[2,5],"C":[3,6]})
tree['C'].apply(lambda x:x+1)

#   
0    4
1    7
Name: C, dtype: int64

applymap () 은 주로 DataFrame 의 모든 요소 에 대해 같은 함수 작업 을 수행 하 는 데 사 용 됩 니 다.

tree.applymap(lambda x:x+1)

#   
	A	B	C
0	2	3	4
1	5	6	7