파이썬 머신러닝 판다스 데이터 분석 - part1_판다스 입문

데이터 과학은 데이터를 연구하는 분야.

판다스 라이브러리는 데이터르 수집하고 정리하는데 최적화된 도구.

오픈소스라 무료다. 

판다스만 배우면 데이터 과학의 80~90% 업무를 처리할 수 있다.

서로 다른 종류의 데이터를 한곳에 담는 컨테이너 1차원 시리즈와 2차원 데이터프레임이 있다. 

 

시리즈

인덱스와 값과 일대일 대응이 된다. 사전구조와 비슷하다. 판다스 내장함수. Series()

type() 객체 자료형 확인하기 

.index 인덱스 배열 선택

.values 값 배열만  선택

len 원소 개수 확인하기

dtype 원소의 자료형 확인하기

shape 배열의 형태 확인하기

ndim 배열이나 데이터 구조의 차원 수

sr[1,2] 리스트 형태로 짝을 이루는 원소 데이터를 모두 반환

st[1:2] 정수형 위치 인덱스, 여러개의 원소 데이터를 반환

import pandas as pd

# Series 생성 (인덱스와 값이 1:1 대응)
sr = pd.Series(
    [90, 85, 100, 95],
    index=["철수", "영희", "민수", "지훈"]
)

# 객체 자료형 확인
print("type :", type(sr))

# 인덱스 배열 확인
print("\nindex :", sr.index)

# 값 배열 확인
print("\nvalues :", sr.values)

# 원소 개수 확인
print("\nlen :", len(sr))

# 원소 자료형 확인
print("\ndtype :", sr.dtype)

# 배열 형태 확인
print("\nshape :", sr.shape)

# 차원 수 확인
print("\nndim :", sr.ndim)

# 여러 개 원소 선택 (1번, 2번 위치)
print("\nsr[[1, 2]]")
print(sr[[1, 2]])

# 슬라이싱 (1번 위치부터 2번 위치까지)
print("\nsr[1:3]")
print(sr[1:3])

type : <class 'pandas.core.series.Series'>

index : Index(['철수', '영희', '민수', '지훈'], dtype='object')

values : [ 90  85 100  95]

len : 4

dtype : int64

shape : (4,)

ndim : 1

sr[[1, 2]]
영희     85
민수    100
dtype: int64

sr[1:3]
영희     85
민수    100
dtype: int64

 

 

 

시리즈 객체 만들기

pd.Series() 빈 배열 형태 시리즈 만들기

pd.Series(5) 상수 원소를 갖는 원소 1있는 시리즈 객체를만든다.

pd.Series(5, index=["a", "b", "c"] 인덱스 배열의 크기만큼 상수값이 복제되는 시리즈 객체를 만든다.

import pandas as pd

# 1. 빈 Series 생성
sr1 = pd.Series()

# 2. 상수 1개를 가진 Series 생성
sr2 = pd.Series(5)

# 3. 인덱스 개수만큼 상수값이 복제된 Series 생성
sr3 = pd.Series(5, index=["a", "b", "c"])

print("=== 빈 Series ===")
print(sr1)

print("\n=== 상수 1개를 가진 Series ===")
print(sr2)

print("\n=== 인덱스 개수만큼 상수값 복제 ===")
print(sr3)

=== 빈 Series ===
Series([], dtype: object)

=== 상수 1개를 가진 Series ===
0    5
dtype: int64

=== 인덱스 개수만큼 상수값 복제 ===
a    5
b    5
c    5
dtype: int64

 

 

 

데이터프레임

2차원배열, 행과 열 excel, rdbms와같은. 대표적인 통계 패키지인 R의 데이터 프레임에서 유래했다고 알려져있다.

1차원 배열의 여러개. 열을 모아놓은 집합.

pd.DataFame() 생성

pd.DataFame(2차원배열, index = 행 인덱스배열, column=열 이름 배열) 

type() 객체확인

df.index 새로운 행 인덱스 배열

df.columns 새로운 열 이름 배열

df.rename(index/columns = {}) 행 인덱스, 열 이름 변경, 원본 객체를 수정하는 것이 아니라 새로운 데이터 프레임 객체를 반환한다. 원본 객체를 변경하려면 원본 객체를 담고 있는 변수를 직접 업데이트한다.

df.drop(행/열/배열, axis = 0/1/index/column) 행또는 열 삭제 마찬가지고 기존 객체를 변경하지 않는다. 

df.loc['서준'] 이름 기준으로 행 선택

df.loc['서준', ['음악', '체육'] df 형 반환

df.iloc[0] 정수형 위치 인덱스 사용

df.열이름

df.iloc[시작 index: 끝 index: 슬라이싱 간격]

import pandas as pd

# 데이터프레임 생성 (2차원 배열)
df = pd.DataFrame(
    [[90, 80, 70],
     [85, 95, 90],
     [100, 90, 95]],
    index=["서준", "우현", "인아"],
    columns=["수학", "영어", "음악"]
)

print("=== 데이터프레임 ===")
print(df)

# 객체 타입 확인
print("\ntype :", type(df))

# 행 인덱스 확인
print("\nindex :")
print(df.index)

# 열 이름 확인
print("\ncolumns :")
print(df.columns)

# 행 인덱스 이름 변경
df2 = df.rename(index={"서준": "민수"})

print("\n=== 행 인덱스 변경 ===")
print(df2)

# 열 이름 변경
df3 = df.rename(columns={"음악": "체육"})

print("\n=== 열 이름 변경 ===")
print(df3)

# 행 삭제
df4 = df.drop("우현", axis=0)

print("\n=== 행 삭제 ===")
print(df4)

# 열 삭제
df5 = df.drop("영어", axis=1)

print("\n=== 열 삭제 ===")
print(df5)

# 이름(라벨) 기준 행 선택
print("\n=== df.loc['서준'] ===")
print(df.loc["서준"])

# 이름 기준 여러 열 선택
print("\n=== df.loc['서준', ['수학', '음악']] ===")
print(df.loc["서준", ["수학", "음악"]])

# 정수 위치 인덱스 사용
print("\n=== df.iloc[0] ===")
print(df.iloc[0])

# 특정 열 선택
print("\n=== df.수학 ===")
print(df.수학)

# 슬라이싱
print("\n=== df.iloc[0:2] ===")
print(df.iloc[0:2])

=== 데이터프레임 ===
     수학  영어  음악
서준   90  80  70
우현   85  95  90
인아  100  90  95

type : <class 'pandas.core.frame.DataFrame'>

index :
Index(['서준', '우현', '인아'], dtype='object')

columns :
Index(['수학', '영어', '음악'], dtype='object')

=== 행 인덱스 변경 ===
     수학  영어  음악
민수   90  80  70
우현   85  95  90
인아  100  90  95

=== 열 이름 변경 ===
     수학  영어  체육
서준   90  80  70
우현   85  95  90
인아  100  90  95

=== 행 삭제 ===
     수학  영어  음악
서준   90  80  70
인아  100  90  95

=== 열 삭제 ===
     수학  음악
서준   90  70
우현   85  90
인아  100  95

=== df.loc['서준'] ===
수학    90
영어    80
음악    70
Name: 서준, dtype: int64

=== df.loc['서준', ['수학', '음악']] ===
수학    90
음악    70
Name: 서준, dtype: int64

=== df.iloc[0] ===
수학    90
영어    80
음악    70
Name: 서준, dtype: int64

=== df.수학 ===
서준     90
우현     85
인아    100
Name: 수학, dtype: int64

=== df.iloc[0:2] ===
     수학  영어  음악
서준   90  80  70
우현   85  95  90

 

 

 

 

df.tanspose() 행과 열 서로 맞바꾸기, 선형대수학의 전치행렬과 가튼 개념. 

df.set_index() 특정행을 인덱스로 설정. 원본이 아닌 새로운 객체를 반환한다. 

df.reindex(new_idex, fill_value=0) 행 인덱스를 새로운 배열로 재지정 fill_value를 지정하지않을시. 존재하지않는 행인덱스가 추가되는 경우 NaN.

df.reset_index() 기존 행 인덱스는 열로 이동하고 인덱스가 새로 생기며 names속성을 지정하면 열이름을 지정할 수 있다. 기존 행 인덱스가 필요없을 경우 drop=True 속성을 지정한다. 

df.sort_index() 행 인덱스를 기준으로 데이터프레임의 값을 정렬한다. ascending=False 옵션으로 내림차순으로 설정할 수 있다. 

import pandas as pd

df = pd.DataFrame({
    "A": [1, 2, 3],
    "B": [4, 5, 6]
}, index=["c", "a", "b"])

# 1. transpose
df_t = df.transpose()

# 2. set_index
df2 = df.reset_index().set_index("index")

# 3. reindex
df3 = df.reindex(["a", "b", "c", "d"], fill_value=0)

# 4. reset_index
df4 = df.reset_index()

# 5. sort_index (오름차순)
df5 = df.sort_index()

# 6. sort_index (내림차순)
df6 = df.sort_index(ascending=False)

print("df_t\n", df_t, "\n")
print("df2\n", df2, "\n")
print("df3\n", df3, "\n")
print("df4\n", df4, "\n")
print("df5\n", df5, "\n")
print("df6\n", df6)

df_t
    c  a  b
A  1  2  3
B  4  5  6


df2
       A  B
index
c      1  4
a      2  5
b      3  6


df3
   A  B
a  2  5
b  3  6
c  1  4
d  0  0


df4
  index  A  B
0     c  1  4
1     a  2  5
2     b  3  6


df5
   A  B
a  2  5
b  3  6
c  1  4


df6
   A  B
c  1  4
b  3  6
a  2  5

 

 

pandas의 객체 산술연산은 내부적으로 단계 프로세스를 거치며 행/열 인덱스를 기준으로 모든 원소를 정렬해 1:1로 대응시켜 대응되는 원소끼리 연산을 처리하고 대응하는 원소가 없으면 NaN으로 처리한다. 

시리즈/데이터프레임와 숫자끼리 덧셈, 뺄셈, 곱셈, 나눗셈 모두 가능하다. 

시리즈/데이터프레임와 시리즈/데이터프레임 사이 사치견산이 가능하다. 

NaN을 포함한 연산결과는 NaN 처리가 된다.

import pandas as pd

s = pd.Series([1, 2, 3], index=["a", "b", "c"])

print(s + 10)
print(s - 1)
print(s * 2)
print(s / 2)

a    11
b    12
c    13
dtype: int64

a    0
b    1
c    2
dtype: int64

a    2
b    4
c    6
dtype: int64

a    0.5
b    1.0
c    1.5
dtype: float64

df = pd.DataFrame({
    "A": [1, 2],
    "B": [3, 4]
})

print(df + 10)
print(df * 2)

    A   B
0  11  13
1  12  14

    A  B
0  2  6
1  4  8

s1 = pd.Series([1, 2, 3], index=["a", "b", "c"])
s2 = pd.Series([10, 20, 30], index=["b", "c", "d"])

print(s1 + s2)

a     NaN
b    12.0
c    23.0
d     NaN
dtype: float64

df1 = pd.DataFrame({
    "A": [1, 2],
    "B": [3, 4]
}, index=["x", "y"])

df2 = pd.DataFrame({
    "A": [10, 20],
    "B": [30, 40]
}, index=["y", "x"])

print(df1 + df2)

      A   B
x  21.0  43.0
y  12.0  34.0

s1 = pd.Series([1, None, 3], index=["a", "b", "c"])
s2 = pd.Series([10, 20, 30], index=["a", "b", "c"])

print(s1 + s2)

a    11.0
b     NaN
c    33.0
dtype: float64

 

 

불린인덱싱

df[df['age'] < 20] 등의 True에 해당하는 행만 선택된다. 불린 인덱싱에서 조건식을 만들때  논리연산자가 사용된다. & | ~

import pandas as pd

df = pd.DataFrame({
    "name": ["A", "B", "C", "D"],
    "age": [18, 22, 19, 25]
})

print(df[df["age"] < 20])

  name  age
0    A   18
2    C   19

print(df[(df["age"] >= 18) & (df["age"] < 20)])

  name  age
0    A   18
2    C   19

print(df[(df["age"] < 20) | (df["age"] > 23)])

  name  age
0    A   18
2    C   19
3    D   25

print(df[~(df["age"] < 20)])

  name  age
1    B   22
3    D   25

 

 

 

query() 문자열표현을 사용해 간편하게 필터링을 수행할 수 있다. 조건은 표준 비교 연산자와 논리연산자를 사용해 표현한다. 

df.query('age <20')

query() 문자열표현을 사용해 간편하게 필터링을 수행할 수 있다. 조건은 표준 비교 연산자와 논리연산자를 사용해 표현한다. 

df.query('age <20')

  name  age
0    A   18
2    C   19

print(df.query("age >= 18 and age < 20"))

  name  age
0    A   18
2    C   19

print(df.query("age < 20 or age > 23"))

  name  age
0    A   18
2    C   19
3    D   25

min_age = 20

print(df.query("age >= @min_age"))

  name  age
1    B   22
3    D   25

 

 

isin()

특정값을 가진 행들을 따로 추출할 수 있다.

data['town'].isin(["서울", "부산"])

isin()

특정값을 가진 행들을 따로 추출할 수 있다.

data['town'].isin(["서울", "부산"])

  name town
0    A   서울
2    C   부산

print(df[df["town"].isin(["서울", "부산", "인천"])])

  name town
0    A   서울
2    C   부산
3    D   인천

df2 = pd.DataFrame({
    "name": ["A", "B", "C", "D"],
    "age": [18, 22, 19, 25]
})

print(df2[df2["age"].isin([18, 25])])

  name  age
0    A   18
3    D   25

 

 

 

Seris에 dtype을 String, pd.StringDtype()으로 지정하지않으면 기본 텍스트 저장은 object 자료형으로 처리된다.   

lower() 소문자 변환, upper() 대문자 변환

expend=True 객체의 문자열을 분할해 부분을 별도 열로 표시한다. 

len 길이계산

get 특정요소 선택

strip() 양쪽 공백 제거, lstrip()왼쪽 공백제거, rstrip() 오른쪽 공백제거

regex=False 옵션으로 단순한 문자열을 찾아 변경하고, regex=True옵션을 설정해 정규표현식을 사용 할 수 있다. 

contains() na = False 결측값이 있으면 False로 처리한다.

extractall()는 모두 추출한다., extract()는 문자열에서 각 부분을 추출한다. 

import pandas as pd

s1 = pd.Series(["a", "b", "c"])
print(s1.dtype)

s2 = pd.Series(["a", "b", "c"], dtype="string")
print(s2.dtype)

s = pd.Series(["Apple", "Banana"])

print(s.str.lower())
print(s.str.upper())

s = pd.Series(["a b", "c d"])

print(s.str.split(" ", expand=True))


   0  1
0  a  b
1  c  d

s = pd.Series(["apple", "hi"])

print(s.str.len())


0    5
1    2
dtype: int64

s = pd.Series(["abc", "def"])

print(s.str.get(0))


0    a
1    d
dtype: object

s = pd.Series(["  hi  ", "  hello"])

print(s.str.strip())
print(s.str.lstrip())
print(s.str.rstrip())


0       hi
1    hello
dtype: object

0      hi  
1    hello
dtype: object

0      hi
1    hello
dtype: object

s = pd.Series(["a1", "b2", "c3"])

print(s.str.replace(r"\d", "X", regex=True))


0    aX
1    bX
2    cX
dtype: object

s = pd.Series(["apple", None, "banana"])

print(s.str.contains("a", na=False))

0     True
1    False
2     True
dtype: bool

s = pd.Series(["a1 b2", "c3 d4"])

print(s.str.extract(r"(\d)"))


     0
0    1
1    3